marshroute

1
import XCTest
2
@testable import Marshroute
3

4
final class PeekAndPopUtilityImplTests_notifiesPeekAndPopStateObservers: BasePeekAndPopUtilityImplTestCase {    
5
    func testPeekAndPopUtility_notifiesPeekAndPopStateObservers_ifPeekGetsCommitedOnOnscreenRegisteredViewController() {
6
        // Given
7
        let expectation = self.expectation()
8
        expectation.expectedFulfillmentCount = 2
9
        
10
        bindSourceViewControllerToWindow()
11
        
12
        registerSourceViewControllerForPreviewing(
13
            onPeek: { _ in
14
                self.invokeTransitionToPeekViewController()
15
            }
16
        )
17
        
18
        var callbackCounter = 0
19

20
        subscribeForPeekAndPopStateChanges(
21
            onPeekAndPopStateChange: { viewController, peekAndPopState in
22
                callbackCounter += 1
23
                expectation.fulfill()
24
                
25
                if callbackCounter == 2 {
26
                    XCTAssert(viewController === self.peekViewController)
27
                    XCTAssert(peekAndPopState == .popped)
28
                }
29
            }
30
        )
31
        
32
        // When
33
        beginPeekOnRegisteredViewController()
34
        
35
        commitPickOnRegisteredViewController()
36
        
37
        // Then
38
        waitForExpectations(timeout: asyncTimeout)
39
    }
40
    
41
    func testPeekAndPopUtility_notifiesPeekAndPopStateObservers_ifPeekBeginsOnOnscreenRegisteredViewController() {
42
        // Given
43
        let expectation = self.expectation()
44
        
45
        bindSourceViewControllerToWindow()
46
        
47
        registerSourceViewControllerForPreviewing(
48
            onPeek: { _ in
49
                self.invokeTransitionToPeekViewController()
50
            }
51
        )
52
        
53
        subscribeForPeekAndPopStateChanges(
54
            onPeekAndPopStateChange: { viewController, peekAndPopState in
55
                XCTAssert(viewController === self.peekViewController)
56
                XCTAssert(peekAndPopState == .inPeek)
57
                expectation.fulfill()
58
            }
59
        )
60
        
61
        // When
62
        beginPeekOnRegisteredViewController()
63
        
64
        // Then
65
        waitForExpectations(timeout: asyncTimeout)
66
    }
67
    
68
    func testPeekAndPopUtility_notifiesPeekAndPopStateObservers_ifPeekGetsInterruptedWithAnotherTransitionOnOnscreenRegisteredViewController() {
69
        // Given
70
        let expectation = self.expectation()
71
        expectation.expectedFulfillmentCount = 2
72
        
73
        bindSourceViewControllerToWindow()
74
        
75
        registerSourceViewControllerForPreviewing(
76
            onPeek: { _ in
77
                self.invokeTransitionToPeekViewController()
78
            }
79
        )
80
        
81
        var callbackCounter = 0
82

83
        subscribeForPeekAndPopStateChanges(
84
            onPeekAndPopStateChange: { viewController, peekAndPopState in
85
                callbackCounter += 1
86
                expectation.fulfill()
87
                
88
                if callbackCounter == 2 {
89
                    XCTAssert(viewController === self.peekViewController)
90
                    XCTAssert(peekAndPopState == .interrupted)
91
                }
92
            }
93
        )
94
        
95
        // When
96
        beginPeekOnRegisteredViewController()
97
        
98
        interruptPeekWithAnotherTransitionOnRegisteredViewController()
99
        
100
        // Then
101
        waitForExpectations(timeout: asyncTimeout)
102
    }
103
    
104
    func testPeekAndPopUtility_notifiesPeekAndPopStateObservers_ifPeekGetsCommitedOnOnscreenRegisteredViewControllerWithNotPeekViewController() {
105
        // Given
106
        let expectation = self.expectation()
107
        expectation.expectedFulfillmentCount = 2
108
        
109
        bindSourceViewControllerToWindow()
110
        
111
        registerSourceViewControllerForPreviewing(
112
            onPeek: { _ in
113
                self.invokeTransitionToPeekViewController()
114
            }
115
        )
116
        
117
        var callbackCounter = 0
118
        
119
        subscribeForPeekAndPopStateChanges(
120
            onPeekAndPopStateChange: { viewController, peekAndPopState in
121
                callbackCounter += 1
122
                expectation.fulfill()
123
                
124
                if callbackCounter == 2 {
125
                    XCTAssert(viewController === self.peekViewController)
126
                    XCTAssert(peekAndPopState == .interrupted)
127
                }
128
            }
129
        )
130
        
131
        // When
132
        beginPeekOnRegisteredViewController()
133
        
134
        commitPickOnRegisteredViewControllerToNotPeekViewController()
135
        
136
        // Then
137
        waitForExpectations(timeout: asyncTimeout)
138
    }
139
    
140
    func testPeekAndPopUtility_notifiesNewPeekAndPopStateObserversImmediately_ifPeekIsInProgress() {
141
        // Given
142
        let expectation = self.expectation()
143
        
144
        bindSourceViewControllerToWindow()
145
        
146
        registerSourceViewControllerForPreviewing(
147
            onPeek: { _ in
148
                self.invokeTransitionToPeekViewController()
149
            }
150
        )
151
        
152
        // When
153
        beginPeekOnRegisteredViewController()
154
        
155
        subscribeForPeekAndPopStateChanges(
156
            onPeekAndPopStateChange: { viewController, peekAndPopState in
157
                XCTAssert(viewController === self.peekViewController)
158
                XCTAssert(peekAndPopState == .inPeek)
159
                
160
                expectation.fulfill()
161
            }
162
        )
163
        
164
        // Then
165
        waitForExpectations(timeout: asyncTimeout)
166
    }
167
    
168
    func testPeekAndPopUtility_notifiesNoPeekAndPopStateObservers_ifSomeTransitionOccursNotDuringActivePeek() {
169
        // Given
170
        let invertedExpectation = self.invertedExpectation()
171
        
172
        bindSourceViewControllerToWindow()
173
        
174
        registerSourceViewControllerForPreviewing()
175
        
176
        subscribeForPeekAndPopStateChanges(
177
            onPeekAndPopStateChange: { _, _ in
178
                invertedExpectation.fulfill()
179
            }
180
        )
181
        
182
        // When
183
        invokeTransitionToPeekViewController()
184
        
185
        // Then
186
        waitForExpectations(timeout: asyncTimeout)
187
    }
188
    
189
    func testPeekAndPopUtility_notifiesNoPeekAndPopStateObservers_ifPeekBeginsOnOffscreenRegisteredViewControllerAndSomeTransitionOccurs() {
190
        // Given
191
        let invertedExpectation = self.invertedExpectation()
192
        
193
        unbindSourceViewControllerFromWindow()
194
        
195
        registerSourceViewControllerForPreviewing()
196
        
197
        subscribeForPeekAndPopStateChanges(
198
            onPeekAndPopStateChange: { _, _ in
199
                invertedExpectation.fulfill()
200
            }
201
        )
202
        
203
        // When
204
        beginPeekOnRegisteredViewController()
205
        
206
        invokeTransitionToPeekViewController()
207
        
208
        // Then
209
        waitForExpectations(timeout: asyncTimeout)
210
    }
211
    
212
    func testPeekAndPopUtility_notifiesNoPeekAndPopStateObservers_ifPeekBeginsOnOnscreenRegisteredViewControllerWithNotNavigationParentViewController() {
213
        // Given
214
        let invertedExpectation = self.invertedExpectation()
215
        
216
        bindSourceViewControllerToWindow()
217
        
218
        bindPeekViewControllerToAnotherParent()
219
        
220
        registerSourceViewControllerForPreviewing(
221
            onPeek: { _ in
222
                self.invokeTransitionToPeekViewController()
223
            }
224
        )
225
        
226
        subscribeForPeekAndPopStateChanges(
227
            onPeekAndPopStateChange: { _, _ in
228
                invertedExpectation.fulfill()
229
            }
230
        )
231
        
232
        // When
233
        beginPeekOnRegisteredViewController()
234
        
235
        // Then
236
        waitForExpectations(timeout: asyncTimeout)
237
    }
238
}    
239