Re-write the space flow state machine configuration and cover it more in UI tests. (#5098)

* Use the old state machine configuration style.

* Test starting the space settings flow in UI tests.

* Test starting the create space room flow in UI tests.

ElementX/Sources/FlowCoordinators/SpaceFlowCoordinator.swift

@@ -195,161 +195,153 @@ class SpaceFlowCoordinator: FlowCoordinatorProtocol {
     
     // MARK: - Private
     
-    // swiftlint:disable:next function_body_length cyclomatic_complexity
+    // swiftlint:disable:next function_body_length
     private func configureStateMachine() {
-        stateMachine.addRoutes(event: .start, transitions: [.initial => .space]) { [weak self] _ in
-            self?.presentSpace()
-        }
-        
-        stateMachine.addRoutes(event: .startUnjoined, transitions: [.initial => .joinSpace]) { [weak self] _ in
-            self?.presentJoinSpaceScreen()
-        }
-        
-        stateMachine.addRoutes(event: .joinedSpace, transitions: [.joinSpace => .space]) { [weak self] _ in
-            self?.presentSpaceAfterJoining()
-        }
-        stateMachine.addRoutes(event: .leftSpace, transitions: [.space => .leftSpace]) { [weak self] _ in
-            self?.clearRoute(animated: true)
-        }
-        
-        stateMachine.addRoutes(event: .addRooms, transitions: [.space => .addingRooms]) { [weak self] _ in
-            self?.presentSpaceAddRoomsScreen()
-        }
-        stateMachine.addRoutes(event: .dismissedAddRooms, transitions: [.addingRooms => .space])
-        
-        stateMachine.addRoutes(event: .presentTransferOwnership, transitions: [.space => .transferOwnership]) { [weak self] context in
-            guard let self, let roomProxy = context.userInfo as? JoinedRoomProxyProtocol else { return }
-            self.presentTransferOwnershipScreen(roomProxy: roomProxy)
-        }
-        stateMachine.addRoutes(event: .dismissedTransferOwnership, transitions: [.transferOwnership => .space])
-        
         stateMachine.addRouteMapping { event, fromState, userInfo in
-            guard event == .startChildFlow else { return nil }
+            switch (fromState, event) {
-            guard let childEntryPoint = userInfo as? SpaceFlowCoordinatorEntryPoint else { fatalError("An entry point must be provided.") }
+            case (.initial, .start):
-            return switch fromState {
+                return .space
-            case .space: .presentingChild(childSpaceID: childEntryPoint.spaceID, previousState: fromState)
+            case (.initial, .startUnjoined):
-            case .roomFlow(let previousState): .presentingChild(childSpaceID: childEntryPoint.spaceID, previousState: previousState)
+                return .joinSpace
-            default: nil
+            
-            }
+            case (.joinSpace, .joinedSpace):
-        } handler: { [weak self] context in
+                return .space
-            guard let self, let entryPoint = context.userInfo as? SpaceFlowCoordinatorEntryPoint else { return }
+            case (.space, .leftSpace):
-            startChildFlow(with: entryPoint)
+                return .leftSpace
-        }
+            
-        
+            case (.space, .addRooms):
-        stateMachine.addRouteMapping { event, fromState, _ in
+                return .addingRooms
-            guard event == .stopChildFlow, case .presentingChild(_, let previousState) = fromState else { return nil }
+            case (.addingRooms, .dismissedAddRooms):
-            return previousState
+                return .space
-        } handler: { [weak self] _ in
+            
-            guard let self else { return }
+            case (.space, .presentTransferOwnership):
-            childSpaceFlowCoordinator = nil
+                return .transferOwnership
-            selectedSpaceRoomSubject.send(nil)
+            case (.transferOwnership, .dismissedTransferOwnership):
-        }
+                return .space
-        
+            
-        stateMachine.addRouteMapping { event, fromState, _ in
+            case (.space, .startChildFlow):
-            guard case .startRoomFlow = event, case .roomFlow = fromState else {
+                guard let childEntryPoint = userInfo as? SpaceFlowCoordinatorEntryPoint else { fatalError("An entry point must be provided.") }
+                return .presentingChild(childSpaceID: childEntryPoint.spaceID, previousState: fromState)
+            case (.roomFlow(let previousState), .startChildFlow):
+                guard let childEntryPoint = userInfo as? SpaceFlowCoordinatorEntryPoint else { fatalError("An entry point must be provided.") }
+                return .presentingChild(childSpaceID: childEntryPoint.spaceID, previousState: previousState)
+            case (.presentingChild(_, let previousState), .stopChildFlow):
+                return previousState
+            
+            case (.space, .startRoomFlow):
+                return .roomFlow(previousState: fromState)
+            case (.roomFlow, .startRoomFlow):
+                return fromState // Ignore tapping on multiple rooms at the same time
+            case (.roomFlow(let previousState), .stopRoomFlow):
+                return previousState
+            
+            case (.space, .startMembersFlow):
+                return .membersFlow
+            case (.membersFlow, .stopMembersFlow):
+                return .space
+            
+            case (.space, .startSettingsFlow):
+                return .settingsFlow
+            case (.settingsFlow, .stopSettingsFlow):
+                return .space
+            
+            case (.space, .startRolesAndPermissionsFlow):
+                return .rolesAndPermissionsFlow
+            case (.rolesAndPermissionsFlow, .stopRolesAndPermissionsFlow):
+                return .space
+            
+            case (.space, .startCreateChildRoomFlow):
+                return .createChildRoomFlow
+            case (.createChildRoomFlow, .stopCreateChildRoomFlow):
+                return .space
+            
+            default:
                 return nil
             }
+        }
+        
+        stateMachine.addAnyHandler(.any => .any) { [weak self] context in
+            guard let self else { return }
+            
+            switch (context.fromState, context.event, context.toState) {
+            case (.initial, .start, .space):
+                presentSpace()
+            case (.initial, .startUnjoined, .joinSpace):
+                presentJoinSpaceScreen()
+            
+            case (.joinSpace, .joinedSpace, .space):
+                presentSpaceAfterJoining()
+            case (.space, .leftSpace, .leftSpace):
+                clearRoute(animated: true)
+            
+            case (.space, .addRooms, .addingRooms):
+                presentSpaceAddRoomsScreen()
+            case (.addingRooms, .dismissedAddRooms, .space):
+                break
+            
+            case (.space, .presentTransferOwnership, .transferOwnership):
+                guard let roomProxy = context.userInfo as? JoinedRoomProxyProtocol else { return }
+                presentTransferOwnershipScreen(roomProxy: roomProxy)
+            case (.transferOwnership, .dismissedTransferOwnership, .space):
+                break
+            
+            case (.space, .startChildFlow, .presentingChild),
+                 (.roomFlow, .startChildFlow, .presentingChild):
+                guard let entryPoint = context.userInfo as? SpaceFlowCoordinatorEntryPoint else { return }
+                startChildFlow(with: entryPoint)
+            case (.presentingChild, .stopChildFlow, _):
+                childSpaceFlowCoordinator = nil
+                selectedSpaceRoomSubject.send(nil)
+            
+            case (.space, .startRoomFlow(let roomID), .roomFlow):
+                startRoomFlow(roomID: roomID)
+            case (.roomFlow, .startRoomFlow, .roomFlow):
+                break // Ignore tapping on multiple rooms at the same time
+            case (.roomFlow, .stopRoomFlow, _):
+                roomFlowCoordinator = nil
+                selectedSpaceRoomSubject.send(nil)
+            
+            case (.space, .startMembersFlow, .membersFlow):
+                guard let roomProxy = context.userInfo as? JoinedRoomProxyProtocol else {
+                    fatalError("The room proxy must always be provided")
+                }
+                startMembersFlow(roomProxy: roomProxy)
+            case (.membersFlow, .stopMembersFlow, .space):
+                membersFlowCoordinator = nil
+            
+            case (.space, .startSettingsFlow, .settingsFlow):
+                guard let roomProxy = context.userInfo as? JoinedRoomProxyProtocol else { return }
+                startSettingsFlow(roomProxy: roomProxy)
+            case (.settingsFlow, .stopSettingsFlow, .space):
+                settingsFlowCoordinator = nil
+            
+            case (.space, .startRolesAndPermissionsFlow, .rolesAndPermissionsFlow):
+                guard let roomProxy = context.userInfo as? JoinedRoomProxyProtocol else { return }
+                startRolesAndPermissionsFlow(roomProxy: roomProxy)
+            case (.rolesAndPermissionsFlow, .stopRolesAndPermissionsFlow, .space):
+                rolesAndPermissionsFlowCoordinator = nil
+            
+            case (.space, .startCreateChildRoomFlow, .createChildRoomFlow):
+                guard let space = context.userInfo as? SpaceServiceRoom else { fatalError("The space is missing") }
+                startCreateChildFlow(space: space)
+            case (.createChildRoomFlow, .stopCreateChildRoomFlow, .space):
+                createChildRoomFlowCoordinator = nil
+            
+            default:
+                break
+            }
             
-            return fromState
+            // Log transitions
-        } handler: { _ in
-            // Ignore tapping on multiple rooms at the same time
-        }
-        
-        stateMachine.addRouteMapping { event, fromState, _ in
-            guard case .startRoomFlow = event, case .space = fromState else { return nil }
-            return .roomFlow(previousState: fromState)
-        } handler: { [weak self] context in
-            guard let self, case let .startRoomFlow(roomID) = context.event else { return }
-            startRoomFlow(roomID: roomID)
-        }
-        
-        stateMachine.addRouteMapping { event, fromState, _ in
-            guard event == .stopRoomFlow, case let .roomFlow(previousState) = fromState else { return nil }
-            return previousState
-        } handler: { [weak self] _ in
-            guard let self else { return }
-            roomFlowCoordinator = nil
-            selectedSpaceRoomSubject.send(nil)
-        }
-        
-        stateMachine.addRouteMapping { event, fromState, _ in
-            guard case .startMembersFlow = event, case .space = fromState else {
-                return nil
-            }
-            return .membersFlow
-        } handler: { [weak self] context in
-            guard let self, let roomProxy = context.userInfo as? JoinedRoomProxyProtocol else {
-                fatalError("The room proxy must always be provided")
-            }
-            startMembersFlow(roomProxy: roomProxy)
-        }
-        
-        stateMachine.addRouteMapping { event, fromState, _ in
-            guard event == .stopMembersFlow, case .membersFlow = fromState else { return nil }
-            return .space
-        } handler: { [weak self] _ in
-            guard let self else { return }
-            membersFlowCoordinator = nil
-        }
-        
-        stateMachine.addRouteMapping { event, fromState, _ in
-            guard event == .startSettingsFlow, case .space = fromState else { return nil }
-            return .settingsFlow
-        } handler: { [weak self] context in
-            guard let self, let roomProxy = context.userInfo as? JoinedRoomProxyProtocol else { return }
-            startSettingsFlow(roomProxy: roomProxy)
-        }
-        
-        stateMachine.addRouteMapping { event, fromState, _ in
-            guard event == .stopSettingsFlow, case .settingsFlow = fromState else { return nil }
-            return .space
-        } handler: { [weak self] _ in
-            guard let self else { return }
-            settingsFlowCoordinator = nil
-        }
-        
-        stateMachine.addRouteMapping { event, fromState, _ in
-            guard event == .startRolesAndPermissionsFlow, case .space = fromState else { return nil }
-            return .rolesAndPermissionsFlow
-        } handler: { [weak self] context in
-            guard let self, let roomProxy = context.userInfo as? JoinedRoomProxyProtocol else { return }
-            startRolesAndPermissionsFlow(roomProxy: roomProxy)
-        }
-        
-        stateMachine.addRouteMapping { event, fromState, _ in
-            guard event == .stopRolesAndPermissionsFlow, case .rolesAndPermissionsFlow = fromState else { return nil }
-            return .space
-        } handler: { [weak self] _ in
-            guard let self else { return }
-            rolesAndPermissionsFlowCoordinator = nil
-        }
-        
-        stateMachine.addRouteMapping { event, fromState, _ in
-            guard event == .startCreateChildRoomFlow, case .space = fromState else { return nil }
-            return .createChildRoomFlow
-        } handler: { [weak self] context in
-            guard let space = context.userInfo as? SpaceServiceRoom else { fatalError("The space is missing") }
-            self?.startCreateChildFlow(space: space)
-        }
-        
-        stateMachine.addRouteMapping { event, fromState, _ in
-            guard event == .stopCreateChildRoomFlow, case .createChildRoomFlow = fromState else { return nil }
-            return .space
-        } handler: { [weak self] _ in
-            self?.createChildRoomFlowCoordinator = nil
-        }
-        
-        stateMachine.addErrorHandler { context in
-            fatalError("Unexpected transition: \(context)")
-        }
-        
-        stateMachine.addAnyHandler(.any => .any) { context in
             if let event = context.event {
                 MXLog.info("Transitioning from `\(context.fromState)` to `\(context.toState)` with event `\(event)`")
             } else {
                 MXLog.info("Transitioning from \(context.fromState)` to `\(context.toState)`")
             }
         }
+        
+        stateMachine.addErrorHandler { context in
+            fatalError("Unexpected transition: \(context)")
+        }
     }
     
     private func presentSpace() {

ElementX/Sources/Mocks/SpaceServiceProxyMock.swift

@@ -22,6 +22,7 @@ extension SpaceServiceProxyMock {
         var joinedParentSpaces: [SpaceServiceRoom] = []
         var editableSpaces: [SpaceServiceRoom] = []
         var spaceRoomLists: [String: SpaceRoomListProxyMock] = [:]
+        var spaceRooms: [SpaceServiceRoom] = []
         var leaveSpaceRooms: [LeaveSpaceRoom] = []
     }
     
@@ -46,7 +47,8 @@ extension SpaceServiceProxyMock {
                                            leaveHandle: LeaveSpaceHandleSDKMock(.init(rooms: configuration.leaveSpaceRooms))))
         }
         spaceForIdentifierSpaceIDClosure = { spaceID in
-            .success(configuration.topLevelSpaces.first { $0.id == spaceID })
+            let space = configuration.topLevelSpaces.first { $0.id == spaceID } ?? configuration.spaceRooms.first { $0.id == spaceID }
+            return .success(space)
         }
         addChildToReturnValue = .success(())
         removeChildFromReturnValue = .success(())
@@ -70,6 +72,7 @@ extension SpaceServiceProxyMock.Configuration {
         
         return .init(topLevelSpaces: .mockJoinedSpaces,
                      spaceFilters: spaceFilters,
-                     spaceRoomLists: .init(uniqueKeysWithValues: spaceRoomLists + subSpaceRoomLists))
+                     spaceRoomLists: .init(uniqueKeysWithValues: spaceRoomLists + subSpaceRoomLists),
+                     spaceRooms: .mockSpaceList)
     }
 }

