Add support for joining rooms from a space. (#4501)

* Add support for joining rooms from a space.

Doesn't yet handle the Join button 🤔

* Handle the join button for both rooms and spaces.

Also refactor more instances of spaceRoom to spaceRoomProxy.

ElementX/Sources/FlowCoordinators/SpaceFlowCoordinator.swift

@@ -158,7 +158,7 @@ class SpaceFlowCoordinator: FlowCoordinatorProtocol {
         let parameters = SpaceScreenCoordinatorParameters(spaceRoomListProxy: spaceRoomListProxy,
                                                           spaceServiceProxy: spaceServiceProxy,
                                                           selectedSpaceRoomPublisher: selectedSpaceRoomSubject.asCurrentValuePublisher(),
-                                                          mediaProvider: flowParameters.userSession.mediaProvider,
+                                                          userSession: flowParameters.userSession,
                                                           userIndicatorController: flowParameters.userIndicatorController)
         let coordinator = SpaceScreenCoordinator(parameters: parameters)
         coordinator.actionsPublisher

ElementX/Sources/Mocks/ClientProxyMock.swift

@@ -15,6 +15,7 @@ struct ClientProxyMockConfiguration {
     var deviceID: String?
     var roomSummaryProvider: RoomSummaryProviderProtocol = RoomSummaryProviderMock(.init())
     var joinedSpaceRooms: [SpaceRoomProxyProtocol] = []
+    var roomPreviews: [RoomPreviewProxyProtocol]?
     var roomDirectorySearchProxy: RoomDirectorySearchProxyProtocol?
     
     var recoveryState: SecureBackupRecoveryState = .enabled
@@ -65,6 +66,7 @@ extension ClientProxyMock {
         directRoomForUserIDReturnValue = .failure(.sdkError(ClientProxyMockError.generic))
         createDirectRoomWithExpectedRoomNameReturnValue = .failure(.sdkError(ClientProxyMockError.generic))
         createRoomNameTopicIsRoomPrivateIsKnockingOnlyUserIDsAvatarURLAliasLocalPartReturnValue = .failure(.sdkError(ClientProxyMockError.generic))
+        canJoinRoomWithReturnValue = true
         uploadMediaReturnValue = .failure(.sdkError(ClientProxyMockError.generic))
         loadUserDisplayNameReturnValue = .failure(.sdkError(ClientProxyMockError.generic))
         setUserDisplayNameReturnValue = .failure(.sdkError(ClientProxyMockError.generic))
@@ -95,13 +97,23 @@ extension ClientProxyMock {
         roomForIdentifierClosure = { [weak self] identifier in
             if let room = self?.roomSummaryProvider.roomListPublisher.value.first(where: { $0.id == identifier }) {
                 await .joined(JoinedRoomProxyMock(.init(id: room.id, name: room.name)))
-            } else if let spaceRoom = configuration.joinedSpaceRooms.first(where: { $0.id == identifier }) {
+            } else if let spaceRoomProxy = configuration.joinedSpaceRooms.first(where: { $0.id == identifier }) {
-                await .joined(JoinedRoomProxyMock(.init(id: spaceRoom.id, name: spaceRoom.name)))
+                await .joined(JoinedRoomProxyMock(.init(id: spaceRoomProxy.id, name: spaceRoomProxy.name)))
             } else {
                 nil
             }
         }
         
+        if let roomPreviews = configuration.roomPreviews {
+            roomPreviewForIdentifierViaClosure = { roomID, _ in
+                if let preview = roomPreviews.first(where: { $0.info.id == roomID }) {
+                    .success(preview)
+                } else {
+                    .failure(.roomPreviewIsPrivate)
+                }
+            }
+        }
+        
         userIdentityForReturnValue = .success(UserIdentityProxyMock(configuration: .init()))
         
         underlyingIsReportRoomSupported = true

ElementX/Sources/Mocks/Generated/GeneratedMocks.swift

@@ -2987,6 +2987,76 @@ class ClientProxyMock: ClientProxyProtocol, @unchecked Sendable {
             return knockRoomAliasMessageReturnValue
         }
     }
+    //MARK: - canJoinRoom
+
+    var canJoinRoomWithUnderlyingCallsCount = 0
+    var canJoinRoomWithCallsCount: Int {
+        get {
+            if Thread.isMainThread {
+                return canJoinRoomWithUnderlyingCallsCount
+            } else {
+                var returnValue: Int? = nil
+                DispatchQueue.main.sync {
+                    returnValue = canJoinRoomWithUnderlyingCallsCount
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                canJoinRoomWithUnderlyingCallsCount = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    canJoinRoomWithUnderlyingCallsCount = newValue
+                }
+            }
+        }
+    }
+    var canJoinRoomWithCalled: Bool {
+        return canJoinRoomWithCallsCount > 0
+    }
+    var canJoinRoomWithReceivedRules: [AllowRule]?
+    var canJoinRoomWithReceivedInvocations: [[AllowRule]] = []
+
+    var canJoinRoomWithUnderlyingReturnValue: Bool!
+    var canJoinRoomWithReturnValue: Bool! {
+        get {
+            if Thread.isMainThread {
+                return canJoinRoomWithUnderlyingReturnValue
+            } else {
+                var returnValue: Bool? = nil
+                DispatchQueue.main.sync {
+                    returnValue = canJoinRoomWithUnderlyingReturnValue
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                canJoinRoomWithUnderlyingReturnValue = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    canJoinRoomWithUnderlyingReturnValue = newValue
+                }
+            }
+        }
+    }
+    var canJoinRoomWithClosure: (([AllowRule]) -> Bool)?
+
+    func canJoinRoom(with rules: [AllowRule]) -> Bool {
+        canJoinRoomWithCallsCount += 1
+        canJoinRoomWithReceivedRules = rules
+        DispatchQueue.main.async {
+            self.canJoinRoomWithReceivedInvocations.append(rules)
+        }
+        if let canJoinRoomWithClosure = canJoinRoomWithClosure {
+            return canJoinRoomWithClosure(rules)
+        } else {
+            return canJoinRoomWithReturnValue
+        }
+    }
     //MARK: - uploadMedia
 
     var uploadMediaUnderlyingCallsCount = 0

ElementX/Sources/Mocks/RoomPreviewProxyMock.swift

@@ -96,4 +96,18 @@ extension RoomPreviewProxyMock {
         
         underlyingOwnMembershipDetails = roomMembershipDetails
     }
+    
+    convenience init(spaceRoomProxy: SpaceRoomProxyProtocol) {
+        self.init(Configuration(roomID: spaceRoomProxy.id,
+                                canonicalAlias: spaceRoomProxy.canonicalAlias ?? "",
+                                name: spaceRoomProxy.name ?? "",
+                                topic: spaceRoomProxy.topic ?? "",
+                                avatarURL: spaceRoomProxy.avatarURL?.absoluteString ?? "",
+                                numJoinedMembers: UInt64(spaceRoomProxy.joinedMembersCount),
+                                numActiveMembers: UInt64(spaceRoomProxy.joinedMembersCount),
+                                roomType: spaceRoomProxy.isSpace ? .space : .room,
+                                membership: nil,
+                                joinRule: spaceRoomProxy.joinRule ?? .restricted(rules: []),
+                                isDirect: false))
+    }
 }

ElementX/Sources/Mocks/SpaceServiceProxyMock.swift

@@ -19,8 +19,8 @@ extension SpaceServiceProxyMock {
         self.init()
         
         joinedSpacesPublisher = .init(configuration.joinedSpaces)
-        spaceRoomListForClosure = { spaceRoom in
+        spaceRoomListForClosure = { spaceRoomProxy in
-            if let spaceRoomList = configuration.spaceRoomLists[spaceRoom.id] {
+            if let spaceRoomList = configuration.spaceRoomLists[spaceRoomProxy.id] {
                 .success(spaceRoomList)
             } else {
                 .failure(.sdkError(ClientProxyMockError.generic))

ElementX/Sources/Screens/JoinRoomScreen/JoinRoomScreenViewModel.swift

@@ -6,6 +6,7 @@
 //
 
 import Combine
+import MatrixRustSDK
 import SwiftUI
 
 typealias JoinRoomScreenViewModelType = StateStoreViewModel<JoinRoomScreenViewState, JoinRoomScreenViewAction>
@@ -211,8 +212,8 @@ class JoinRoomScreenViewModel: JoinRoomScreenViewModelType, JoinRoomScreenViewMo
                     state.mode = .inviteRequired
                 case .knock, .knockRestricted:
                     state.mode = appSettings.knockingEnabled ? .knockable : .joinable
-                case .restricted:
+                case .restricted(let rules):
-                    state.mode = .restricted
+                    state.mode = clientProxy.canJoinRoom(with: rules) ? .joinable : .restricted
                 default:
                     state.mode = .joinable
                 }

ElementX/Sources/Screens/JoinRoomScreen/View/JoinRoomScreen.swift

@@ -306,7 +306,8 @@ struct JoinRoomScreen: View {
 struct JoinRoomScreen_Previews: PreviewProvider, TestablePreview {
     static let unknownViewModel = makeViewModel(mode: .unknown)
     static let joinableViewModel = makeViewModel(mode: .joinable)
-    static let restrictedViewModel = makeViewModel(mode: .restricted)
+    static let restrictedViewModel = makeViewModel(mode: .restricted, canJoinRoom: false)
+    static let restrictedJoinableViewModel = makeViewModel(mode: .restricted)
     static let inviteRequiredViewModel = makeViewModel(mode: .inviteRequired)
     static let invitedViewModel = makeViewModel(mode: .invited(isDM: false))
     static let invitedDMViewModel = makeViewModel(mode: .invited(isDM: true))
@@ -321,6 +322,8 @@ struct JoinRoomScreen_Previews: PreviewProvider, TestablePreview {
         makePreview(viewModel: unknownViewModel, mode: .unknown)
         makePreview(viewModel: joinableViewModel, mode: .joinable)
         makePreview(viewModel: restrictedViewModel, mode: .restricted)
+        makePreview(viewModel: restrictedJoinableViewModel, mode: .restricted,
+                    customPreviewName: "RestrictedJoinable")
         makePreview(viewModel: inviteRequiredViewModel, mode: .inviteRequired)
         makePreview(viewModel: invitedViewModel, mode: .invited(isDM: false))
         makePreview(viewModel: invitedDMViewModel, mode: .invited(isDM: true))
@@ -359,11 +362,14 @@ struct JoinRoomScreen_Previews: PreviewProvider, TestablePreview {
         }
     }
     
-    static func makeViewModel(mode: JoinRoomScreenMode, hideInviteAvatars: Bool = false) -> JoinRoomScreenViewModel {
+    static func makeViewModel(mode: JoinRoomScreenMode,
+                              canJoinRoom: Bool = true,
+                              hideInviteAvatars: Bool = false) -> JoinRoomScreenViewModel {
         let appSettings = AppSettings()
         appSettings.knockingEnabled = true
         
         let clientProxy = ClientProxyMock(.init(hideInviteAvatars: hideInviteAvatars))
+        clientProxy.canJoinRoomWithReturnValue = canJoinRoom
         
         switch mode {
         case .unknown:

ElementX/Sources/Screens/Spaces/Common/SpaceRoomCell.swift

@@ -14,6 +14,7 @@ struct SpaceRoomCell: View {
     
     let spaceRoomProxy: SpaceRoomProxyProtocol
     let isSelected: Bool
+    var isJoining = false
     let mediaProvider: MediaProviderProtocol!
     
     enum Action { case select(SpaceRoomProxyProtocol), join(SpaceRoomProxyProtocol) }
@@ -116,6 +117,12 @@ struct SpaceRoomCell: View {
             Button(L10n.actionJoin) { action(.join(spaceRoomProxy)) }
                 .font(.compound.bodyLG)
                 .foregroundStyle(.compound.textActionAccent)
+                .opacity(isJoining ? 0 : 1)
+                .overlay {
+                    if isJoining {
+                        ProgressView()
+                    }
+                }
         case .joined, .knocked, .banned:
             EmptyView()
         }
@@ -145,6 +152,15 @@ struct SpaceRoomCell_Previews: PreviewProvider, TestablePreview {
                               isSelected: false,
                               mediaProvider: mediaProvider) { _ in }
             }
+            
+            SpaceRoomCell(spaceRoomProxy: SpaceRoomProxyMock(.init(id: "Space being joined", isSpace: true)),
+                          isSelected: false,
+                          isJoining: true,
+                          mediaProvider: mediaProvider) { _ in }
+            SpaceRoomCell(spaceRoomProxy: SpaceRoomProxyMock(.init(id: "Room being joined", isSpace: false)),
+                          isSelected: false,
+                          isJoining: true,
+                          mediaProvider: mediaProvider) { _ in }
         }
     }
 }

ElementX/Sources/Screens/Spaces/SpaceListScreen/SpaceListScreenViewModel.swift

@@ -58,7 +58,7 @@ class SpaceListScreenViewModel: SpaceListScreenViewModelType, SpaceListScreenVie
         switch viewAction {
         case .spaceAction(.select(let spaceRoomProxy)):
             Task { await selectSpace(spaceRoomProxy) }
-        case .spaceAction(.join(let spaceRoom)):
+        case .spaceAction(.join(let spaceRoomProxy)):
             #warning("Implement joining.")
         case .showSettings:
             actionsSubject.send(.showSettings)

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

@@ -58,9 +58,9 @@ struct SpaceListScreen: View {
     }
     
     var spaces: some View {
-        ForEach(context.viewState.joinedSpaces, id: \.id) { spaceRoom in
+        ForEach(context.viewState.joinedSpaces, id: \.id) { spaceRoomProxy in
-            SpaceRoomCell(spaceRoomProxy: spaceRoom,
+            SpaceRoomCell(spaceRoomProxy: spaceRoomProxy,
-                          isSelected: spaceRoom.id == context.viewState.selectedSpaceID,
+                          isSelected: spaceRoomProxy.id == context.viewState.selectedSpaceID,
                           mediaProvider: context.mediaProvider) { action in
                 context.send(viewAction: .spaceAction(action))
             }

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

@@ -14,7 +14,7 @@ struct SpaceScreenCoordinatorParameters {
     let spaceRoomListProxy: SpaceRoomListProxyProtocol
     let spaceServiceProxy: SpaceServiceProxyProtocol
     let selectedSpaceRoomPublisher: CurrentValuePublisher<String?, Never>
-    let mediaProvider: MediaProviderProtocol
+    let userSession: UserSessionProtocol
     let userIndicatorController: UserIndicatorControllerProtocol
 }
 
@@ -40,7 +40,7 @@ final class SpaceScreenCoordinator: CoordinatorProtocol {
         viewModel = SpaceScreenViewModel(spaceRoomListProxy: parameters.spaceRoomListProxy,
                                          spaceServiceProxy: parameters.spaceServiceProxy,
                                          selectedSpaceRoomPublisher: parameters.selectedSpaceRoomPublisher,
-                                         mediaProvider: parameters.mediaProvider,
+                                         userSession: parameters.userSession,
                                          userIndicatorController: parameters.userIndicatorController)
     }
     
@@ -58,6 +58,10 @@ final class SpaceScreenCoordinator: CoordinatorProtocol {
         }
         .store(in: &cancellables)
     }
+    
+    func stop() {
+        viewModel.stop()
+    }
         
     func toPresentable() -> AnyView {
         AnyView(SpaceScreen(context: viewModel.context))

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

@@ -18,6 +18,7 @@ struct SpaceScreenViewState: BindableState {
     var isPaginating = false
     var rooms: [SpaceRoomProxyProtocol]
     var selectedSpaceRoomID: String?
+    var joiningRoomIDs: Set<String> = []
     
     var bindings = SpaceScreenViewStateBindings()
     

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

@@ -12,6 +12,7 @@ typealias SpaceScreenViewModelType = StateStoreViewModelV2<SpaceScreenViewState,
 
 class SpaceScreenViewModel: SpaceScreenViewModelType, SpaceScreenViewModelProtocol {
     private let spaceServiceProxy: SpaceServiceProxyProtocol
+    private let clientProxy: ClientProxyProtocol
     private let userIndicatorController: UserIndicatorControllerProtocol
     
     private let actionsSubject: PassthroughSubject<SpaceScreenViewModelAction, Never> = .init()
@@ -22,15 +23,16 @@ class SpaceScreenViewModel: SpaceScreenViewModelType, SpaceScreenViewModelProtoc
     init(spaceRoomListProxy: SpaceRoomListProxyProtocol,
          spaceServiceProxy: SpaceServiceProxyProtocol,
          selectedSpaceRoomPublisher: CurrentValuePublisher<String?, Never>,
-         mediaProvider: MediaProviderProtocol,
+         userSession: UserSessionProtocol,
          userIndicatorController: UserIndicatorControllerProtocol) {
         self.spaceServiceProxy = spaceServiceProxy
+        clientProxy = userSession.clientProxy
         self.userIndicatorController = userIndicatorController
         
         super.init(initialViewState: SpaceScreenViewState(space: spaceRoomListProxy.spaceRoomProxy,
                                                           rooms: spaceRoomListProxy.spaceRoomsPublisher.value,
                                                           selectedSpaceRoomID: selectedSpaceRoomPublisher.value),
-                   mediaProvider: mediaProvider)
+                   mediaProvider: userSession.mediaProvider)
         
         spaceRoomListProxy.spaceRoomsPublisher
             .receive(on: DispatchQueue.main)
@@ -67,16 +69,20 @@ class SpaceScreenViewModel: SpaceScreenViewModelType, SpaceScreenViewModelProtoc
         case .spaceAction(.select(let spaceRoomProxy)):
             if spaceRoomProxy.isSpace {
                 Task { await selectSpace(spaceRoomProxy) }
-            } else if spaceRoomProxy.state == .joined {
+            } else {
-                // This probably doesn't need the state condition as the room flow will show a join screen,
+                // No need to check the join state, the room flow will show an appropriately configured join screen if needed.
-                // but we can allow this later, once we've updated the design to indicate the parent space.
                 actionsSubject.send(.selectRoom(roomID: spaceRoomProxy.id))
             }
-        case .spaceAction(.join(let spaceID)):
+        case .spaceAction(.join(let spaceRoomProxy)):
-            #warning("Implement joining.")
+            Task { await join(spaceRoomProxy) }
         }
     }
     
+    func stop() {
+        // If we pop this screen with running join operations, we don't want them to do anything.
+        state.joiningRoomIDs.removeAll()
+    }
+    
     // MARK: - Private
     
     private func selectSpace(_ spaceRoomProxy: SpaceRoomProxyProtocol) async {
@@ -89,6 +95,25 @@ class SpaceScreenViewModel: SpaceScreenViewModelType, SpaceScreenViewModelProtoc
         }
     }
     
+    private func join(_ spaceRoomProxy: SpaceRoomProxyProtocol) async {
+        state.joiningRoomIDs.insert(spaceRoomProxy.id)
+        defer { state.joiningRoomIDs.remove(spaceRoomProxy.id) }
+        
+        guard case .success = await clientProxy.joinRoom(spaceRoomProxy.id, via: []) else {
+            showFailureIndicator()
+            return
+        }
+        
+        // If multiple join operations are running, then only show the last one.
+        guard state.joiningRoomIDs == [spaceRoomProxy.id] else { return }
+        
+        if spaceRoomProxy.isSpace {
+            await selectSpace(spaceRoomProxy)
+        } else {
+            actionsSubject.send(.selectRoom(roomID: spaceRoomProxy.id))
+        }
+    }
+    
     // MARK: - Indicators
     
     private static var failureIndicatorID: String { "\(Self.self)-Failure" }

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

@@ -11,4 +11,6 @@ import Combine
 protocol SpaceScreenViewModelProtocol {
     var actionsPublisher: AnyPublisher<SpaceScreenViewModelAction, Never> { get }
     var context: SpaceScreenViewModelType.Context { get }
+    
+    func stop()
 }

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

@@ -30,6 +30,7 @@ struct SpaceScreen: View {
         ForEach(context.viewState.rooms, id: \.id) { spaceRoomProxy in
             SpaceRoomCell(spaceRoomProxy: spaceRoomProxy,
                           isSelected: spaceRoomProxy.id == context.viewState.selectedSpaceRoomID,
+                          isJoining: context.viewState.joiningRoomIDs.contains(spaceRoomProxy.id),
                           mediaProvider: context.mediaProvider) { action in
                 context.send(viewAction: .spaceAction(action))
             }
@@ -78,7 +79,7 @@ struct SpaceScreen_Previews: PreviewProvider, TestablePreview {
         let viewModel = SpaceScreenViewModel(spaceRoomListProxy: spaceRoomListProxy,
                                              spaceServiceProxy: SpaceServiceProxyMock(.init()),
                                              selectedSpaceRoomPublisher: .init(nil),
-                                             mediaProvider: MediaProviderMock(configuration: .init()),
+                                             userSession: UserSessionMock(.init()),
                                              userIndicatorController: UserIndicatorControllerMock())
         return viewModel
     }

ElementX/Sources/Services/Client/ClientProxy.swift

@@ -542,6 +542,17 @@ class ClientProxy: ClientProxyProtocol {
         }
     }
     
+    func canJoinRoom(with rules: [AllowRule]) -> Bool {
+        for rule in rules {
+            if case let .roomMembership(roomID) = rule,
+               let room = try? client.getRoom(roomId: roomID),
+               room.membership() == .joined {
+                return true
+            }
+        }
+        return false
+    }
+    
     func uploadMedia(_ media: MediaInfo) async -> Result<String, ClientProxyError> {
         guard let mimeType = media.mimeType else {
             MXLog.error("Failed uploading media, invalid mime type: \(media)")

ElementX/Sources/Services/Client/ClientProxyProtocol.swift

@@ -165,6 +165,8 @@ protocol ClientProxyProtocol: AnyObject {
     
     func knockRoomAlias(_ roomAlias: String, message: String?) async -> Result<Void, ClientProxyError>
     
+    func canJoinRoom(with rules: [AllowRule]) -> Bool
+    
     func uploadMedia(_ media: MediaInfo) async -> Result<String, ClientProxyError>
     
     func roomForIdentifier(_ identifier: String) async -> RoomProxyType?

ElementX/Sources/UITests/UITestsAppCoordinator.swift

@@ -574,7 +574,8 @@ class MockScreen: Identifiable {
             let clientProxy = ClientProxyMock(.init(userID: "@mock:client.com",
                                                     deviceID: "MOCKCLIENT",
                                                     roomSummaryProvider: RoomSummaryProviderMock(.init(state: .loaded(.mockRooms))),
-                                                    joinedSpaceRooms: .mockSingleRoom))
+                                                    joinedSpaceRooms: .mockSingleRoom,
+                                                    roomPreviews: [SpaceRoomProxyProtocol].mockSpaceList.map(RoomPreviewProxyMock.init)))
             
             // The tab bar remains hidden for the non-spaces tests as we don't supply any mock spaces.
             let spaceServiceProxy = SpaceServiceProxyMock(id == .userSessionSpacesFlow ? .populated : .init())

PreviewTests/Sources/__Snapshots__/PreviewTests/joinRoomScreen.RestrictedJoinable-iPad-en-GB.png

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

PreviewTests/Sources/__Snapshots__/PreviewTests/joinRoomScreen.RestrictedJoinable-iPad-pseudo.png

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

PreviewTests/Sources/__Snapshots__/PreviewTests/joinRoomScreen.RestrictedJoinable-iPhone-16-en-GB.png

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

PreviewTests/Sources/__Snapshots__/PreviewTests/joinRoomScreen.RestrictedJoinable-iPhone-16-pseudo.png

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

PreviewTests/Sources/__Snapshots__/PreviewTests/spaceRoomCell.iPad-en-GB-0.png

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:5e2b6b775f3a198e0a52991a296bc1ad5756af00b67c3e867eac90313e62513a
+oid sha256:54368559609ff14224342f399d05e2a5dbd2a8955aaf4154d53b6f0ac356dd3a
-size 207919
+size 237461

PreviewTests/Sources/__Snapshots__/PreviewTests/spaceRoomCell.iPad-pseudo-0.png

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:f95f1258a7467c48a260c4d9968822f7e4a68f07e664c115f9d6a127c1cd2cf6
+oid sha256:074fc2ca164c28f15ab817ebee9f8ec74eb1cb99737996777e03b65873935e5e
-size 237067
+size 278733

PreviewTests/Sources/__Snapshots__/PreviewTests/spaceRoomCell.iPhone-16-en-GB-0.png

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:104cfb4b0707e035efd03a941da0da8a6c01d189e8d1b66ec1ed4ef1e245062c
+oid sha256:37ff651fc4d7b3e559df8148424d5f58935aa885fd51795db37e8ac687ceaf20
-size 149502
+size 173995

PreviewTests/Sources/__Snapshots__/PreviewTests/spaceRoomCell.iPhone-16-pseudo-0.png

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:b4fb5143447b96770909c6a0daddb237e64a3df4e0a48b7aa0d3a60e18c7e586
+oid sha256:3e8846578b4730e1fb88c183078eb2be0fe707f528ec3ae9dd56a4720f5caa2a
-size 167301
+size 197153

UITests/Sources/UserSessionScreenTests.swift

@@ -11,6 +11,7 @@ import XCTest
 class UserSessionScreenTests: XCTestCase {
     let firstRoomName = "Foundation 🔭🪐🌌"
     let firstSpaceName = "The Foundation"
+    let firstSpaceRoomName = "Company Room"
     let firstSubspaceName = "Company Space"
     let firstSubspaceRoomName = "Management"
     
@@ -23,6 +24,7 @@ class UserSessionScreenTests: XCTestCase {
         static let spaceScreen = 6
         static let subspaceScreen = 7
         static let subspaceRoomScreen = 8
+        static let spaceJoinRoomScreen = 9
     }
     
     func testUserSessionFlows() async throws {
@@ -94,5 +96,16 @@ class UserSessionScreenTests: XCTestCase {
         XCTAssert(app.staticTexts[firstSubspaceRoomName].waitForExistence(timeout: 5.0))
         try await Task.sleep(for: .seconds(1))
         try await app.assertScreenshot(step: Step.subspaceRoomScreen)
+        
+        app.navigationBars.buttons[firstSubspaceName].firstMatch.tap(.center)
+        XCTAssert(app.staticTexts[firstSubspaceName].waitForExistence(timeout: 5.0))
+        
+        app.navigationBars.buttons[firstSpaceName].firstMatch.tap(.center)
+        XCTAssert(app.staticTexts[firstSpaceName].waitForExistence(timeout: 5.0))
+        
+        app.buttons[A11yIdentifiers.spaceListScreen.spaceRoomName(firstSpaceRoomName)].tap()
+        XCTAssert(app.staticTexts[firstSpaceRoomName].waitForExistence(timeout: 5.0))
+        try await Task.sleep(for: .seconds(1))
+        try await app.assertScreenshot(step: Step.spaceJoinRoomScreen)
     }
 }

UITests/Sources/__Snapshots__/Application/userSessionScreen.testSpaceExploration-iPad-18-5-en-GB-9.png

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

UITests/Sources/__Snapshots__/Application/userSessionScreen.testSpaceExploration-iPhone-18-5-en-GB-9.png

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

UnitTests/Sources/SpaceScreenViewModelTests.swift

@@ -15,6 +15,7 @@ import MatrixRustSDK
 class SpaceScreenViewModelTests: XCTestCase {
     var spaceRoomListProxy: SpaceRoomListProxyMock!
     let mockSpaceRooms = [SpaceRoomProxyProtocol].mockSpaceList
+    var clientProxy: ClientProxyMock!
     var paginationStateSubject: CurrentValueSubject<SpaceRoomListPaginationState, Never> = .init(.idle(endReached: true))
     
     var viewModel: SpaceScreenViewModelProtocol!
@@ -92,7 +93,7 @@ class SpaceScreenViewModelTests: XCTestCase {
     func testSelectingSpace() async throws {
         setupViewModel()
         
-        let selectedSpace = mockSpaceRooms[0]
+        let selectedSpace = try XCTUnwrap(mockSpaceRooms.first { $0.isSpace }, "There should be a space to select.")
         let deferred = deferFulfillment(viewModel.actionsPublisher) { _ in true }
         viewModel.context.send(viewAction: .spaceAction(.select(selectedSpace)))
         let action = try await deferred.fulfill()
@@ -105,6 +106,76 @@ class SpaceScreenViewModelTests: XCTestCase {
         }
     }
     
+    func testSelectingRoom() async throws {
+        setupViewModel()
+        
+        let selectedRoom = try XCTUnwrap(mockSpaceRooms.first { !$0.isSpace }, "There should be a room to select.")
+        let deferred = deferFulfillment(viewModel.actionsPublisher) { _ in true }
+        viewModel.context.send(viewAction: .spaceAction(.select(selectedRoom)))
+        let action = try await deferred.fulfill()
+        
+        switch action {
+        case .selectRoom(let roomID) where roomID == selectedRoom.id:
+            break
+        default:
+            XCTFail("The action should select the room.")
+        }
+    }
+    
+    func testJoiningSpace() async throws {
+        setupViewModel()
+        
+        let selectedSpace = try XCTUnwrap(mockSpaceRooms.first { $0.isSpace }, "There should be a space to select.")
+        
+        let expectation = XCTestExpectation(description: "Join room")
+        clientProxy.joinRoomViaClosure = { _, _ in
+            expectation.fulfill()
+            return .success(())
+        }
+        let deferred = deferFulfillment(viewModel.actionsPublisher) { _ in true }
+        let deferredState = deferFulfillment(viewModel.context.observe(\.viewState.joiningRoomIDs), transitionValues: [[selectedSpace.id], []])
+        
+        viewModel.context.send(viewAction: .spaceAction(.join(selectedSpace)))
+        
+        await fulfillment(of: [expectation])
+        try await deferredState.fulfill()
+        let action = try await deferred.fulfill()
+        
+        switch action {
+        case .selectSpace(let spaceRoomListProxy) where spaceRoomListProxy.spaceRoomProxy.id == selectedSpace.id:
+            break
+        default:
+            XCTFail("The join should finish by selecting the space.")
+        }
+    }
+    
+    func testJoiningRoom() async throws {
+        setupViewModel()
+        
+        let selectedRoom = try XCTUnwrap(mockSpaceRooms.first { !$0.isSpace }, "There should be a room to select.")
+        
+        let expectation = XCTestExpectation(description: "Join room")
+        clientProxy.joinRoomViaClosure = { _, _ in
+            expectation.fulfill()
+            return .success(())
+        }
+        let deferred = deferFulfillment(viewModel.actionsPublisher) { _ in true }
+        let deferredState = deferFulfillment(viewModel.context.observe(\.viewState.joiningRoomIDs), transitionValues: [[selectedRoom.id], []])
+        
+        viewModel.context.send(viewAction: .spaceAction(.join(selectedRoom)))
+        
+        await fulfillment(of: [expectation])
+        try await deferredState.fulfill()
+        let action = try await deferred.fulfill()
+        
+        switch action {
+        case .selectRoom(let roomID) where roomID == selectedRoom.id:
+            break
+        default:
+            XCTFail("The join should finish by selecting the room.")
+        }
+    }
+    
     // MARK: - Helpers
     
     private func setupViewModel(paginationResponses: [[SpaceRoomProxyProtocol]] = []) {
@@ -115,10 +186,12 @@ class SpaceScreenViewModelTests: XCTestCase {
         let spaceServiceProxy = SpaceServiceProxyMock(.init())
         spaceServiceProxy.spaceRoomListForClosure = { .success(SpaceRoomListProxyMock(.init(spaceRoomProxy: $0))) }
         
+        clientProxy = ClientProxyMock(.init())
+        
         viewModel = SpaceScreenViewModel(spaceRoomListProxy: spaceRoomListProxy,
                                          spaceServiceProxy: spaceServiceProxy,
                                          selectedSpaceRoomPublisher: .init(nil),
-                                         mediaProvider: MediaProviderMock(configuration: .init()),
+                                         userSession: UserSessionMock(.init(clientProxy: clientProxy)),
                                          userIndicatorController: UserIndicatorControllerMock())
     }
 }