Emcee

1
import BalancingBucketQueue
2
import BucketQueue
3
import BucketQueueModels
4
import BucketQueueTestHelpers
5
import CommonTestModelsTestHelpers
6
import Foundation
7
import QueueModels
8
import QueueModelsTestHelpers
9
import TestHelpers
10
import XCTest
11

12
final class MultipleQueuesBucketResultAcceptorTests: XCTestCase {
13
    private lazy var bucketResultAcceptorProvider = FakeBucketResultAcceptorProvider()
14
    private lazy var multipleQueuesContainer = MultipleQueuesContainer()
15
    private lazy var multipleQueuesBucketResultAcceptor = MultipleQueuesBucketResultAcceptor(
16
        bucketResultAcceptorProvider: bucketResultAcceptorProvider,
17
        multipleQueuesContainer: multipleQueuesContainer
18
    )
19
    private lazy var workerId = WorkerId("worker")
20
    
21
    func test___accepting_results___rethrows___if_accepter_throws() {
22
        bucketResultAcceptorProvider.resultProvider = { _, _, _ in
23
            throw ErrorForTestingPurposes()
24
        }
25
        
26
        assertThrows {
27
            _ = try multipleQueuesBucketResultAcceptor.accept(
28
                bucketId: "bucket_id",
29
                bucketResult: .testingResult(
30
                    TestingResultFixtures().testingResult()
31
                ),
32
                workerId: workerId
33
            )
34
        }
35
    }
36
    
37
    
38
    func test___accepting_results___in_running_job___does_not_throw___if_accepter_does_not_throw() {
39
        let jobQueue = createJobQueue()
40
        multipleQueuesContainer.add(runningJobQueue: jobQueue)
41
        
42
        let acceptanceRoutineInvoked = XCTestExpectation()
43

44
        bucketResultAcceptorProvider.resultProvider = { bucketId, bucketResult, workerId in
45
            assertTrue { workerId == self.workerId }
46
            
47
            acceptanceRoutineInvoked.fulfill()
48
            
49
            return BucketQueueAcceptResult(
50
                dequeuedBucket: DequeuedBucket(
51
                    enqueuedBucket: EnqueuedBucket(
52
                        bucket: BucketFixtures().with(bucketId: "bucket_id").bucket(),
53
                        enqueueTimestamp: Date(),
54
                        uniqueIdentifier: "doesnotmatter"
55
                    ),
56
                    workerId: self.workerId
57
                ),
58
                bucketResultToCollect: bucketResult
59
            )
60
        }
61
        
62
        assertDoesNotThrow {
63
            _ = try multipleQueuesBucketResultAcceptor.accept(
64
                bucketId: "bucket_id",
65
                bucketResult: .testingResult(TestingResultFixtures().testingResult()),
66
                workerId: workerId
67
            )
68
        }
69
                
70
        wait(for: [acceptanceRoutineInvoked], timeout: 15)
71
    }
72
    
73
    
74
    func test___accepting_results___in_deleted_job___does_not_throw___if_accepter_does_not_throw() {
75
        let jobQueue = createJobQueue()
76
        multipleQueuesContainer.add(deletedJobQueues: [jobQueue])
77
        
78
        let acceptanceRoutineInvoked = XCTestExpectation()
79

80
        bucketResultAcceptorProvider.resultProvider = { bucketId, bucketResult, workerId in
81
            assertTrue { workerId == self.workerId }
82
            
83
            acceptanceRoutineInvoked.fulfill()
84
            
85
            return BucketQueueAcceptResult(
86
                dequeuedBucket: DequeuedBucket(
87
                    enqueuedBucket: EnqueuedBucket(
88
                        bucket: BucketFixtures().with(bucketId: "bucket_id").bucket(),
89
                        enqueueTimestamp: Date(),
90
                        uniqueIdentifier: "doesnotmatter"
91
                    ),
92
                    workerId: self.workerId
93
                ),
94
                bucketResultToCollect: bucketResult
95
            )
96
        }
97
        
98
        assertDoesNotThrow {
99
            _ = try multipleQueuesBucketResultAcceptor.accept(
100
                bucketId: "bucket_id",
101
                bucketResult: .testingResult(TestingResultFixtures().testingResult()),
102
                workerId: workerId
103
            )
104
        }
105
                
106
        wait(for: [acceptanceRoutineInvoked], timeout: 15)
107
    }
108
    
109
    func test___accepting_unknown_bucket___throws() {
110
        assertThrows {
111
            _ = try multipleQueuesBucketResultAcceptor.accept(
112
                bucketId: "bucket_id",
113
                bucketResult: .testingResult(TestingResultFixtures().testingResult()),
114
                workerId: "worker"
115
            )
116
        }
117
    }
118
}
119

120