Configure the AuthenticationService later now that we have 2 flows on the start screen. (#3316)

* Don't query the homeserver until confirming it (or selecting a different one). * Setup the infrastructure to test AuthenticationService. Implement basic tests for configuration & password login. * Use the real AuthenticationService with a mock Client in all of the tests. * Add tests for the ServerConfirmationScreenViewModel. * Remove redundant view state and test for it.
2026-11-02 21:33:26 +00:00 · 2024-09-25 14:40:18 +01:00
parent af8c16150b
commit a8dbda90d9
44 changed files with 1209 additions and 298 deletions
@@ -0,0 +1,96 @@
+//
+// Copyright 2024 New Vector Ltd.
+//
+// SPDX-License-Identifier: AGPL-3.0-only
+// Please see LICENSE in the repository root for full details.
+//
+
+import XCTest
+
+@testable import ElementX
+
+class AuthenticationServiceTests: XCTestCase {
+    var client: ClientSDKMock!
+    var userSessionStore: UserSessionStoreMock!
+    var encryptionKeyProvider: MockEncryptionKeyProvider!
+    
+    var service: AuthenticationService!
+    
+    func testLogin() async {
+        setupMocks()
+        
+        switch await service.configure(for: "matrix.org", flow: .login) {
+        case .success:
+            break
+        case .failure(let error):
+            XCTFail("Unexpected failure: \(error)")
+        }
+        
+        XCTAssertEqual(service.flow, .login)
+        XCTAssertEqual(service.homeserver.value, .mockMatrixDotOrg)
+        
+        switch await service.login(username: "alice", password: "12345678", initialDeviceName: nil, deviceID: nil) {
+        case .success:
+            XCTAssertEqual(client.loginUsernamePasswordInitialDeviceNameDeviceIdCallsCount, 1)
+            XCTAssertEqual(userSessionStore.userSessionForSessionDirectoriesPassphraseCallsCount, 1)
+            XCTAssertEqual(userSessionStore.userSessionForSessionDirectoriesPassphraseReceivedArguments?.passphrase,
+                           encryptionKeyProvider.generateKey().base64EncodedString())
+        case .failure(let error):
+            XCTFail("Unexpected failure: \(error)")
+        }
+    }
+    
+    func testConfigureRegister() async {
+        setupMocks()
+        
+        switch await service.configure(for: "matrix.org", flow: .register) {
+        case .success:
+            break
+        case .failure(let error):
+            XCTFail("Unexpected failure: \(error)")
+        }
+        
+        XCTAssertEqual(service.flow, .register)
+        XCTAssertEqual(service.homeserver.value, .mockMatrixDotOrg)
+    }
+    
+    func testConfigureRegisterNoSupport() async {
+        let homeserverAddress = "example.com"
+        setupMocks(serverAddress: homeserverAddress)
+        
+        switch await service.configure(for: homeserverAddress, flow: .register) {
+        case .success:
+            XCTFail("Configuration should have failed")
+        case .failure(let error):
+            XCTAssertEqual(error, .registrationNotSupported)
+        }
+        
+        XCTAssertEqual(service.flow, .login)
+        XCTAssertEqual(service.homeserver.value, .init(address: "matrix.org", loginMode: .unknown))
+    }
+    
+    // MARK: - Helpers
+    
+    private func setupMocks(serverAddress: String = "matrix.org") {
+        let configuration: AuthenticationClientBuilderMock.Configuration = .init()
+        let clientBuilderFactory = AuthenticationClientBuilderFactoryMock(configuration: .init(builderConfiguration: configuration))
+        
+        client = configuration.homeserverClients[serverAddress]
+        userSessionStore = UserSessionStoreMock(configuration: .init())
+        encryptionKeyProvider = MockEncryptionKeyProvider()
+        
+        service = AuthenticationService(userSessionStore: userSessionStore,
+                                        encryptionKeyProvider: encryptionKeyProvider,
+                                        clientBuilderFactory: clientBuilderFactory,
+                                        appSettings: ServiceLocator.shared.settings,
+                                        appHooks: AppHooks())
+    }
+}
+
+struct MockEncryptionKeyProvider: EncryptionKeyProviderProtocol {
+    private let key = "12345678"
+    
+    func generateKey() -> Data {
+        Data(key.utf8)
+    }
+}
@@ -26,18 +26,11 @@ class ServerConfirmationScreenViewStateTests: XCTestCase {
    
    func testRegisterMessageString() {
        let matrixDotOrgRegister = ServerConfirmationScreenViewState(homeserverAddress: LoginHomeserver.mockMatrixDotOrg.address,
-                                                                     authenticationFlow: .register,
-                                                                     homeserverSupportsRegistration: true)
+                                                                     authenticationFlow: .register)
        XCTAssertEqual(matrixDotOrgRegister.message, L10n.screenServerConfirmationMessageRegister, "The registration message should always be the same.")
        
        let oidcRegister = ServerConfirmationScreenViewState(homeserverAddress: LoginHomeserver.mockOIDC.address,
-                                                             authenticationFlow: .register,
-                                                             homeserverSupportsRegistration: true)
+                                                             authenticationFlow: .register)
        XCTAssertEqual(oidcRegister.message, L10n.screenServerConfirmationMessageRegister, "The registration message should always be the same.")
-        
-        let otherRegister = ServerConfirmationScreenViewState(homeserverAddress: LoginHomeserver.mockBasicServer.address,
-                                                              authenticationFlow: .register,
-                                                              homeserverSupportsRegistration: false)
-        XCTAssertEqual(otherRegister.message, L10n.errorAccountCreationNotPossible, "The registration message should always be the same.")
    }
 }
