marshroute

1
import XCTest
2
@testable import Marshroute
3

4
final class NavigationTransitionsHandlerImpl_TransitionAnimationsLauncherTests_BaseMasterDetailRouter: XCTestCase {
5

6
    var sourceViewController: UIViewController!
7
    var targetViewController: UIViewController!
8
    var masterNavigationController: UINavigationController!
9
    var detailNavigationController: UINavigationController!
10
    
11
    var router: BaseMasterDetailRouter!
12
    
13
    override func setUp() {
14
        super.setUp()
15
        
16
        sourceViewController = UIViewController()
17
        targetViewController = UIViewController()
18
        
19
        masterNavigationController = UINavigationController()
20
        detailNavigationController = UINavigationController()
21
        
22
        let transitionIdGenerator = TransitionIdGeneratorImpl()
23
        let transitionId = transitionIdGenerator.generateNewTransitionId()
24
        
25
        let stackClientProvider = TransitionContextsStackClientProviderImpl()
26
        
27
        let peekAndPopTransitionsCoordinator = PeekAndPopUtilityImpl()
28
        
29
        let transitionsCoordinator = TransitionsCoordinatorImpl(
30
            stackClientProvider: stackClientProvider,
31
            peekAndPopTransitionsCoordinator: peekAndPopTransitionsCoordinator
32
        )
33
        
34
        let masterNavigationTransitionsHandler = NavigationTransitionsHandlerImpl(
35
            navigationController: masterNavigationController,
36
            transitionsCoordinator: transitionsCoordinator
37
        )
38
        
39
        let setMasterRootViewControllerContext = ResettingTransitionContext(
40
            settingRootViewController: sourceViewController,
41
            forNavigationController: masterNavigationController,
42
            navigationTransitionsHandler: masterNavigationTransitionsHandler,
43
            animator: SetNavigationTransitionsAnimator(),
44
            transitionId: transitionId
45
        )
46
        
47
        // set root view controller for a master navigation controller
48
        masterNavigationTransitionsHandler.resetWithTransition(context: setMasterRootViewControllerContext)
49
        
50
        let detailNavigationTransitionsHandler = NavigationTransitionsHandlerImpl(
51
            navigationController: detailNavigationController,
52
            transitionsCoordinator: transitionsCoordinator
53
        )
54
        
55
        let setDetailRootViewControllerContext = ResettingTransitionContext(
56
            settingRootViewController: sourceViewController,
57
            forNavigationController: detailNavigationController,
58
            navigationTransitionsHandler: detailNavigationTransitionsHandler,
59
            animator: SetNavigationTransitionsAnimator(),
60
            transitionId: transitionId
61
        )
62
        
63
        // set root view controller for a detail navigation controller
64
        detailNavigationTransitionsHandler.resetWithTransition(context: setDetailRootViewControllerContext)
65
        
66
        router = BaseMasterDetailRouter(
67
            routerSeed: MasterDetailRouterSeed(
68
                masterTransitionsHandlerBox: .init(
69
                    animatingTransitionsHandler: masterNavigationTransitionsHandler
70
                ),
71
                detailTransitionsHandlerBox: .init(
72
                    animatingTransitionsHandler: detailNavigationTransitionsHandler
73
                ),
74
                transitionId: transitionIdGenerator.generateNewTransitionId(),
75
                presentingTransitionsHandler: nil,
76
                transitionsHandlersProvider: transitionsCoordinator,
77
                transitionIdGenerator: transitionIdGenerator,
78
                controllersProvider: RouterControllersProviderImpl(),
79
                routerTransitionDelegate: nil
80
            )
81
        )
82
    }
83
    
84
    // MARK: - TransitionAnimationsLauncher
85
    
86
    // MARK: MasterRouter
87
    func testThatAnimatorIsCalledWithCorectResettingAnimationContextOn_SetMasterViewControllerDerivedFrom() {
88
        // Given
89
        let resetNavigationTransitionsAnimatorSpy = ResetNavigationTransitionsAnimatorSpy()
90
        
91
        // When
92
        router.setMasterViewControllerDerivedFrom( { (_) -> UIViewController in
93
            return targetViewController
94
            }, animator: resetNavigationTransitionsAnimatorSpy
95
        )
96
        
97
        // Then
98
        if case .called(let animationContext) = resetNavigationTransitionsAnimatorSpy.animateResetting! {
99
            XCTAssert(animationContext.rootViewController === targetViewController)
100
        } else { XCTFail() }
101
    }
102
    
103
    func testThatAnimatorIsCalledWithCorectPresentationAnimationContextOn_PushMasterViewControllerDerivedFrom() {
104
        // Given
105
        let navigationTransitionsAnimator = NavigationTransitionsAnimatorSpy()
106
        
107
        // When
108
        router.pushMasterViewControllerDerivedFrom( { (_) -> UIViewController in
109
            return targetViewController
110
            }, animator: navigationTransitionsAnimator
111
        )
112
        
113
        // Then
114
        if case .called(let animationContext) = navigationTransitionsAnimator.animatePerforming! {
115
            XCTAssert(animationContext.sourceViewController === sourceViewController)
116
            XCTAssert(animationContext.targetViewController === targetViewController)
117
        } else { XCTFail() }
118
    }
119
    
120
    func testThatAnimatorIsCalledWithCorectResettingAnimationContextOn_SetDetailViewControllerDerivedFrom() {
121
        // Given
122
        let resetNavigationTransitionsAnimatorSpy = ResetNavigationTransitionsAnimatorSpy()
123
        
124
        // When
125
        router.setDetailViewControllerDerivedFrom( { (_) -> UIViewController in
126
            return targetViewController
127
            }, animator: resetNavigationTransitionsAnimatorSpy
128
        )
129
        
130
        // Then
131
        if case .called(let animationContext) = resetNavigationTransitionsAnimatorSpy.animateResetting! {
132
            XCTAssert(animationContext.rootViewController === targetViewController)
133
        } else { XCTFail() }
134
    }
135
    
136
    func testThatAnimatorIsCalledWithCorectPresentationAnimationContextOn_PushDetailViewControllerDerivedFrom() {
137
        // Given
138
        let navigationTransitionsAnimator = NavigationTransitionsAnimatorSpy()
139
        
140
        // When
141
        router.pushDetailViewControllerDerivedFrom( { (_) -> UIViewController in
142
            return targetViewController
143
            }, animator: navigationTransitionsAnimator
144
        )
145
        
146
        // Then
147
        if case .called(let animationContext) = navigationTransitionsAnimator.animatePerforming! {
148
            XCTAssert(animationContext.sourceViewController === sourceViewController)
149
            XCTAssert(animationContext.targetViewController === targetViewController)
150
        } else { XCTFail() }
151
    }
152
    
153
    // MARK: EndpointRouter
154
    
155
    func testThatAnimatorIsCalledWithCorectPresentationAnimationContextOn_PresentModalEndpointNavigationController() {
156
        // Given
157
        let targetNavigationController = UINavigationController()
158
        let modalEndpointNavigationTransitionsAnimator = ModalEndpointNavigationTransitionsAnimatorSpy()
159
        
160
        // When
161
        router.presentModalEndpointNavigationController(
162
            targetNavigationController,
163
            animator: modalEndpointNavigationTransitionsAnimator
164
        ) { _ in }
165
        
166
        // Then
167
        if case .called(let animationContext) = modalEndpointNavigationTransitionsAnimator.animatePerforming! {
168
            XCTAssert(animationContext.sourceViewController === sourceViewController)
169
            XCTAssert(animationContext.targetNavigationController === targetNavigationController)
170
        } else { XCTFail() }
171
    }
172
    
173
    // MARK: ModalPresentationRouter
174
    
175
    func testThatAnimatorIsCalledWithCorectPresentationAnimationContextOn_PresentModalViewControllerDerivedFrom() {
176
        // Given
177
        let modalTransitionsAnimator = ModalTransitionsAnimatorSpy()
178
        
179
        // When
180
        router.presentModalViewControllerDerivedFrom( { (_) -> UIViewController in
181
            return targetViewController
182
            }, animator: modalTransitionsAnimator
183
        )
184
        
185
        // Then
186
        if case .called(let animationContext) = modalTransitionsAnimator.animatePerforming! {
187
            XCTAssert(animationContext.sourceViewController === sourceViewController)
188
            XCTAssert(animationContext.targetViewController === targetViewController)
189
        } else { XCTFail() }
190
    }
191
    
192
    func testThatAnimatorIsCalledWithCorectPresentationAnimationContextOn_PresentModalMasterDetailViewControllerDerivedFrom() {
193
        // Given
194
        let modalMasterDetailTransitionsAnimator = ModalMasterDetailTransitionsAnimatorSpy()
195
        
196
        // When
197
        router.presentModalMasterDetailViewControllerDerivedFrom(
198
            deriveMasterViewController: { (_) -> UIViewController in
199
                return UIViewController()
200
            },
201
            deriveDetailViewController: { (_) -> UIViewController in
202
                return UIViewController()
203
            },
204
            animator: modalMasterDetailTransitionsAnimator
205
        )
206
        
207
        // Then
208
        if case .called(let animationContext) = modalMasterDetailTransitionsAnimator.animatePerforming! {
209
            XCTAssert(animationContext.sourceViewController === sourceViewController)
210
        } else { XCTFail() }
211
    }
212
    
213
    func testThatAnimatorIsCalledWithCorectPresentationAnimationContextOn_PresentModalMasterDetailViewControllerDerivedFrom_IfCustomCustomMasterNavigationController_CustomDetailNavigationController_CustomSplitViewController() {
214
        // Given
215
        let modalMasterDetailTransitionsAnimator = ModalMasterDetailTransitionsAnimatorSpy()
216
        let splitViewController = UISplitViewController()
217
        
218
        // When
219
        router.presentModalMasterDetailViewControllerDerivedFrom(
220
            deriveMasterViewController: { (_) -> UIViewController in
221
                return UIViewController()
222
            },
223
            deriveDetailViewController: { (_) -> UIViewController in
224
                return UIViewController()
225
            },
226
            animator: modalMasterDetailTransitionsAnimator,
227
            masterNavigationController: UINavigationController(),
228
            detailNavigationController: UINavigationController(),
229
            splitViewController: splitViewController
230
        )
231
        
232
        // Then
233
        if case .called(let animationContext) = modalMasterDetailTransitionsAnimator.animatePerforming! {
234
            XCTAssert(animationContext.sourceViewController === sourceViewController)
235
            XCTAssert(animationContext.targetViewController === splitViewController)
236
        } else { XCTFail() }
237
    }
238
    
239
    func testThatAnimatorIsCalledWithCorectPresentationAnimationContextOn_PresentModalNavigationControllerWithRootViewControllerDerivedFrom() {
240
        // Given
241
        let modalNavigationTransitionsAnimator = ModalNavigationTransitionsAnimatorSpy()
242
        
243
        // When
244
        router.presentModalNavigationControllerWithRootViewControllerDerivedFrom( { (_) -> UIViewController in
245
            return targetViewController
246
            }, animator: modalNavigationTransitionsAnimator
247
        )
248
        
249
        // Then
250
        if case .called(let animationContext) = modalNavigationTransitionsAnimator.animatePerforming! {
251
            XCTAssert(animationContext.sourceViewController === sourceViewController)
252
            XCTAssert(animationContext.targetViewController === targetViewController)
253
        } else { XCTFail() }
254
    }
255
    
256
    func testThatAnimatorIsCalledWithCorectPresentationAnimationContextOn_PresentModalNavigationControllerWithRootViewControllerDerivedFrom_IfCustomNavigationController() {
257
        // Given
258
        let navigationController = UINavigationController()
259
        let modalNavigationTransitionsAnimator = ModalNavigationTransitionsAnimatorSpy()
260
        
261
        // When
262
        router.presentModalNavigationControllerWithRootViewControllerDerivedFrom( { (_) -> UIViewController in
263
            return targetViewController
264
            }, animator: modalNavigationTransitionsAnimator,
265
               navigationController: navigationController
266
        )
267
        
268
        // Then
269
        if case .called(let animationContext) = modalNavigationTransitionsAnimator.animatePerforming! {
270
            XCTAssert(animationContext.sourceViewController === sourceViewController)
271
            XCTAssert(animationContext.targetViewController === targetViewController)
272
            XCTAssert(animationContext.targetNavigationController === navigationController)
273
        } else { XCTFail() }
274
    }
275
    
276
    // MARK: PopoverPresentationRouter
277
    
278
    func testThatAnimatorIsCalledWithCorectPresentationAnimationContextOn_PresentPopoverFromRect() {
279
        guard UIDevice.current.userInterfaceIdiom == .pad
280
            else { return }
281
        
282
        // Given
283
        let rect = CGRect(x: 0, y: 1, width: 2, height: 3)
284
        let view = UIView()
285
        let popoverTransitionsAnimator = PopoverTransitionsAnimatorSpy()
286
        
287
        // When
288
        router.presentPopoverFromRect(
289
            rect,
290
            inView: view,
291
            withViewControllerDerivedFrom: { (_) -> UIViewController in
292
                return targetViewController
293
            },
294
            animator: popoverTransitionsAnimator
295
        )
296
        
297
        // Then
298
        if case .called(let animationContext) = popoverTransitionsAnimator.animatePerforming! {
299
            XCTAssert(animationContext.sourceViewController === sourceViewController)
300
            XCTAssert(animationContext.targetViewController === targetViewController)
301
            if case .popoverFromView(let sourceView, let sourceRect) = animationContext.transitionStyle {
302
                XCTAssertEqual(sourceRect, rect)
303
                XCTAssertEqual(sourceView, view)
304
            } else { XCTFail() }
305
        } else { XCTFail() }
306
    }
307
    
308
    func testThatAnimatorIsCalledWithCorectPresentationAnimationContextOn_PresentPopoverFromBarButtonItem() {
309
        guard UIDevice.current.userInterfaceIdiom == .pad
310
            else { return }
311
        
312
        // Given
313
        let barButtonItem = UIBarButtonItem()
314
        let popoverTransitionsAnimator = PopoverTransitionsAnimatorSpy()
315
        
316
        // When
317
        router.presentPopoverFromBarButtonItem(
318
            barButtonItem,
319
            withViewControllerDerivedFrom: { (_) -> UIViewController in
320
                return targetViewController
321
            },
322
            animator: popoverTransitionsAnimator
323
            )
324
        
325
        // Then
326
        if case .called(let animationContext) = popoverTransitionsAnimator.animatePerforming! {
327
            XCTAssert(animationContext.sourceViewController === sourceViewController)
328
            XCTAssert(animationContext.targetViewController === targetViewController)
329
            if case .popoverFromBarButtonItem(let buttonItem) = animationContext.transitionStyle {
330
                XCTAssert(buttonItem === barButtonItem)
331
            } else { XCTFail() }
332
        } else { XCTFail() }
333
    }
334
    
335
    func testThatAnimatorIsCalledWithCorectPresentationAnimationContextOn_PresentPopoverWithNavigationControllerFromRect() {
336
        guard UIDevice.current.userInterfaceIdiom == .pad
337
            else { return }
338
        
339
        // Given
340
        let rect = CGRect(x: 0, y: 1, width: 2, height: 3)
341
        let view = UIView()
342
        let popoverNavigationTransitionsAnimator = PopoverNavigationTransitionsAnimatorSpy()
343
        
344
        // When
345
        router.presentPopoverWithNavigationControllerFromRect(
346
            rect,
347
            inView: view,
348
            withViewControllerDerivedFrom: { (_) -> UIViewController in
349
                return targetViewController
350
            },
351
            animator: popoverNavigationTransitionsAnimator
352
        )
353
        
354
        // Then
355
        if case .called(let animationContext) = popoverNavigationTransitionsAnimator.animatePerforming! {
356
            XCTAssert(animationContext.sourceViewController === sourceViewController)
357
            XCTAssert(animationContext.targetViewController === targetViewController)
358
            if case .popoverFromView(let sourceView, let sourceRect) = animationContext.transitionStyle {
359
                XCTAssertEqual(sourceRect, rect)
360
                XCTAssertEqual(sourceView, view)
361
            } else { XCTFail() }
362
        } else { XCTFail() }
363
    }
364
    
365
    func testThatAnimatorIsCalledWithCorectPresentationAnimationContextOn_PresentPopoverWithNavigationControllerFromRect_IfCustomNavigationController() {
366
        guard UIDevice.current.userInterfaceIdiom == .pad
367
            else { return }
368
        
369
        // Given
370
        let rect = CGRect(x: 0, y: 1, width: 2, height: 3)
371
        let view = UIView()
372
        let navigationController = UINavigationController()
373
        let popoverNavigationTransitionsAnimator = PopoverNavigationTransitionsAnimatorSpy()
374
        
375
        // When
376
        router.presentPopoverWithNavigationControllerFromRect(
377
            rect,
378
            inView: view,
379
            withViewControllerDerivedFrom: { (_) -> UIViewController in
380
                return targetViewController
381
            },
382
            animator: popoverNavigationTransitionsAnimator,
383
            navigationController: navigationController
384
        )
385
        
386
        // Then
387
        if case .called(let animationContext) = popoverNavigationTransitionsAnimator.animatePerforming! {
388
            XCTAssert(animationContext.sourceViewController === sourceViewController)
389
            XCTAssert(animationContext.targetViewController === targetViewController)
390
            XCTAssert(animationContext.targetNavigationController === navigationController)
391
            if case .popoverFromView(let sourceView, let sourceRect) = animationContext.transitionStyle {
392
                XCTAssertEqual(sourceRect, rect)
393
                XCTAssertEqual(sourceView, view)
394
            } else { XCTFail() }
395
        } else { XCTFail() }
396
    }
397
    
398
    func testThatAnimatorIsCalledWithCorectPresentationAnimationContextOn_PresentPopoverWithNavigationControllerFromBarButtonItem() {
399
        guard UIDevice.current.userInterfaceIdiom == .pad
400
            else { return }
401
        
402
        // Given
403
        let barButtonItem = UIBarButtonItem()
404
        let popoverNavigationTransitionsAnimator = PopoverNavigationTransitionsAnimatorSpy()
405
        
406
        // When
407
        router.presentPopoverWithNavigationControllerFromBarButtonItem(
408
            barButtonItem,
409
            withViewControllerDerivedFrom: { (_) -> UIViewController in
410
                return targetViewController
411
            },
412
            animator: popoverNavigationTransitionsAnimator
413
        )
414
        
415
        // Then
416
        if case .called(let animationContext) = popoverNavigationTransitionsAnimator.animatePerforming! {
417
            XCTAssert(animationContext.sourceViewController === sourceViewController)
418
            XCTAssert(animationContext.targetViewController === targetViewController)
419
            if case .popoverFromBarButtonItem(let buttonItem) = animationContext.transitionStyle {
420
                XCTAssert(buttonItem === barButtonItem)
421
            } else { XCTFail() }
422
        } else { XCTFail() }
423
    }
424
    
425
    func testThatAnimatorIsCalledWithCorectPresentationAnimationContextOn_PresentPopoverWithNavigationControllerFromBarButtonItem_IfCustomnavigationController() {
426
        guard UIDevice.current.userInterfaceIdiom == .pad
427
            else { return }
428
        
429
        // Given
430
        let barButtonItem = UIBarButtonItem()
431
        let navigationController = UINavigationController()
432
        let popoverNavigationTransitionsAnimator = PopoverNavigationTransitionsAnimatorSpy()
433
        
434
        // When
435
        router.presentPopoverWithNavigationControllerFromBarButtonItem(
436
            barButtonItem,
437
            withViewControllerDerivedFrom: { (_) -> UIViewController in
438
                return targetViewController
439
            },
440
            animator: popoverNavigationTransitionsAnimator,
441
            navigationController: navigationController
442
        )
443
        
444
        // Then
445
        if case .called(let animationContext) = popoverNavigationTransitionsAnimator.animatePerforming! {
446
            XCTAssert(animationContext.sourceViewController === sourceViewController)
447
            XCTAssert(animationContext.targetViewController === targetViewController)
448
            XCTAssert(animationContext.targetNavigationController === navigationController)
449
            if case .popoverFromBarButtonItem(let buttonItem) = animationContext.transitionStyle {
450
                XCTAssert(buttonItem === barButtonItem)
451
            } else { XCTFail() }
452
        } else { XCTFail() }
453
    }
454
}
455