marshroute

1
import XCTest
2
@testable import Marshroute
3

4
final class AnimatingTransitionsHandler_TransitionAnimationsLauncherTests_BaseMasterDetailRouter: XCTestCase {
5

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