Emcee

1
import AtomicModels
2
import CommonTestModels
3
import DateProvider
4
import Foundation
5
import Metrics
6
import MetricsExtensions
7
import QueueModels
8

9
public final class MetricReportingTestRunnerStream: TestRunnerStream {
10
    private let dateProvider: DateProvider
11
    private let version: Version
12
    private let host: String
13
    private let persistentMetricsJobId: String?
14
    private let lastTestStoppedEventTimestamp = AtomicValue<Date?>(nil)
15
    private let willRunEventTimestamp = AtomicValue<Date?>(nil)
16
    private let specificMetricRecorder: SpecificMetricRecorder
17
    
18
    public init(
19
        dateProvider: DateProvider,
20
        version: Version,
21
        host: String,
22
        persistentMetricsJobId: String?,
23
        specificMetricRecorder: SpecificMetricRecorder
24
    ) {
25
        self.dateProvider = dateProvider
26
        self.host = host
27
        self.version = version
28
        self.persistentMetricsJobId = persistentMetricsJobId
29
        self.specificMetricRecorder = specificMetricRecorder
30
    }
31
    
32
    public func openStream() {
33
        willRunEventTimestamp.set(dateProvider.currentDate())
34
    }
35
    
36
    public func testStarted(testName: TestName) {
37
        willRunEventTimestamp.withExclusiveAccess { value in
38
            if let willRunEventTimestamp = value {
39
                specificMetricRecorder.capture(
40
                    TestPreflightMetric(
41
                        host: host,
42
                        duration: dateProvider.currentDate().timeIntervalSince(willRunEventTimestamp),
43
                        version: version,
44
                        timestamp: dateProvider.currentDate()
45
                    )
46
                )
47
                value = nil
48
            }
49
        }
50
        
51
        specificMetricRecorder.capture(
52
            TestStartedMetric(
53
                host: host,
54
                testClassName: testName.className,
55
                testMethodName: testName.methodName,
56
                version: version,
57
                timestamp: dateProvider.currentDate()
58
            )
59
        )
60
        
61
        if let timestamp = lastTestStoppedEventTimestamp.currentValue() {
62
            specificMetricRecorder.capture(
63
                TimeBetweenTestsMetric(
64
                    host: host,
65
                    duration: dateProvider.currentDate().timeIntervalSince(timestamp),
66
                    version: version,
67
                    timestamp: dateProvider.currentDate()
68
                )
69
            )
70
            lastTestStoppedEventTimestamp.set(nil)
71
        }
72
    }
73
    
74
    public func testStopped(testStoppedEvent: TestStoppedEvent) {
75
        specificMetricRecorder.capture(
76
            TestFinishedMetric(
77
                result: testStoppedEvent.result.rawValue,
78
                host: host,
79
                testClassName: testStoppedEvent.testName.className,
80
                testMethodName: testStoppedEvent.testName.methodName,
81
                version: version,
82
                timestamp: dateProvider.currentDate()
83
            ),
84
            ConcreteTestDurationMetric(
85
                result: testStoppedEvent.result.rawValue,
86
                host: host,
87
                testClassName: testStoppedEvent.testName.className,
88
                testMethodName: testStoppedEvent.testName.methodName,
89
                duration: testStoppedEvent.testDuration,
90
                version: version,
91
                timestamp: dateProvider.currentDate()
92
            )
93
        )
94
        if let persistentMetricsJobId = persistentMetricsJobId {
95
            specificMetricRecorder.capture(
96
                AggregatedTestsDurationMetric(
97
                    result: testStoppedEvent.result.rawValue,
98
                    host: host,
99
                    version: version,
100
                    persistentMetricsJobId: persistentMetricsJobId,
101
                    duration: testStoppedEvent.testDuration
102
                )
103
            )
104
        }
105
        
106
        lastTestStoppedEventTimestamp.set(dateProvider.currentDate())
107
    }
108
    
109
    public func caughtException(testException: TestException) {}
110
    
111
    public func logCaptured(entry: TestLogEntry) {}
112
    
113
    public func closeStream() {
114
        lastTestStoppedEventTimestamp.withExclusiveAccess { value in
115
            if let lastTestStoppedEventTimestamp = value {
116
                specificMetricRecorder.capture(
117
                    TestPostflightMetric(
118
                        host: host,
119
                        duration: dateProvider.currentDate().timeIntervalSince(lastTestStoppedEventTimestamp),
120
                        version: version,
121
                        timestamp: dateProvider.currentDate()
122
                    )
123
                )
124
            }
125
            value = nil
126
        }
127
        
128
        if let streamOpenEventTimestamp = willRunEventTimestamp.currentValue() {
129
            specificMetricRecorder.capture(
130
                UselessTestRunnerInvocationMetric(
131
                    host: host,
132
                    version: version,
133
                    duration: dateProvider.currentDate().timeIntervalSince(streamOpenEventTimestamp),
134
                    timestamp: dateProvider.currentDate()
135
                )
136
            )
137
        }
138
    }
139
}
140