Hard code the room flow to a single room proxy. (#2599)

* Don't give the room flow a split coordinator any more.
2026-11-03 16:10:20 +00:00 · 2024-03-27 10:56:58 +00:00
parent e424a02a2b
commit 144f3a7fc4
11 changed files with 624 additions and 401 deletions
@@ -83,6 +83,34 @@ extension XCTestCase {
        return deferred
    }
    
+    /// XCTest utility that assists in subscribing to a publisher and deferring the failure for a particular value until some other actions have been performed.
+    /// - Parameters:
+    ///   - publisher: The publisher to wait on.
+    ///   - timeout: A timeout after which we give up.
+    ///   - message: An optional custom expectation message
+    ///   - until: callback that evaluates outputs until some condition is reached
+    /// - Returns: The deferred fulfilment to be executed after some actions. The publisher's result is not returned from this fulfilment.
+    func deferFailure<P: Publisher>(_ publisher: P,
+                                    timeout: TimeInterval,
+                                    message: String? = nil,
+                                    until condition: @escaping (P.Output) -> Bool) -> DeferredFulfillment<Void> where P.Failure == Never {
+        let expectation = expectation(description: message ?? "Awaiting publisher")
+        expectation.isInverted = true
+        var hasFulfilled = false
+        let cancellable = publisher
+            .sink { value in
+                if condition(value), !hasFulfilled {
+                    expectation.fulfill()
+                    hasFulfilled = true
+                }
+            }
+        
+        return DeferredFulfillment<Void> {
+            await self.fulfillment(of: [expectation], timeout: timeout)
+            cancellable.cancel()
+        }
+    }
+    
    struct DeferredFulfillment<T> {
        let closure: () async throws -> T
        @discardableResult func fulfill() async throws -> T {
@@ -38,86 +38,63 @@ class RoomFlowCoordinatorTests: XCTestCase {
        navigationStackCoordinator = NavigationStackCoordinator()
        navigationSplitCoordinator.setDetailCoordinator(navigationStackCoordinator)
        
-        roomFlowCoordinator = RoomFlowCoordinator(userSession: userSession,
-                                                  roomTimelineControllerFactory: MockRoomTimelineControllerFactory(),
-                                                  navigationStackCoordinator: navigationStackCoordinator,
-                                                  navigationSplitCoordinator: navigationSplitCoordinator,
-                                                  emojiProvider: EmojiProvider(),
-                                                  appSettings: ServiceLocator.shared.settings,
-                                                  analytics: ServiceLocator.shared.analytics,
-                                                  userIndicatorController: ServiceLocator.shared.userIndicatorController,
-                                                  orientationManager: OrientationManagerMock())
+        roomFlowCoordinator = await RoomFlowCoordinator(roomProxy: RoomProxyMock(with: .init(id: "1")),
+                                                        userSession: userSession,
+                                                        roomTimelineControllerFactory: MockRoomTimelineControllerFactory(),
+                                                        navigationStackCoordinator: navigationStackCoordinator,
+                                                        emojiProvider: EmojiProvider(),
+                                                        appSettings: ServiceLocator.shared.settings,
+                                                        analytics: ServiceLocator.shared.analytics,
+                                                        userIndicatorController: ServiceLocator.shared.userIndicatorController,
+                                                        orientationManager: OrientationManagerMock())
    }
    
    func testRoomPresentation() async throws {
-        try await process(route: .room(roomID: "1"), expectedAction: .presentedRoom("1"))
+        try await process(route: .room(roomID: "1"))
        XCTAssert(navigationStackCoordinator.rootCoordinator is RoomScreenCoordinator)
        
-        try await process(route: .roomList, expectedAction: .dismissedRoom)
-        XCTAssertNil(navigationStackCoordinator.rootCoordinator)
-        
-        try await process(route: .room(roomID: "1"), expectedAction: .presentedRoom("1"))
-        XCTAssert(navigationStackCoordinator.rootCoordinator is RoomScreenCoordinator)
-        
-        try await process(route: .room(roomID: "2"), expectedAction: .presentedRoom("2"))
-        XCTAssert(navigationStackCoordinator.rootCoordinator is RoomScreenCoordinator)
-        
-        try await process(route: .roomList, expectedAction: .dismissedRoom)
+        try await process(route: .roomList, expectedAction: .finished)
        XCTAssertNil(navigationStackCoordinator.rootCoordinator)
    }
    
    func testRoomDetailsPresentation() async throws {
-        try await process(route: .roomDetails(roomID: "1"), expectedAction: .presentedRoom("1"))
+        try await process(route: .roomDetails(roomID: "1"))
        XCTAssert(navigationStackCoordinator.rootCoordinator is RoomDetailsScreenCoordinator)
        
-        try await process(route: .roomList, expectedAction: .dismissedRoom)
+        try await process(route: .roomList, expectedAction: .finished)
        XCTAssertNil(navigationStackCoordinator.rootCoordinator)
    }
    
-    func testStackUnwinding() async throws {
-        try await process(route: .roomDetails(roomID: "1"), expectedAction: .presentedRoom("1"))
-        XCTAssert(navigationStackCoordinator.rootCoordinator is RoomDetailsScreenCoordinator)
-        
-        try await process(route: .room(roomID: "2"), expectedAction: .presentedRoom("2"))
-        XCTAssert(navigationStackCoordinator.rootCoordinator is RoomScreenCoordinator)
-    }
-    
    func testNoOp() async throws {
-        try await process(route: .roomDetails(roomID: "1"), expectedAction: .presentedRoom("1"))
+        try await process(route: .roomDetails(roomID: "1"))
        XCTAssert(navigationStackCoordinator.rootCoordinator is RoomDetailsScreenCoordinator)
+        let detailsCoordinator = navigationStackCoordinator.rootCoordinator
+        
        roomFlowCoordinator.handleAppRoute(.roomDetails(roomID: "1"), animated: true)
        await Task.yield()
-        XCTAssert(navigationStackCoordinator.rootCoordinator is RoomDetailsScreenCoordinator)
-    }
-    
-    func testSwitchToDifferentDetails() async throws {
-        try await process(route: .roomDetails(roomID: "1"), expectedAction: .presentedRoom("1"))
-        XCTAssert(navigationStackCoordinator.rootCoordinator is RoomDetailsScreenCoordinator)
        
-        try await process(route: .roomDetails(roomID: "2"), expectedAction: .presentedRoom("2"))
        XCTAssert(navigationStackCoordinator.rootCoordinator is RoomDetailsScreenCoordinator)
+        XCTAssert(navigationStackCoordinator.rootCoordinator === detailsCoordinator)
    }
    
    func testPushDetails() async throws {
-        try await process(route: .room(roomID: "1"), expectedAction: .presentedRoom("1"))
+        try await process(route: .room(roomID: "1"))
        XCTAssert(navigationStackCoordinator.rootCoordinator is RoomScreenCoordinator)
+        XCTAssertEqual(navigationStackCoordinator.stackCoordinators.count, 0)
        
-        try await process(route: .roomDetails(roomID: "1"), expectedAction: .presentedRoom("1"))
+        try await process(route: .roomDetails(roomID: "1"))
        XCTAssert(navigationStackCoordinator.rootCoordinator is RoomScreenCoordinator)
        XCTAssertEqual(navigationStackCoordinator.stackCoordinators.count, 1)
        XCTAssert(navigationStackCoordinator.stackCoordinators.first is RoomDetailsScreenCoordinator)
    }
    
-    func testReplaceDetailsWithTimeline() async throws {
-        try await process(route: .roomDetails(roomID: "1"), expectedAction: .presentedRoom("1"))
-        XCTAssert(navigationStackCoordinator.rootCoordinator is RoomDetailsScreenCoordinator)
-        
-        try await process(route: .room(roomID: "1"), expectedActions: [.dismissedRoom, .presentedRoom("1")])
-        XCTAssert(navigationStackCoordinator.rootCoordinator is RoomScreenCoordinator)
-    }
-    
    // MARK: - Private
    
+    private func process(route: AppRoute) async throws {
+        roomFlowCoordinator.handleAppRoute(route, animated: true)
+        await Task.yield()
+    }
+    
    private func process(route: AppRoute, expectedAction: RoomFlowCoordinatorAction) async throws {
        try await process(route: route, expectedActions: [expectedAction])
    }
@@ -0,0 +1,164 @@
+//
+// Copyright 2023 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
+
+import Combine
+@testable import ElementX
+
+@MainActor
+class UserSessionFlowCoordinatorTests: XCTestCase {
+    var userSessionFlowCoordinator: UserSessionFlowCoordinator!
+    var navigationRootCoordinator: NavigationRootCoordinator!
+    var cancellables = Set<AnyCancellable>()
+    
+    var detailCoordinator: CoordinatorProtocol? {
+        let navigationSplitCoordinator = navigationRootCoordinator.rootCoordinator as? NavigationSplitCoordinator
+        return navigationSplitCoordinator?.detailCoordinator
+    }
+    
+    var detailNavigationStack: NavigationStackCoordinator? {
+        detailCoordinator as? NavigationStackCoordinator
+    }
+    
+    override func setUp() async throws {
+        cancellables.removeAll()
+        let clientProxy = ClientProxyMock(.init(userID: "hi@bob", roomSummaryProvider: RoomSummaryProviderMock(.init(state: .loaded(.mockRooms)))))
+        let mediaProvider = MockMediaProvider()
+        let voiceMessageMediaManager = VoiceMessageMediaManagerMock()
+        let userSession = MockUserSession(clientProxy: clientProxy,
+                                          mediaProvider: mediaProvider,
+                                          voiceMessageMediaManager: voiceMessageMediaManager)
+        
+        navigationRootCoordinator = NavigationRootCoordinator()
+        
+        userSessionFlowCoordinator = UserSessionFlowCoordinator(userSession: userSession,
+                                                                navigationRootCoordinator: navigationRootCoordinator,
+                                                                windowManager: WindowManagerMock(),
+                                                                appLockService: AppLockServiceMock(),
+                                                                bugReportService: BugReportServiceMock(),
+                                                                roomTimelineControllerFactory: MockRoomTimelineControllerFactory(),
+                                                                appSettings: ServiceLocator.shared.settings,
+                                                                analytics: ServiceLocator.shared.analytics,
+                                                                notificationManager: NotificationManagerMock(),
+                                                                isNewLogin: false)
+        
+        let deferred = deferFulfillment(userSessionFlowCoordinator.statePublisher) { $0 == .roomList(selectedRoomID: nil) }
+        userSessionFlowCoordinator.start()
+        try await deferred.fulfill()
+    }
+    
+    func testRoomPresentation() async throws {
+        try await process(route: .room(roomID: "1"), expectedState: .roomList(selectedRoomID: "1"))
+        XCTAssertTrue(detailNavigationStack?.rootCoordinator is RoomScreenCoordinator)
+        XCTAssertNotNil(detailCoordinator)
+        
+        try await process(route: .roomList, expectedState: .roomList(selectedRoomID: nil))
+        XCTAssertNil(detailNavigationStack?.rootCoordinator)
+        XCTAssertNil(detailCoordinator)
+        
+        try await process(route: .room(roomID: "1"), expectedState: .roomList(selectedRoomID: "1"))
+        XCTAssertTrue(detailNavigationStack?.rootCoordinator is RoomScreenCoordinator)
+        XCTAssertNotNil(detailCoordinator)
+        
+        try await process(route: .room(roomID: "2"), expectedState: .roomList(selectedRoomID: "2"))
+        XCTAssertTrue(detailNavigationStack?.rootCoordinator is RoomScreenCoordinator)
+        XCTAssertNotNil(detailCoordinator)
+        
+        try await process(route: .roomList, expectedState: .roomList(selectedRoomID: nil))
+        XCTAssertNil(detailNavigationStack?.rootCoordinator)
+        XCTAssertNil(detailCoordinator)
+    }
+    
+    func testRoomDetailsPresentation() async throws {
+        try await process(route: .roomDetails(roomID: "1"), expectedState: .roomList(selectedRoomID: "1"))
+        XCTAssertTrue(detailNavigationStack?.rootCoordinator is RoomDetailsScreenCoordinator)
+        XCTAssertNotNil(detailCoordinator)
+        
+        try await process(route: .roomList, expectedState: .roomList(selectedRoomID: nil))
+        XCTAssertNil(detailNavigationStack?.rootCoordinator)
+        XCTAssertNil(detailCoordinator)
+    }
+    
+    func testStackUnwinding() async throws {
+        try await process(route: .roomDetails(roomID: "1"), expectedState: .roomList(selectedRoomID: "1"))
+        XCTAssertTrue(detailNavigationStack?.rootCoordinator is RoomDetailsScreenCoordinator)
+        XCTAssertNotNil(detailCoordinator)
+        
+        try await process(route: .room(roomID: "2"), expectedState: .roomList(selectedRoomID: "2"))
+        XCTAssertTrue(detailNavigationStack?.rootCoordinator is RoomScreenCoordinator)
+        XCTAssertNotNil(detailCoordinator)
+    }
+    
+    func testNoOp() async throws {
+        try await process(route: .roomDetails(roomID: "1"), expectedState: .roomList(selectedRoomID: "1"))
+        XCTAssertTrue(detailNavigationStack?.rootCoordinator is RoomDetailsScreenCoordinator)
+        XCTAssertNotNil(detailCoordinator)
+        
+        let unexpectedFulfillment = deferFailure(userSessionFlowCoordinator.statePublisher, timeout: 1) { _ in true }
+        userSessionFlowCoordinator.handleAppRoute(.roomDetails(roomID: "1"), animated: true)
+        try await unexpectedFulfillment.fulfill()
+        
+        XCTAssertTrue(detailNavigationStack?.rootCoordinator is RoomDetailsScreenCoordinator)
+        XCTAssertNotNil(detailCoordinator)
+    }
+    
+    func testSwitchToDifferentDetails() async throws {
+        try await process(route: .roomDetails(roomID: "1"), expectedState: .roomList(selectedRoomID: "1"))
+        XCTAssertTrue(detailNavigationStack?.rootCoordinator is RoomDetailsScreenCoordinator)
+        XCTAssertNotNil(detailCoordinator)
+        
+        try await process(route: .roomDetails(roomID: "2"), expectedState: .roomList(selectedRoomID: "2"))
+        XCTAssertTrue(detailNavigationStack?.rootCoordinator is RoomDetailsScreenCoordinator)
+        XCTAssertNotNil(detailCoordinator)
+    }
+    
+    func testPushDetails() async throws {
+        try await process(route: .room(roomID: "1"), expectedState: .roomList(selectedRoomID: "1"))
+        XCTAssertTrue(detailNavigationStack?.rootCoordinator is RoomScreenCoordinator)
+        XCTAssertNotNil(detailCoordinator)
+        
+        let unexpectedFulfillment = deferFailure(userSessionFlowCoordinator.statePublisher, timeout: 1) { _ in true }
+        userSessionFlowCoordinator.handleAppRoute(.roomDetails(roomID: "1"), animated: true)
+        try await unexpectedFulfillment.fulfill()
+        
+        XCTAssertTrue(detailNavigationStack?.rootCoordinator is RoomScreenCoordinator)
+        XCTAssertEqual(detailNavigationStack?.stackCoordinators.count, 1)
+        XCTAssertTrue(detailNavigationStack?.stackCoordinators.first is RoomDetailsScreenCoordinator)
+        XCTAssertNotNil(detailCoordinator)
+    }
+    
+    func testReplaceDetailsWithTimeline() async throws {
+        try await process(route: .roomDetails(roomID: "1"), expectedState: .roomList(selectedRoomID: "1"))
+        XCTAssertTrue(detailNavigationStack?.rootCoordinator is RoomDetailsScreenCoordinator)
+        XCTAssertNotNil(detailCoordinator)
+        
+        try await process(route: .room(roomID: "1"), expectedState: .roomList(selectedRoomID: "1"))
+        XCTAssertTrue(detailNavigationStack?.rootCoordinator is RoomScreenCoordinator)
+        XCTAssertNotNil(detailCoordinator)
+    }
+    
+    // MARK: - Private
+    
+    private func process(route: AppRoute, expectedState: UserSessionFlowCoordinatorStateMachine.State) async throws {
+        // Sometimes the state machine's state changes before the coordinators have updated the stack.
+        let delayedPublisher = userSessionFlowCoordinator.statePublisher.delay(for: .milliseconds(10), scheduler: DispatchQueue.main)
+        
+        let deferred = deferFulfillment(delayedPublisher) { $0 == expectedState }
+        userSessionFlowCoordinator.handleAppRoute(route, animated: true)
+        try await deferred.fulfill()
+    }
+}