code polishing and test improvement

ElementX/Sources/Mocks/RoomPreviewProxyMock.swift

@@ -43,7 +43,7 @@ extension RoomPreviewProxyMock {
         return .init(.init(membership: .invited, joinRule: .invite))
     }
 
-    static func dmInvite(roomID: String? = nil) -> RoomPreviewProxyMock {
+    static func inviteDM(roomID: String? = nil) -> RoomPreviewProxyMock {
         if let roomID {
             return .init(.init(roomID: roomID, topic: nil, numJoinedMembers: 1, membership: .invited, joinRule: .invite, isDirect: true))
         }

ElementX/Sources/Screens/JoinRoomScreen/JoinRoomScreenModels.swift

@@ -18,10 +18,11 @@ enum JoinRoomScreenMode: Equatable {
     case joinable
     case restricted
     case inviteRequired
-    case invited
+    case invited(isDM: Bool)
     case knockable
     case knocked
     case banned(sender: String?, reason: String?)
+    case forbidden
 }
 
 struct JoinRoomScreenRoomDetails {
@@ -40,9 +41,7 @@ struct JoinRoomScreenViewState: BindableState {
     var roomDetails: JoinRoomScreenRoomDetails?
 
     var mode: JoinRoomScreenMode = .loading
-
-    var shouldShowForbiddenError = false
-
+
     var bindings = JoinRoomScreenViewStateBindings()
 
     var title: String {
@@ -54,15 +53,16 @@ struct JoinRoomScreenViewState: BindableState {
     }
 
     var subtitle: String? {
-        if isDMInvite, let inviter = roomDetails?.inviter {
-            return inviter.displayName != nil ? inviter.id : nil
-        } else {
-            switch mode {
-            case .loading, .unknown, .knocked:
-                return nil
-            default:
-                return roomDetails?.canonicalAlias
+        switch mode {
+        case .invited(isDM: true):
+            if let inviter = roomDetails?.inviter {
+                return inviter.displayName != nil ? inviter.id : nil
             }
+            return nil
+        case .loading, .unknown, .knocked:
+            return nil
+        default:
+            return roomDetails?.canonicalAlias
         }
     }
 
@@ -79,7 +79,7 @@ struct JoinRoomScreenViewState: BindableState {
     }
 
     var isDMInvite: Bool {
-        mode == .invited && roomDetails?.isDirect == true && roomDetails?.memberCount == 1
+        mode == .invited(isDM: true)
     }
 }
 

ElementX/Sources/Screens/JoinRoomScreen/JoinRoomScreenViewModel.swift

@@ -165,7 +165,7 @@ class JoinRoomScreenViewModel: JoinRoomScreenViewModelType, JoinRoomScreenViewMo
 
             switch roomPreview.info.membership {
             case .invited:
-                state.mode = .invited
+                state.mode = .invited(isDM: state.roomDetails?.isDirect == true && state.roomDetails?.memberCount == 1)
             case .knocked:
                 state.mode = .knocked
             case .banned:
@@ -186,7 +186,7 @@ class JoinRoomScreenViewModel: JoinRoomScreenViewModelType, JoinRoomScreenViewMo
         } else if let room {
             switch room {
             case .invited:
-                state.mode = .invited
+                state.mode = .invited(isDM: state.roomDetails?.isDirect == true && state.roomDetails?.memberCount == 1)
             case .knocked:
                 state.mode = .knocked
             case .banned:
@@ -212,7 +212,7 @@ class JoinRoomScreenViewModel: JoinRoomScreenViewModelType, JoinRoomScreenViewMo
             case .failure(let error):
                 if case .forbiddenAccess = error {
                     MXLog.error("Failed joining room alias: \(alias) forbidden access")
-                    state.shouldShowForbiddenError = true
+                    state.mode = .forbidden
                 } else {
                     MXLog.error("Failed joining room alias: \(alias) with error: \(error)")
                     userIndicatorController.submitIndicator(.init(title: L10n.errorUnknown))
@@ -225,7 +225,7 @@ class JoinRoomScreenViewModel: JoinRoomScreenViewModelType, JoinRoomScreenViewMo
             case .failure(let error):
                 if case .forbiddenAccess = error {
                     MXLog.error("Failed joining room id: \(roomID) forbidden access")
-                    state.shouldShowForbiddenError = true
+                    state.mode = .forbidden
                 } else {
                     MXLog.error("Failed joining room id: \(roomID) with error: \(error)")
                     userIndicatorController.submitIndicator(.init(title: L10n.errorUnknown))

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

@@ -161,20 +161,12 @@ struct JoinRoomScreen: View {
         case .loading:
             EmptyView()
         case .joinable:
-            if context.viewState.shouldShowForbiddenError {
-                forbiddenView
-            } else {
-                joinButton
-            }
+            joinButton
         case .unknown, .restricted: // If unknown, do our best.
-            if context.viewState.shouldShowForbiddenError {
-                forbiddenView
-            } else {
-                VStack(spacing: 24) {
-                    bottomNoticeMessage(L10n.screenJoinRoomJoinRestrictedMessage)
-
-                    joinButton
-                }
+            VStack(spacing: 24) {
+                bottomNoticeMessage(L10n.screenJoinRoomJoinRestrictedMessage)
+
+                joinButton
             }
         case .knockable:
             Button(L10n.screenJoinRoomKnockAction) { context.send(viewAction: .knock) }
@@ -203,6 +195,8 @@ struct JoinRoomScreen: View {
                 }
                 .buttonStyle(.compound(.primary))
             }
+        case .forbidden:
+            forbiddenView
         }
     }
 
@@ -285,35 +279,51 @@ struct JoinRoomScreen_Previews: PreviewProvider, TestablePreview {
     static let joinableViewModel = makeViewModel(mode: .joinable)
     static let restrictedViewModel = makeViewModel(mode: .restricted)
     static let inviteRequiredViewModel = makeViewModel(mode: .inviteRequired)
-    static let invitedViewModel = makeViewModel(mode: .invited)
-    static let dmInviteViewModel = makeViewModel(mode: .invited, isDM: true)
+    static let invitedViewModel = makeViewModel(mode: .invited(isDM: false))
+    static let invitedDMViewModel = makeViewModel(mode: .invited(isDM: true))
     static let knockableViewModel = makeViewModel(mode: .knockable)
     static let knockedViewModel = makeViewModel(mode: .knocked)
     static let bannedViewModel = makeViewModel(mode: .banned(sender: "Bob", reason: "Spamming"))
+    static let forbiddenViewModel = makeViewModel(mode: .forbidden)
 
     static var previews: some View {
-        makePreview(viewModel: unknownViewModel, previewDisplayName: "Unknown")
-        makePreview(viewModel: joinableViewModel, previewDisplayName: "Joinable")
-        makePreview(viewModel: restrictedViewModel, previewDisplayName: "Restricted")
-        makePreview(viewModel: inviteRequiredViewModel, previewDisplayName: "InviteRequired")
-        makePreview(viewModel: invitedViewModel, previewDisplayName: "Invited")
-        makePreview(viewModel: dmInviteViewModel, previewDisplayName: "DM Invite")
-        makePreview(viewModel: knockableViewModel, previewDisplayName: "Knockable")
-        makePreview(viewModel: knockedViewModel, previewDisplayName: "Knocked")
-        makePreview(viewModel: bannedViewModel, previewDisplayName: "Banned")
+        makePreview(viewModel: unknownViewModel, mode: .unknown)
+        makePreview(viewModel: joinableViewModel, mode: .joinable)
+        makePreview(viewModel: restrictedViewModel, mode: .restricted)
+        makePreview(viewModel: inviteRequiredViewModel, mode: .inviteRequired)
+        makePreview(viewModel: invitedViewModel, mode: .invited(isDM: false))
+        makePreview(viewModel: invitedDMViewModel, mode: .invited(isDM: true))
+        makePreview(viewModel: knockableViewModel, mode: .knockable)
+        makePreview(viewModel: knockedViewModel, mode: .knocked)
+        makePreview(viewModel: bannedViewModel, mode: .banned(sender: nil, reason: nil))
+        makePreview(viewModel: forbiddenViewModel, mode: .forbidden)
     }
 
-    static func makePreview(viewModel: JoinRoomScreenViewModel, previewDisplayName: String) -> some View {
-        NavigationStack {
-            JoinRoomScreen(context: viewModel.context)
+    @ViewBuilder
+    static func makePreview(viewModel: JoinRoomScreenViewModel, mode: JoinRoomScreenMode) -> some View {
+        if mode == .forbidden {
+            NavigationStack {
+                JoinRoomScreen(context: viewModel.context)
+            }
+            .snapshotPreferences(expect: viewModel.context.$viewState.map { state in
+                state.mode == .forbidden
+            })
+            .onAppear {
+                forbiddenViewModel.context.send(viewAction: .join)
+            }
+            .previewDisplayName(mode.previewDisplayName)
+        } else {
+            NavigationStack {
+                JoinRoomScreen(context: viewModel.context)
+            }
+            .snapshotPreferences(expect: viewModel.context.$viewState.map { state in
+                state.roomDetails != nil
+            })
+            .previewDisplayName(mode.previewDisplayName)
         }
-        .snapshotPreferences(expect: viewModel.context.$viewState.map { state in
-            state.roomDetails != nil
-        })
-        .previewDisplayName(previewDisplayName)
     }
 
-    static func makeViewModel(mode: JoinRoomScreenMode, isDM: Bool = false) -> JoinRoomScreenViewModel {
+    static func makeViewModel(mode: JoinRoomScreenMode) -> JoinRoomScreenViewModel {
         ServiceLocator.shared.settings.knockingEnabled = true
 
         let clientProxy = ClientProxyMock(.init())
@@ -331,9 +341,9 @@ struct JoinRoomScreen_Previews: PreviewProvider, TestablePreview {
         case .inviteRequired:
             clientProxy.roomPreviewForIdentifierViaReturnValue = .success(RoomPreviewProxyMock.inviteRequired)
             clientProxy.roomForIdentifierReturnValue = nil
-        case .invited:
+        case .invited(let isDM):
             if isDM {
-                clientProxy.roomPreviewForIdentifierViaReturnValue = .success(RoomPreviewProxyMock.dmInvite())
+                clientProxy.roomPreviewForIdentifierViaReturnValue = .success(RoomPreviewProxyMock.inviteDM())
                 clientProxy.roomForIdentifierClosure = { _ in
                     .invited(InvitedRoomProxyMock(.init(avatarURL: .mockMXCAvatar)))
                 }
@@ -356,6 +366,12 @@ struct JoinRoomScreen_Previews: PreviewProvider, TestablePreview {
             clientProxy.roomForIdentifierClosure = { _ in
                 .banned
             }
+        case .forbidden:
+            clientProxy.roomPreviewForIdentifierViaReturnValue = .success(RoomPreviewProxyMock.restricted)
+            clientProxy.roomForIdentifierReturnValue = nil
+            clientProxy.joinRoomAliasClosure = { _ in
+                .failure(.forbiddenAccess)
+            }
         default:
             break
         }
@@ -368,3 +384,30 @@ struct JoinRoomScreen_Previews: PreviewProvider, TestablePreview {
                                        userIndicatorController: ServiceLocator.shared.userIndicatorController)
     }
 }
+
+private extension JoinRoomScreenMode {
+    var previewDisplayName: String {
+        switch self {
+        case .unknown:
+            return "Unknown"
+        case .loading:
+            return "Loading"
+        case .joinable:
+            return "Joinable"
+        case .restricted:
+            return "Restricted"
+        case .inviteRequired:
+            return "InviteRequired"
+        case .invited(isDM: let isDM):
+            return isDM ? "InvitedDM" : "Invited"
+        case .knockable:
+            return "Knockable"
+        case .knocked:
+            return "Knocked"
+        case .banned:
+            return "Banned"
+        case .forbidden:
+            return "Forbidden"
+        }
+    }
+}