Fixes #317 - Adopt a split layout for iPad and Mac apps

Rename navigation components: SplitScreenCoordinator -> NavigationSplitCoordinator, StackScreenCoordinator -> NavigationStackCoordinator and SingleScreenCoordinator -> NavigationRootCoordinator
[0c161039] Tweak navigation logging
[826c19cf] Move the navigation dismissal callbacks to the NavigationModule, add SingleScreenCoordinator tests
[b8830d9c] Add tests
[252ad119] Merge the StackScreenCoordinator and SplitScreenCoordinators into a single file and stop publicly exposing their internal workings. Add more documentation.
[37671699] Cleanup navigation logging
[51406184] Use the parent SplitScreenCoordinator to present embedded StackScreenCoordinator sheets
[b94b04c9] Retract the room "syncing" indicator when dismissing a room
[1467b0ac] Correctly move to the no room selected state when popping in compact layouts
[10bf2ad8] Allow nilling root coordinators, replace present/dismiss sheet with setSheetCoordinator(?)
[33716784] Add single screen coordinator fade transition animation
[3cbe65e7] Prevent the timeline table view from being reused between different rooms
[9c94c50b] Move files around
[c10b6bc5] Adapt the user session state machine to the split layout
[7115a319] Fix unit and UI tests
[1ece59e8] Fix login flows
[6884dc3b] Use modules everywhere the underlying object is a NavigationModule
[ab08d44c] Rename navigation components to: SingleScreenCoordinator, SplitScreenCoordinator and StackScreenCoordinator
[ada2be57] Add SplitNavigationController