@@ -11,5 +11,117 @@ import XCTest

@MainActor
 class ServerConfirmationScreenViewModelTests: XCTestCase {
-    // Nothing to test, the view model has no mutable state.
+    var clientBuilderFactory: AuthenticationClientBuilderFactoryMock!
+    var service: AuthenticationServiceProtocol!
+    
+    var viewModel: ServerConfirmationScreenViewModel!
+    var context: ServerConfirmationScreenViewModel.Context { viewModel.context }
+    
+    func testConfirmLoginWithoutConfiguration() async throws {
+        // Given a view model for login using a service that hasn't been configured.
+        setupViewModel(authenticationFlow: .login)
+        XCTAssertEqual(service.homeserver.value.loginMode, .unknown)
+        XCTAssertEqual(clientBuilderFactory.makeBuilderSessionDirectoriesPassphraseClientSessionDelegateAppSettingsAppHooksCallsCount, 0)
+        
+        // When continuing from the confirmation screen.
+        let deferred = deferFulfillment(viewModel.actions) { $0 == .confirm }
+        context.send(viewAction: .confirm)
+        try await deferred.fulfill()
+        
+        // Then a call to configure service should be made.
+        XCTAssertEqual(clientBuilderFactory.makeBuilderSessionDirectoriesPassphraseClientSessionDelegateAppSettingsAppHooksCallsCount, 1)
+        XCTAssertNotEqual(service.homeserver.value.loginMode, .unknown)
+    }
+    
+    func testConfirmLoginAfterConfiguration() async throws {
+        // Given a view model for login using a service that has already been configured (via the server selection screen).
+        setupViewModel(authenticationFlow: .login)
+        guard case .success = await service.configure(for: viewModel.state.homeserverAddress, flow: .login) else {
+            XCTFail("The configuration should succeed.")
+            return
+        }
+        XCTAssertNotEqual(service.homeserver.value.loginMode, .unknown)
+        XCTAssertEqual(clientBuilderFactory.makeBuilderSessionDirectoriesPassphraseClientSessionDelegateAppSettingsAppHooksCallsCount, 1)
+        
+        // When continuing from the confirmation screen.
+        let deferred = deferFulfillment(viewModel.actions) { $0 == .confirm }
+        context.send(viewAction: .confirm)
+        try await deferred.fulfill()
+        
+        // Then the configured homeserver should be used and no additional call should be made to the service.
+        XCTAssertEqual(clientBuilderFactory.makeBuilderSessionDirectoriesPassphraseClientSessionDelegateAppSettingsAppHooksCallsCount, 1)
+    }
+    
+    func testConfirmRegisterWithoutConfiguration() async throws {
+        // Given a view model for registration using a service that hasn't been configured.
+        setupViewModel(authenticationFlow: .register)
+        XCTAssertEqual(service.homeserver.value.loginMode, .unknown)
+        XCTAssertEqual(clientBuilderFactory.makeBuilderSessionDirectoriesPassphraseClientSessionDelegateAppSettingsAppHooksCallsCount, 0)
+        
+        // When continuing from the confirmation screen.
+        let deferred = deferFulfillment(viewModel.actions) { $0 == .confirm }
+        context.send(viewAction: .confirm)
+        try await deferred.fulfill()
+        
+        // Then a call to configure service should be made.
+        XCTAssertEqual(clientBuilderFactory.makeBuilderSessionDirectoriesPassphraseClientSessionDelegateAppSettingsAppHooksCallsCount, 1)
+        XCTAssertNotEqual(service.homeserver.value.loginMode, .unknown)
+    }
+    
+    func testConfirmRegisterAfterConfiguration() async throws {
+        // Given a view model for registration using a service that has already been configured (via the server selection screen).
+        setupViewModel(authenticationFlow: .register)
+        guard case .success = await service.configure(for: viewModel.state.homeserverAddress, flow: .register) else {
+            XCTFail("The configuration should succeed.")
+            return
+        }
+        XCTAssertNotEqual(service.homeserver.value.loginMode, .unknown)
+        XCTAssertEqual(clientBuilderFactory.makeBuilderSessionDirectoriesPassphraseClientSessionDelegateAppSettingsAppHooksCallsCount, 1)
+        
+        // When continuing from the confirmation screen.
+        let deferred = deferFulfillment(viewModel.actions) { $0 == .confirm }
+        context.send(viewAction: .confirm)
+        try await deferred.fulfill()
+        
+        // Then the configured homeserver should be used and no additional call should be made to the service.
+        XCTAssertEqual(clientBuilderFactory.makeBuilderSessionDirectoriesPassphraseClientSessionDelegateAppSettingsAppHooksCallsCount, 1)
+    }
+    
+    func testRegistrationNotSupportedAlert() async throws {
+        // Given a view model for registration using a service that hasn't been configured and the default server doesn't support registration.
+        setupViewModel(authenticationFlow: .register, elementWellKnown: false)
+        XCTAssertEqual(service.homeserver.value.loginMode, .unknown)
+        XCTAssertFalse(service.homeserver.value.supportsRegistration)
+        XCTAssertEqual(clientBuilderFactory.makeBuilderSessionDirectoriesPassphraseClientSessionDelegateAppSettingsAppHooksCallsCount, 0)
+        XCTAssertNil(context.alertInfo)
+        
+        // When continuing from the confirmation screen.
+        let deferred = deferFulfillment(context.$viewState) { $0.bindings.alertInfo != nil }
+        context.send(viewAction: .confirm)
+        try await deferred.fulfill()
+        
+        // Then the configured homeserver should be used and no additional call should be made to the service.
+        XCTAssertEqual(clientBuilderFactory.makeBuilderSessionDirectoriesPassphraseClientSessionDelegateAppSettingsAppHooksCallsCount, 1)
+        XCTAssertEqual(context.alertInfo?.id, .registration)
+    }
+    
+    // MARK: - Helpers
+    
+    private func setupViewModel(authenticationFlow: AuthenticationFlow, elementWellKnown: Bool = true) {
+        let client = ClientSDKMock(configuration: elementWellKnown ? .init() : .init(elementWellKnown: ""))
+        let configuration = AuthenticationClientBuilderMock.Configuration(homeserverClients: ["matrix.org": client],
+                                                                          qrCodeClient: client)
+        
+        clientBuilderFactory = AuthenticationClientBuilderFactoryMock(configuration: .init(builderConfiguration: configuration))
+        service = AuthenticationService(userSessionStore: UserSessionStoreMock(configuration: .init()),
+                                        encryptionKeyProvider: EncryptionKeyProvider(),
+                                        clientBuilderFactory: clientBuilderFactory,
+                                        appSettings: ServiceLocator.shared.settings,
+                                        appHooks: AppHooks())
+        
+        viewModel = ServerConfirmationScreenViewModel(authenticationService: service,
+                                                      authenticationFlow: authenticationFlow,
+                                                      slidingSyncLearnMoreURL: ServiceLocator.shared.settings.slidingSyncLearnMoreURL,
+                                                      userIndicatorController: UserIndicatorControllerMock())
+    }
 }
@@ -16,8 +16,7 @@ class ServerSelectionViewModelTests: XCTestCase {
    
    @MainActor override func setUp() {
        viewModel = ServerSelectionScreenViewModel(homeserverAddress: "",
-                                                   slidingSyncLearnMoreURL: ServiceLocator.shared.settings.slidingSyncLearnMoreURL,
-                                                   isModallyPresented: true)
+                                                   slidingSyncLearnMoreURL: ServiceLocator.shared.settings.slidingSyncLearnMoreURL)
        context = viewModel.context
    }