ElementX/Sources/Other/AccessibilityIdentifiers.swift

@@ -48,6 +48,7 @@ enum A11yIdentifiers {
     static let spacesScreen = SpacesScreen()
     static let spaceScreen = SpaceScreen()
     static let spaceAddRoomsScreen = SpaceAddRoomsScreen()
+    static let spaceSettingsScreen = SpaceSettingsScreen()
     static let linkNewDeviceScreen = LinkNewDeviceScreen()
     
     struct AlertInfo {
@@ -276,6 +277,7 @@ enum A11yIdentifiers {
     
     struct CreateRoomScreen {
         let create = "create_room-create"
+        let cancel = "create_room-cancel"
         let roomAvatar = "create_room-room_avatar"
         let roomName = "create_room-room_name"
         let roomTopic = "create_room-room_topic"
@@ -328,14 +330,20 @@ enum A11yIdentifiers {
     
     struct SpaceScreen {
         let moreMenu = "space_screen-more_menu"
+        let createRoom = "space_screen-create_room"
         let addExistingRooms = "space_screen-add_existing_rooms"
         let viewMembers = "space_screen-view_members"
+        let settings = "space_screen-settings"
     }
     
     struct SpaceAddRoomsScreen {
         let cancel = "space_add_rooms_screen-cancel"
     }
     
+    struct SpaceSettingsScreen {
+        let editBaseInfo = "space_settings_screen-edit_space_info"
+    }
+    
     struct LinkNewDeviceScreen {
         let cancel = "link_new_device_screen-cancel"
         let mobileDevice = "link_new_device_screen-mobile_device"

ElementX/Sources/Screens/CreateRoomScreen/View/CreateRoomScreen.swift

@@ -252,6 +252,7 @@ struct CreateRoomScreen: View {
                 ToolbarButton(role: .cancel) {
                     context.send(viewAction: .dismiss)
                 }
+                .accessibilityIdentifier(A11yIdentifiers.createRoomScreen.cancel)
             }
         }
         

ElementX/Sources/Screens/Spaces/SpaceScreen/View/SpaceScreen.swift

@@ -132,7 +132,9 @@ struct SpaceScreen: View {
                                 Button { context.send(viewAction: .createChildRoom) } label: {
                                     Label(L10n.actionCreateRoom, icon: \.plus)
                                 }
+                                .accessibilityIdentifier(A11yIdentifiers.spaceScreen.createRoom)
                             }
+                            
                             Button { context.send(viewAction: .addExistingRooms) } label: {
                                 Label(L10n.actionAddExistingRooms, icon: \.room)
                             }
@@ -165,6 +167,7 @@ struct SpaceScreen: View {
                             Button { context.send(viewAction: .spaceSettings(roomProxy: roomProxy)) } label: {
                                 Label(L10n.commonSettings, icon: \.settings)
                             }
+                            .accessibilityIdentifier(A11yIdentifiers.spaceScreen.settings)
                         }
                     }
                     

ElementX/Sources/Screens/Spaces/SpaceSettingsScreen/View/SpaceSettingsScreen.swift

@@ -30,6 +30,7 @@ struct SpaceSettingsScreen: View {
     private var editSection: some View {
         Section {
             ListRow(kind: .custom { editRow })
+                .accessibilityIdentifier(A11yIdentifiers.spaceSettingsScreen.editBaseInfo)
         }
     }
     

UITests/Sources/UserSessionScreenTests.swift

@@ -29,6 +29,8 @@ class UserSessionScreenTests: XCTestCase {
         static let spaceJoinRoomScreen = 9
         static let spaceAddRoomsScreen = 10
         static let spaceMembersListScreen = 11
+        static let spaceSettingsScreen = 12
+        static let createSpaceRoomScreen = 13
     }
     
     func testUserSessionFlows() async throws {
@@ -96,6 +98,15 @@ class UserSessionScreenTests: XCTestCase {
         try await Task.sleep(for: .seconds(1))
         try await app.assertScreenshot(step: Step.subspaceScreen)
         
+        app.buttons[A11yIdentifiers.spaceScreen.moreMenu].tap()
+        app.buttons[A11yIdentifiers.spaceScreen.createRoom].tap()
+        XCTAssertTrue(app.buttons[A11yIdentifiers.createRoomScreen.cancel].waitForExistence(timeout: 5.0))
+        try await Task.sleep(for: .seconds(1))
+        try await app.assertScreenshot(step: Step.createSpaceRoomScreen)
+        
+        app.buttons[A11yIdentifiers.createRoomScreen.cancel].tap()
+        XCTAssert(app.staticTexts[joinedSubspaceName].waitForExistence(timeout: 5.0))
+        
         app.buttons[A11yIdentifiers.spaceScreen.moreMenu].tap()
         app.buttons[A11yIdentifiers.spaceScreen.addExistingRooms].tap()
         XCTAssert(app.buttons[A11yIdentifiers.spaceAddRoomsScreen.cancel].waitForExistence(timeout: 5.0))
@@ -114,6 +125,15 @@ class UserSessionScreenTests: XCTestCase {
         app.navigationBars.buttons[joinedSubspaceName].firstMatch.tap(.center)
         XCTAssert(app.staticTexts[joinedSubspaceName].waitForExistence(timeout: 5.0))
         
+        app.buttons[A11yIdentifiers.spaceScreen.moreMenu].tap()
+        app.buttons[A11yIdentifiers.spaceScreen.settings].tap()
+        XCTAssert(app.buttons[A11yIdentifiers.spaceSettingsScreen.editBaseInfo].waitForExistence(timeout: 5.0))
+        try await Task.sleep(for: .seconds(1))
+        try await app.assertScreenshot(step: Step.spaceSettingsScreen)
+        
+        app.navigationBars.buttons[joinedSubspaceName].firstMatch.tap(.center)
+        XCTAssert(app.staticTexts[joinedSubspaceName].waitForExistence(timeout: 5.0))
+        
         app.buttons[A11yIdentifiers.spacesScreen.spaceRoomName(joinedSubspaceRoomName)].tap()
         XCTAssert(app.buttons[joinedSubspaceRoomName].waitForExistence(timeout: 5.0))
         try await Task.sleep(for: .seconds(1))

UITests/Sources/__Snapshots__/Application/userSessionScreen.testSpaceExploration-iPad-en-GB-12.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a9a76ebfb64858e3e501e7e83c5f807dafc77b4b0e973190809a2240045c973a
+size 264477

UITests/Sources/__Snapshots__/Application/userSessionScreen.testSpaceExploration-iPad-en-GB-13.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b4bed76c5b0fd4ab4ef243a7b4966ce1a8d0396771407ddd6905eb0498895cfe
+size 307993

UITests/Sources/__Snapshots__/Application/userSessionScreen.testSpaceExploration-iPhone-en-GB-12.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6d6d275b6bd0e5cbbd5b4c2400ab9bfc5b9c5ecc851149266792ea62f9903018
+size 120898

UITests/Sources/__Snapshots__/Application/userSessionScreen.testSpaceExploration-iPhone-en-GB-13.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:638dd34b225e913bb4d13f8191ccac8a15b8f7f106668e859aa7656fd5e66761
+size 154018