* Remove the navigationRootCoordinator from the UserSessionFlowCoordinator
This commit is contained in:
Stefan Ceriu
2022-12-12 12:31:27 +02:00
committed by GitHub
parent 5ef53e9220
commit cd40da6c3f
22 changed files with 1407 additions and 541 deletions
@@ -1,221 +0,0 @@
//
// Copyright 2022 New Vector Ltd
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
import XCTest
@testable import ElementX
@MainActor
class NavigationControllerTests: XCTestCase {
private var navigationController: NavigationController!
override func setUp() {
navigationController = NavigationController()
}
func testRoot() {
let rootCoordinator = SomeTestCoordinator()
navigationController.setRootCoordinator(rootCoordinator)
assertCoordinatorsEqual(rootCoordinator, navigationController.rootCoordinator)
}
func testSingleSheet() {
let rootCoordinator = SomeTestCoordinator()
navigationController.setRootCoordinator(rootCoordinator)
let coordinator = SomeTestCoordinator()
navigationController.presentSheet(coordinator)
assertCoordinatorsEqual(rootCoordinator, navigationController.rootCoordinator)
assertCoordinatorsEqual(coordinator, navigationController.sheetCoordinator)
navigationController.dismissSheet()
assertCoordinatorsEqual(rootCoordinator, navigationController.rootCoordinator)
XCTAssertNil(navigationController.sheetCoordinator)
}
func testMultipleSheets() {
let rootCoordinator = SomeTestCoordinator()
navigationController.setRootCoordinator(rootCoordinator)
let sheetCoordinator = SomeTestCoordinator()
navigationController.presentSheet(sheetCoordinator)
assertCoordinatorsEqual(rootCoordinator, navigationController.rootCoordinator)
XCTAssert(navigationController.coordinators.isEmpty)
assertCoordinatorsEqual(sheetCoordinator, navigationController.sheetCoordinator)
let someOtherSheetCoordinator = SomeTestCoordinator()
navigationController.presentSheet(someOtherSheetCoordinator)
assertCoordinatorsEqual(rootCoordinator, navigationController.rootCoordinator)
XCTAssert(navigationController.coordinators.isEmpty)
assertCoordinatorsEqual(someOtherSheetCoordinator, navigationController.sheetCoordinator)
}
func testSinglePush() {
let rootCoordinator = SomeTestCoordinator()
navigationController.setRootCoordinator(rootCoordinator)
let coordinator = SomeTestCoordinator()
navigationController.push(coordinator)
assertCoordinatorsEqual(rootCoordinator, navigationController.rootCoordinator)
assertCoordinatorsEqual(coordinator, navigationController.coordinators.first)
navigationController.pop()
assertCoordinatorsEqual(rootCoordinator, navigationController.rootCoordinator)
XCTAssert(navigationController.coordinators.isEmpty)
}
func testMultiplePushes() {
let rootCoordinator = SomeTestCoordinator()
navigationController.setRootCoordinator(rootCoordinator)
var coordinators = [CoordinatorProtocol]()
for _ in 0...10 {
let coordinator = SomeTestCoordinator()
coordinators.append(coordinator)
navigationController.push(coordinator)
}
assertCoordinatorsEqual(rootCoordinator, navigationController.rootCoordinator)
XCTAssertEqual(navigationController.coordinators.count, coordinators.count)
for index in coordinators.indices {
assertCoordinatorsEqual(coordinators[index], navigationController.coordinators[index])
}
navigationController.popToRoot()
assertCoordinatorsEqual(rootCoordinator, navigationController.rootCoordinator)
XCTAssert(navigationController.coordinators.isEmpty)
}
func testRootReplacementDimissesTheRest() {
let rootCoordinator = SomeTestCoordinator()
navigationController.setRootCoordinator(rootCoordinator)
let sheetCoordinator = SomeTestCoordinator()
navigationController.presentSheet(sheetCoordinator)
let pushedCoordinator = SomeTestCoordinator()
navigationController.push(pushedCoordinator)
assertCoordinatorsEqual(rootCoordinator, navigationController.rootCoordinator)
assertCoordinatorsEqual(pushedCoordinator, navigationController.coordinators.first)
assertCoordinatorsEqual(sheetCoordinator, navigationController.sheetCoordinator)
let newRootCoordinator = SomeTestCoordinator()
navigationController.setRootCoordinator(newRootCoordinator)
assertCoordinatorsEqual(newRootCoordinator, navigationController.rootCoordinator)
XCTAssert(navigationController.coordinators.isEmpty)
XCTAssertNil(navigationController.sheetCoordinator)
}
func testPushesDontReplaceSheet() {
let sheetCoordinator = SomeTestCoordinator()
navigationController.presentSheet(sheetCoordinator)
let pushedCoordinator = SomeTestCoordinator()
navigationController.push(pushedCoordinator)
assertCoordinatorsEqual(pushedCoordinator, navigationController.coordinators.first)
assertCoordinatorsEqual(sheetCoordinator, navigationController.sheetCoordinator)
let newlyPushedCoordinator = SomeTestCoordinator()
navigationController.push(newlyPushedCoordinator)
assertCoordinatorsEqual(pushedCoordinator, navigationController.coordinators.first)
assertCoordinatorsEqual(newlyPushedCoordinator, navigationController.coordinators.last)
assertCoordinatorsEqual(sheetCoordinator, navigationController.sheetCoordinator)
}
func testPopDismissalCallbacks() {
let pushedCoordinator = SomeTestCoordinator()
let expectation = expectation(description: "Wait for callback")
navigationController.push(pushedCoordinator) {
expectation.fulfill()
}
navigationController.pop()
waitForExpectations(timeout: 1.0)
}
func testPopToRootDismissalCallbacks() {
navigationController.push(SomeTestCoordinator())
navigationController.push(SomeTestCoordinator())
let coordinator = SomeTestCoordinator()
let expectation = expectation(description: "Wait for callback")
navigationController.push(coordinator) {
expectation.fulfill()
}
navigationController.popToRoot()
waitForExpectations(timeout: 1.0)
}
func testSheetDismissalCallbac() {
let coordinator = SomeTestCoordinator()
let expectation = expectation(description: "Wait for callback")
navigationController.presentSheet(coordinator) {
expectation.fulfill()
}
navigationController.dismissSheet()
waitForExpectations(timeout: 1.0)
}
func testRootReplacmeentCallbacks() {
navigationController.setRootCoordinator(SomeTestCoordinator())
let popExpectation = expectation(description: "Waiting for callback")
navigationController.push(SomeTestCoordinator()) {
popExpectation.fulfill()
}
let sheetExpectation = expectation(description: "Waiting for callback")
navigationController.presentSheet(SomeTestCoordinator()) {
sheetExpectation.fulfill()
}
navigationController.setRootCoordinator(SomeTestCoordinator())
waitForExpectations(timeout: 1.0)
}
// MARK: - Private
private func assertCoordinatorsEqual(_ lhs: CoordinatorProtocol?, _ rhs: CoordinatorProtocol?) {
guard let lhs = lhs as? SomeTestCoordinator,
let rhs = rhs as? SomeTestCoordinator else {
XCTFail("Coordinators are not the same")
return
}
XCTAssertEqual(lhs.id, rhs.id)
}
}
private struct SomeTestCoordinator: CoordinatorProtocol {
let id = UUID()
}
@@ -0,0 +1,72 @@
//
// Copyright 2022 New Vector Ltd
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
import XCTest
@testable import ElementX
@MainActor
class NavigationRootCoordinatorTests: XCTestCase {
private var navigationRootCoordinator: NavigationRootCoordinator!
override func setUp() {
navigationRootCoordinator = NavigationRootCoordinator()
}
func testRootChanges() {
XCTAssertNil(navigationRootCoordinator.rootCoordinator)
let firstRootCoordinator = SomeTestCoordinator()
navigationRootCoordinator.setRootCoordinator(firstRootCoordinator)
assertCoordinatorsEqual(firstRootCoordinator, navigationRootCoordinator.rootCoordinator)
let secondRootCoordinator = SomeTestCoordinator()
navigationRootCoordinator.setRootCoordinator(secondRootCoordinator)
assertCoordinatorsEqual(secondRootCoordinator, navigationRootCoordinator.rootCoordinator)
}
func testReplacementDismissalCallbacks() {
XCTAssertNil(navigationRootCoordinator.rootCoordinator)
let rootCoordinator = SomeTestCoordinator()
let expectation = expectation(description: "Wait for callback")
navigationRootCoordinator.setRootCoordinator(rootCoordinator) {
expectation.fulfill()
}
navigationRootCoordinator.setRootCoordinator(nil)
waitForExpectations(timeout: 1.0)
}
// MARK: - Private
private func assertCoordinatorsEqual(_ lhs: CoordinatorProtocol?, _ rhs: CoordinatorProtocol?) {
guard let lhs = lhs as? SomeTestCoordinator,
let rhs = rhs as? SomeTestCoordinator else {
XCTFail("Coordinators are not the same")
return
}
XCTAssertEqual(lhs.id, rhs.id)
}
}
private struct SomeTestCoordinator: CoordinatorProtocol {
let id = UUID()
}
@@ -0,0 +1,274 @@
//
// Copyright 2022 New Vector Ltd
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
import XCTest
@testable import ElementX
@MainActor
class NavigationSplitCoordinatorTests: XCTestCase {
private var navigationSplitCoordinator: NavigationSplitCoordinator!
override func setUp() {
navigationSplitCoordinator = NavigationSplitCoordinator(placeholderCoordinator: SomeTestCoordinator())
}
func testSidebar() {
XCTAssertNil(navigationSplitCoordinator.sidebarCoordinator)
XCTAssertNil(navigationSplitCoordinator.detailCoordinator)
let sidebarCoordinator = SomeTestCoordinator()
navigationSplitCoordinator.setSidebarCoordinator(sidebarCoordinator)
assertCoordinatorsEqual(sidebarCoordinator, navigationSplitCoordinator.sidebarCoordinator)
}
func testDetail() {
XCTAssertNil(navigationSplitCoordinator.sidebarCoordinator)
XCTAssertNil(navigationSplitCoordinator.detailCoordinator)
let detailCoordinator = SomeTestCoordinator()
navigationSplitCoordinator.setDetailCoordinator(detailCoordinator)
assertCoordinatorsEqual(detailCoordinator, navigationSplitCoordinator.detailCoordinator)
}
func testSidebarAndDetail() {
XCTAssertNil(navigationSplitCoordinator.sidebarCoordinator)
XCTAssertNil(navigationSplitCoordinator.detailCoordinator)
let sidebarCoordinator = SomeTestCoordinator()
navigationSplitCoordinator.setSidebarCoordinator(sidebarCoordinator)
let detailCoordinator = SomeTestCoordinator()
navigationSplitCoordinator.setDetailCoordinator(detailCoordinator)
assertCoordinatorsEqual(sidebarCoordinator, navigationSplitCoordinator.sidebarCoordinator)
assertCoordinatorsEqual(detailCoordinator, navigationSplitCoordinator.detailCoordinator)
}
func testSingleSheet() {
let sidebarCoordinator = SomeTestCoordinator()
navigationSplitCoordinator.setSidebarCoordinator(sidebarCoordinator)
let detailCoordinator = SomeTestCoordinator()
navigationSplitCoordinator.setDetailCoordinator(detailCoordinator)
let sheetCoordinator = SomeTestCoordinator()
navigationSplitCoordinator.setSheetCoordinator(sheetCoordinator)
assertCoordinatorsEqual(sidebarCoordinator, navigationSplitCoordinator.sidebarCoordinator)
assertCoordinatorsEqual(detailCoordinator, navigationSplitCoordinator.detailCoordinator)
assertCoordinatorsEqual(sheetCoordinator, navigationSplitCoordinator.sheetCoordinator)
navigationSplitCoordinator.setSheetCoordinator(nil)
assertCoordinatorsEqual(sidebarCoordinator, navigationSplitCoordinator.sidebarCoordinator)
assertCoordinatorsEqual(detailCoordinator, navigationSplitCoordinator.detailCoordinator)
XCTAssertNil(navigationSplitCoordinator.sheetCoordinator)
}
func testMultipleSheets() {
let sidebarCoordinator = SomeTestCoordinator()
navigationSplitCoordinator.setSidebarCoordinator(sidebarCoordinator)
let detailCoordinator = SomeTestCoordinator()
navigationSplitCoordinator.setDetailCoordinator(detailCoordinator)
let sheetCoordinator = SomeTestCoordinator()
navigationSplitCoordinator.setSheetCoordinator(sheetCoordinator)
assertCoordinatorsEqual(sidebarCoordinator, navigationSplitCoordinator.sidebarCoordinator)
assertCoordinatorsEqual(detailCoordinator, navigationSplitCoordinator.detailCoordinator)
assertCoordinatorsEqual(sheetCoordinator, navigationSplitCoordinator.sheetCoordinator)
let someOtherSheetCoordinator = SomeTestCoordinator()
navigationSplitCoordinator.setSheetCoordinator(someOtherSheetCoordinator)
assertCoordinatorsEqual(sidebarCoordinator, navigationSplitCoordinator.sidebarCoordinator)
assertCoordinatorsEqual(detailCoordinator, navigationSplitCoordinator.detailCoordinator)
assertCoordinatorsEqual(someOtherSheetCoordinator, navigationSplitCoordinator.sheetCoordinator)
}
func testSidebarReplacementCallbacks() {
let sidebarCoordinator = SomeTestCoordinator()
let expectation = expectation(description: "Wait for callback")
navigationSplitCoordinator.setSidebarCoordinator(sidebarCoordinator) {
expectation.fulfill()
}
navigationSplitCoordinator.setSidebarCoordinator(nil)
waitForExpectations(timeout: 1.0)
}
func testDetailReplacementCallbacks() {
let detailCoordinator = SomeTestCoordinator()
let expectation = expectation(description: "Wait for callback")
navigationSplitCoordinator.setDetailCoordinator(detailCoordinator) {
expectation.fulfill()
}
navigationSplitCoordinator.setDetailCoordinator(nil)
waitForExpectations(timeout: 1.0)
}
func testSheetDismissalCallback() {
let sheetCoordinator = SomeTestCoordinator()
let expectation = expectation(description: "Wait for callback")
navigationSplitCoordinator.setSheetCoordinator(sheetCoordinator) {
expectation.fulfill()
}
navigationSplitCoordinator.setSheetCoordinator(nil)
waitForExpectations(timeout: 1.0)
}
func testEmbeddedStackPresentsSheetThroughSplit() {
let sidebarNavigationStackCoordinator = NavigationStackCoordinator(navigationSplitCoordinator: navigationSplitCoordinator)
sidebarNavigationStackCoordinator.setRootCoordinator(SomeTestCoordinator())
let sheetCoordinator = SomeTestCoordinator()
sidebarNavigationStackCoordinator.setSheetCoordinator(sheetCoordinator)
navigationSplitCoordinator.setSidebarCoordinator(sidebarNavigationStackCoordinator)
assertCoordinatorsEqual(sheetCoordinator, sidebarNavigationStackCoordinator.sheetCoordinator)
assertCoordinatorsEqual(sheetCoordinator, navigationSplitCoordinator.sheetCoordinator)
}
func testSplitTracksEmbeddedStackRootChanges() {
let sidebarNavigationStackCoordinator = NavigationStackCoordinator(navigationSplitCoordinator: navigationSplitCoordinator)
sidebarNavigationStackCoordinator.setRootCoordinator(SomeTestCoordinator())
navigationSplitCoordinator.setSidebarCoordinator(sidebarNavigationStackCoordinator)
assertCoordinatorsEqual(sidebarNavigationStackCoordinator.rootCoordinator, navigationSplitCoordinator.compactLayoutRootCoordinator)
sidebarNavigationStackCoordinator.setRootCoordinator(SomeTestCoordinator())
let expectation = expectation(description: "Coordinators should match")
DispatchQueue.main.async {
self.assertCoordinatorsEqual(sidebarNavigationStackCoordinator.rootCoordinator, self.navigationSplitCoordinator.compactLayoutRootCoordinator)
expectation.fulfill()
}
waitForExpectations(timeout: 1.0)
}
func testSplitTracksEmbeddedStackChanges() {
let sidebarNavigationStackCoordinator = NavigationStackCoordinator(navigationSplitCoordinator: navigationSplitCoordinator)
sidebarNavigationStackCoordinator.setRootCoordinator(SomeTestCoordinator())
navigationSplitCoordinator.setSidebarCoordinator(sidebarNavigationStackCoordinator)
assertCoordinatorsEqual(sidebarNavigationStackCoordinator.rootCoordinator, navigationSplitCoordinator.compactLayoutRootCoordinator)
sidebarNavigationStackCoordinator.push(SomeTestCoordinator())
let expectation = expectation(description: "Coordinators should match")
DispatchQueue.main.async {
XCTAssertEqual(sidebarNavigationStackCoordinator.stackCoordinators.count, self.navigationSplitCoordinator.compactLayoutStackCoordinators.count)
for index in sidebarNavigationStackCoordinator.stackCoordinators.indices {
self.assertCoordinatorsEqual(sidebarNavigationStackCoordinator.stackCoordinators[index], self.navigationSplitCoordinator.compactLayoutStackCoordinators[index])
}
expectation.fulfill()
}
waitForExpectations(timeout: 1.0)
}
func testSplitPropagatesCompactStackChanges() {
let sidebarNavigationStackCoordinator = NavigationStackCoordinator(navigationSplitCoordinator: navigationSplitCoordinator)
sidebarNavigationStackCoordinator.setRootCoordinator(SomeTestCoordinator())
sidebarNavigationStackCoordinator.push(SomeTestCoordinator())
navigationSplitCoordinator.setSidebarCoordinator(sidebarNavigationStackCoordinator)
assertCoordinatorsEqual(sidebarNavigationStackCoordinator.rootCoordinator, navigationSplitCoordinator.compactLayoutRootCoordinator)
XCTAssertEqual(sidebarNavigationStackCoordinator.stackCoordinators.count, navigationSplitCoordinator.compactLayoutStackCoordinators.count)
navigationSplitCoordinator.compactLayoutStackModules.removeAll()
XCTAssertTrue(sidebarNavigationStackCoordinator.stackCoordinators.isEmpty)
}
func testCompactStackCreation() {
let sidebarCoordinator = NavigationStackCoordinator()
sidebarCoordinator.setRootCoordinator(SomeTestCoordinator())
sidebarCoordinator.push(SomeTestCoordinator())
let detailCoordinator = NavigationStackCoordinator()
detailCoordinator.setRootCoordinator(SomeTestCoordinator())
detailCoordinator.push(SomeTestCoordinator())
detailCoordinator.push(SomeTestCoordinator())
navigationSplitCoordinator.setSidebarCoordinator(sidebarCoordinator)
navigationSplitCoordinator.setDetailCoordinator(detailCoordinator)
let expectation = expectation(description: "Coordinators should match")
DispatchQueue.main.async {
self.assertCoordinatorsEqual(self.navigationSplitCoordinator.compactLayoutRootCoordinator, sidebarCoordinator.rootCoordinator)
self.assertCoordinatorsEqual(self.navigationSplitCoordinator.compactLayoutStackModules[0].coordinator, sidebarCoordinator.stackCoordinators.first)
self.assertCoordinatorsEqual(self.navigationSplitCoordinator.compactLayoutStackModules[1].coordinator, detailCoordinator.rootCoordinator)
self.assertCoordinatorsEqual(self.navigationSplitCoordinator.compactLayoutStackModules[2].coordinator, detailCoordinator.stackCoordinators.first)
self.assertCoordinatorsEqual(self.navigationSplitCoordinator.compactLayoutStackModules[3].coordinator, detailCoordinator.stackCoordinators.last)
expectation.fulfill()
}
waitForExpectations(timeout: 1.0)
}
func testRemovesDetailRootFromCompactStack() {
let sidebarCoordinator = NavigationStackCoordinator()
sidebarCoordinator.setRootCoordinator(SomeTestCoordinator())
let detailCoordinator = NavigationStackCoordinator()
detailCoordinator.setRootCoordinator(SomeTestCoordinator())
detailCoordinator.push(SomeTestCoordinator())
navigationSplitCoordinator.setSidebarCoordinator(sidebarCoordinator)
navigationSplitCoordinator.setDetailCoordinator(detailCoordinator)
let expectation = expectation(description: "Coordinators should match")
DispatchQueue.main.async {
self.assertCoordinatorsEqual(self.navigationSplitCoordinator.compactLayoutRootCoordinator, sidebarCoordinator.rootCoordinator)
self.assertCoordinatorsEqual(self.navigationSplitCoordinator.compactLayoutStackModules[0].coordinator, detailCoordinator.rootCoordinator)
self.assertCoordinatorsEqual(self.navigationSplitCoordinator.compactLayoutStackModules[1].coordinator, detailCoordinator.stackCoordinators.first)
detailCoordinator.setRootCoordinator(nil)
DispatchQueue.main.async {
self.assertCoordinatorsEqual(self.navigationSplitCoordinator.compactLayoutRootCoordinator, sidebarCoordinator.rootCoordinator)
self.assertCoordinatorsEqual(self.navigationSplitCoordinator.compactLayoutStackModules[0].coordinator, detailCoordinator.stackCoordinators.first)
}
expectation.fulfill()
}
waitForExpectations(timeout: 1.0)
}
// MARK: - Private
private func assertCoordinatorsEqual(_ lhs: CoordinatorProtocol?, _ rhs: CoordinatorProtocol?) {
guard let lhs = lhs as? SomeTestCoordinator,
let rhs = rhs as? SomeTestCoordinator else {
XCTFail("Coordinators are not the same")
return
}
XCTAssertEqual(lhs.id, rhs.id)
}
}
private struct SomeTestCoordinator: CoordinatorProtocol {
let id = UUID()
}
@@ -0,0 +1,217 @@
//
// Copyright 2022 New Vector Ltd
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
import XCTest
@testable import ElementX
@MainActor
class NavigationStackCoordinatorTests: XCTestCase {
private var navigationStackCoordinator: NavigationStackCoordinator!
override func setUp() {
navigationStackCoordinator = NavigationStackCoordinator()
}
func testRoot() {
XCTAssertNil(navigationStackCoordinator.rootCoordinator)
let rootCoordinator = SomeTestCoordinator()
navigationStackCoordinator.setRootCoordinator(rootCoordinator)
assertCoordinatorsEqual(rootCoordinator, navigationStackCoordinator.rootCoordinator)
}
func testSingleSheet() {
let rootCoordinator = SomeTestCoordinator()
navigationStackCoordinator.setRootCoordinator(rootCoordinator)
let coordinator = SomeTestCoordinator()
navigationStackCoordinator.setSheetCoordinator(coordinator)
assertCoordinatorsEqual(rootCoordinator, navigationStackCoordinator.rootCoordinator)
assertCoordinatorsEqual(coordinator, navigationStackCoordinator.sheetCoordinator)
navigationStackCoordinator.setSheetCoordinator(nil)
assertCoordinatorsEqual(rootCoordinator, navigationStackCoordinator.rootCoordinator)
XCTAssertNil(navigationStackCoordinator.sheetCoordinator)
}
func testMultipleSheets() {
let rootCoordinator = SomeTestCoordinator()
navigationStackCoordinator.setRootCoordinator(rootCoordinator)
let sheetCoordinator = SomeTestCoordinator()
navigationStackCoordinator.setSheetCoordinator(sheetCoordinator)
assertCoordinatorsEqual(rootCoordinator, navigationStackCoordinator.rootCoordinator)
XCTAssert(navigationStackCoordinator.stackCoordinators.isEmpty)
assertCoordinatorsEqual(sheetCoordinator, navigationStackCoordinator.sheetCoordinator)
let someOtherSheetCoordinator = SomeTestCoordinator()
navigationStackCoordinator.setSheetCoordinator(someOtherSheetCoordinator)
assertCoordinatorsEqual(rootCoordinator, navigationStackCoordinator.rootCoordinator)
XCTAssert(navigationStackCoordinator.stackCoordinators.isEmpty)
assertCoordinatorsEqual(someOtherSheetCoordinator, navigationStackCoordinator.sheetCoordinator)
}
func testSinglePush() {
let rootCoordinator = SomeTestCoordinator()
navigationStackCoordinator.setRootCoordinator(rootCoordinator)
let coordinator = SomeTestCoordinator()
navigationStackCoordinator.push(coordinator)
assertCoordinatorsEqual(rootCoordinator, navigationStackCoordinator.rootCoordinator)
assertCoordinatorsEqual(coordinator, navigationStackCoordinator.stackCoordinators.first)
navigationStackCoordinator.pop()
assertCoordinatorsEqual(rootCoordinator, navigationStackCoordinator.rootCoordinator)
XCTAssert(navigationStackCoordinator.stackCoordinators.isEmpty)
}
func testMultiplePushes() {
let rootCoordinator = SomeTestCoordinator()
navigationStackCoordinator.setRootCoordinator(rootCoordinator)
var coordinators = [CoordinatorProtocol]()
for _ in 0...10 {
let coordinator = SomeTestCoordinator()
coordinators.append(coordinator)
navigationStackCoordinator.push(coordinator)
}
assertCoordinatorsEqual(rootCoordinator, navigationStackCoordinator.rootCoordinator)
XCTAssertEqual(navigationStackCoordinator.stackCoordinators.count, coordinators.count)
for index in coordinators.indices {
assertCoordinatorsEqual(coordinators[index], navigationStackCoordinator.stackCoordinators[index])
}
navigationStackCoordinator.popToRoot()
assertCoordinatorsEqual(rootCoordinator, navigationStackCoordinator.rootCoordinator)
XCTAssert(navigationStackCoordinator.stackCoordinators.isEmpty)
}
func testRootReplacementDimissesTheRest() {
let rootCoordinator = SomeTestCoordinator()
navigationStackCoordinator.setRootCoordinator(rootCoordinator)
let sheetCoordinator = SomeTestCoordinator()
navigationStackCoordinator.setSheetCoordinator(sheetCoordinator)
let pushedCoordinator = SomeTestCoordinator()
navigationStackCoordinator.push(pushedCoordinator)
assertCoordinatorsEqual(rootCoordinator, navigationStackCoordinator.rootCoordinator)
assertCoordinatorsEqual(pushedCoordinator, navigationStackCoordinator.stackCoordinators.first)
assertCoordinatorsEqual(sheetCoordinator, navigationStackCoordinator.sheetCoordinator)
let newRootCoordinator = SomeTestCoordinator()
navigationStackCoordinator.setRootCoordinator(newRootCoordinator)
assertCoordinatorsEqual(newRootCoordinator, navigationStackCoordinator.rootCoordinator)
XCTAssert(navigationStackCoordinator.stackCoordinators.isEmpty)
}
func testPushesDontReplaceSheet() {
let sheetCoordinator = SomeTestCoordinator()
navigationStackCoordinator.setSheetCoordinator(sheetCoordinator)
let pushedCoordinator = SomeTestCoordinator()
navigationStackCoordinator.push(pushedCoordinator)
assertCoordinatorsEqual(pushedCoordinator, navigationStackCoordinator.stackCoordinators.first)
assertCoordinatorsEqual(sheetCoordinator, navigationStackCoordinator.sheetCoordinator)
let newlyPushedCoordinator = SomeTestCoordinator()
navigationStackCoordinator.push(newlyPushedCoordinator)
assertCoordinatorsEqual(pushedCoordinator, navigationStackCoordinator.stackCoordinators.first)
assertCoordinatorsEqual(newlyPushedCoordinator, navigationStackCoordinator.stackCoordinators.last)
assertCoordinatorsEqual(sheetCoordinator, navigationStackCoordinator.sheetCoordinator)
}
func testPopDismissalCallbacks() {
let pushedCoordinator = SomeTestCoordinator()
let expectation = expectation(description: "Wait for callback")
navigationStackCoordinator.push(pushedCoordinator) {
expectation.fulfill()
}
navigationStackCoordinator.pop()
waitForExpectations(timeout: 1.0)
}
func testPopToRootDismissalCallbacks() {
navigationStackCoordinator.push(SomeTestCoordinator())
navigationStackCoordinator.push(SomeTestCoordinator())
let coordinator = SomeTestCoordinator()
let expectation = expectation(description: "Wait for callback")
navigationStackCoordinator.push(coordinator) {
expectation.fulfill()
}
navigationStackCoordinator.popToRoot()
waitForExpectations(timeout: 1.0)
}
func testSheetDismissalCallback() {
let coordinator = SomeTestCoordinator()
let expectation = expectation(description: "Wait for callback")
navigationStackCoordinator.setSheetCoordinator(coordinator) {
expectation.fulfill()
}
navigationStackCoordinator.setSheetCoordinator(nil)
waitForExpectations(timeout: 1.0)
}
func testRootReplacementCallbacks() {
navigationStackCoordinator.setRootCoordinator(SomeTestCoordinator())
let popExpectation = expectation(description: "Waiting for callback")
navigationStackCoordinator.push(SomeTestCoordinator()) {
popExpectation.fulfill()
}
navigationStackCoordinator.setRootCoordinator(SomeTestCoordinator())
waitForExpectations(timeout: 1.0)
}
// MARK: - Private
private func assertCoordinatorsEqual(_ lhs: CoordinatorProtocol?, _ rhs: CoordinatorProtocol?) {
guard let lhs = lhs as? SomeTestCoordinator,
let rhs = rhs as? SomeTestCoordinator else {
XCTFail("Coordinators are not the same")
return
}
XCTAssertEqual(lhs.id, rhs.id)
}
}
private struct SomeTestCoordinator: CoordinatorProtocol {
let id = UUID()
}