Emcee

1
import AtomicModels
2
import CommonTestModels
3
import DateProvider
4
import Foundation
5
import EmceeLogging
6
import EmceeTypes
7
import Timer
8

9
public final class TestTimeoutTrackingTestRunnerSream: TestRunnerStream {
10
    struct LastStartedTestInfo {
11
        let testName: TestName
12
        let testStartedAt: DateSince1970ReferenceDate
13
    }
14
    
15
    private let dateProvider: DateProvider
16
    private let detectedLongRunningTest: (TestName, DateSince1970ReferenceDate) -> ()
17
    private let lastStartedTestInfo = AtomicValue<LastStartedTestInfo?>(nil)
18
    private let logger: () -> ContextualLogger
19
    private let maximumTestDuration: TimeInterval
20
    private let pollPeriod: DispatchTimeInterval
21
    private var testHangTrackingTimer: DispatchBasedTimer?
22
    
23
    public init(
24
        dateProvider: DateProvider,
25
        detectedLongRunningTest: @escaping (TestName, DateSince1970ReferenceDate) -> (),
26
        logger: @escaping () -> ContextualLogger,
27
        maximumTestDuration: TimeInterval,
28
        pollPeriod: DispatchTimeInterval
29
    ) {
30
        self.dateProvider = dateProvider
31
        self.detectedLongRunningTest = detectedLongRunningTest
32
        self.logger = logger
33
        self.maximumTestDuration = maximumTestDuration
34
        self.pollPeriod = pollPeriod
35
    }
36
    
37
    public func openStream() {}
38
        
39
    public func testStarted(testName: TestName) {
40
        startMonitoringForHangs(testName: testName)
41
    }
42
    
43
    public func caughtException(testException: TestException) {}
44
    
45
    public func logCaptured(entry: TestLogEntry) {}
46
    
47
    public func testStopped(testStoppedEvent: TestStoppedEvent) {
48
        stopMonitoringForHangs(testStoppedEvent: testStoppedEvent)
49
    }
50
    
51
    public func closeStream() {
52
        stopTimer()
53
    }
54
    
55
    private func startMonitoringForHangs(testName: TestName) {
56
        lastStartedTestInfo.set(
57
            LastStartedTestInfo(testName: testName, testStartedAt: dateProvider.dateSince1970ReferenceDate())
58
        )
59
        
60
        testHangTrackingTimer = DispatchBasedTimer.startedTimer(repeating: pollPeriod, leeway: pollPeriod) { [weak self] timer in
61
            guard let strongSelf = self else { return timer.stop() }
62
            guard let lastStartedTestInfo = strongSelf.lastStartedTestInfo.currentValue() else { return timer.stop() }
63
            
64
            if strongSelf.dateProvider.currentDate().timeIntervalSince(lastStartedTestInfo.testStartedAt.date) > strongSelf.maximumTestDuration {
65
                strongSelf.didDetectLongRunningTest(lastStartedTestInfo: lastStartedTestInfo)
66
                timer.stop()
67
            }
68
        }
69
        
70
        logger().trace("Started monitoring duration of test \(testName)")
71
    }
72
    
73
    private func stopMonitoringForHangs(testStoppedEvent: TestStoppedEvent) {
74
        stopTimer()
75
        
76
        logger().trace("Stopped monitoring duration of test \(testStoppedEvent.testName), test finished with result \(testStoppedEvent.result)")
77
    }
78
    
79
    private func didDetectLongRunningTest(lastStartedTestInfo: LastStartedTestInfo) {
80
        logger().warning("Detected a long running test: \(lastStartedTestInfo.testName) was running for more than \(maximumTestDuration.loggableInSeconds()), test started at: \(lastStartedTestInfo.testStartedAt.date.loggable())")
81
        
82
        detectedLongRunningTest(lastStartedTestInfo.testName, lastStartedTestInfo.testStartedAt)
83
    }
84
    
85
    private func stopTimer() {
86
        lastStartedTestInfo.set(nil)
87
        testHangTrackingTimer?.stop()
88
        testHangTrackingTimer = nil
89
    }
90
}
91