marshroute

RouterFocusableTests.swift
286 строк · 13.6 Кб
Перенос по словам
1
import XCTest
2
@testable import Marshroute
3

4
final class RouterFocusableTests: XCTestCase
5
{
6
    var transitionId: TransitionId!
7
    var transitionIdGenerator: TransitionIdGenerator!
8
    var transitionsCoordinator: TransitionsCoordinatorImpl!
9
    
10
    var masterAnimatingTransitionsHandlerSpy: AnimatingTransitionsHandlerSpy!
11
    var detailAnimatingTransitionsHandlerSpy: AnimatingTransitionsHandlerSpy!
12
    var masterContainingTransitionsHandlerSpy: ContainingTransitionsHandlerSpy!
13
    var detailContainingTransitionsHandlerSpy: ContainingTransitionsHandlerSpy!
14
    
15
    var dummyPresentingTransitionsHandler: DummyAnimatingTransitionsHandler!
16
    
17
    override func setUp() {
18
        super.setUp()
19
        
20
        transitionIdGenerator = TransitionIdGeneratorImpl()
21
        transitionId = transitionIdGenerator.generateNewTransitionId()
22
        
23
        let peekAndPopTransitionsCoordinator = PeekAndPopUtilityImpl()
24
        
25
        transitionsCoordinator = TransitionsCoordinatorImpl(
26
            stackClientProvider: TransitionContextsStackClientProviderImpl(),
27
            peekAndPopTransitionsCoordinator: peekAndPopTransitionsCoordinator
28
        )
29
        
30
        masterAnimatingTransitionsHandlerSpy = AnimatingTransitionsHandlerSpy(
31
            transitionsCoordinator: transitionsCoordinator
32
        )
33
        
34
        detailAnimatingTransitionsHandlerSpy = AnimatingTransitionsHandlerSpy(
35
            transitionsCoordinator: transitionsCoordinator
36
        )
37
        
38
        masterContainingTransitionsHandlerSpy = ContainingTransitionsHandlerSpy(
39
            transitionsCoordinator: transitionsCoordinator
40
        )
41
        
42
        detailContainingTransitionsHandlerSpy = ContainingTransitionsHandlerSpy(
43
            transitionsCoordinator: transitionsCoordinator
44
        )
45
        
46
        dummyPresentingTransitionsHandler = DummyAnimatingTransitionsHandler()
47
    }
48

49
    // MARK: - BaseRouter
50
    
51
    func testThatNotRootRouterCallsItsTransitionsHandlerOn_FocusOnCurrentModule_IfItsTransitionHandlerIsAnimating() {
52
        // Given
53
        let router = BaseRouter( // Base Router
54
            routerSeed: RouterSeed(
55
                transitionsHandlerBox: .init(
56
                    animatingTransitionsHandler: masterAnimatingTransitionsHandlerSpy // Animating Transitions Handler
57
                ),
58
                transitionId: transitionId,
59
                presentingTransitionsHandler: dummyPresentingTransitionsHandler, // Not Root Router
60
                transitionsHandlersProvider: transitionsCoordinator,
61
                transitionIdGenerator: transitionIdGenerator,
62
                controllersProvider: RouterControllersProviderImpl(),
63
                routerTransitionDelegate: nil
64
            )
65
        )
66
        
67
        // When
68
        router.focusOnCurrentModule()
69
        
70
        // Then 
71
        XCTAssert(router.transitionsHandlerBox.unbox() === masterAnimatingTransitionsHandlerSpy)
72
        XCTAssert(router.presentingTransitionsHandler === dummyPresentingTransitionsHandler)
73
        
74
        XCTAssert(masterAnimatingTransitionsHandlerSpy.undoTransitionsAfterCalled)
75
        XCTAssertEqual(masterAnimatingTransitionsHandlerSpy.undoTransitionsAfterTransitionIdParameter, transitionId)
76
    }
77
    
78
    func testThatNotRootRouterCallsItsTransitionsHandlerOn_FocusOnCurrentModule_IfItsTransitionHandlerIsContaining() {
79
        // Given
80
        let router = BaseRouter( // Base Router
81
            routerSeed: RouterSeed(
82
                transitionsHandlerBox: .init(
83
                    containingTransitionsHandler: masterContainingTransitionsHandlerSpy // Containing Transitions Handler
84
                ),
85
                transitionId: transitionId,
86
                presentingTransitionsHandler: dummyPresentingTransitionsHandler, // Not Root Router
87
                transitionsHandlersProvider: transitionsCoordinator,
88
                transitionIdGenerator: transitionIdGenerator,
89
                controllersProvider: RouterControllersProviderImpl(),
90
                routerTransitionDelegate: nil
91
            )
92
        )
93
        
94
        // When
95
        router.focusOnCurrentModule()
96
        
97
        // Then
98
        XCTAssert(router.transitionsHandlerBox.unbox() === masterContainingTransitionsHandlerSpy)
99
        XCTAssert(router.presentingTransitionsHandler === dummyPresentingTransitionsHandler)
100
        
101
        XCTAssert(masterContainingTransitionsHandlerSpy.undoTransitionsAfterCalled)
102
        XCTAssertEqual(masterContainingTransitionsHandlerSpy.undoTransitionsAfterTransitionIdParameter, transitionId)
103
    }
104
    
105
    func testThatRootRouterCallsItsTransitionsHandlerOn_FocusOnCurrentModule_IfItsTransitionHandlerIsAnimating() {
106
        // Given
107
        let router = BaseRouter( // Router
108
            routerSeed: RouterSeed(
109
                transitionsHandlerBox: .init(
110
                    animatingTransitionsHandler: masterAnimatingTransitionsHandlerSpy  // Animating Transitions Handler
111
                ),
112
                transitionId: transitionId,
113
                presentingTransitionsHandler: nil, // Root Router
114
                transitionsHandlersProvider: transitionsCoordinator,
115
                transitionIdGenerator: transitionIdGenerator,
116
                controllersProvider: RouterControllersProviderImpl(),
117
                routerTransitionDelegate: nil
118
            )
119
        )
120
        
121
        // When
122
        router.focusOnCurrentModule()
123
        
124
        // Then
125
        XCTAssert(router.transitionsHandlerBox.unbox() === masterAnimatingTransitionsHandlerSpy)
126
        XCTAssertNil(router.presentingTransitionsHandler)
127
        
128
        XCTAssert(masterAnimatingTransitionsHandlerSpy.undoTransitionsAfterCalled)
129
        XCTAssertEqual(masterAnimatingTransitionsHandlerSpy.undoTransitionsAfterTransitionIdParameter, transitionId)
130
    }
131
    
132
    func testThatRootRouterDoesNotCallItsTransitionsHandlerOn_FocusOnCurrentModule_IfItsTransitionHandlerIsContaining() {
133
        // Given
134
        let router = BaseRouter( // Router
135
            routerSeed: RouterSeed(
136
                transitionsHandlerBox: .init(
137
                    containingTransitionsHandler: masterContainingTransitionsHandlerSpy // Containing Transitions Handler
138
                ),
139
                transitionId: transitionId,
140
                presentingTransitionsHandler: nil, // Root Router
141
                transitionsHandlersProvider: transitionsCoordinator,
142
                transitionIdGenerator: transitionIdGenerator,
143
                controllersProvider: RouterControllersProviderImpl(),
144
                routerTransitionDelegate: nil
145
            )
146
        )
147
        
148
        // When
149
        router.focusOnCurrentModule()
150
        
151
        // Then
152
        XCTAssert(router.transitionsHandlerBox.unbox() === masterContainingTransitionsHandlerSpy)
153
        XCTAssertNil(router.presentingTransitionsHandler)
154
        
155
        XCTAssertFalse(masterContainingTransitionsHandlerSpy.undoTransitionsAfterCalled)
156
    }
157
    
158
    // MARK: - BaseMasterDetailRouter
159
    
160
    func testThatNotRootMasterDetailRouterCallsItsMasterTransitionsHandlerOn_FocusOnCurrentModule_IfItsMasterTransitionHandlerIsAnimating() {
161
        // Given
162
        let masterDetailRouter = BaseMasterDetailRouter( // MasterDetail Router
163
            routerSeed: MasterDetailRouterSeed(
164
                masterTransitionsHandlerBox: .init(
165
                    animatingTransitionsHandler: masterAnimatingTransitionsHandlerSpy // Animating Master Transitions Handler
166
                ),
167
                detailTransitionsHandlerBox: .init(
168
                    animatingTransitionsHandler: detailAnimatingTransitionsHandlerSpy
169
                ),
170
                transitionId: transitionId,
171
                presentingTransitionsHandler: dummyPresentingTransitionsHandler, // Not Root Router
172
                transitionsHandlersProvider: transitionsCoordinator,
173
                transitionIdGenerator: transitionIdGenerator,
174
                controllersProvider: RouterControllersProviderImpl(),
175
                routerTransitionDelegate: nil
176
            )
177
        )
178
        
179
        // When
180
        masterDetailRouter.focusOnCurrentModule()
181
        
182
        // Then
183
        XCTAssert(masterDetailRouter.masterTransitionsHandlerBox.unbox() === masterAnimatingTransitionsHandlerSpy)
184
        XCTAssert(masterDetailRouter.detailTransitionsHandlerBox.unbox() === detailAnimatingTransitionsHandlerSpy)
185
        XCTAssert(masterDetailRouter.presentingTransitionsHandler === dummyPresentingTransitionsHandler)
186
        
187
        XCTAssert(masterAnimatingTransitionsHandlerSpy.undoTransitionsAfterCalled)
188
        XCTAssertEqual(masterAnimatingTransitionsHandlerSpy.undoTransitionsAfterTransitionIdParameter, transitionId)
189
        XCTAssertFalse(detailAnimatingTransitionsHandlerSpy.undoTransitionsAfterCalled)
190
    }
191
    
192
    func testThatNotRootMasterDetailRouterCallsItsMasterTransitionsHandlerOn_FocusOnCurrentModule_IfItsMasterTransitionHandlerIsContaining() {
193
        // Given
194
        let masterDetailRouter = BaseMasterDetailRouter( // MasterDetail Router
195
            routerSeed: MasterDetailRouterSeed(
196
                masterTransitionsHandlerBox: .init(
197
                    containingTransitionsHandler: masterContainingTransitionsHandlerSpy // Containing Master Transitions Handler
198
                ),
199
                detailTransitionsHandlerBox: .init(
200
                    containingTransitionsHandler: detailContainingTransitionsHandlerSpy
201
                ),
202
                transitionId: transitionId,
203
                presentingTransitionsHandler: dummyPresentingTransitionsHandler, // Not Root Router
204
                transitionsHandlersProvider: transitionsCoordinator,
205
                transitionIdGenerator: transitionIdGenerator,
206
                controllersProvider: RouterControllersProviderImpl(),
207
                routerTransitionDelegate: nil
208
            )
209
        )
210
        
211
        // When
212
        masterDetailRouter.focusOnCurrentModule()
213
        
214
        // Then
215
        XCTAssert(masterDetailRouter.masterTransitionsHandlerBox.unbox() === masterContainingTransitionsHandlerSpy)
216
        XCTAssert(masterDetailRouter.detailTransitionsHandlerBox.unbox() === detailContainingTransitionsHandlerSpy)
217
        XCTAssert(masterDetailRouter.presentingTransitionsHandler === dummyPresentingTransitionsHandler)
218
        
219
        XCTAssert(masterContainingTransitionsHandlerSpy.undoTransitionsAfterCalled)
220
        XCTAssertEqual(masterContainingTransitionsHandlerSpy.undoTransitionsAfterTransitionIdParameter, transitionId)
221
        XCTAssertFalse(detailContainingTransitionsHandlerSpy.undoTransitionsAfterCalled)
222
    }
223
    
224
    func testThatRootMasterDetailRouterCallsItsMasterTransitionsHandlerOn_FocusOnCurrentModule_IfItsMasterTransitionHandlerIsAnimating() {
225
        // Given
226
        let masterDetailRouter = BaseMasterDetailRouter( // MasterDetail Router
227
            routerSeed: MasterDetailRouterSeed(
228
                masterTransitionsHandlerBox: .init(
229
                    animatingTransitionsHandler: masterAnimatingTransitionsHandlerSpy // Animating Master Transitions Handler
230
                ),
231
                detailTransitionsHandlerBox: .init(
232
                    animatingTransitionsHandler: detailAnimatingTransitionsHandlerSpy
233
                ),
234
                transitionId: transitionId,
235
                presentingTransitionsHandler: nil, // Root Router
236
                transitionsHandlersProvider: transitionsCoordinator,
237
                transitionIdGenerator: transitionIdGenerator,
238
                controllersProvider: RouterControllersProviderImpl(),
239
                routerTransitionDelegate: nil
240
            )
241
        )
242
        
243
        // When
244
        masterDetailRouter.focusOnCurrentModule()
245
        
246
        // Then
247
        XCTAssert(masterDetailRouter.masterTransitionsHandlerBox.unbox() === masterAnimatingTransitionsHandlerSpy)
248
        XCTAssert(masterDetailRouter.detailTransitionsHandlerBox.unbox() === detailAnimatingTransitionsHandlerSpy)
249
        XCTAssertNil(masterDetailRouter.presentingTransitionsHandler)
250
        
251
        XCTAssert(masterAnimatingTransitionsHandlerSpy.undoTransitionsAfterCalled)
252
        XCTAssertEqual(masterAnimatingTransitionsHandlerSpy.undoTransitionsAfterTransitionIdParameter, transitionId)
253
        XCTAssertFalse(detailAnimatingTransitionsHandlerSpy.undoTransitionsAfterCalled)
254
    }
255
    
256
    func testThatRootMasterDetailRouterDoesNotCallItsMasterTransitionsHandlerOn_FocusOnCurrentModule_IfItsMasterTransitionHandlerIsContaining() {
257
        // Given
258
        let masterDetailRouter = BaseMasterDetailRouter( // MasterDetail Router
259
            routerSeed: MasterDetailRouterSeed(
260
                masterTransitionsHandlerBox: .init(
261
                    containingTransitionsHandler: masterContainingTransitionsHandlerSpy // Containing Master Transitions Handler
262
                ),
263
                detailTransitionsHandlerBox: .init(
264
                    containingTransitionsHandler: detailContainingTransitionsHandlerSpy
265
                ),
266
                transitionId: transitionId,
267
                presentingTransitionsHandler: nil, // Root Router
268
                transitionsHandlersProvider: transitionsCoordinator,
269
                transitionIdGenerator: transitionIdGenerator,
270
                controllersProvider: RouterControllersProviderImpl(),
271
                routerTransitionDelegate: nil
272
            )
273
        )
274
        
275
        // When
276
        masterDetailRouter.focusOnCurrentModule()
277
        
278
        // Then
279
        XCTAssert(masterDetailRouter.masterTransitionsHandlerBox.unbox() === masterContainingTransitionsHandlerSpy)
280
        XCTAssert(masterDetailRouter.detailTransitionsHandlerBox.unbox() === detailContainingTransitionsHandlerSpy)
281
        XCTAssertNil(masterDetailRouter.presentingTransitionsHandler)
282
        
283
        XCTAssertFalse(masterContainingTransitionsHandlerSpy.undoTransitionsAfterCalled)
284
        XCTAssertFalse(detailContainingTransitionsHandlerSpy.undoTransitionsAfterCalled)
285
    }
286
}
287
marshroute

Использование cookies
