/
avito.tech
/
marshroute
GigaCode
beta
ОбзорЦентр заботыВойти

marshroute

Форк
0
Ветки: 19Коммиты: 508Теги: 28
marshroute
/MarshrouteTests
/Sources
/Routers
/PopoverPresentationRouterTests
/
PopoverPresentationRouterTests_BaseMasterDetailRouter.swift 
402 строки · 20.6 Кб
1
import XCTest
2
@testable import Marshroute
3


4
final class PopoverPresentationRouterTests_BaseMasterDetailRouter: XCTestCase
5
{
6
    var masterAnimatingTransitionsHandlerSpy: AnimatingTransitionsHandlerSpy!
7
    var router: PopoverPresentationRouter!
8
    
9
    let rect = CGRect(x: 0, y: 1, width: 2, height: 3)
10
    let view = UIView()
11
    let barButtonItem = UIBarButtonItem()
12
    
13
    override func setUp() {
14
        super.setUp()
15
        
16
        let transitionIdGenerator = TransitionIdGeneratorImpl()
17
        
18
        let peekAndPopTransitionsCoordinator = PeekAndPopUtilityImpl()
19
        
20
        let transitionsCoordinator = TransitionsCoordinatorImpl(
21
            stackClientProvider: TransitionContextsStackClientProviderImpl(),
22
            peekAndPopTransitionsCoordinator: peekAndPopTransitionsCoordinator
23
        )
24
        
25
        masterAnimatingTransitionsHandlerSpy = AnimatingTransitionsHandlerSpy(
26
            transitionsCoordinator: transitionsCoordinator
27
        )
28
        
29
        router = BaseMasterDetailRouter(
30
            routerSeed: MasterDetailRouterSeed(
31
                masterTransitionsHandlerBox: .init(
32
                    animatingTransitionsHandler: masterAnimatingTransitionsHandlerSpy
33
                ),
34
                detailTransitionsHandlerBox: .init(
35
                    animatingTransitionsHandler: AnimatingTransitionsHandlerSpy(
36
                        transitionsCoordinator: transitionsCoordinator
37
                    )
38
                ),
39
                transitionId: transitionIdGenerator.generateNewTransitionId(),
40
                presentingTransitionsHandler: nil,
41
                transitionsHandlersProvider: transitionsCoordinator,
42
                transitionIdGenerator: transitionIdGenerator,
43
                controllersProvider: RouterControllersProviderImpl(),
44
                routerTransitionDelegate: nil
45
            )
46
        )
47
    }
48


49
    // MARK: - UIViewController in UIPopoverController
50
    
51
    func testThatMasterDetailRouterCallsItsMasterTransitionsHandlerOn_presentPopoverFromRect_WithCorrectPresentationContext() {
52
        guard UIDevice.current.userInterfaceIdiom == .pad
53
            else { return }
54
        
55
        // Given
56
        let targetViewController = UIViewController()
57
        var nextModuleRouterSeed: RouterSeed!
58
        
59
        // When
60
        router.presentPopoverFromRect(rect, inView: view) { (routerSeed) -> UIViewController in
61
            nextModuleRouterSeed = routerSeed
62
            return targetViewController
63
        }
64
        
65
        // Then
66
        XCTAssert(masterAnimatingTransitionsHandlerSpy.performTransitionCalled)
67
        
68
        let presentationContext = masterAnimatingTransitionsHandlerSpy.perFormTransitionContextParameter
69
        XCTAssertEqual(presentationContext?.transitionId, nextModuleRouterSeed.transitionId)
70
        XCTAssert(presentationContext?.targetViewController === targetViewController)
71
        if case .some(.animating) = presentationContext?.targetTransitionsHandlerBox {} else { XCTFail() }
72
        XCTAssert(presentationContext?.storableParameters! is PopoverTransitionStorableParameters)
73
        if case .some(.popover(let launchingContext)) = presentationContext?.presentationAnimationLaunchingContextBox {
74
            if case .popoverFromView(let sourceView, let sourceRect) = launchingContext.transitionStyle {
75
                XCTAssertEqual(sourceRect, rect)
76
                XCTAssertEqual(sourceView, view)
77
            } else { XCTFail() }
78
            XCTAssert(launchingContext.targetViewController! === targetViewController)
79
        } else { XCTFail() }
80
    }
81
    
82
    func testThatMasterDetailRouterCallsItsMasterTransitionsHandlerOn_PresentPopoverFromRect_WithCorrectPresentationContext_IfCustomAnimator() {
83
        guard UIDevice.current.userInterfaceIdiom == .pad
84
            else { return }
85
        
86
        // Given
87
        let targetViewController = UIViewController()
88
        var nextModuleRouterSeed: RouterSeed!
89
        let popoverTransitionsAnimator = PopoverTransitionsAnimator()
90
        
91
        // When
92
        router.presentPopoverFromRect(
93
            rect,
94
            inView: view,
95
            withViewControllerDerivedFrom: { (routerSeed) -> UIViewController in
96
                nextModuleRouterSeed = routerSeed
97
                return targetViewController
98
            },
99
            animator: popoverTransitionsAnimator
100
        )
101
        
102
        // Then
103
        XCTAssert(masterAnimatingTransitionsHandlerSpy.performTransitionCalled)
104
        
105
        let presentationContext = masterAnimatingTransitionsHandlerSpy.perFormTransitionContextParameter
106
        XCTAssertEqual(presentationContext?.transitionId, nextModuleRouterSeed.transitionId)
107
        XCTAssert(presentationContext?.targetViewController === targetViewController)
108
        if case .some(.animating) = presentationContext?.targetTransitionsHandlerBox {} else { XCTFail() }
109
        XCTAssert(presentationContext?.storableParameters! is PopoverTransitionStorableParameters)
110
        if case .some(.popover(let launchingContext)) = presentationContext?.presentationAnimationLaunchingContextBox {
111
            if case .popoverFromView(let sourceView, let sourceRect) = launchingContext.transitionStyle {
112
                XCTAssertEqual(sourceRect, rect)
113
                XCTAssertEqual(sourceView, view)
114
            } else { XCTFail() }
115
            XCTAssert(launchingContext.animator === popoverTransitionsAnimator)
116
            XCTAssert(launchingContext.targetViewController! === targetViewController)
117
        } else { XCTFail() }
118
    }
119
    
120
    func testThatMasterDetailRouterCallsItsMasterTransitionsHandlerOn_presentPopoverFromBarButtonItem_WithCorrectPresentationContext() {
121
        guard UIDevice.current.userInterfaceIdiom == .pad
122
            else { return }
123
        
124
        // Given
125
        let targetViewController = UIViewController()
126
        var nextModuleRouterSeed: RouterSeed!
127
        
128
        // When
129
        router.presentPopoverFromBarButtonItem(barButtonItem) { (routerSeed) -> UIViewController in
130
            nextModuleRouterSeed = routerSeed
131
            return targetViewController
132
        }
133
        
134
        // Then
135
        XCTAssert(masterAnimatingTransitionsHandlerSpy.performTransitionCalled)
136
        
137
        let presentationContext = masterAnimatingTransitionsHandlerSpy.perFormTransitionContextParameter
138
        XCTAssertEqual(presentationContext?.transitionId, nextModuleRouterSeed.transitionId)
139
        XCTAssert(presentationContext?.targetViewController === targetViewController)
140
        if case .some(.animating) = presentationContext?.targetTransitionsHandlerBox {} else { XCTFail() }
141
        XCTAssert(presentationContext?.storableParameters! is PopoverTransitionStorableParameters)
142
        if case .some(.popover(let launchingContext)) = presentationContext?.presentationAnimationLaunchingContextBox {
143
            if case .popoverFromBarButtonItem(let buttonItem) = launchingContext.transitionStyle {
144
                XCTAssert(buttonItem === barButtonItem)
145
            } else { XCTFail() }
146
            XCTAssert(launchingContext.targetViewController! === targetViewController)
147
        } else { XCTFail() }
148
    }
149
    
150
    func testThatMasterDetailRouterCallsItsMasterTransitionsHandlerOn_presentPopoverFromBarButtonItem_WithCorrectPresentationContext_IfCustomAnimator() {
151
        guard UIDevice.current.userInterfaceIdiom == .pad
152
            else { return }
153
        
154
        // Given
155
        let targetViewController = UIViewController()
156
        var nextModuleRouterSeed: RouterSeed!
157
        let popoverTransitionsAnimator = PopoverTransitionsAnimator()
158
        
159
        // When
160
        router.presentPopoverFromBarButtonItem(
161
            barButtonItem,
162
            withViewControllerDerivedFrom: { (routerSeed) -> UIViewController in
163
                nextModuleRouterSeed = routerSeed
164
                return targetViewController
165
            },
166
            animator: popoverTransitionsAnimator
167
        )
168
        
169
        // Then
170
        XCTAssert(masterAnimatingTransitionsHandlerSpy.performTransitionCalled)
171
        
172
        let presentationContext = masterAnimatingTransitionsHandlerSpy.perFormTransitionContextParameter
173
        XCTAssertEqual(presentationContext?.transitionId, nextModuleRouterSeed.transitionId)
174
        XCTAssert(presentationContext?.targetViewController === targetViewController)
175
        if case .some(.animating) = presentationContext?.targetTransitionsHandlerBox {} else { XCTFail() }
176
        XCTAssert(presentationContext?.storableParameters! is PopoverTransitionStorableParameters)
177
        if case .some(.popover(let launchingContext)) = presentationContext?.presentationAnimationLaunchingContextBox {
178
            if case .popoverFromBarButtonItem(let buttonItem) = launchingContext.transitionStyle {
179
                XCTAssert(buttonItem === barButtonItem)
180
            } else { XCTFail() }
181
            XCTAssert(launchingContext.animator === popoverTransitionsAnimator)
182
            XCTAssert(launchingContext.targetViewController! === targetViewController)
183
        } else { XCTFail() }
184
    }
185
    
186
    // MARK: - UIViewController in UINavigationController in UIPopoverController
187
    
188
    func testThatMasterDetailRouterCallsItsMasterTransitionsHandlerOn_presentPopoverWithNavigationControllerFromRect_WithCorrectPresentationContext() {
189
        guard UIDevice.current.userInterfaceIdiom == .pad
190
            else { return }
191
        
192
        // Given
193
        let targetViewController = UIViewController()
194
        var nextModuleRouterSeed: RouterSeed!
195
        
196
        // When
197
        router.presentPopoverWithNavigationControllerFromRect(rect, inView: view) { (routerSeed) -> UIViewController in
198
            nextModuleRouterSeed = routerSeed
199
            return targetViewController
200
        }
201
        
202
        // Then
203
        XCTAssert(masterAnimatingTransitionsHandlerSpy.performTransitionCalled)
204
        
205
        let presentationContext = masterAnimatingTransitionsHandlerSpy.perFormTransitionContextParameter
206
        XCTAssertEqual(presentationContext?.transitionId, nextModuleRouterSeed.transitionId)
207
        XCTAssert(presentationContext?.targetViewController === targetViewController)
208
        if case .some(.animating) = presentationContext?.targetTransitionsHandlerBox {} else { XCTFail() }
209
        XCTAssert(presentationContext?.storableParameters! is PopoverTransitionStorableParameters)
210
        if case .some(.popoverNavigation(let launchingContext)) = presentationContext?.presentationAnimationLaunchingContextBox {
211
            if case .popoverFromView(let sourceView, let sourceRect) = launchingContext.transitionStyle {
212
                XCTAssertEqual(sourceRect, rect)
213
                XCTAssertEqual(sourceView, view)
214
            } else { XCTFail() }
215
            XCTAssert(launchingContext.targetViewController! === targetViewController)
216
        } else { XCTFail() }
217
    }
218
    
219
    func testThatMasterDetailRouterCallsItsMasterTransitionsHandlerOn_PresentPopoverWithNavigationControllerFromRect_WithCorrectPresentationContext_IfCustomAnimator() {
220
        guard UIDevice.current.userInterfaceIdiom == .pad
221
            else { return }
222
        
223
        // Given
224
        let targetViewController = UIViewController()
225
        var nextModuleRouterSeed: RouterSeed!
226
        let popoverNavigationTransitionsAnimator = PopoverNavigationTransitionsAnimator()
227
        
228
        // When
229
        router.presentPopoverWithNavigationControllerFromRect(
230
            rect,
231
            inView: view,
232
            withViewControllerDerivedFrom: { (routerSeed) -> UIViewController in
233
                nextModuleRouterSeed = routerSeed
234
                return targetViewController
235
            },
236
            animator: popoverNavigationTransitionsAnimator
237
        )
238
        
239
        // Then
240
        XCTAssert(masterAnimatingTransitionsHandlerSpy.performTransitionCalled)
241
        
242
        let presentationContext = masterAnimatingTransitionsHandlerSpy.perFormTransitionContextParameter
243
        XCTAssertEqual(presentationContext?.transitionId, nextModuleRouterSeed.transitionId)
244
        XCTAssert(presentationContext?.targetViewController === targetViewController)
245
        if case .some(.animating) = presentationContext?.targetTransitionsHandlerBox {} else { XCTFail() }
246
        XCTAssert(presentationContext?.storableParameters! is PopoverTransitionStorableParameters)
247
        if case .some(.popoverNavigation(let launchingContext)) = presentationContext?.presentationAnimationLaunchingContextBox {
248
            if case .popoverFromView(let sourceView, let sourceRect) = launchingContext.transitionStyle {
249
                XCTAssertEqual(sourceRect, rect)
250
                XCTAssertEqual(sourceView, view)
251
            } else { XCTFail() }
252
            XCTAssert(launchingContext.animator === popoverNavigationTransitionsAnimator)
253
            XCTAssert(launchingContext.targetViewController! === targetViewController)
254
        } else { XCTFail() }
255
    }
256
    
257
    func testThatMasterDetailRouterCallsItsMasterTransitionsHandlerOn_PresentPopoverWithNavigationControllerFromRect_WithCorrectPresentationContext_IfCustomAnimator_CustomNavigationController() {
258
        guard UIDevice.current.userInterfaceIdiom == .pad
259
            else { return }
260
        
261
        // Given
262
        let targetViewController = UIViewController()
263
        let navigationController = UINavigationController()
264
        var nextModuleRouterSeed: RouterSeed!
265
        let popoverNavigationTransitionsAnimator = PopoverNavigationTransitionsAnimator()
266
        
267
        // When
268
        router.presentPopoverWithNavigationControllerFromRect(
269
            rect,
270
            inView: view,
271
            withViewControllerDerivedFrom: { (routerSeed) -> UIViewController in
272
                nextModuleRouterSeed = routerSeed
273
                return targetViewController
274
            },
275
            animator: popoverNavigationTransitionsAnimator,
276
            navigationController: navigationController
277
        )
278
        
279
        // Then
280
        XCTAssert(masterAnimatingTransitionsHandlerSpy.performTransitionCalled)
281
        
282
        let presentationContext = masterAnimatingTransitionsHandlerSpy.perFormTransitionContextParameter
283
        XCTAssertEqual(presentationContext?.transitionId, nextModuleRouterSeed.transitionId)
284
        XCTAssert(presentationContext?.targetViewController === targetViewController)
285
        if case .some(.animating) = presentationContext?.targetTransitionsHandlerBox {} else { XCTFail() }
286
        XCTAssert(presentationContext?.storableParameters! is PopoverTransitionStorableParameters)
287
        if case .some(.popoverNavigation(let launchingContext)) = presentationContext?.presentationAnimationLaunchingContextBox {
288
            if case .popoverFromView(let sourceView, let sourceRect) = launchingContext.transitionStyle {
289
                XCTAssertEqual(sourceRect, rect)
290
                XCTAssertEqual(sourceView, view)
291
            } else { XCTFail() }
292
            XCTAssert(launchingContext.animator === popoverNavigationTransitionsAnimator)
293
            XCTAssert(launchingContext.targetViewController! === targetViewController)
294
            XCTAssert(launchingContext.targetNavigationController! === navigationController)
295
        } else { XCTFail() }
296
    }
297
    
298
    func testThatMasterDetailRouterCallsItsMasterTransitionsHandlerOn_presentPopoverWithNavigationControllerFromBarButtonItem_WithCorrectPresentationContext() {
299
        guard UIDevice.current.userInterfaceIdiom == .pad
300
            else { return }
301
        
302
        // Given
303
        let targetViewController = UIViewController()
304
        var nextModuleRouterSeed: RouterSeed!
305
        
306
        // When
307
        router.presentPopoverWithNavigationControllerFromBarButtonItem(barButtonItem) { (routerSeed) -> UIViewController in
308
            nextModuleRouterSeed = routerSeed
309
            return targetViewController
310
        }
311
        
312
        // Then
313
        XCTAssert(masterAnimatingTransitionsHandlerSpy.performTransitionCalled)
314
        
315
        let presentationContext = masterAnimatingTransitionsHandlerSpy.perFormTransitionContextParameter
316
        XCTAssertEqual(presentationContext?.transitionId, nextModuleRouterSeed.transitionId)
317
        XCTAssert(presentationContext?.targetViewController === targetViewController)
318
        if case .some(.animating) = presentationContext?.targetTransitionsHandlerBox {} else { XCTFail() }
319
        XCTAssert(presentationContext?.storableParameters! is PopoverTransitionStorableParameters)
320
        if case .some(.popoverNavigation(let launchingContext)) = presentationContext?.presentationAnimationLaunchingContextBox {
321
            if case .popoverFromBarButtonItem(let buttonItem) = launchingContext.transitionStyle {
322
                XCTAssert(buttonItem === barButtonItem)
323
            } else { XCTFail() }
324
            XCTAssert(launchingContext.targetViewController! === targetViewController)
325
        } else { XCTFail() }
326
    }
327
    
328
    func testThatMasterDetailRouterCallsItsMasterTransitionsHandlerOn_presentPopoverWithNavigationControllerFromBarButtonItem_WithCorrectPresentationContext_IfCustomAnimator() {
329
        guard UIDevice.current.userInterfaceIdiom == .pad
330
            else { return }
331
        
332
        // Given
333
        let targetViewController = UIViewController()
334
        var nextModuleRouterSeed: RouterSeed!
335
        let popoverNavigationTransitionsAnimator = PopoverNavigationTransitionsAnimator()
336
        
337
        // When
338
        router.presentPopoverWithNavigationControllerFromBarButtonItem(
339
            barButtonItem,
340
            withViewControllerDerivedFrom: { (routerSeed) -> UIViewController in
341
                nextModuleRouterSeed = routerSeed
342
                return targetViewController
343
            },
344
            animator: popoverNavigationTransitionsAnimator
345
        )
346
        
347
        // Then
348
        XCTAssert(masterAnimatingTransitionsHandlerSpy.performTransitionCalled)
349
        
350
        let presentationContext = masterAnimatingTransitionsHandlerSpy.perFormTransitionContextParameter
351
        XCTAssertEqual(presentationContext?.transitionId, nextModuleRouterSeed.transitionId)
352
        XCTAssert(presentationContext?.targetViewController === targetViewController)
353
        if case .some(.animating) = presentationContext?.targetTransitionsHandlerBox {} else { XCTFail() }
354
        XCTAssert(presentationContext?.storableParameters! is PopoverTransitionStorableParameters)
355
        if case .some(.popoverNavigation(let launchingContext)) = presentationContext?.presentationAnimationLaunchingContextBox {
356
            if case .popoverFromBarButtonItem(let buttonItem) = launchingContext.transitionStyle {
357
                XCTAssert(buttonItem === barButtonItem)
358
            } else { XCTFail() }
359
            XCTAssert(launchingContext.animator === popoverNavigationTransitionsAnimator)
360
            XCTAssert(launchingContext.targetViewController! === targetViewController)
361
        } else { XCTFail() }
362
    }
363
    
364
    func testThatMasterDetailRouterCallsItsMasterTransitionsHandlerOn_presentPopoverWithNavigationControllerFromBarButtonItem_WithCorrectPresentationContext_IfCustomAnimator_CustomNavigationController() {
365
        guard UIDevice.current.userInterfaceIdiom == .pad
366
            else { return }
367
        
368
        // Given
369
        let targetViewController = UIViewController()
370
        let navigationController = UINavigationController()
371
        var nextModuleRouterSeed: RouterSeed!
372
        let popoverNavigationTransitionsAnimator = PopoverNavigationTransitionsAnimator()
373
        
374
        // When
375
        router.presentPopoverWithNavigationControllerFromBarButtonItem(
376
            barButtonItem,
377
            withViewControllerDerivedFrom: { (routerSeed) -> UIViewController in
378
                nextModuleRouterSeed = routerSeed
379
                return targetViewController
380
            },
381
            animator: popoverNavigationTransitionsAnimator,
382
            navigationController: navigationController
383
        )
384
        
385
        // Then
386
        XCTAssert(masterAnimatingTransitionsHandlerSpy.performTransitionCalled)
387
        
388
        let presentationContext = masterAnimatingTransitionsHandlerSpy.perFormTransitionContextParameter
389
        XCTAssertEqual(presentationContext?.transitionId, nextModuleRouterSeed.transitionId)
390
        XCTAssert(presentationContext?.targetViewController === targetViewController)
391
        if case .some(.animating) = presentationContext?.targetTransitionsHandlerBox {} else { XCTFail() }
392
        XCTAssert(presentationContext?.storableParameters! is PopoverTransitionStorableParameters)
393
        if case .some(.popoverNavigation(let launchingContext)) = presentationContext?.presentationAnimationLaunchingContextBox {
394
            if case .popoverFromBarButtonItem(let buttonItem) = launchingContext.transitionStyle {
395
                XCTAssert(buttonItem === barButtonItem)
396
            } else { XCTFail() }
397
            XCTAssert(launchingContext.animator === popoverNavigationTransitionsAnimator)
398
            XCTAssert(launchingContext.targetViewController! === targetViewController)
399
            XCTAssert(launchingContext.targetNavigationController! === navigationController)
400
        } else { XCTFail() }
401
    }
402
}
403

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

Мы используем файлы cookie в соответствии с Политикой конфиденциальности и Политикой использования cookies.

Нажимая кнопку «Принимаю», Вы даете АО «СберТех» согласие на обработку Ваших персональных данных в целях совершенствования нашего веб-сайта и Сервиса GitVerse, а также повышения удобства их использования.

Запретить использование cookies Вы можете самостоятельно в настройках Вашего браузера.