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

marshroute

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


4
final class PopoverPresentationRouterTests_BaseRouter: XCTestCase
5
{
6
    var detailAnimatingTransitionsHandlerSpy: 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
        detailAnimatingTransitionsHandlerSpy = AnimatingTransitionsHandlerSpy(
26
            transitionsCoordinator: transitionsCoordinator
27
        )
28
        
29
        router = BaseRouter(
30
            routerSeed: RouterSeed(
31
                transitionsHandlerBox: .init(
32
                    animatingTransitionsHandler: detailAnimatingTransitionsHandlerSpy
33
                ),
34
                transitionId: transitionIdGenerator.generateNewTransitionId(),
35
                presentingTransitionsHandler: nil,
36
                transitionsHandlersProvider: transitionsCoordinator,
37
                transitionIdGenerator: transitionIdGenerator,
38
                controllersProvider: RouterControllersProviderImpl(),
39
                routerTransitionDelegate: nil
40
            )
41
        )
42
    }
43


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

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

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

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

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