Emcee

1
import CommonTestModels
2
import Foundation
3
import RunnerModels
4

5
public enum AppleRunnerEvent: Codable, Equatable, CustomStringConvertible {
6
    /// Event indicates that a set of tests will be run.
7
    case willRun(testEntries: [TestEntry], testContext: AppleTestContext)
8

9
    /// Event occurs after test starts.
10
    /// At this time there is no information about its result yet.
11
    /// This event will be triggered for each test from the set of tests which has started before.
12
    case testStarted(testEntry: TestEntry, testContext: AppleTestContext)
13
    
14
    /// Event occurs after test finishes. At this time only a limited test result information is available.
15
    /// At the moment of this event triggering, some tests still may be up to be executed by the test runner.
16
    /// This event will be triggered for each test from the set of tests which has started before.
17
    /// This event is not an appropriate place to process test results, because not all test results can be available, or test results may be not complete.
18
    case testFinished(testEntry: TestEntry, succeeded: Bool, testContext: AppleTestContext)
19
    
20
    /// This event indicates that test runner has finished running all tests from the test set it has been executing.
21
    /// At this point, all test results are final and contain maximum details test runner managed to obtain.
22
    /// This event is a good place to process test results.
23
    case didRun(results: [TestEntryResult], testContext: AppleTestContext)
24
    
25
    public var testContext: AppleTestContext {
26
        switch self {
27
        case .willRun(_, let testContext):
28
            return testContext
29
        case .didRun(_, let testContext):
30
            return testContext
31
        case .testStarted(_, let testContext):
32
            return testContext
33
        case .testFinished(_, _, let testContext):
34
            return testContext
35
        }
36
    }
37
    
38
    public var description: String {
39
        let eventName: String
40
        let testContext: AppleTestContext
41
        let additionalInfo: String
42
        
43
        switch self {
44
        case .willRun(let testEntries, let context):
45
            eventName = "willRun"
46
            testContext = context
47
            additionalInfo = "testEntries: " + testEntries.map { $0.description }.joined(separator: ", ")
48
        case .didRun(let results, let context):
49
            eventName = "didRun"
50
            testContext = context
51
            additionalInfo = "results: " + results.map { $0.description }.joined(separator: ", ")
52
        case .testStarted(let testEntry, let context):
53
            eventName = "testStarted"
54
            testContext = context
55
            additionalInfo = "testEntry: \(testEntry)"
56
        case .testFinished(let testEntry, let succeeded, let context):
57
            eventName = "testFinished"
58
            testContext = context
59
            additionalInfo = "testEntry: \(testEntry), \(succeeded ? "succeeded" : "failed")"
60
        }
61
        
62
        return "<\(type(of: self)) " + [eventName, String(describing: testContext), additionalInfo].joined(separator: ", ") + ">"
63
    }
64

65
    private enum CodingKeys: CodingKey {
66
        case eventType
67
        case succeeded
68
        case testEntries
69
        case testEntry
70
        case testContext
71
        case results
72
    }
73
    
74
    private enum EventType: String, Codable {
75
        case willRun
76
        case didRun
77
        case testStarted
78
        case testFinished
79
    }
80
    
81
    public init(from decoder: Decoder) throws {
82
        let container = try decoder.container(keyedBy: CodingKeys.self)
83
        let eventType = try container.decode(EventType.self, forKey: .eventType)
84
        
85
        switch eventType {
86
        case .willRun:
87
            let testEntries = try container.decode([TestEntry].self, forKey: .testEntries)
88
            let testContext = try container.decode(AppleTestContext.self, forKey: .testContext)
89
            self = .willRun(testEntries: testEntries, testContext: testContext)
90
        case .didRun:
91
            let results = try container.decode([TestEntryResult].self, forKey: .results)
92
            let testContext = try container.decode(AppleTestContext.self, forKey: .testContext)
93
            self = .didRun(results: results, testContext: testContext)
94
        case .testStarted:
95
            let testEntry = try container.decode(TestEntry.self, forKey: .testEntry)
96
            let testContext = try container.decode(AppleTestContext.self, forKey: .testContext)
97
            self = .testStarted(testEntry: testEntry, testContext: testContext)
98
        case .testFinished:
99
            let testEntry = try container.decode(TestEntry.self, forKey: .testEntry)
100
            let testContext = try container.decode(AppleTestContext.self, forKey: .testContext)
101
            let succeeded = try container.decode(Bool.self, forKey: .succeeded)
102
            self = .testFinished(testEntry: testEntry, succeeded: succeeded, testContext: testContext)
103
        }
104
    }
105
    
106
    public func encode(to encoder: Encoder) throws {
107
        var container = encoder.container(keyedBy: CodingKeys.self)
108
        
109
        switch self {
110
        case .willRun(let testEntries, let testContext):
111
            try container.encode(EventType.willRun, forKey: .eventType)
112
            try container.encode(testEntries, forKey: .testEntries)
113
            try container.encode(testContext, forKey: .testContext)
114
        case .didRun(let results, let testContext):
115
            try container.encode(EventType.didRun, forKey: .eventType)
116
            try container.encode(results, forKey: .results)
117
            try container.encode(testContext, forKey: .testContext)
118
        case .testStarted(let testEntry, let testContext):
119
            try container.encode(EventType.testStarted, forKey: .eventType)
120
            try container.encode(testEntry, forKey: .testEntry)
121
            try container.encode(testContext, forKey: .testContext)
122
        case .testFinished(let testEntry, let succeeded, let testContext):
123
            try container.encode(EventType.testFinished, forKey: .eventType)
124
            try container.encode(testEntry, forKey: .testEntry)
125
            try container.encode(succeeded, forKey: .succeeded)
126
            try container.encode(testContext, forKey: .testContext)
127
        }
128
    }
129
}
130