From 6887092ce45bc16a8e1c301c7f51f9f0cc812df3 Mon Sep 17 00:00:00 2001 From: Benoit Marty Date: Wed, 2 Sep 2026 17:54:08 +0200 Subject: [PATCH] Replace String by AccountProvider to be able to get baseUrl and serverName. --- .../android/appconfig/AuthenticationConfig.kt | 7 - .../io/element/android/appnav/RootFlowNode.kt | 5 +- enterprise | 2 +- .../enterprise/api/EnterpriseService.kt | 30 ++-- .../impl/DefaultEnterpriseService.kt | 6 +- .../impl/DefaultEnterpriseServiceTest.kt | 15 +- .../enterprise/test/FakeEnterpriseService.kt | 18 ++- features/login/api/build.gradle.kts | 1 + .../AccountProviderAccessControl.kt | 6 +- .../DefaultAccountProviderAccessControl.kt | 20 +-- .../impl/accountprovider/AccountProvider.kt | 17 --- .../AccountProviderDataSource.kt | 31 ++--- .../AccountProviderPreviewParam.kt | 32 ++--- .../accountprovider/AccountProviderView.kt | 43 +----- .../SaveAccountProviderToHistory.kt | 9 +- .../impl/changeserver/ChangeServerEvent.kt | 2 +- .../changeserver/ChangeServerPresenter.kt | 11 +- .../ChooseAccountProviderEvent.kt | 2 +- .../ChooseAccountProviderPresenter.kt | 20 +-- .../ChooseAccountProviderState.kt | 2 +- .../ChooseAccountProviderStatePreviewParam.kt | 28 ++-- .../ChooseAccountProviderView.kt | 10 +- .../ConfirmAccountProviderPresenter.kt | 29 ++-- .../loginpassword/LoginPasswordState.kt | 2 +- .../LoginPasswordStatePreviewParam.kt | 6 +- .../loginpassword/LoginPasswordView.kt | 2 +- .../screens/onboarding/OnBoardingEvent.kt | 4 +- .../screens/onboarding/OnBoardingPresenter.kt | 45 +++--- .../screens/onboarding/OnBoardingState.kt | 3 +- .../onboarding/OnBoardingStatePreviewParam.kt | 9 +- .../impl/screens/onboarding/OnBoardingView.kt | 2 +- .../impl/src/main/res/drawable/ic_matrix.xml | 12 -- ...DefaultAccountProviderAccessControlTest.kt | 90 ++++++------ .../AccountProviderDataSourceTest.kt | 131 +++++++----------- .../SaveAccountProviderToHistoryTest.kt | 6 +- .../changeserver/ChangeServerPresenterTest.kt | 45 +++--- .../ChooseAccountProviderPresenterTest.kt | 25 +--- .../ChooseAccountProviderStateTest.kt | 8 +- .../ChooseAccountProviderViewTest.kt | 6 +- .../ConfirmAccountProviderPresenterTest.kt | 59 +++++--- .../LoginPasswordPresenterTest.kt | 6 +- .../onboarding/OnBoardingPresenterTest.kt | 79 +++++++++-- .../screens/onboarding/OnboardingViewTest.kt | 7 +- features/login/test/build.gradle.kts | 1 + .../FakeAccountProviderAccessControl.kt | 7 +- .../api/accountprovider/AccountProvider.kt | 67 +++++++++ .../accountprovider/AccountProviderTest.kt | 89 ++++++++++++ .../accountprovider/AccountProviderFixture.kt | 28 ++++ 48 files changed, 608 insertions(+), 477 deletions(-) delete mode 100644 features/login/impl/src/main/kotlin/io/element/android/features/login/impl/accountprovider/AccountProvider.kt delete mode 100644 features/login/impl/src/main/res/drawable/ic_matrix.xml create mode 100644 libraries/matrix/api/src/main/kotlin/io/element/android/libraries/matrix/api/accountprovider/AccountProvider.kt create mode 100644 libraries/matrix/api/src/test/kotlin/io/element/android/libraries/matrix/api/accountprovider/AccountProviderTest.kt create mode 100644 libraries/matrix/test/src/main/kotlin/io/element/android/libraries/matrix/test/accountprovider/AccountProviderFixture.kt diff --git a/appconfig/src/main/kotlin/io/element/android/appconfig/AuthenticationConfig.kt b/appconfig/src/main/kotlin/io/element/android/appconfig/AuthenticationConfig.kt index 7432a6904f..a04abe1417 100644 --- a/appconfig/src/main/kotlin/io/element/android/appconfig/AuthenticationConfig.kt +++ b/appconfig/src/main/kotlin/io/element/android/appconfig/AuthenticationConfig.kt @@ -9,15 +9,8 @@ package io.element.android.appconfig object AuthenticationConfig { - const val MATRIX_ORG_URL = "https://matrix.org" - /** * URL with some docs that explain what's sliding sync and how to add it to your home server. */ const val SLIDING_SYNC_READ_MORE_URL = "https://github.com/matrix-org/sliding-sync/blob/main/docs/Landing.md" - - /** - * Force a sliding sync proxy url, if not null, the proxy url in the .well-known file will be ignored. - */ - val SLIDING_SYNC_PROXY_URL: String? = null } diff --git a/appnav/src/main/kotlin/io/element/android/appnav/RootFlowNode.kt b/appnav/src/main/kotlin/io/element/android/appnav/RootFlowNode.kt index c9deaeb3b3..5f2dc837ad 100644 --- a/appnav/src/main/kotlin/io/element/android/appnav/RootFlowNode.kt +++ b/appnav/src/main/kotlin/io/element/android/appnav/RootFlowNode.kt @@ -52,11 +52,11 @@ import io.element.android.libraries.architecture.BaseFlowNode import io.element.android.libraries.architecture.appyx.rememberDelegateTransitionHandler import io.element.android.libraries.architecture.createNode import io.element.android.libraries.architecture.waitForChildAttached -import io.element.android.libraries.core.uri.ensureProtocol import io.element.android.libraries.deeplink.api.DeeplinkData import io.element.android.libraries.di.annotations.AppCoroutineScope import io.element.android.libraries.featureflag.api.FeatureFlagService import io.element.android.libraries.featureflag.api.FeatureFlags +import io.element.android.libraries.matrix.api.accountprovider.AccountProvider import io.element.android.libraries.matrix.api.core.EventId import io.element.android.libraries.matrix.api.core.SessionId import io.element.android.libraries.matrix.api.core.ThreadId @@ -410,7 +410,8 @@ class RootFlowNode( } private suspend fun onLoginLink(params: LoginParams) { - if (accountProviderAccessControl.isAllowedToConnectToAccountProvider(params.accountProvider.ensureProtocol())) { + val accountProvider = AccountProvider.Generic(params.accountProvider) + if (accountProviderAccessControl.isAllowedToConnectToAccountProvider(accountProvider)) { // Is there a session already? val sessions = sessionStore.getAllSessions() if (sessions.isNotEmpty()) { diff --git a/enterprise b/enterprise index f463003f68..307b0fd01f 160000 --- a/enterprise +++ b/enterprise @@ -1 +1 @@ -Subproject commit f463003f6813ad33fc00f80786bc83b6a7f0d8e2 +Subproject commit 307b0fd01f36191dddf6b51ed9ceb92887b360a2 diff --git a/features/enterprise/api/src/main/kotlin/io/element/android/features/enterprise/api/EnterpriseService.kt b/features/enterprise/api/src/main/kotlin/io/element/android/features/enterprise/api/EnterpriseService.kt index 2cb4a356be..5483d1e60e 100644 --- a/features/enterprise/api/src/main/kotlin/io/element/android/features/enterprise/api/EnterpriseService.kt +++ b/features/enterprise/api/src/main/kotlin/io/element/android/features/enterprise/api/EnterpriseService.kt @@ -11,6 +11,7 @@ package io.element.android.features.enterprise.api import androidx.compose.ui.graphics.Color import io.element.android.compound.colors.SemanticColorsLightDark import io.element.android.libraries.matrix.api.ClientUrlContentFetcher +import io.element.android.libraries.matrix.api.accountprovider.AccountProvider import io.element.android.libraries.matrix.api.core.SessionId import kotlinx.coroutines.flow.Flow @@ -36,18 +37,21 @@ interface EnterpriseService { suspend fun tweakMasUrl(url: String, urlContentFetcher: ClientUrlContentFetcher): String /** - * Returns the list of homeservers the user is allowed to sign in to. - * - * If the list is empty or contains the special value [ANY_ACCOUNT_PROVIDER], the user is allowed to sign in to any homeserver. + * Returns the list of account provider the user is allowed to sign in to. */ - fun homeserverAllowList(): List + fun accountProviderAllowList(): List /** - * Whether the user is allowed to sign in to a given homeserver, according to [homeserverAllowList]. - * - * @param homeserverUrl the server the user is trying to use. + * Whether the user is allowed to sign in to any account provider. */ - suspend fun isAllowedToConnectToHomeserver(homeserverUrl: String): Boolean + fun canConnectToAnyAccountProvider(): Boolean + + /** + * Whether the user is allowed to sign in to a given homeserver, according to [accountProviderAllowList]. + * + * @param accountProvider the account provider the user is trying to use. + */ + suspend fun isAllowedToConnectToAccountProvider(accountProvider: AccountProvider): Boolean /** * Whether the given homeserver enforces the use of Element Pro or a derived app. @@ -97,14 +101,4 @@ interface EnterpriseService { * @param sessionId the session whose channel is requested. */ fun getNoisyNotificationChannelId(sessionId: SessionId): String? - - companion object { - const val ANY_ACCOUNT_PROVIDER = "*" - } -} - -fun EnterpriseService.canConnectToAnyHomeserver(): Boolean { - return homeserverAllowList().let { - it.isEmpty() || it.contains(EnterpriseService.ANY_ACCOUNT_PROVIDER) - } } diff --git a/features/enterprise/impl-foss/src/main/kotlin/io/element/android/features/enterprise/impl/DefaultEnterpriseService.kt b/features/enterprise/impl-foss/src/main/kotlin/io/element/android/features/enterprise/impl/DefaultEnterpriseService.kt index 6ccf70cd02..02fa9b282c 100644 --- a/features/enterprise/impl-foss/src/main/kotlin/io/element/android/features/enterprise/impl/DefaultEnterpriseService.kt +++ b/features/enterprise/impl-foss/src/main/kotlin/io/element/android/features/enterprise/impl/DefaultEnterpriseService.kt @@ -19,6 +19,7 @@ import io.element.android.libraries.core.extensions.mapCatchingExceptions import io.element.android.libraries.core.uri.ensureProtocol import io.element.android.libraries.matrix.api.ClientUrlContentFetcher import io.element.android.libraries.matrix.api.TemporaryMatrixClientFactory +import io.element.android.libraries.matrix.api.accountprovider.AccountProvider import io.element.android.libraries.matrix.api.core.SessionId import kotlinx.coroutines.flow.Flow import kotlinx.coroutines.flow.flowOf @@ -33,8 +34,9 @@ class DefaultEnterpriseService( ) : EnterpriseService { override suspend fun isEnterpriseUser(sessionId: SessionId) = false override suspend fun tweakMasUrl(url: String, urlContentFetcher: ClientUrlContentFetcher) = url - override fun homeserverAllowList(): List = emptyList() - override suspend fun isAllowedToConnectToHomeserver(homeserverUrl: String) = true + override fun accountProviderAllowList(): List = emptyList() + override fun canConnectToAnyAccountProvider(): Boolean = true + override suspend fun isAllowedToConnectToAccountProvider(accountProvider: AccountProvider) = true override suspend fun isElementProEnforced(serverName: String): Boolean { val temporaryMatrixClient = temporaryMatrixClientFactory.create(serverName).getOrElse { return false } return temporaryMatrixClient.use { client -> diff --git a/features/enterprise/impl-foss/src/test/kotlin/io/element/android/features/enterprise/impl/DefaultEnterpriseServiceTest.kt b/features/enterprise/impl-foss/src/test/kotlin/io/element/android/features/enterprise/impl/DefaultEnterpriseServiceTest.kt index 026c9caf9e..f43284e0bd 100644 --- a/features/enterprise/impl-foss/src/test/kotlin/io/element/android/features/enterprise/impl/DefaultEnterpriseServiceTest.kt +++ b/features/enterprise/impl-foss/src/test/kotlin/io/element/android/features/enterprise/impl/DefaultEnterpriseServiceTest.kt @@ -18,6 +18,7 @@ import io.element.android.libraries.matrix.test.A_HOMESERVER_URL import io.element.android.libraries.matrix.test.A_SESSION_ID import io.element.android.libraries.matrix.test.FakeTemporaryMatrixClient import io.element.android.libraries.matrix.test.FakeTemporaryMatrixClientFactory +import io.element.android.libraries.matrix.test.accountprovider.anAccountProviderGeneric import io.element.android.tests.testutils.lambda.lambdaRecorder import io.element.android.tests.testutils.lambda.value import kotlinx.coroutines.test.runTest @@ -26,15 +27,21 @@ import org.junit.Test class DefaultEnterpriseServiceTest { @Test - fun homeserverWhitelist() { + fun accountProviderAllowList() { val defaultEnterpriseService = createDefaultEnterpriseService() - assertThat(defaultEnterpriseService.homeserverAllowList()).isEmpty() + assertThat(defaultEnterpriseService.accountProviderAllowList()).isEmpty() } @Test - fun `isAllowedToConnectToHomeserver is true for all homeserver urls`() = runTest { + fun `canConnectToAnyAccountProvider is always true`() { val defaultEnterpriseService = createDefaultEnterpriseService() - assertThat(defaultEnterpriseService.isAllowedToConnectToHomeserver(A_HOMESERVER_URL)).isTrue() + assertThat(defaultEnterpriseService.canConnectToAnyAccountProvider()).isTrue() + } + + @Test + fun `isAllowedToConnectToAccountProvider is true for all account providers`() = runTest { + val defaultEnterpriseService = createDefaultEnterpriseService() + assertThat(defaultEnterpriseService.isAllowedToConnectToAccountProvider(anAccountProviderGeneric())).isTrue() } @Test diff --git a/features/enterprise/test/src/main/kotlin/io/element/android/features/enterprise/test/FakeEnterpriseService.kt b/features/enterprise/test/src/main/kotlin/io/element/android/features/enterprise/test/FakeEnterpriseService.kt index a8efcb5873..3ca30d410d 100644 --- a/features/enterprise/test/src/main/kotlin/io/element/android/features/enterprise/test/FakeEnterpriseService.kt +++ b/features/enterprise/test/src/main/kotlin/io/element/android/features/enterprise/test/FakeEnterpriseService.kt @@ -13,6 +13,7 @@ import io.element.android.compound.colors.SemanticColorsLightDark import io.element.android.features.enterprise.api.BugReportUrl import io.element.android.features.enterprise.api.EnterpriseService import io.element.android.libraries.matrix.api.ClientUrlContentFetcher +import io.element.android.libraries.matrix.api.accountprovider.AccountProvider import io.element.android.libraries.matrix.api.core.SessionId import io.element.android.tests.testutils.lambda.lambdaError import io.element.android.tests.testutils.simulateLongTask @@ -22,8 +23,9 @@ import kotlinx.coroutines.flow.asStateFlow class FakeEnterpriseService( private val isEnterpriseUserResult: (SessionId) -> Boolean = { lambdaError() }, - private val defaultHomeserverListResult: () -> List = { emptyList() }, - private val isAllowedToConnectToHomeserverResult: (String) -> Boolean = { lambdaError() }, + private val accountProviderAllowListResult: () -> List = { emptyList() }, + private val canConnectToAnyAccountProviderResult: () -> Boolean = { true }, + private val isAllowedToConnectToAccountProviderResult: (AccountProvider) -> Boolean = { lambdaError() }, initialSemanticColors: SemanticColorsLightDark = SemanticColorsLightDark.default, initialBrandColor: Color? = null, private val overrideBrandColorResult: (SessionId?, String?) -> Unit = { _, _ -> lambdaError() }, @@ -44,12 +46,16 @@ class FakeEnterpriseService( tweakMasUrlResult(url, urlContentFetcher) } - override fun homeserverAllowList(): List { - return defaultHomeserverListResult() + override fun accountProviderAllowList(): List { + return accountProviderAllowListResult() } - override suspend fun isAllowedToConnectToHomeserver(homeserverUrl: String): Boolean = simulateLongTask { - isAllowedToConnectToHomeserverResult(homeserverUrl) + override fun canConnectToAnyAccountProvider(): Boolean { + return canConnectToAnyAccountProviderResult() + } + + override suspend fun isAllowedToConnectToAccountProvider(accountProvider: AccountProvider): Boolean = simulateLongTask { + isAllowedToConnectToAccountProviderResult(accountProvider) } override suspend fun isElementProEnforced(serverName: String): Boolean = simulateLongTask { diff --git a/features/login/api/build.gradle.kts b/features/login/api/build.gradle.kts index 2a4e3ecb7c..a0683c814e 100644 --- a/features/login/api/build.gradle.kts +++ b/features/login/api/build.gradle.kts @@ -16,4 +16,5 @@ android { dependencies { implementation(projects.libraries.architecture) + implementation(projects.libraries.matrix.api) } diff --git a/features/login/api/src/main/kotlin/io/element/android/features/login/api/accesscontrol/AccountProviderAccessControl.kt b/features/login/api/src/main/kotlin/io/element/android/features/login/api/accesscontrol/AccountProviderAccessControl.kt index 0c35c1655f..55cfa4b1ba 100644 --- a/features/login/api/src/main/kotlin/io/element/android/features/login/api/accesscontrol/AccountProviderAccessControl.kt +++ b/features/login/api/src/main/kotlin/io/element/android/features/login/api/accesscontrol/AccountProviderAccessControl.kt @@ -8,6 +8,8 @@ package io.element.android.features.login.api.accesscontrol +import io.element.android.libraries.matrix.api.accountprovider.AccountProvider + /** * Enforces the restriction an enterprise deployment can put on which account providers the user may sign in to. */ @@ -15,7 +17,7 @@ interface AccountProviderAccessControl { /** * Whether sign-in to this provider is permitted; `true` on a build with no such restriction. * - * @param accountProviderUrl the server the user is trying to use. + * @param accountProvider the account provider the user is trying to use. */ - suspend fun isAllowedToConnectToAccountProvider(accountProviderUrl: String): Boolean + suspend fun isAllowedToConnectToAccountProvider(accountProvider: AccountProvider): Boolean } diff --git a/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/accesscontrol/DefaultAccountProviderAccessControl.kt b/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/accesscontrol/DefaultAccountProviderAccessControl.kt index a3a475df2f..58fbeed4bc 100644 --- a/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/accesscontrol/DefaultAccountProviderAccessControl.kt +++ b/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/accesscontrol/DefaultAccountProviderAccessControl.kt @@ -14,16 +14,16 @@ import io.element.android.features.enterprise.api.EnterpriseService import io.element.android.features.enterprise.api.IsEnterpriseBuild import io.element.android.features.login.api.accesscontrol.AccountProviderAccessControl import io.element.android.features.login.impl.changeserver.AccountProviderAccessException +import io.element.android.libraries.matrix.api.accountprovider.AccountProvider @ContributesBinding(AppScope::class) class DefaultAccountProviderAccessControl( private val isEnterpriseBuild: IsEnterpriseBuild, private val enterpriseService: EnterpriseService, ) : AccountProviderAccessControl { - override suspend fun isAllowedToConnectToAccountProvider(accountProviderUrl: String) = try { + override suspend fun isAllowedToConnectToAccountProvider(accountProvider: AccountProvider) = try { assertIsAllowedToConnectToAccountProvider( - title = accountProviderUrl, - accountProviderUrl = accountProviderUrl, + accountProvider = accountProvider, ) true } catch (_: AccountProviderAccessException) { @@ -32,22 +32,22 @@ class DefaultAccountProviderAccessControl( @Throws(AccountProviderAccessException::class) suspend fun assertIsAllowedToConnectToAccountProvider( - title: String, - accountProviderUrl: String, + accountProvider: AccountProvider, ) { if (isEnterpriseBuild().not()) { // Ensure that Element Pro is not required for this account provider - if (enterpriseService.isElementProEnforced(accountProviderUrl)) { + if (enterpriseService.isElementProEnforced(accountProvider.serverNameOrBaseUrl())) { throw AccountProviderAccessException.NeedElementProException( - unauthorisedAccountProviderTitle = title, + unauthorisedAccountProviderTitle = accountProvider.friendlyServerName(), applicationId = ELEMENT_PRO_APPLICATION_ID, ) } } - if (enterpriseService.isAllowedToConnectToHomeserver(accountProviderUrl).not()) { + if (enterpriseService.isAllowedToConnectToAccountProvider(accountProvider).not()) { throw AccountProviderAccessException.UnauthorizedAccountProviderException( - unauthorisedAccountProviderTitle = title, - authorisedAccountProviderTitles = enterpriseService.homeserverAllowList(), + unauthorisedAccountProviderTitle = accountProvider.friendlyServerName(), + authorisedAccountProviderTitles = enterpriseService.accountProviderAllowList() + .map { it.friendlyServerName() }, ) } } diff --git a/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/accountprovider/AccountProvider.kt b/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/accountprovider/AccountProvider.kt deleted file mode 100644 index 7ca467da7d..0000000000 --- a/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/accountprovider/AccountProvider.kt +++ /dev/null @@ -1,17 +0,0 @@ -/* - * Copyright (c) 2025 Element Creations Ltd. - * Copyright 2023-2025 New Vector Ltd. - * - * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial. - * Please see LICENSE files in the repository root for full details. - */ - -package io.element.android.features.login.impl.accountprovider - -data class AccountProvider( - val url: String, - val title: String = url.removePrefix("https://").removePrefix("http://"), - val subtitle: String? = null, - val isPublic: Boolean = false, - val isMatrixOrg: Boolean = false, -) diff --git a/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/accountprovider/AccountProviderDataSource.kt b/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/accountprovider/AccountProviderDataSource.kt index 6d85f2c5ff..3e8e7657a4 100644 --- a/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/accountprovider/AccountProviderDataSource.kt +++ b/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/accountprovider/AccountProviderDataSource.kt @@ -11,10 +11,10 @@ package io.element.android.features.login.impl.accountprovider import dev.zacsweers.metro.AppScope import dev.zacsweers.metro.Inject import dev.zacsweers.metro.SingleIn -import io.element.android.appconfig.AuthenticationConfig import io.element.android.features.enterprise.api.EnterpriseService -import io.element.android.features.enterprise.api.canConnectToAnyHomeserver import io.element.android.libraries.di.annotations.AppCoroutineScope +import io.element.android.libraries.matrix.api.accountprovider.AccountProvider +import io.element.android.libraries.matrix.api.accountprovider.matrixOrgAccountProvider import io.element.android.libraries.preferences.api.store.AppPreferencesStore import kotlinx.coroutines.CoroutineScope import kotlinx.coroutines.flow.MutableStateFlow @@ -33,11 +33,9 @@ class AccountProviderDataSource( ) { // The provider used when the user has not selected one: an enterprise/MDM-configured provider, // else matrix.org. The most recently used provider (from history) can override it, see init. - private val configuredAccountProvider = createAccountProvider( - url = enterpriseService.homeserverAllowList() - .firstOrNull { it != EnterpriseService.ANY_ACCOUNT_PROVIDER } - ?: AuthenticationConfig.MATRIX_ORG_URL - ) + private val configuredAccountProvider = enterpriseService.accountProviderAllowList() + .firstOrNull() + ?: matrixOrgAccountProvider private val accountProvider: MutableStateFlow = MutableStateFlow(configuredAccountProvider) @@ -46,7 +44,7 @@ class AccountProviderDataSource( // The account provider the user last explicitly selected (via [setAccountProvider] / [setUrl]). // Unlike [flow], this is not recomputed by [reset], so it survives to be persisted to history on a // successful sign-in even when the login flow is torn down in between (e.g. across an OAuth round-trip). - var lastSelectedAccountProviderUrl: String? = null + var lastSelectedAccountProvider: AccountProvider? = null private set init { @@ -66,28 +64,19 @@ class AccountProviderDataSource( * connect to any provider, otherwise the enterprise/MDM-configured provider. */ private suspend fun defaultAccountProvider(): AccountProvider { - if (!enterpriseService.canConnectToAnyHomeserver()) { + if (!enterpriseService.canConnectToAnyAccountProvider()) { return configuredAccountProvider } val lastUsedProvider = appPreferencesStore.getHomeserverHistoryFlow().first().firstOrNull() - return lastUsedProvider?.let { createAccountProvider(it) } ?: configuredAccountProvider + return lastUsedProvider?.let { AccountProvider.Generic(it) } ?: configuredAccountProvider } suspend fun setUrl(url: String) { - setAccountProvider(createAccountProvider(url)) + setAccountProvider(AccountProvider.Generic(url)) } suspend fun setAccountProvider(data: AccountProvider) { - lastSelectedAccountProviderUrl = data.url + lastSelectedAccountProvider = data accountProvider.emit(data) } - - private fun createAccountProvider(url: String): AccountProvider { - return AccountProvider( - url = url, - subtitle = null, - isPublic = url == AuthenticationConfig.MATRIX_ORG_URL, - isMatrixOrg = url == AuthenticationConfig.MATRIX_ORG_URL, - ) - } } diff --git a/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/accountprovider/AccountProviderPreviewParam.kt b/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/accountprovider/AccountProviderPreviewParam.kt index c14827d1a6..aca64b9db7 100644 --- a/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/accountprovider/AccountProviderPreviewParam.kt +++ b/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/accountprovider/AccountProviderPreviewParam.kt @@ -9,27 +9,27 @@ package io.element.android.features.login.impl.accountprovider import androidx.compose.ui.tooling.preview.PreviewParameterProvider -import io.element.android.appconfig.AuthenticationConfig +import io.element.android.libraries.matrix.api.accountprovider.AccountProvider open class AccountProviderPreviewParam : PreviewParameterProvider { override val values: Sequence get() = sequenceOf( - anAccountProvider(), - anAccountProvider().copy(subtitle = null), - anAccountProvider().copy(subtitle = null, title = "invalid"), - anAccountProvider().copy(subtitle = null, title = "Other", isPublic = false, isMatrixOrg = false), - // Add other state here + anAccountProviderManaged(), ) } -fun anAccountProvider( - url: String = AuthenticationConfig.MATRIX_ORG_URL, - subtitle: String? = "Matrix.org is an open network for secure, decentralized communication.", - isPublic: Boolean = true, - isMatrixOrg: Boolean = true, -) = AccountProvider( - url = url, - subtitle = subtitle, - isPublic = isPublic, - isMatrixOrg = isMatrixOrg, +fun anAccountProviderManaged( + serverName: String = "matrix.org", + baseUrl: String = "https://matrix-client.matrix.org", + canUseServerName: Boolean = true, +) = AccountProvider.Managed( + serverName = serverName, + baseUrl = baseUrl, + canUseServerName = canUseServerName, +) + +fun anAccountProviderGeneric( + serverName: String = "matrix.org", +) = AccountProvider.Generic( + serverName = serverName, ) diff --git a/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/accountprovider/AccountProviderView.kt b/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/accountprovider/AccountProviderView.kt index 09b423f713..8365e9286c 100644 --- a/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/accountprovider/AccountProviderView.kt +++ b/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/accountprovider/AccountProviderView.kt @@ -14,17 +14,14 @@ import androidx.compose.foundation.layout.Row import androidx.compose.foundation.layout.fillMaxWidth import androidx.compose.foundation.layout.heightIn import androidx.compose.foundation.layout.padding -import androidx.compose.foundation.layout.size import androidx.compose.runtime.Composable import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier -import androidx.compose.ui.graphics.Color import androidx.compose.ui.semantics.Role import androidx.compose.ui.tooling.preview.PreviewParameter import androidx.compose.ui.unit.dp import io.element.android.compound.theme.ElementTheme import io.element.android.compound.tokens.generated.CompoundIcons -import io.element.android.features.login.impl.R import io.element.android.libraries.designsystem.atomic.atoms.RoundedIconAtom import io.element.android.libraries.designsystem.atomic.atoms.RoundedIconAtomSize import io.element.android.libraries.designsystem.preview.ElementPreview @@ -32,6 +29,7 @@ import io.element.android.libraries.designsystem.preview.PreviewsDayNight import io.element.android.libraries.designsystem.theme.components.HorizontalDivider import io.element.android.libraries.designsystem.theme.components.Icon import io.element.android.libraries.designsystem.theme.components.Text +import io.element.android.libraries.matrix.api.accountprovider.AccountProvider /** * https://www.figma.com/file/o9p34zmiuEpZRyvZXJZAYL/FTUE?type=design&node-id=604-60817 @@ -60,37 +58,19 @@ fun AccountProviderView( .heightIn(min = 44.dp), verticalAlignment = Alignment.CenterVertically ) { - if (item.isMatrixOrg) { - RoundedIconAtom( - size = RoundedIconAtomSize.Medium, - resourceId = R.drawable.ic_matrix, - tint = Color.Unspecified, - ) - } else { - RoundedIconAtom( - size = RoundedIconAtomSize.Medium, - imageVector = CompoundIcons.Host(), - tint = ElementTheme.colors.iconPrimary, - ) - } + RoundedIconAtom( + size = RoundedIconAtomSize.Medium, + imageVector = CompoundIcons.Host(), + tint = ElementTheme.colors.iconPrimary, + ) Text( modifier = Modifier .padding(start = 16.dp) .weight(1f), - text = item.title, + text = item.friendlyServerName(), style = ElementTheme.typography.fontBodyLgMedium, color = ElementTheme.colors.textPrimary, ) - if (item.isPublic) { - Icon( - modifier = Modifier - .padding(start = 10.dp) - .size(16.dp), - imageVector = CompoundIcons.Public(), - contentDescription = null, - tint = ElementTheme.colors.iconSecondary, - ) - } if (selected) { Icon( modifier = Modifier @@ -101,15 +81,6 @@ fun AccountProviderView( ) } } - if (item.subtitle != null) { - Text( - modifier = Modifier - .padding(start = 46.dp, bottom = 12.dp, end = 26.dp), - text = item.subtitle, - style = ElementTheme.typography.fontBodyMdRegular, - color = ElementTheme.colors.textSecondary, - ) - } } } } diff --git a/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/accountprovider/SaveAccountProviderToHistory.kt b/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/accountprovider/SaveAccountProviderToHistory.kt index b3b99115cc..14c1b0346b 100644 --- a/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/accountprovider/SaveAccountProviderToHistory.kt +++ b/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/accountprovider/SaveAccountProviderToHistory.kt @@ -25,8 +25,11 @@ class SaveAccountProviderToHistory( suspend operator fun invoke() { // Persist the provider the user actually selected, not the currently-exposed default: the latter can be // reset back to the history default while the login flow is torn down across an OAuth round-trip. - val url = accountProviderDataSource.lastSelectedAccountProviderUrl - ?: accountProviderDataSource.flow.value.url - appPreferencesStore.addHomeserverToHistory(url) + val accountProvider = accountProviderDataSource.lastSelectedAccountProvider + ?: accountProviderDataSource.flow.value + // Persist the sanitized name the user knows the provider by rather than its base url, which can be an + // internal client API url (e.g. matrix.org resolves to matrix-client.matrix.org) the user would not + // recognise, and so that the same provider is not stored twice with and without its scheme. + appPreferencesStore.addHomeserverToHistory(accountProvider.serverNameOrBaseUrl()) } } diff --git a/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/changeserver/ChangeServerEvent.kt b/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/changeserver/ChangeServerEvent.kt index f3fd02713f..d1b68190c6 100644 --- a/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/changeserver/ChangeServerEvent.kt +++ b/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/changeserver/ChangeServerEvent.kt @@ -8,7 +8,7 @@ package io.element.android.features.login.impl.changeserver -import io.element.android.features.login.impl.accountprovider.AccountProvider +import io.element.android.libraries.matrix.api.accountprovider.AccountProvider sealed interface ChangeServerEvent { data class ChangeServer(val accountProvider: AccountProvider) : ChangeServerEvent diff --git a/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/changeserver/ChangeServerPresenter.kt b/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/changeserver/ChangeServerPresenter.kt index 9106d6e1c4..2e3a4c73b8 100644 --- a/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/changeserver/ChangeServerPresenter.kt +++ b/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/changeserver/ChangeServerPresenter.kt @@ -14,13 +14,13 @@ import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.remember import dev.zacsweers.metro.Inject import io.element.android.features.login.impl.accesscontrol.DefaultAccountProviderAccessControl -import io.element.android.features.login.impl.accountprovider.AccountProvider import io.element.android.features.login.impl.accountprovider.AccountProviderDataSource import io.element.android.features.login.impl.error.ChangeServerError import io.element.android.features.login.impl.localnetwork.LocalNetworkPermissionGate import io.element.android.libraries.architecture.AsyncData import io.element.android.libraries.architecture.Presenter import io.element.android.libraries.architecture.runCatchingUpdatingState +import io.element.android.libraries.matrix.api.accountprovider.AccountProvider import io.element.android.libraries.matrix.api.auth.MatrixAuthenticationService import io.element.android.libraries.matrix.api.auth.MatrixHomeServerDetails @@ -38,7 +38,7 @@ class ChangeServerPresenter( } val gateState = localNetworkPermissionGate.present( - urlOf = { provider -> provider.url }, + urlOf = { provider -> provider.serverNameOrBaseUrl() }, onProceed = { provider -> changeServer(provider, changeServerAction) }, ) @@ -63,11 +63,8 @@ class ChangeServerPresenter( changeServerAction: MutableState>, ) { suspend { - defaultAccountProviderAccessControl.assertIsAllowedToConnectToAccountProvider( - title = data.title, - accountProviderUrl = data.url, - ) - val details = authenticationService.setHomeserver(data.url).getOrThrow() + defaultAccountProviderAccessControl.assertIsAllowedToConnectToAccountProvider(data) + val details = authenticationService.setHomeserver(data.serverNameOrBaseUrl()).getOrThrow() if (!details.isSupported) { throw ChangeServerError.UnsupportedServer } diff --git a/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/chooseaccountprovider/ChooseAccountProviderEvent.kt b/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/chooseaccountprovider/ChooseAccountProviderEvent.kt index bb50f123cb..d3fddeeb1f 100644 --- a/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/chooseaccountprovider/ChooseAccountProviderEvent.kt +++ b/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/chooseaccountprovider/ChooseAccountProviderEvent.kt @@ -8,7 +8,7 @@ package io.element.android.features.login.impl.screens.chooseaccountprovider -import io.element.android.features.login.impl.accountprovider.AccountProvider +import io.element.android.libraries.matrix.api.accountprovider.AccountProvider sealed interface ChooseAccountProviderEvent { data class SelectAccountProvider(val accountProvider: AccountProvider) : ChooseAccountProviderEvent diff --git a/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/chooseaccountprovider/ChooseAccountProviderPresenter.kt b/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/chooseaccountprovider/ChooseAccountProviderPresenter.kt index e2863a295a..8984216ac8 100644 --- a/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/chooseaccountprovider/ChooseAccountProviderPresenter.kt +++ b/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/chooseaccountprovider/ChooseAccountProviderPresenter.kt @@ -14,14 +14,12 @@ import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.remember import androidx.compose.runtime.setValue import dev.zacsweers.metro.Inject -import io.element.android.appconfig.AuthenticationConfig import io.element.android.features.enterprise.api.EnterpriseService -import io.element.android.features.login.impl.accountprovider.AccountProvider import io.element.android.features.login.impl.login.LoginModeEvent import io.element.android.features.login.impl.login.LoginModeState import io.element.android.libraries.architecture.AsyncData import io.element.android.libraries.architecture.Presenter -import io.element.android.libraries.core.uri.ensureProtocol +import io.element.android.libraries.matrix.api.accountprovider.AccountProvider import kotlinx.collections.immutable.toImmutableList @Inject @@ -41,7 +39,7 @@ class ChooseAccountProviderPresenter( loginModeState.eventSink( LoginModeEvent.Submit( isAccountCreation = false, - homeserverUrl = provider.url, + homeserverUrl = provider.serverNameOrBaseUrl(), resolvedHomeserverUrl = null, loginHint = null, ) @@ -59,18 +57,8 @@ class ChooseAccountProviderPresenter( } val staticAccountProviderList = remember { - // The list cannot contains ANY_ACCOUNT_PROVIDER ("*") and cannot be empty at this point - enterpriseService.homeserverAllowList() - .map { it.ensureProtocol() } - .map { url -> - AccountProvider( - url = url, - subtitle = null, - isPublic = url == AuthenticationConfig.MATRIX_ORG_URL, - isMatrixOrg = url == AuthenticationConfig.MATRIX_ORG_URL, - ) - } - .toImmutableList() + // The list cannot be empty at this point + enterpriseService.accountProviderAllowList().toImmutableList() } return ChooseAccountProviderState( diff --git a/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/chooseaccountprovider/ChooseAccountProviderState.kt b/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/chooseaccountprovider/ChooseAccountProviderState.kt index 398e32d687..b1e84fe8ec 100644 --- a/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/chooseaccountprovider/ChooseAccountProviderState.kt +++ b/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/chooseaccountprovider/ChooseAccountProviderState.kt @@ -8,9 +8,9 @@ package io.element.android.features.login.impl.screens.chooseaccountprovider -import io.element.android.features.login.impl.accountprovider.AccountProvider import io.element.android.features.login.impl.login.LoginModeState import io.element.android.libraries.architecture.AsyncData +import io.element.android.libraries.matrix.api.accountprovider.AccountProvider import kotlinx.collections.immutable.ImmutableList data class ChooseAccountProviderState( diff --git a/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/chooseaccountprovider/ChooseAccountProviderStatePreviewParam.kt b/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/chooseaccountprovider/ChooseAccountProviderStatePreviewParam.kt index ceb1cfd6ea..9dc99b466c 100644 --- a/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/chooseaccountprovider/ChooseAccountProviderStatePreviewParam.kt +++ b/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/chooseaccountprovider/ChooseAccountProviderStatePreviewParam.kt @@ -9,31 +9,22 @@ package io.element.android.features.login.impl.screens.chooseaccountprovider import androidx.compose.ui.tooling.preview.PreviewParameterProvider -import io.element.android.features.login.impl.accountprovider.AccountProvider -import io.element.android.features.login.impl.accountprovider.anAccountProvider +import io.element.android.features.login.impl.accountprovider.anAccountProviderManaged import io.element.android.features.login.impl.login.LoginModeState import io.element.android.features.login.impl.login.aLoginModeState import io.element.android.libraries.architecture.AsyncData +import io.element.android.libraries.matrix.api.accountprovider.AccountProvider import kotlinx.collections.immutable.toImmutableList open class ChooseAccountProviderStatePreviewParam : PreviewParameterProvider { - private val server1 = anAccountProvider( - url = "https://server1.io", - subtitle = null, - isPublic = false, - isMatrixOrg = false, + private val server1 = anAccountProviderManaged( + baseUrl = "https://server1.io", ) - private val server2 = anAccountProvider( - url = "https://server2.io", - subtitle = null, - isPublic = false, - isMatrixOrg = false, + private val server2 = anAccountProviderManaged( + baseUrl = "https://server2.io", ) - private val server3 = anAccountProvider( - url = "https://server3.io", - subtitle = null, - isPublic = false, - isMatrixOrg = false, + private val server3 = anAccountProviderManaged( + baseUrl = "https://server3.io", ) override val values: Sequence get() = sequenceOf( @@ -61,13 +52,12 @@ open class ChooseAccountProviderStatePreviewParam : PreviewParameterProvider = listOf( - anAccountProvider() + anAccountProviderManaged() ), selectedAccountProvider: AccountProvider? = null, loginModeState: LoginModeState = aLoginModeState(), diff --git a/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/chooseaccountprovider/ChooseAccountProviderView.kt b/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/chooseaccountprovider/ChooseAccountProviderView.kt index 552165a7b2..c2d0bd05b2 100644 --- a/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/chooseaccountprovider/ChooseAccountProviderView.kt +++ b/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/chooseaccountprovider/ChooseAccountProviderView.kt @@ -96,16 +96,8 @@ fun ChooseAccountProviderView( ) state.accountProviders.forEach { item -> - val alteredItem = if (item.isMatrixOrg) { - // Set the subtitle from the resource - item.copy( - subtitle = stringResource(id = R.string.screen_change_account_provider_matrix_org_subtitle), - ) - } else { - item - } AccountProviderView( - item = alteredItem, + item = item, selected = item == state.selectedAccountProvider, onClick = { state.eventSink(ChooseAccountProviderEvent.SelectAccountProvider(item)) diff --git a/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/confirmaccountprovider/ConfirmAccountProviderPresenter.kt b/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/confirmaccountprovider/ConfirmAccountProviderPresenter.kt index 627620ff31..201571a8ff 100644 --- a/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/confirmaccountprovider/ConfirmAccountProviderPresenter.kt +++ b/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/confirmaccountprovider/ConfirmAccountProviderPresenter.kt @@ -20,9 +20,7 @@ import androidx.compose.runtime.setValue import dev.zacsweers.metro.Assisted import dev.zacsweers.metro.AssistedFactory import dev.zacsweers.metro.AssistedInject -import io.element.android.appconfig.AuthenticationConfig import io.element.android.features.enterprise.api.EnterpriseService -import io.element.android.features.login.impl.accountprovider.AccountProvider import io.element.android.features.login.impl.accountprovider.AccountProviderDataSource import io.element.android.features.login.impl.changeserver.ChangeServerEvent import io.element.android.features.login.impl.changeserver.ChangeServerState @@ -30,8 +28,11 @@ import io.element.android.features.login.impl.login.LoginModeEvent import io.element.android.features.login.impl.login.LoginModeState import io.element.android.libraries.architecture.Presenter import io.element.android.libraries.core.uri.ensureProtocol +import io.element.android.libraries.matrix.api.accountprovider.AccountProvider +import io.element.android.libraries.matrix.api.accountprovider.matrixOrgAccountProvider import io.element.android.libraries.matrix.api.core.MatrixPatterns import io.element.android.libraries.preferences.api.store.AppPreferencesStore +import kotlinx.coroutines.flow.map @AssistedInject class ConfirmAccountProviderPresenter( @@ -56,23 +57,25 @@ class ConfirmAccountProviderPresenter( val accountProvider by accountProviderDataSource.flow.collectAsState() val loginModeState = loginModePresenter.present() val changeServerState = changeServerPresenter.present() - val homeserverHistory by appPreferencesStore.getHomeserverHistoryFlow().collectAsState(emptyList()) + val homeserverHistory by remember { + appPreferencesStore.getHomeserverHistoryFlow().map { history -> + history.map { AccountProvider.Generic(it) } + } + }.collectAsState(emptyList()) // The account providers offered for autocomplete: previously-used ones first, then the // enterprise/MDM-configured allow-list, then matrix.org (always available, even before any sign-in). - // The "*" wildcard is a routing marker, not a real provider, so it is filtered out. Everything is - // rendered without the https:// scheme (added back at connection time). + // Everything is rendered without the https:// scheme (added back at connection time). val autocompleteCandidates = remember(homeserverHistory) { - (homeserverHistory + enterpriseService.homeserverAllowList() + AuthenticationConfig.MATRIX_ORG_URL) - .filter { it != EnterpriseService.ANY_ACCOUNT_PROVIDER } - .map { it.withoutScheme() } + (homeserverHistory + enterpriseService.accountProviderAllowList() + matrixOrgAccountProvider) + .map { it.friendlyServerName() } .distinct() } // Editable input, seeded from the current (history-defaulted) account provider until the user edits it. // Displayed without the scheme, so the field shows e.g. "matrix.org" rather than "https://matrix.org". var userInput by rememberSaveable { mutableStateOf(null) } - val accountProviderInput = userInput ?: accountProvider.url.withoutScheme() + val accountProviderInput = userInput ?: accountProvider.friendlyServerName() // Offer the first candidate that the current input is a (case-insensitive) prefix of. val accountProviderSuggestion = remember(accountProviderInput, autocompleteCandidates) { @@ -134,7 +137,7 @@ class ConfirmAccountProviderPresenter( val accountProviderUrl = host.ensureProtocol() submittedAccountProvider = accountProviderUrl changeServerState.eventSink( - ChangeServerEvent.ChangeServer(AccountProvider(url = accountProviderUrl)) + ChangeServerEvent.ChangeServer(AccountProvider.Generic(host)) ) } ConfirmAccountProviderEvent.ClearError -> { @@ -154,9 +157,3 @@ class ConfirmAccountProviderPresenter( ) } } - -/** - * The host part of an account provider URL, i.e. the value with any `https://` / `http://` scheme removed. - * Returns the input unchanged when it has no scheme (e.g. `matrix.org`). - */ -private fun String.withoutScheme(): String = substringAfter("://") diff --git a/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/loginpassword/LoginPasswordState.kt b/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/loginpassword/LoginPasswordState.kt index db04e7b7ba..13d189af6f 100644 --- a/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/loginpassword/LoginPasswordState.kt +++ b/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/loginpassword/LoginPasswordState.kt @@ -9,8 +9,8 @@ package io.element.android.features.login.impl.screens.loginpassword import android.os.Parcelable -import io.element.android.features.login.impl.accountprovider.AccountProvider import io.element.android.libraries.architecture.AsyncData +import io.element.android.libraries.matrix.api.accountprovider.AccountProvider import io.element.android.libraries.matrix.api.core.SessionId import kotlinx.parcelize.Parcelize diff --git a/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/loginpassword/LoginPasswordStatePreviewParam.kt b/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/loginpassword/LoginPasswordStatePreviewParam.kt index ba48e57b5d..bae4ed4df3 100644 --- a/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/loginpassword/LoginPasswordStatePreviewParam.kt +++ b/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/loginpassword/LoginPasswordStatePreviewParam.kt @@ -9,9 +9,9 @@ package io.element.android.features.login.impl.screens.loginpassword import androidx.compose.ui.tooling.preview.PreviewParameterProvider -import io.element.android.features.login.impl.accountprovider.AccountProvider -import io.element.android.features.login.impl.accountprovider.anAccountProvider +import io.element.android.features.login.impl.accountprovider.anAccountProviderManaged import io.element.android.libraries.architecture.AsyncData +import io.element.android.libraries.matrix.api.accountprovider.AccountProvider import io.element.android.libraries.matrix.api.core.SessionId open class LoginPasswordStatePreviewParam : PreviewParameterProvider { @@ -26,7 +26,7 @@ open class LoginPasswordStatePreviewParam : PreviewParameterProvider = AsyncData.Uninitialized, eventSink: (LoginPasswordEvent) -> Unit = {}, diff --git a/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/loginpassword/LoginPasswordView.kt b/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/loginpassword/LoginPasswordView.kt index 9a2dc3097b..c2a983a692 100644 --- a/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/loginpassword/LoginPasswordView.kt +++ b/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/loginpassword/LoginPasswordView.kt @@ -131,7 +131,7 @@ fun LoginPasswordView( iconStyle = BigIcon.Style.Default(CompoundIcons.UserProfileSolid()), title = stringResource( id = R.string.screen_account_provider_signin_title, - state.accountProvider.title + state.accountProvider.friendlyServerName() ), subTitle = stringResource(id = R.string.screen_login_subtitle) ) diff --git a/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/onboarding/OnBoardingEvent.kt b/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/onboarding/OnBoardingEvent.kt index 4b3993e2d1..6d5979946d 100644 --- a/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/onboarding/OnBoardingEvent.kt +++ b/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/onboarding/OnBoardingEvent.kt @@ -8,9 +8,11 @@ package io.element.android.features.login.impl.screens.onboarding +import io.element.android.libraries.matrix.api.accountprovider.AccountProvider + sealed interface OnBoardingEvent { data class OnSignIn( - val defaultAccountProvider: String + val defaultAccountProvider: AccountProvider ) : OnBoardingEvent data object OnVersionClick : OnBoardingEvent diff --git a/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/onboarding/OnBoardingPresenter.kt b/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/onboarding/OnBoardingPresenter.kt index 7e48ae22e8..c108aa1de0 100644 --- a/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/onboarding/OnBoardingPresenter.kt +++ b/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/onboarding/OnBoardingPresenter.kt @@ -22,7 +22,6 @@ import dev.zacsweers.metro.AssistedFactory import dev.zacsweers.metro.AssistedInject import io.element.android.appconfig.OnBoardingConfig import io.element.android.features.enterprise.api.EnterpriseService -import io.element.android.features.enterprise.api.canConnectToAnyHomeserver import io.element.android.features.login.impl.accesscontrol.DefaultAccountProviderAccessControl import io.element.android.features.login.impl.accountprovider.AccountProviderDataSource import io.element.android.features.login.impl.login.LoginModeEvent @@ -31,6 +30,7 @@ import io.element.android.features.rageshake.api.RageshakeFeatureAvailability import io.element.android.libraries.architecture.Presenter import io.element.android.libraries.core.meta.BuildMeta import io.element.android.libraries.core.meta.BuildType +import io.element.android.libraries.matrix.api.accountprovider.AccountProvider import io.element.android.libraries.sessionstorage.api.SessionStore import io.element.android.libraries.ui.utils.MultipleTapToUnlock import kotlinx.coroutines.launch @@ -59,27 +59,34 @@ class OnBoardingPresenter( @Composable override fun present(): OnBoardingState { val localCoroutineScope = rememberCoroutineScope() - val forcedAccountProvider = remember { - // If homeserverAllowList() returns a singleton list, this is the default account provider. - // In this case, the user can sign in using this homeserver, or use QrCode login - enterpriseService.homeserverAllowList().singleOrNull() + val canConnectToAnyAccountProvider = remember { + enterpriseService.canConnectToAnyAccountProvider() } - val canConnectToAnyHomeserver = remember { - enterpriseService.canConnectToAnyHomeserver() + val forcedAccountProvider = remember { + // If accountProviderAllowList() returns a singleton list, and the user is not free to use another + // account provider, this is the default account provider. + // In this case, the user can sign in using this homeserver, or use QrCode login + if (canConnectToAnyAccountProvider) { + null + } else { + enterpriseService.accountProviderAllowList().singleOrNull() + } } val mustChooseAccountProvider = remember { - !canConnectToAnyHomeserver && enterpriseService.homeserverAllowList().size > 1 + !canConnectToAnyAccountProvider && enterpriseService.accountProviderAllowList().size > 1 } - val linkAccountProvider by produceState(initialValue = null) { + val linkAccountProvider by produceState(initialValue = null) { // Account provider from the link, if allowed by the enterprise service - value = params.accountProvider?.takeIf { - try { - defaultAccountProviderAccessControl.assertIsAllowedToConnectToAccountProvider(it, it) - true - } catch (_: Exception) { - false + value = params.accountProvider + ?.let { AccountProvider.Generic(it) } + ?.takeIf { + try { + defaultAccountProviderAccessControl.assertIsAllowedToConnectToAccountProvider(it) + true + } catch (_: Exception) { + false + } } - } } val defaultAccountProvider = remember(linkAccountProvider) { // If there is a forced account provider, this is the default account provider @@ -105,11 +112,11 @@ class OnBoardingPresenter( when (event) { is OnBoardingEvent.OnSignIn -> localCoroutineScope.launch { // Ensure that the current account provider is set - accountProviderDataSource.setUrl(event.defaultAccountProvider) + accountProviderDataSource.setAccountProvider(event.defaultAccountProvider) loginModeState.eventSink( LoginModeEvent.Submit( isAccountCreation = false, - homeserverUrl = event.defaultAccountProvider, + homeserverUrl = event.defaultAccountProvider.serverNameOrBaseUrl(), resolvedHomeserverUrl = null, loginHint = params.loginHint?.takeIf { forcedAccountProvider == null }, ) @@ -134,7 +141,7 @@ class OnBoardingPresenter( defaultAccountProvider = defaultAccountProvider, mustChooseAccountProvider = mustChooseAccountProvider, canLoginWithQrCode = canLoginWithQrCode, - canCreateAccount = defaultAccountProvider == null && canConnectToAnyHomeserver && OnBoardingConfig.CAN_CREATE_ACCOUNT, + canCreateAccount = defaultAccountProvider == null && canConnectToAnyAccountProvider && OnBoardingConfig.CAN_CREATE_ACCOUNT, canReportBug = canReportBug && showReportBug, loginModeState = loginModeState, version = buildMeta.versionName, diff --git a/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/onboarding/OnBoardingState.kt b/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/onboarding/OnBoardingState.kt index 97ebed67f6..87d4605ceb 100644 --- a/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/onboarding/OnBoardingState.kt +++ b/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/onboarding/OnBoardingState.kt @@ -11,13 +11,14 @@ package io.element.android.features.login.impl.screens.onboarding import androidx.annotation.DrawableRes import io.element.android.features.login.impl.login.LoginModeState import io.element.android.libraries.architecture.AsyncData +import io.element.android.libraries.matrix.api.accountprovider.AccountProvider data class OnBoardingState( val isAddingAccount: Boolean, val showBackButton: Boolean, val showDeveloperSettings: Boolean, val productionApplicationName: String, - val defaultAccountProvider: String?, + val defaultAccountProvider: AccountProvider?, val mustChooseAccountProvider: Boolean, val canLoginWithQrCode: Boolean, val canCreateAccount: Boolean, diff --git a/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/onboarding/OnBoardingStatePreviewParam.kt b/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/onboarding/OnBoardingStatePreviewParam.kt index c7d89b21d5..09a2c8a245 100644 --- a/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/onboarding/OnBoardingStatePreviewParam.kt +++ b/features/login/impl/src/main/kotlin/io/element/android/features/login/impl/screens/onboarding/OnBoardingStatePreviewParam.kt @@ -13,6 +13,7 @@ import androidx.compose.ui.tooling.preview.PreviewParameterProvider import io.element.android.features.login.impl.login.LoginModeState import io.element.android.features.login.impl.login.aLoginModeState import io.element.android.libraries.designsystem.R +import io.element.android.libraries.matrix.api.accountprovider.AccountProvider open class OnBoardingStatePreviewParam : PreviewParameterProvider { override val values: Sequence @@ -22,7 +23,11 @@ open class OnBoardingStatePreviewParam : PreviewParameterProvider - - - diff --git a/features/login/impl/src/test/kotlin/io/element/android/features/login/impl/accesscontrol/DefaultAccountProviderAccessControlTest.kt b/features/login/impl/src/test/kotlin/io/element/android/features/login/impl/accesscontrol/DefaultAccountProviderAccessControlTest.kt index fbfae984fc..86bbd0eadb 100644 --- a/features/login/impl/src/test/kotlin/io/element/android/features/login/impl/accesscontrol/DefaultAccountProviderAccessControlTest.kt +++ b/features/login/impl/src/test/kotlin/io/element/android/features/login/impl/accesscontrol/DefaultAccountProviderAccessControlTest.kt @@ -11,19 +11,30 @@ package io.element.android.features.login.impl.accesscontrol import com.google.common.truth.Truth.assertThat import io.element.android.features.enterprise.test.FakeEnterpriseService import io.element.android.features.login.impl.changeserver.AccountProviderAccessException +import io.element.android.libraries.matrix.api.accountprovider.AccountProvider import io.element.android.libraries.matrix.test.AN_ACCOUNT_PROVIDER import io.element.android.libraries.matrix.test.AN_ACCOUNT_PROVIDER_2 import io.element.android.libraries.matrix.test.AN_ACCOUNT_PROVIDER_URL +import io.element.android.libraries.matrix.test.accountprovider.anAccountProviderManaged import kotlinx.coroutines.test.runTest import org.junit.Assert.assertThrows import org.junit.Test class DefaultAccountProviderAccessControlTest { + /** + * The account provider the assertions are run against: its server name is the title reported by the exceptions, + * its base url is what the enterprise service is queried with. + */ + private fun anAccountProviderUnderTest() = anAccountProviderManaged( + serverName = AN_ACCOUNT_PROVIDER, + baseUrl = AN_ACCOUNT_PROVIDER_URL, + ) + @Test fun `foss build should not allow using account provider that enforce enterprise build`() { val accessControl = createDefaultAccountProviderAccessControl( isEnterpriseBuild = false, - isAllowedToConnectToHomeserver = true, + isAllowedToConnectToAccountProvider = true, enterpriseService = FakeEnterpriseService(isElementProEnforcedResult = { true }), ) accessControl.expectNeedElementProException() @@ -34,7 +45,7 @@ class DefaultAccountProviderAccessControlTest { val accessControl = createDefaultAccountProviderAccessControl( isEnterpriseBuild = false, // false here. - isAllowedToConnectToHomeserver = false, + isAllowedToConnectToAccountProvider = false, enterpriseService = FakeEnterpriseService(isElementProEnforcedResult = { true }), ) accessControl.expectNeedElementProException() @@ -44,9 +55,9 @@ class DefaultAccountProviderAccessControlTest { fun `foss build should allow using account provider that does not enforce enterprise build`() = runTest { val accessControl = createDefaultAccountProviderAccessControl( isEnterpriseBuild = false, - isAllowedToConnectToHomeserver = true, + isAllowedToConnectToAccountProvider = true, enterpriseService = FakeEnterpriseService( - isAllowedToConnectToHomeserverResult = { true }, + isAllowedToConnectToAccountProviderResult = { true }, isElementProEnforcedResult = { false } ), ) @@ -57,7 +68,7 @@ class DefaultAccountProviderAccessControlTest { fun `foss build should allow using account provider twith missing key in wellknown`() = runTest { val accessControl = createDefaultAccountProviderAccessControl( isEnterpriseBuild = false, - isAllowedToConnectToHomeserver = true, + isAllowedToConnectToAccountProvider = true, ) accessControl.expectAllowed() } @@ -66,7 +77,7 @@ class DefaultAccountProviderAccessControlTest { fun `foss build should allow using account provider with missing wellknown`() = runTest { val accessControl = createDefaultAccountProviderAccessControl( isEnterpriseBuild = false, - isAllowedToConnectToHomeserver = true, + isAllowedToConnectToAccountProvider = true, ) accessControl.expectAllowed() } @@ -75,12 +86,12 @@ class DefaultAccountProviderAccessControlTest { fun `foss build should not allow using account provider that do not enforce enterprise build but is not allowed`() { val accessControl = createDefaultAccountProviderAccessControl( isEnterpriseBuild = false, - isAllowedToConnectToHomeserver = false, - allowedAccountProviders = listOf(AN_ACCOUNT_PROVIDER_2), + isAllowedToConnectToAccountProvider = false, + allowedAccountProviders = listOf(anAccountProviderManaged(serverName = AN_ACCOUNT_PROVIDER_2)), enterpriseService = FakeEnterpriseService( - isAllowedToConnectToHomeserverResult = { false }, + isAllowedToConnectToAccountProviderResult = { false }, isElementProEnforcedResult = { false }, - defaultHomeserverListResult = { listOf(AN_ACCOUNT_PROVIDER_2) }, + accountProviderAllowListResult = { listOf(anAccountProviderManaged(serverName = AN_ACCOUNT_PROVIDER_2)) }, ), ) accessControl.expectUnauthorizedAccountProviderException() @@ -90,9 +101,9 @@ class DefaultAccountProviderAccessControlTest { fun `enterprise build should allow using account provider that enforce enterprise build`() = runTest { val accessControl = createDefaultAccountProviderAccessControl( isEnterpriseBuild = true, - isAllowedToConnectToHomeserver = true, + isAllowedToConnectToAccountProvider = true, enterpriseService = FakeEnterpriseService( - isAllowedToConnectToHomeserverResult = { true }, + isAllowedToConnectToAccountProviderResult = { true }, isElementProEnforcedResult = { true }, ), ) @@ -103,9 +114,9 @@ class DefaultAccountProviderAccessControlTest { fun `enterprise build should allow using account provider that do not enforce enterprise build`() = runTest { val accessControl = createDefaultAccountProviderAccessControl( isEnterpriseBuild = true, - isAllowedToConnectToHomeserver = true, + isAllowedToConnectToAccountProvider = true, enterpriseService = FakeEnterpriseService( - isAllowedToConnectToHomeserverResult = { true }, + isAllowedToConnectToAccountProviderResult = { true }, isElementProEnforcedResult = { false }, ), ) @@ -116,12 +127,12 @@ class DefaultAccountProviderAccessControlTest { fun `enterprise build should not allow using account provider that enforce enterprise build but is not allowed`() = runTest { val accessControl = createDefaultAccountProviderAccessControl( isEnterpriseBuild = true, - isAllowedToConnectToHomeserver = false, - allowedAccountProviders = listOf(AN_ACCOUNT_PROVIDER_2), + isAllowedToConnectToAccountProvider = false, + allowedAccountProviders = listOf(anAccountProviderManaged(serverName = AN_ACCOUNT_PROVIDER_2)), enterpriseService = FakeEnterpriseService( - isAllowedToConnectToHomeserverResult = { false }, + isAllowedToConnectToAccountProviderResult = { false }, isElementProEnforcedResult = { true }, - defaultHomeserverListResult = { listOf(AN_ACCOUNT_PROVIDER_2) }, + accountProviderAllowListResult = { listOf(anAccountProviderManaged(serverName = AN_ACCOUNT_PROVIDER_2)) }, ), ) accessControl.expectUnauthorizedAccountProviderException() @@ -131,12 +142,12 @@ class DefaultAccountProviderAccessControlTest { fun `enterprise build should not allow using account provider that do not enforce enterprise build but is not allowed`() = runTest { val accessControl = createDefaultAccountProviderAccessControl( isEnterpriseBuild = true, - isAllowedToConnectToHomeserver = false, - allowedAccountProviders = listOf(AN_ACCOUNT_PROVIDER_2), + isAllowedToConnectToAccountProvider = false, + allowedAccountProviders = listOf(anAccountProviderManaged(serverName = AN_ACCOUNT_PROVIDER_2)), enterpriseService = FakeEnterpriseService( - isAllowedToConnectToHomeserverResult = { false }, + isAllowedToConnectToAccountProviderResult = { false }, isElementProEnforcedResult = { false }, - defaultHomeserverListResult = { listOf(AN_ACCOUNT_PROVIDER_2) }, + accountProviderAllowListResult = { listOf(anAccountProviderManaged(serverName = AN_ACCOUNT_PROVIDER_2)) }, ), ) accessControl.expectUnauthorizedAccountProviderException() @@ -144,11 +155,11 @@ class DefaultAccountProviderAccessControlTest { private fun createDefaultAccountProviderAccessControl( isEnterpriseBuild: Boolean = false, - isAllowedToConnectToHomeserver: Boolean = false, - allowedAccountProviders: List = emptyList(), + isAllowedToConnectToAccountProvider: Boolean = false, + allowedAccountProviders: List = emptyList(), enterpriseService: FakeEnterpriseService = FakeEnterpriseService( - isAllowedToConnectToHomeserverResult = { isAllowedToConnectToHomeserver }, - defaultHomeserverListResult = { allowedAccountProviders }, + isAllowedToConnectToAccountProviderResult = { isAllowedToConnectToAccountProvider }, + accountProviderAllowListResult = { allowedAccountProviders }, isElementProEnforcedResult = { false }, ) ) = DefaultAccountProviderAccessControl( @@ -159,19 +170,14 @@ class DefaultAccountProviderAccessControlTest { private fun DefaultAccountProviderAccessControl.expectNeedElementProException() { val exception = assertThrows(AccountProviderAccessException.NeedElementProException::class.java) { runTest { - assertIsAllowedToConnectToAccountProvider( - title = AN_ACCOUNT_PROVIDER, - accountProviderUrl = AN_ACCOUNT_PROVIDER_URL, - ) + assertIsAllowedToConnectToAccountProvider(anAccountProviderUnderTest()) } } assertThat(exception.unauthorisedAccountProviderTitle).isEqualTo(AN_ACCOUNT_PROVIDER) assertThat(exception.applicationId).isEqualTo("io.element.enterprise") runTest { assertThat( - isAllowedToConnectToAccountProvider( - accountProviderUrl = AN_ACCOUNT_PROVIDER_URL, - ) + isAllowedToConnectToAccountProvider(anAccountProviderUnderTest()) ).isFalse() } } @@ -179,34 +185,24 @@ class DefaultAccountProviderAccessControlTest { private fun DefaultAccountProviderAccessControl.expectUnauthorizedAccountProviderException() { val exception = assertThrows(AccountProviderAccessException.UnauthorizedAccountProviderException::class.java) { runTest { - assertIsAllowedToConnectToAccountProvider( - title = AN_ACCOUNT_PROVIDER, - accountProviderUrl = AN_ACCOUNT_PROVIDER_URL, - ) + assertIsAllowedToConnectToAccountProvider(anAccountProviderUnderTest()) } } assertThat(exception.unauthorisedAccountProviderTitle).isEqualTo(AN_ACCOUNT_PROVIDER) assertThat(exception.authorisedAccountProviderTitles).containsExactly(AN_ACCOUNT_PROVIDER_2) runTest { assertThat( - isAllowedToConnectToAccountProvider( - accountProviderUrl = AN_ACCOUNT_PROVIDER_URL, - ) + isAllowedToConnectToAccountProvider(anAccountProviderUnderTest()) ).isFalse() } } private suspend fun DefaultAccountProviderAccessControl.expectAllowed() { // If no exception is thrown, the test passes - assertIsAllowedToConnectToAccountProvider( - title = AN_ACCOUNT_PROVIDER, - accountProviderUrl = AN_ACCOUNT_PROVIDER_URL, - ) + assertIsAllowedToConnectToAccountProvider(anAccountProviderUnderTest()) runTest { assertThat( - isAllowedToConnectToAccountProvider( - accountProviderUrl = AN_ACCOUNT_PROVIDER_URL, - ) + isAllowedToConnectToAccountProvider(anAccountProviderUnderTest()) ).isTrue() } } diff --git a/features/login/impl/src/test/kotlin/io/element/android/features/login/impl/accountprovider/AccountProviderDataSourceTest.kt b/features/login/impl/src/test/kotlin/io/element/android/features/login/impl/accountprovider/AccountProviderDataSourceTest.kt index 30e25c8c3e..ff03d79989 100644 --- a/features/login/impl/src/test/kotlin/io/element/android/features/login/impl/accountprovider/AccountProviderDataSourceTest.kt +++ b/features/login/impl/src/test/kotlin/io/element/android/features/login/impl/accountprovider/AccountProviderDataSourceTest.kt @@ -10,9 +10,10 @@ package io.element.android.features.login.impl.accountprovider import app.cash.turbine.test import com.google.common.truth.Truth.assertThat -import io.element.android.appconfig.AuthenticationConfig -import io.element.android.features.enterprise.api.EnterpriseService import io.element.android.features.enterprise.test.FakeEnterpriseService +import io.element.android.libraries.matrix.api.accountprovider.AccountProvider +import io.element.android.libraries.matrix.api.accountprovider.matrixOrgAccountProvider +import io.element.android.libraries.matrix.test.accountprovider.anAccountProviderManaged import io.element.android.libraries.preferences.test.InMemoryAppPreferencesStore import io.element.android.tests.testutils.WarmUpRule import kotlinx.coroutines.test.runTest @@ -24,61 +25,24 @@ class AccountProviderDataSourceTest { val warmUpRule = WarmUpRule() @Test - fun `present - initial state`() = runTest { + fun `present - initial state - matrix org is the default when nothing is configured`() = runTest { val sut = anAccountProviderDataSource() sut.flow.test { - val initialState = awaitItem() - assertThat(initialState).isEqualTo( - AccountProvider( - url = AuthenticationConfig.MATRIX_ORG_URL, - title = "matrix.org", - subtitle = null, - isPublic = true, - isMatrixOrg = true, - ) - ) + assertThat(awaitItem()).isEqualTo(matrixOrgAccountProvider) } } @Test - fun `present - initial state - matrix org`() = runTest { + fun `present - initial state - the first configured account provider is the default`() = runTest { val sut = anAccountProviderDataSource( enterpriseService = FakeEnterpriseService( - defaultHomeserverListResult = { listOf(AuthenticationConfig.MATRIX_ORG_URL) } + accountProviderAllowListResult = { + listOf(anAccountProviderManaged(serverName = "first.org"), anAccountProviderManaged(serverName = "second.org")) + } ), ) sut.flow.test { - val initialState = awaitItem() - assertThat(initialState).isEqualTo( - AccountProvider( - url = AuthenticationConfig.MATRIX_ORG_URL, - title = "matrix.org", - subtitle = null, - isPublic = true, - isMatrixOrg = true, - ) - ) - } - } - - @Test - fun `present - ensure that default homeserver is not star char`() = runTest { - val sut = anAccountProviderDataSource( - enterpriseService = FakeEnterpriseService( - defaultHomeserverListResult = { listOf(EnterpriseService.ANY_ACCOUNT_PROVIDER, AuthenticationConfig.MATRIX_ORG_URL) } - ), - ) - sut.flow.test { - val initialState = awaitItem() - assertThat(initialState).isEqualTo( - AccountProvider( - url = AuthenticationConfig.MATRIX_ORG_URL, - title = "matrix.org", - subtitle = null, - isPublic = true, - isMatrixOrg = true, - ) - ) + assertThat(awaitItem()).isEqualTo(anAccountProviderManaged(serverName = "first.org")) } } @@ -86,22 +50,11 @@ class AccountProviderDataSourceTest { fun `present - user change and reset`() = runTest { val sut = anAccountProviderDataSource() sut.flow.test { - val initialState = awaitItem() - assertThat(initialState.url).isEqualTo(AuthenticationConfig.MATRIX_ORG_URL) - sut.setAccountProvider(AccountProvider(url = "https://example.com")) - val changedState = awaitItem() - assertThat(changedState).isEqualTo( - AccountProvider( - url = "https://example.com", - title = "example.com", - subtitle = null, - isPublic = false, - isMatrixOrg = false, - ) - ) + assertThat(awaitItem()).isEqualTo(matrixOrgAccountProvider) + sut.setAccountProvider(AccountProvider.Generic("https://example.com")) + assertThat(awaitItem()).isEqualTo(AccountProvider.Generic("https://example.com")) sut.reset() - val resetState = awaitItem() - assertThat(resetState.url).isEqualTo(AuthenticationConfig.MATRIX_ORG_URL) + assertThat(awaitItem()).isEqualTo(matrixOrgAccountProvider) } } @@ -109,22 +62,23 @@ class AccountProviderDataSourceTest { fun `present - set url and reset`() = runTest { val sut = anAccountProviderDataSource() sut.flow.test { - val initialState = awaitItem() - assertThat(initialState.url).isEqualTo(AuthenticationConfig.MATRIX_ORG_URL) + assertThat(awaitItem()).isEqualTo(matrixOrgAccountProvider) sut.setUrl(url = "https://example.com") - val changedState = awaitItem() - assertThat(changedState).isEqualTo( - AccountProvider( - url = "https://example.com", - title = "example.com", - subtitle = null, - isPublic = false, - isMatrixOrg = false, - ) + assertThat(awaitItem()).isEqualTo( + AccountProvider.Generic("https://example.com") ) sut.reset() - val resetState = awaitItem() - assertThat(resetState.url).isEqualTo(AuthenticationConfig.MATRIX_ORG_URL) + assertThat(awaitItem()).isEqualTo(matrixOrgAccountProvider) + } + } + + @Test + fun `present - a provider set by the user is stored as they input it`() = runTest { + val sut = anAccountProviderDataSource() + sut.flow.test { + skipItems(1) + sut.setUrl(url = "example.com") + assertThat(awaitItem()).isEqualTo(AccountProvider.Generic("example.com")) } } @@ -136,7 +90,7 @@ class AccountProviderDataSourceTest { ), ) sut.flow.test { - assertThat(awaitItem().url).isEqualTo("https://example.com") + assertThat(awaitItem()).isEqualTo(AccountProvider.Generic("https://example.com")) } } @@ -144,14 +98,31 @@ class AccountProviderDataSourceTest { fun `present - history is ignored when the account provider is enforced`() = runTest { val sut = anAccountProviderDataSource( enterpriseService = FakeEnterpriseService( - defaultHomeserverListResult = { listOf("https://enforced.org") } + accountProviderAllowListResult = { listOf(anAccountProviderManaged(serverName = "enforced.org")) }, + canConnectToAnyAccountProviderResult = { false }, ), appPreferencesStore = InMemoryAppPreferencesStore( homeserverHistory = listOf("https://example.com"), ), ) sut.flow.test { - assertThat(awaitItem().url).isEqualTo("https://enforced.org") + assertThat(awaitItem()).isEqualTo(anAccountProviderManaged(serverName = "enforced.org")) + } + } + + @Test + fun `present - history wins over the configured provider when other providers are allowed`() = runTest { + val sut = anAccountProviderDataSource( + enterpriseService = FakeEnterpriseService( + accountProviderAllowListResult = { listOf(anAccountProviderManaged(serverName = "preferred.org")) }, + canConnectToAnyAccountProviderResult = { true }, + ), + appPreferencesStore = InMemoryAppPreferencesStore( + homeserverHistory = listOf("https://example.com"), + ), + ) + sut.flow.test { + assertThat(awaitItem()).isEqualTo(AccountProvider.Generic("https://example.com")) } } @@ -163,11 +134,11 @@ class AccountProviderDataSourceTest { ), ) sut.flow.test { - assertThat(awaitItem().url).isEqualTo("https://example.com") + assertThat(awaitItem()).isEqualTo(AccountProvider.Generic("https://example.com")) sut.setUrl("https://other.com") - assertThat(awaitItem().url).isEqualTo("https://other.com") + assertThat(awaitItem()).isEqualTo(AccountProvider.Generic("https://other.com")) sut.reset() - assertThat(awaitItem().url).isEqualTo("https://example.com") + assertThat(awaitItem()).isEqualTo(AccountProvider.Generic("https://example.com")) } } } diff --git a/features/login/impl/src/test/kotlin/io/element/android/features/login/impl/accountprovider/SaveAccountProviderToHistoryTest.kt b/features/login/impl/src/test/kotlin/io/element/android/features/login/impl/accountprovider/SaveAccountProviderToHistoryTest.kt index 0af8188f3f..604e01acfe 100644 --- a/features/login/impl/src/test/kotlin/io/element/android/features/login/impl/accountprovider/SaveAccountProviderToHistoryTest.kt +++ b/features/login/impl/src/test/kotlin/io/element/android/features/login/impl/accountprovider/SaveAccountProviderToHistoryTest.kt @@ -20,7 +20,7 @@ class SaveAccountProviderToHistoryTest { val warmUpRule = WarmUpRule() @Test - fun `invoke saves the current account provider url to history`() = runTest { + fun `invoke saves the current account provider server name to history`() = runTest { val appPreferencesStore = InMemoryAppPreferencesStore() val accountProviderDataSource = anAccountProviderDataSource() accountProviderDataSource.setUrl("https://example.com") @@ -29,7 +29,7 @@ class SaveAccountProviderToHistoryTest { sut() assertThat(appPreferencesStore.getHomeserverHistoryFlow().first()) - .containsExactly("https://example.com") + .containsExactly("example.com") } @Test @@ -45,6 +45,6 @@ class SaveAccountProviderToHistoryTest { sut() assertThat(appPreferencesStore.getHomeserverHistoryFlow().first()) - .containsExactly("https://example.com") + .containsExactly("example.com") } } diff --git a/features/login/impl/src/test/kotlin/io/element/android/features/login/impl/changeserver/ChangeServerPresenterTest.kt b/features/login/impl/src/test/kotlin/io/element/android/features/login/impl/changeserver/ChangeServerPresenterTest.kt index 44a3bbd5cb..f43a575d37 100644 --- a/features/login/impl/src/test/kotlin/io/element/android/features/login/impl/changeserver/ChangeServerPresenterTest.kt +++ b/features/login/impl/src/test/kotlin/io/element/android/features/login/impl/changeserver/ChangeServerPresenterTest.kt @@ -12,14 +12,15 @@ import com.google.common.truth.Truth.assertThat import io.element.android.features.enterprise.api.EnterpriseService import io.element.android.features.enterprise.test.FakeEnterpriseService import io.element.android.features.login.impl.accesscontrol.DefaultAccountProviderAccessControl -import io.element.android.features.login.impl.accountprovider.AccountProvider import io.element.android.features.login.impl.accountprovider.AccountProviderDataSource import io.element.android.features.login.impl.accountprovider.anAccountProviderDataSource import io.element.android.features.login.impl.error.ChangeServerError import io.element.android.features.login.impl.localnetwork.LocalNetworkPermissionGate import io.element.android.libraries.architecture.AsyncData +import io.element.android.libraries.matrix.api.accountprovider.AccountProvider import io.element.android.libraries.matrix.test.AN_EXCEPTION import io.element.android.libraries.matrix.test.A_HOMESERVER_URL +import io.element.android.libraries.matrix.test.accountprovider.anAccountProviderManaged import io.element.android.libraries.matrix.test.auth.FakeMatrixAuthenticationService import io.element.android.libraries.matrix.test.auth.aMatrixHomeServerDetails import io.element.android.libraries.permissions.api.localnetwork.LocalNetworkPermissionDialog @@ -57,13 +58,13 @@ class ChangeServerPresenterTest { createPresenter( authenticationService = authenticationService, enterpriseService = FakeEnterpriseService( - isAllowedToConnectToHomeserverResult = { true }, + isAllowedToConnectToAccountProviderResult = { true }, isElementProEnforcedResult = { false }, ), ).test { val initialState = awaitItem() assertThat(initialState.changeServerAction).isEqualTo(AsyncData.Uninitialized) - initialState.eventSink.invoke(ChangeServerEvent.ChangeServer(AccountProvider(url = A_HOMESERVER_URL))) + initialState.eventSink.invoke(ChangeServerEvent.ChangeServer(AccountProvider.Generic(A_HOMESERVER_URL))) val loadingState = awaitItem() assertThat(loadingState.changeServerAction).isInstanceOf(AsyncData.Loading::class.java) val successState = awaitItem() @@ -80,14 +81,14 @@ class ChangeServerPresenterTest { ) createPresenter( enterpriseService = FakeEnterpriseService( - isAllowedToConnectToHomeserverResult = { true }, + isAllowedToConnectToAccountProviderResult = { true }, isElementProEnforcedResult = { false }, ), authenticationService = authenticationService, ).test { val initialState = awaitItem() assertThat(initialState.changeServerAction).isEqualTo(AsyncData.Uninitialized) - initialState.eventSink.invoke(ChangeServerEvent.ChangeServer(AccountProvider(url = A_HOMESERVER_URL))) + initialState.eventSink.invoke(ChangeServerEvent.ChangeServer(AccountProvider.Generic(A_HOMESERVER_URL))) val loadingState = awaitItem() assertThat(loadingState.changeServerAction).isInstanceOf(AsyncData.Loading::class.java) val failureState = awaitItem() @@ -108,14 +109,14 @@ class ChangeServerPresenterTest { ) createPresenter( enterpriseService = FakeEnterpriseService( - isAllowedToConnectToHomeserverResult = { true }, + isAllowedToConnectToAccountProviderResult = { true }, isElementProEnforcedResult = { false }, ), authenticationService = authenticationService, ).test { val initialState = awaitItem() assertThat(initialState.changeServerAction).isEqualTo(AsyncData.Uninitialized) - initialState.eventSink.invoke(ChangeServerEvent.ChangeServer(AccountProvider(url = A_HOMESERVER_URL))) + initialState.eventSink.invoke(ChangeServerEvent.ChangeServer(AccountProvider.Generic(A_HOMESERVER_URL))) val loadingState = awaitItem() assertThat(loadingState.changeServerAction).isInstanceOf(AsyncData.Loading::class.java) val failureState = awaitItem() @@ -128,30 +129,30 @@ class ChangeServerPresenterTest { @Test fun `present - change server not allowed error`() = runTest { - val isAllowedToConnectToHomeserverResult = lambdaRecorder { false } + val isAllowedToConnectToAccountProviderResult = lambdaRecorder { false } createPresenter( enterpriseService = FakeEnterpriseService( - isAllowedToConnectToHomeserverResult = isAllowedToConnectToHomeserverResult, - defaultHomeserverListResult = { listOf("element.io") }, + isAllowedToConnectToAccountProviderResult = isAllowedToConnectToAccountProviderResult, + accountProviderAllowListResult = { listOf(anAccountProviderManaged(serverName = "element.io")) }, isElementProEnforcedResult = { false }, ), ).test { val initialState = awaitItem() assertThat(initialState.changeServerAction).isEqualTo(AsyncData.Uninitialized) - val anAccountProvider = AccountProvider(url = A_HOMESERVER_URL) + val anAccountProvider = AccountProvider.Generic(A_HOMESERVER_URL) initialState.eventSink.invoke(ChangeServerEvent.ChangeServer(anAccountProvider)) val loadingState = awaitItem() assertThat(loadingState.changeServerAction).isInstanceOf(AsyncData.Loading::class.java) val failureState = awaitItem() assertThat( (failureState.changeServerAction.errorOrNull() as ChangeServerError.UnauthorizedAccountProvider).unauthorisedAccountProviderTitle - ).isEqualTo(anAccountProvider.title) + ).isEqualTo(anAccountProvider.serverNameOrBaseUrl()) assertThat( (failureState.changeServerAction.errorOrNull() as ChangeServerError.UnauthorizedAccountProvider).authorisedAccountProviderTitles ).containsExactly("element.io") - isAllowedToConnectToHomeserverResult.assertions() + isAllowedToConnectToAccountProviderResult.assertions() .isCalledOnce() - .with(value(A_HOMESERVER_URL)) + .with(value(AccountProvider.Generic(A_HOMESERVER_URL))) } } @@ -166,14 +167,14 @@ class ChangeServerPresenterTest { ).test { val initialState = awaitItem() assertThat(initialState.changeServerAction).isEqualTo(AsyncData.Uninitialized) - val anAccountProvider = AccountProvider(url = A_HOMESERVER_URL) + val anAccountProvider = AccountProvider.Generic(A_HOMESERVER_URL) initialState.eventSink.invoke(ChangeServerEvent.ChangeServer(anAccountProvider)) // Skip loading state skipItems(1) val failureState = awaitItem() assertThat( (failureState.changeServerAction.errorOrNull() as ChangeServerError.NeedElementPro).unauthorisedAccountProviderTitle - ).isEqualTo(anAccountProvider.title) + ).isEqualTo(anAccountProvider.serverNameOrBaseUrl()) assertThat( (failureState.changeServerAction.errorOrNull() as ChangeServerError.NeedElementPro).applicationId ).isEqualTo("io.element.enterprise") @@ -188,13 +189,13 @@ class ChangeServerPresenterTest { ) createPresenter( authenticationService = authenticationService, - enterpriseService = FakeEnterpriseService(isAllowedToConnectToHomeserverResult = { true }), + enterpriseService = FakeEnterpriseService(isAllowedToConnectToAccountProviderResult = { true }), localNetworkPermissionAdvisor = FakeLocalNetworkPermissionAdvisor(shouldPrompt = true), permissionsPresenter = FakePermissionsPresenter(), ).test { val initialState = awaitItem() assertThat(initialState.localNetworkPermissionDialog).isEqualTo(LocalNetworkPermissionDialog.None) - initialState.eventSink.invoke(ChangeServerEvent.ChangeServer(AccountProvider(url = A_HOMESERVER_URL))) + initialState.eventSink.invoke(ChangeServerEvent.ChangeServer(AccountProvider.Generic(A_HOMESERVER_URL))) val promptState = expectMostRecentItem() // Dialog is shown, permission has not been requested yet, setHomeserver has not been called. assertThat(promptState.localNetworkPermissionDialog).isNotEqualTo(LocalNetworkPermissionDialog.None) @@ -208,12 +209,12 @@ class ChangeServerPresenterTest { authenticationService = FakeMatrixAuthenticationService( setHomeserverResult = { Result.success(aMatrixHomeServerDetails(supportsOAuthLogin = true)) }, ), - enterpriseService = FakeEnterpriseService(isAllowedToConnectToHomeserverResult = { true }), + enterpriseService = FakeEnterpriseService(isAllowedToConnectToAccountProviderResult = { true }), localNetworkPermissionAdvisor = FakeLocalNetworkPermissionAdvisor(shouldPrompt = true), permissionsPresenter = FakePermissionsPresenter(), ).test { val initialState = awaitItem() - initialState.eventSink.invoke(ChangeServerEvent.ChangeServer(AccountProvider(url = A_HOMESERVER_URL))) + initialState.eventSink.invoke(ChangeServerEvent.ChangeServer(AccountProvider.Generic(A_HOMESERVER_URL))) val promptState = expectMostRecentItem() assertThat(promptState.localNetworkPermissionDialog).isNotEqualTo(LocalNetworkPermissionDialog.None) promptState.eventSink.invoke(ChangeServerEvent.DismissLocalNetworkPermission) @@ -231,12 +232,12 @@ class ChangeServerPresenterTest { val permissionsPresenter = FakePermissionsPresenter() createPresenter( authenticationService = authenticationService, - enterpriseService = FakeEnterpriseService(isAllowedToConnectToHomeserverResult = { true }, isElementProEnforcedResult = { false }), + enterpriseService = FakeEnterpriseService(isAllowedToConnectToAccountProviderResult = { true }, isElementProEnforcedResult = { false }), localNetworkPermissionAdvisor = FakeLocalNetworkPermissionAdvisor(shouldPrompt = true), permissionsPresenter = permissionsPresenter, ).test { val initialState = awaitItem() - initialState.eventSink.invoke(ChangeServerEvent.ChangeServer(AccountProvider(url = A_HOMESERVER_URL))) + initialState.eventSink.invoke(ChangeServerEvent.ChangeServer(AccountProvider.Generic(A_HOMESERVER_URL))) val promptState = expectMostRecentItem() assertThat(promptState.localNetworkPermissionDialog).isNotEqualTo(LocalNetworkPermissionDialog.None) permissionsPresenter.setPermissionGranted() diff --git a/features/login/impl/src/test/kotlin/io/element/android/features/login/impl/screens/chooseaccountprovider/ChooseAccountProviderPresenterTest.kt b/features/login/impl/src/test/kotlin/io/element/android/features/login/impl/screens/chooseaccountprovider/ChooseAccountProviderPresenterTest.kt index 78f4293489..17711cc469 100644 --- a/features/login/impl/src/test/kotlin/io/element/android/features/login/impl/screens/chooseaccountprovider/ChooseAccountProviderPresenterTest.kt +++ b/features/login/impl/src/test/kotlin/io/element/android/features/login/impl/screens/chooseaccountprovider/ChooseAccountProviderPresenterTest.kt @@ -11,14 +11,13 @@ package io.element.android.features.login.impl.screens.chooseaccountprovider import com.google.common.truth.Truth.assertThat import io.element.android.features.enterprise.api.EnterpriseService import io.element.android.features.enterprise.test.FakeEnterpriseService -import io.element.android.features.login.impl.accountprovider.AccountProvider import io.element.android.features.login.impl.login.LoginModePresenter import io.element.android.features.login.impl.screens.onboarding.createLoginModePresenter import io.element.android.libraries.architecture.AsyncData -import io.element.android.libraries.core.uri.ensureProtocol import io.element.android.libraries.matrix.test.AN_ACCOUNT_PROVIDER_2 import io.element.android.libraries.matrix.test.AN_ACCOUNT_PROVIDER_3 import io.element.android.libraries.matrix.test.AN_EXCEPTION +import io.element.android.libraries.matrix.test.accountprovider.anAccountProviderManaged import io.element.android.libraries.matrix.test.auth.FakeMatrixAuthenticationService import io.element.android.tests.testutils.WarmUpRule import io.element.android.tests.testutils.test @@ -33,18 +32,8 @@ class ChooseAccountProviderPresenterTest { companion object { private const val ACCOUNT_PROVIDER_FROM_CONFIG_1 = AN_ACCOUNT_PROVIDER_2 private const val ACCOUNT_PROVIDER_FROM_CONFIG_2 = AN_ACCOUNT_PROVIDER_3 - val accountProvider1 = AccountProvider( - url = ACCOUNT_PROVIDER_FROM_CONFIG_1.ensureProtocol(), - subtitle = null, - isPublic = false, - isMatrixOrg = false, - ) - val accountProvider2 = AccountProvider( - url = ACCOUNT_PROVIDER_FROM_CONFIG_2.ensureProtocol(), - subtitle = null, - isPublic = false, - isMatrixOrg = false, - ) + val accountProvider1 = anAccountProviderManaged(serverName = ACCOUNT_PROVIDER_FROM_CONFIG_1) + val accountProvider2 = anAccountProviderManaged(serverName = ACCOUNT_PROVIDER_FROM_CONFIG_2) } @Test @@ -61,7 +50,7 @@ class ChooseAccountProviderPresenterTest { fun `present - initial state`() = runTest { val presenter = createPresenter( enterpriseService = FakeEnterpriseService( - defaultHomeserverListResult = { listOf(ACCOUNT_PROVIDER_FROM_CONFIG_1, ACCOUNT_PROVIDER_FROM_CONFIG_2) }, + accountProviderAllowListResult = { listOf(accountProvider1, accountProvider2) }, ), ) presenter.test { @@ -79,7 +68,7 @@ class ChooseAccountProviderPresenterTest { val authenticationService = FakeMatrixAuthenticationService() val presenter = createPresenter( enterpriseService = FakeEnterpriseService( - defaultHomeserverListResult = { listOf(ACCOUNT_PROVIDER_FROM_CONFIG_1, ACCOUNT_PROVIDER_FROM_CONFIG_2) }, + accountProviderAllowListResult = { listOf(accountProvider1, accountProvider2) }, ), loginModePresenter = createLoginModePresenter( authenticationService = authenticationService, @@ -103,7 +92,7 @@ class ChooseAccountProviderPresenterTest { ) val presenter = createPresenter( enterpriseService = FakeEnterpriseService( - defaultHomeserverListResult = { listOf(ACCOUNT_PROVIDER_FROM_CONFIG_1, ACCOUNT_PROVIDER_FROM_CONFIG_2) }, + accountProviderAllowListResult = { listOf(accountProvider1, accountProvider2) }, ), loginModePresenter = createLoginModePresenter( authenticationService = authenticationService, @@ -136,7 +125,7 @@ class ChooseAccountProviderPresenterTest { val authenticationService = FakeMatrixAuthenticationService() val presenter = createPresenter( enterpriseService = FakeEnterpriseService( - defaultHomeserverListResult = { listOf(ACCOUNT_PROVIDER_FROM_CONFIG_1, ACCOUNT_PROVIDER_FROM_CONFIG_2) }, + accountProviderAllowListResult = { listOf(accountProvider1, accountProvider2) }, ), loginModePresenter = createLoginModePresenter( authenticationService = authenticationService, diff --git a/features/login/impl/src/test/kotlin/io/element/android/features/login/impl/screens/chooseaccountprovider/ChooseAccountProviderStateTest.kt b/features/login/impl/src/test/kotlin/io/element/android/features/login/impl/screens/chooseaccountprovider/ChooseAccountProviderStateTest.kt index a5cb54e7e1..c4af8f9544 100644 --- a/features/login/impl/src/test/kotlin/io/element/android/features/login/impl/screens/chooseaccountprovider/ChooseAccountProviderStateTest.kt +++ b/features/login/impl/src/test/kotlin/io/element/android/features/login/impl/screens/chooseaccountprovider/ChooseAccountProviderStateTest.kt @@ -9,7 +9,7 @@ package io.element.android.features.login.impl.screens.chooseaccountprovider import com.google.common.truth.Truth.assertThat -import io.element.android.features.login.impl.accountprovider.anAccountProvider +import io.element.android.features.login.impl.accountprovider.anAccountProviderManaged import io.element.android.features.login.impl.login.LoginMode import io.element.android.features.login.impl.login.aLoginModeState import io.element.android.libraries.architecture.AsyncData @@ -27,7 +27,7 @@ class ChooseAccountProviderStateTest { @Test fun `submitEnabled returns true when there is a selectedAccountProvider`() { val sut = aChooseAccountProviderState( - selectedAccountProvider = anAccountProvider(), + selectedAccountProvider = anAccountProviderManaged(), ) assertThat(sut.submitEnabled).isTrue() } @@ -35,7 +35,7 @@ class ChooseAccountProviderStateTest { @Test fun `submitEnabled returns false when there is a selectedAccountProvider but there is an error`() { val sut = aChooseAccountProviderState( - selectedAccountProvider = anAccountProvider(), + selectedAccountProvider = anAccountProviderManaged(), loginModeState = aLoginModeState(loginMode = AsyncData.Failure(Throwable("Error"))), ) assertThat(sut.submitEnabled).isFalse() @@ -44,7 +44,7 @@ class ChooseAccountProviderStateTest { @Test fun `submitEnabled returns false when there is a selectedAccountProvider but the result is successful`() { val sut = aChooseAccountProviderState( - selectedAccountProvider = anAccountProvider(), + selectedAccountProvider = anAccountProviderManaged(), loginModeState = aLoginModeState(loginMode = AsyncData.Success(LoginMode.PasswordLogin)), ) assertThat(sut.submitEnabled).isFalse() diff --git a/features/login/impl/src/test/kotlin/io/element/android/features/login/impl/screens/chooseaccountprovider/ChooseAccountProviderViewTest.kt b/features/login/impl/src/test/kotlin/io/element/android/features/login/impl/screens/chooseaccountprovider/ChooseAccountProviderViewTest.kt index 4ef7a71966..9bb8da717e 100644 --- a/features/login/impl/src/test/kotlin/io/element/android/features/login/impl/screens/chooseaccountprovider/ChooseAccountProviderViewTest.kt +++ b/features/login/impl/src/test/kotlin/io/element/android/features/login/impl/screens/chooseaccountprovider/ChooseAccountProviderViewTest.kt @@ -16,7 +16,7 @@ import androidx.compose.ui.test.ExperimentalTestApi import androidx.compose.ui.test.onNodeWithText import androidx.compose.ui.test.performClick import androidx.compose.ui.test.v2.runAndroidComposeUiTest -import io.element.android.features.login.impl.accountprovider.anAccountProvider +import io.element.android.features.login.impl.accountprovider.anAccountProviderManaged import io.element.android.features.login.impl.login.aLoginModeState import io.element.android.libraries.architecture.AsyncData import io.element.android.libraries.matrix.api.auth.OAuthDetails @@ -57,11 +57,11 @@ class ChooseAccountProviderViewTest : RobolectricTest() { ChooseAccountProviderPresenterTest.accountProvider1, ChooseAccountProviderPresenterTest.accountProvider2, ), - selectedAccountProvider = anAccountProvider(), + selectedAccountProvider = anAccountProviderManaged(), eventSink = eventSink, ), ) - onNodeWithText(ChooseAccountProviderPresenterTest.accountProvider1.title).performClick() + onNodeWithText(ChooseAccountProviderPresenterTest.accountProvider1.friendlyServerName()).performClick() eventSink.assertSingle(ChooseAccountProviderEvent.SelectAccountProvider(ChooseAccountProviderPresenterTest.accountProvider1)) } diff --git a/features/login/impl/src/test/kotlin/io/element/android/features/login/impl/screens/confirmaccountprovider/ConfirmAccountProviderPresenterTest.kt b/features/login/impl/src/test/kotlin/io/element/android/features/login/impl/screens/confirmaccountprovider/ConfirmAccountProviderPresenterTest.kt index 19afbe0f28..9bccb2c261 100644 --- a/features/login/impl/src/test/kotlin/io/element/android/features/login/impl/screens/confirmaccountprovider/ConfirmAccountProviderPresenterTest.kt +++ b/features/login/impl/src/test/kotlin/io/element/android/features/login/impl/screens/confirmaccountprovider/ConfirmAccountProviderPresenterTest.kt @@ -10,7 +10,6 @@ package io.element.android.features.login.impl.screens.confirmaccountprovider import app.cash.turbine.ReceiveTurbine import com.google.common.truth.Truth.assertThat -import io.element.android.appconfig.AuthenticationConfig import io.element.android.features.enterprise.api.EnterpriseService import io.element.android.features.enterprise.test.FakeEnterpriseService import io.element.android.features.login.impl.accesscontrol.DefaultAccountProviderAccessControl @@ -24,6 +23,7 @@ import io.element.android.features.login.impl.screens.onboarding.createLoginMode import io.element.android.libraries.architecture.AsyncData import io.element.android.libraries.matrix.api.auth.MatrixAuthenticationService import io.element.android.libraries.matrix.test.AN_EXCEPTION +import io.element.android.libraries.matrix.test.accountprovider.anAccountProviderManaged import io.element.android.libraries.matrix.test.auth.FakeMatrixAuthenticationService import io.element.android.libraries.matrix.test.auth.aMatrixHomeServerDetails import io.element.android.libraries.oauth.api.OAuthAction @@ -44,6 +44,11 @@ class ConfirmAccountProviderPresenterTest { @get:Rule val warmUpRule = WarmUpRule() + companion object { + private const val MATRIX_ORG_SERVER_NAME = "matrix.org" + private const val MATRIX_ORG_URL = "https://matrix.org" + } + @Test fun `present - initial test`() = runTest { val presenter = createConfirmAccountProviderPresenter() @@ -68,7 +73,7 @@ class ConfirmAccountProviderPresenterTest { ) presenter.test { val initialState = awaitItem() - initialState.eventSink.invoke(ConfirmAccountProviderEvent.Continue(AuthenticationConfig.MATRIX_ORG_URL)) + initialState.eventSink.invoke(ConfirmAccountProviderEvent.Continue(MATRIX_ORG_URL)) val successState = awaitLoginMode { it is AsyncData.Success } assertThat(successState.loginModeState.loginMode.dataOrNull()).isEqualTo(LoginMode.PasswordLogin) cancelAndIgnoreRemainingEvents() @@ -87,7 +92,7 @@ class ConfirmAccountProviderPresenterTest { ) presenter.test { val initialState = awaitItem() - initialState.eventSink.invoke(ConfirmAccountProviderEvent.Continue(AuthenticationConfig.MATRIX_ORG_URL)) + initialState.eventSink.invoke(ConfirmAccountProviderEvent.Continue(MATRIX_ORG_URL)) val successState = awaitLoginMode { it is AsyncData.Success } assertThat(successState.loginModeState.loginMode.dataOrNull()).isInstanceOf(LoginMode.OAuth::class.java) cancelAndIgnoreRemainingEvents() @@ -108,7 +113,7 @@ class ConfirmAccountProviderPresenterTest { ) presenter.test { val initialState = awaitItem() - initialState.eventSink.invoke(ConfirmAccountProviderEvent.Continue(AuthenticationConfig.MATRIX_ORG_URL)) + initialState.eventSink.invoke(ConfirmAccountProviderEvent.Continue(MATRIX_ORG_URL)) val successState = awaitLoginMode { it is AsyncData.Success } assertThat(successState.loginModeState.loginMode.dataOrNull()).isInstanceOf(LoginMode.OAuth::class.java) authenticationService.givenOAuthCancelError(AN_EXCEPTION) @@ -133,7 +138,7 @@ class ConfirmAccountProviderPresenterTest { ) presenter.test { val initialState = awaitItem() - initialState.eventSink.invoke(ConfirmAccountProviderEvent.Continue(AuthenticationConfig.MATRIX_ORG_URL)) + initialState.eventSink.invoke(ConfirmAccountProviderEvent.Continue(MATRIX_ORG_URL)) val successState = awaitLoginMode { it is AsyncData.Success } assertThat(successState.loginModeState.loginMode.dataOrNull()).isInstanceOf(LoginMode.OAuth::class.java) defaultOAuthActionFlow.post(OAuthAction.GoBack()) @@ -157,7 +162,7 @@ class ConfirmAccountProviderPresenterTest { ) presenter.test { val initialState = awaitItem() - initialState.eventSink.invoke(ConfirmAccountProviderEvent.Continue(AuthenticationConfig.MATRIX_ORG_URL)) + initialState.eventSink.invoke(ConfirmAccountProviderEvent.Continue(MATRIX_ORG_URL)) awaitLoginMode { it is AsyncData.Loading } defaultOAuthActionFlow.post(OAuthAction.GoBack(toUnblock = true)) val cancelFinalState = awaitLoginMode { it is AsyncData.Uninitialized } @@ -180,7 +185,7 @@ class ConfirmAccountProviderPresenterTest { ) presenter.test { val initialState = awaitItem() - initialState.eventSink.invoke(ConfirmAccountProviderEvent.Continue(AuthenticationConfig.MATRIX_ORG_URL)) + initialState.eventSink.invoke(ConfirmAccountProviderEvent.Continue(MATRIX_ORG_URL)) val successState = awaitLoginMode { it is AsyncData.Success } assertThat(successState.loginModeState.loginMode.dataOrNull()).isInstanceOf(LoginMode.OAuth::class.java) authenticationService.givenLoginError(AN_EXCEPTION) @@ -205,7 +210,7 @@ class ConfirmAccountProviderPresenterTest { ) presenter.test { val initialState = awaitItem() - initialState.eventSink.invoke(ConfirmAccountProviderEvent.Continue(AuthenticationConfig.MATRIX_ORG_URL)) + initialState.eventSink.invoke(ConfirmAccountProviderEvent.Continue(MATRIX_ORG_URL)) val successState = awaitLoginMode { it is AsyncData.Success } assertThat(successState.loginModeState.loginMode.dataOrNull()).isInstanceOf(LoginMode.OAuth::class.java) defaultOidcActionFlow.post(OAuthAction.Success("aUrl")) @@ -227,7 +232,7 @@ class ConfirmAccountProviderPresenterTest { ) presenter.test { val initialState = awaitItem() - initialState.eventSink.invoke(ConfirmAccountProviderEvent.Continue(AuthenticationConfig.MATRIX_ORG_URL)) + initialState.eventSink.invoke(ConfirmAccountProviderEvent.Continue(MATRIX_ORG_URL)) // The account provider validation fails, so the login is never attempted. val failureState = awaitState { it.changeServerState.changeServerAction is AsyncData.Failure } assertThat(failureState.loginModeState.loginMode).isEqualTo(AsyncData.Uninitialized) @@ -249,7 +254,7 @@ class ConfirmAccountProviderPresenterTest { val initialState = awaitItem() // Submit will return an error while validating the account provider - initialState.eventSink(ConfirmAccountProviderEvent.Continue(AuthenticationConfig.MATRIX_ORG_URL)) + initialState.eventSink(ConfirmAccountProviderEvent.Continue(MATRIX_ORG_URL)) // Check an error was returned val submittedState = awaitState { it.changeServerState.changeServerAction is AsyncData.Failure } @@ -274,7 +279,7 @@ class ConfirmAccountProviderPresenterTest { ) presenter.test { val initialState = awaitItem() - initialState.eventSink(ConfirmAccountProviderEvent.Continue(AuthenticationConfig.MATRIX_ORG_URL)) + initialState.eventSink(ConfirmAccountProviderEvent.Continue(MATRIX_ORG_URL)) // Check an error was returned val submittedState = awaitLoginMode { it is AsyncData.Failure } assertThat(submittedState.loginModeState.loginMode.errorOrNull()).isInstanceOf(AccountCreationNotSupported::class.java) @@ -299,7 +304,7 @@ class ConfirmAccountProviderPresenterTest { ) presenter.test { val initialState = awaitItem() - initialState.eventSink(ConfirmAccountProviderEvent.Continue(AuthenticationConfig.MATRIX_ORG_URL)) + initialState.eventSink(ConfirmAccountProviderEvent.Continue(MATRIX_ORG_URL)) val submittedState = awaitLoginMode { it is AsyncData.Success } assertThat(submittedState.loginModeState.loginMode.dataOrNull()).isInstanceOf(LoginMode.OAuth::class.java) cancelAndIgnoreRemainingEvents() @@ -344,7 +349,7 @@ class ConfirmAccountProviderPresenterTest { val suggestionState = awaitState { it.accountProviderSuggestion != null } suggestionState.eventSink(ConfirmAccountProviderEvent.Continue("randomcommunity.org")) awaitLoginMode { it is AsyncData.Success } - assertThat(submittedUrls.first()).isEqualTo("https://randomcommunity.org") + assertThat(submittedUrls.first()).isEqualTo("randomcommunity.org") cancelAndIgnoreRemainingEvents() } } @@ -375,8 +380,7 @@ class ConfirmAccountProviderPresenterTest { val presenter = createConfirmAccountProviderPresenter( appPreferencesStore = InMemoryAppPreferencesStore(homeserverHistory = emptyList()), enterpriseService = FakeEnterpriseService( - // Preferred servers plus the "*" (any) wildcard: the wildcard is filtered out, the rest complete. - defaultHomeserverListResult = { listOf("https://element.io", EnterpriseService.ANY_ACCOUNT_PROVIDER) }, + accountProviderAllowListResult = { listOf(anAccountProviderManaged(serverName = "element.io")) }, ), ) presenter.test { @@ -387,6 +391,19 @@ class ConfirmAccountProviderPresenterTest { } } + @Test + fun `present - offers the previously used servers without the scheme as autocomplete suggestions`() = runTest { + val presenter = createConfirmAccountProviderPresenter( + appPreferencesStore = InMemoryAppPreferencesStore(homeserverHistory = listOf("https://previous.org")), + ) + presenter.test { + val initialState = awaitItem() + initialState.eventSink(ConfirmAccountProviderEvent.UserInputChanged("prev")) + val suggestionState = awaitState { it.accountProviderInput == "prev" } + assertThat(suggestionState.accountProviderSuggestion).isEqualTo("previous.org") + } + } + @Test fun `present - offers matrix_org without the scheme as an autocomplete suggestion`() = runTest { val presenter = createConfirmAccountProviderPresenter( @@ -432,7 +449,7 @@ class ConfirmAccountProviderPresenterTest { val initialState = awaitItem() initialState.eventSink(ConfirmAccountProviderEvent.Continue("matrix.org")) awaitLoginMode { it is AsyncData.Success } - assertThat(submittedUrls.first()).isEqualTo(AuthenticationConfig.MATRIX_ORG_URL) + assertThat(submittedUrls.first()).isEqualTo(MATRIX_ORG_SERVER_NAME) cancelAndIgnoreRemainingEvents() } } @@ -453,9 +470,9 @@ class ConfirmAccountProviderPresenterTest { ) presenter.test { val initialState = awaitItem() - initialState.eventSink(ConfirmAccountProviderEvent.Continue(AuthenticationConfig.MATRIX_ORG_URL)) + initialState.eventSink(ConfirmAccountProviderEvent.Continue(MATRIX_ORG_URL)) awaitLoginMode { it is AsyncData.Success } - assertThat(submittedUrls).containsExactly(AuthenticationConfig.MATRIX_ORG_URL) + assertThat(submittedUrls).containsExactly(MATRIX_ORG_SERVER_NAME) cancelAndIgnoreRemainingEvents() } } @@ -474,7 +491,7 @@ class ConfirmAccountProviderPresenterTest { val initialState = awaitItem() initialState.eventSink(ConfirmAccountProviderEvent.Continue("@alice:example.org")) awaitLoginMode { it is AsyncData.Success } - assertThat(submittedUrls.first()).isEqualTo("https://example.org") + assertThat(submittedUrls.first()).isEqualTo("example.org") assertThat(authenticationService.getOAuthUrlLoginHint).isEqualTo("mxid:@alice:example.org") cancelAndIgnoreRemainingEvents() } @@ -494,7 +511,7 @@ class ConfirmAccountProviderPresenterTest { val initialState = awaitItem() initialState.eventSink(ConfirmAccountProviderEvent.Continue("@alice:example.org:8448")) awaitLoginMode { it is AsyncData.Success } - assertThat(submittedUrls.first()).isEqualTo("https://example.org:8448") + assertThat(submittedUrls.first()).isEqualTo("example.org:8448") cancelAndIgnoreRemainingEvents() } } @@ -570,7 +587,7 @@ class ConfirmAccountProviderPresenterTest { accountProviderDataSource = accountProviderDataSource, defaultAccountProviderAccessControl = DefaultAccountProviderAccessControl( enterpriseService = FakeEnterpriseService( - isAllowedToConnectToHomeserverResult = { true }, + isAllowedToConnectToAccountProviderResult = { true }, isElementProEnforcedResult = { false }, ), isEnterpriseBuild = { false }, diff --git a/features/login/impl/src/test/kotlin/io/element/android/features/login/impl/screens/loginpassword/LoginPasswordPresenterTest.kt b/features/login/impl/src/test/kotlin/io/element/android/features/login/impl/screens/loginpassword/LoginPasswordPresenterTest.kt index b12c9ec667..015ece9e23 100644 --- a/features/login/impl/src/test/kotlin/io/element/android/features/login/impl/screens/loginpassword/LoginPasswordPresenterTest.kt +++ b/features/login/impl/src/test/kotlin/io/element/android/features/login/impl/screens/loginpassword/LoginPasswordPresenterTest.kt @@ -9,11 +9,11 @@ package io.element.android.features.login.impl.screens.loginpassword import com.google.common.truth.Truth.assertThat -import io.element.android.appconfig.AuthenticationConfig import io.element.android.features.login.impl.accountprovider.AccountProviderDataSource import io.element.android.features.login.impl.accountprovider.SaveAccountProviderToHistory import io.element.android.features.login.impl.accountprovider.anAccountProviderDataSource import io.element.android.libraries.architecture.AsyncData +import io.element.android.libraries.matrix.api.accountprovider.matrixOrgAccountProvider import io.element.android.libraries.matrix.api.core.SessionId import io.element.android.libraries.matrix.test.AN_EXCEPTION import io.element.android.libraries.matrix.test.A_PASSWORD @@ -39,7 +39,7 @@ class LoginPasswordPresenterTest { fun `present - initial state`() = runTest { createLoginPasswordPresenter().test { val initialState = awaitItem() - assertThat(initialState.accountProvider.url).isEqualTo(AuthenticationConfig.MATRIX_ORG_URL) + assertThat(initialState.accountProvider).isEqualTo(matrixOrgAccountProvider) assertThat(initialState.formState).isEqualTo(LoginFormState.Default) assertThat(initialState.loginAction).isEqualTo(AsyncData.Uninitialized) assertThat(initialState.submitEnabled).isFalse() @@ -127,7 +127,7 @@ class LoginPasswordPresenterTest { val loggedInState = awaitItem() assertThat(loggedInState.loginAction).isEqualTo(AsyncData.Success(A_SESSION_ID)) assertThat(appPreferencesStore.getHomeserverHistoryFlow().first()) - .containsExactly(AuthenticationConfig.MATRIX_ORG_URL) + .containsExactly(matrixOrgAccountProvider.serverName) } } diff --git a/features/login/impl/src/test/kotlin/io/element/android/features/login/impl/screens/onboarding/OnBoardingPresenterTest.kt b/features/login/impl/src/test/kotlin/io/element/android/features/login/impl/screens/onboarding/OnBoardingPresenterTest.kt index 1088a87538..4fecc3ada8 100644 --- a/features/login/impl/src/test/kotlin/io/element/android/features/login/impl/screens/onboarding/OnBoardingPresenterTest.kt +++ b/features/login/impl/src/test/kotlin/io/element/android/features/login/impl/screens/onboarding/OnBoardingPresenterTest.kt @@ -9,7 +9,6 @@ package io.element.android.features.login.impl.screens.onboarding import com.google.common.truth.Truth.assertThat -import io.element.android.appconfig.AuthenticationConfig import io.element.android.appconfig.OnBoardingConfig import io.element.android.features.enterprise.api.EnterpriseService import io.element.android.features.enterprise.api.IsEnterpriseBuild @@ -22,6 +21,8 @@ import io.element.android.features.login.impl.localnetwork.LocalNetworkPermissio import io.element.android.features.login.impl.login.LoginModePresenter import io.element.android.libraries.architecture.AsyncData import io.element.android.libraries.core.meta.BuildMeta +import io.element.android.libraries.matrix.api.accountprovider.AccountProvider +import io.element.android.libraries.matrix.api.accountprovider.matrixOrgAccountProvider import io.element.android.libraries.matrix.api.auth.MatrixAuthenticationService import io.element.android.libraries.matrix.test.AN_ACCOUNT_PROVIDER import io.element.android.libraries.matrix.test.AN_ACCOUNT_PROVIDER_2 @@ -30,6 +31,7 @@ import io.element.android.libraries.matrix.test.AN_EXCEPTION import io.element.android.libraries.matrix.test.A_HOMESERVER_URL import io.element.android.libraries.matrix.test.A_HOMESERVER_URL_2 import io.element.android.libraries.matrix.test.A_LOGIN_HINT +import io.element.android.libraries.matrix.test.accountprovider.anAccountProviderManaged import io.element.android.libraries.matrix.test.auth.FakeMatrixAuthenticationService import io.element.android.libraries.matrix.test.core.aBuildMeta import io.element.android.libraries.oauth.api.OAuthActionFlow @@ -82,7 +84,8 @@ class OnBoardingPresenterTest { val presenter = createPresenter( buildMeta = buildMeta, enterpriseService = FakeEnterpriseService( - defaultHomeserverListResult = { listOf(ACCOUNT_PROVIDER_FROM_CONFIG, EnterpriseService.ANY_ACCOUNT_PROVIDER) }, + accountProviderAllowListResult = { listOf(anAccountProviderManaged(serverName = ACCOUNT_PROVIDER_FROM_CONFIG)) }, + canConnectToAnyAccountProviderResult = { true }, ), ) presenter.test { @@ -184,15 +187,16 @@ class OnBoardingPresenterTest { showBackButton = false, ), enterpriseService = FakeEnterpriseService( - defaultHomeserverListResult = { listOf(ACCOUNT_PROVIDER_FROM_CONFIG, EnterpriseService.ANY_ACCOUNT_PROVIDER) }, - isAllowedToConnectToHomeserverResult = { true }, + accountProviderAllowListResult = { listOf(anAccountProviderManaged(serverName = ACCOUNT_PROVIDER_FROM_CONFIG)) }, + canConnectToAnyAccountProviderResult = { true }, + isAllowedToConnectToAccountProviderResult = { true }, isElementProEnforcedResult = { false }, ), ) presenter.test { skipItems(3) awaitItem().also { - assertThat(it.defaultAccountProvider).isEqualTo(ACCOUNT_PROVIDER_FROM_LINK) + assertThat(it.defaultAccountProvider).isEqualTo(AccountProvider.Generic(ACCOUNT_PROVIDER_FROM_LINK)) assertThat(it.canLoginWithQrCode).isFalse() assertThat(it.canCreateAccount).isFalse() } @@ -208,8 +212,14 @@ class OnBoardingPresenterTest { showBackButton = false, ), enterpriseService = FakeEnterpriseService( - defaultHomeserverListResult = { listOf(ACCOUNT_PROVIDER_FROM_CONFIG, ACCOUNT_PROVIDER_FROM_CONFIG_2) }, - isAllowedToConnectToHomeserverResult = { false }, + accountProviderAllowListResult = { + listOf( + anAccountProviderManaged(serverName = ACCOUNT_PROVIDER_FROM_CONFIG), + anAccountProviderManaged(serverName = ACCOUNT_PROVIDER_FROM_CONFIG_2) + ) + }, + canConnectToAnyAccountProviderResult = { false }, + isAllowedToConnectToAccountProviderResult = { false }, ), ) presenter.test { @@ -231,19 +241,60 @@ class OnBoardingPresenterTest { showBackButton = false, ), enterpriseService = FakeEnterpriseService( - defaultHomeserverListResult = { listOf(ACCOUNT_PROVIDER_FROM_CONFIG) }, + accountProviderAllowListResult = { listOf(anAccountProviderManaged(serverName = ACCOUNT_PROVIDER_FROM_CONFIG)) }, + canConnectToAnyAccountProviderResult = { false }, ) ) presenter.test { skipItems(1) awaitItem().also { - assertThat(it.defaultAccountProvider).isEqualTo(ACCOUNT_PROVIDER_FROM_CONFIG) + assertThat(it.defaultAccountProvider).isEqualTo(anAccountProviderManaged(serverName = ACCOUNT_PROVIDER_FROM_CONFIG)) assertThat(it.canLoginWithQrCode).isTrue() assertThat(it.canCreateAccount).isFalse() } } } + @Test + fun `present - a single configured account provider is not forced when the user may use another one`() = runTest { + // A singleton allow list only forces the account provider when the user is not free to use another one. + val presenter = createPresenter( + enterpriseService = FakeEnterpriseService( + accountProviderAllowListResult = { listOf(anAccountProviderManaged(serverName = ACCOUNT_PROVIDER_FROM_CONFIG)) }, + canConnectToAnyAccountProviderResult = { true }, + ), + ) + presenter.test { + awaitItem().also { + assertThat(it.defaultAccountProvider).isNull() + assertThat(it.mustChooseAccountProvider).isFalse() + } + skipItems(1) + } + } + + @Test + fun `present - the user must choose when several account providers are configured and enforced`() = runTest { + val presenter = createPresenter( + enterpriseService = FakeEnterpriseService( + accountProviderAllowListResult = { + listOf( + anAccountProviderManaged(serverName = ACCOUNT_PROVIDER_FROM_CONFIG), + anAccountProviderManaged(serverName = ACCOUNT_PROVIDER_FROM_CONFIG_2) + ) + }, + canConnectToAnyAccountProviderResult = { false }, + ), + ) + presenter.test { + awaitItem().also { + assertThat(it.defaultAccountProvider).isNull() + assertThat(it.mustChooseAccountProvider).isTrue() + } + skipItems(1) + } + } + @Test fun `present - default account provider - login and clear error`() = runTest { val authenticationService = FakeMatrixAuthenticationService( @@ -259,7 +310,7 @@ class OnBoardingPresenterTest { showBackButton = false, ), enterpriseService = FakeEnterpriseService( - isAllowedToConnectToHomeserverResult = { true }, + isAllowedToConnectToAccountProviderResult = { true }, isElementProEnforcedResult = { false }, ), loginModePresenter = createLoginModePresenter( @@ -270,12 +321,12 @@ class OnBoardingPresenterTest { presenter.test { skipItems(3) awaitItem().also { - assertThat(it.defaultAccountProvider).isEqualTo(A_HOMESERVER_URL) - assertThat(accountProviderDataSource.flow.first().url).isEqualTo(AuthenticationConfig.MATRIX_ORG_URL) - it.eventSink(OnBoardingEvent.OnSignIn(A_HOMESERVER_URL_2)) + assertThat(it.defaultAccountProvider).isEqualTo(AccountProvider.Generic(A_HOMESERVER_URL)) + assertThat(accountProviderDataSource.flow.first()).isEqualTo(matrixOrgAccountProvider) + it.eventSink(OnBoardingEvent.OnSignIn(AccountProvider.Generic(A_HOMESERVER_URL_2))) skipItems(1) // Loading // Account data source has been updated - assertThat(accountProviderDataSource.flow.first().url).isEqualTo(A_HOMESERVER_URL_2) + assertThat(accountProviderDataSource.flow.first()).isEqualTo(AccountProvider.Generic(A_HOMESERVER_URL_2)) // Check an error was returned val submittedState = awaitItem() assertThat(submittedState.loginModeState.loginMode).isInstanceOf(AsyncData.Failure::class.java) diff --git a/features/login/impl/src/test/kotlin/io/element/android/features/login/impl/screens/onboarding/OnboardingViewTest.kt b/features/login/impl/src/test/kotlin/io/element/android/features/login/impl/screens/onboarding/OnboardingViewTest.kt index 88c9acf55f..c7cc2b9f03 100644 --- a/features/login/impl/src/test/kotlin/io/element/android/features/login/impl/screens/onboarding/OnboardingViewTest.kt +++ b/features/login/impl/src/test/kotlin/io/element/android/features/login/impl/screens/onboarding/OnboardingViewTest.kt @@ -23,6 +23,7 @@ import io.element.android.features.login.impl.R import io.element.android.features.login.impl.login.LoginMode import io.element.android.features.login.impl.login.aLoginModeState import io.element.android.libraries.architecture.AsyncData +import io.element.android.libraries.matrix.api.accountprovider.AccountProvider import io.element.android.libraries.matrix.api.auth.OAuthDetails import io.element.android.libraries.matrix.test.AN_EXCEPTION import io.element.android.libraries.ui.strings.CommonStrings @@ -134,13 +135,13 @@ class OnboardingViewTest : RobolectricTestParameter() { val eventSink = EventsRecorder() setOnboardingView( state = anOnBoardingState( - defaultAccountProvider = "element.io", + defaultAccountProvider = AccountProvider.Generic("element.io"), eventSink = eventSink, ), ) val buttonText = activity!!.getString(R.string.screen_onboarding_sign_in_to, "element.io") onNodeWithText(buttonText).performClick() - eventSink.assertSingle(OnBoardingEvent.OnSignIn("element.io")) + eventSink.assertSingle(OnBoardingEvent.OnSignIn(AccountProvider.Generic("element.io"))) } @Test @@ -148,7 +149,7 @@ class OnboardingViewTest : RobolectricTestParameter() { val eventSink = EventsRecorder() setOnboardingView( state = anOnBoardingState( - defaultAccountProvider = "element.io", + defaultAccountProvider = AccountProvider.Generic("element.io"), loginModeState = aLoginModeState(loginMode = AsyncData.Failure(AN_EXCEPTION)), eventSink = eventSink, ), diff --git a/features/login/test/build.gradle.kts b/features/login/test/build.gradle.kts index 4cbf0910db..41c231a594 100644 --- a/features/login/test/build.gradle.kts +++ b/features/login/test/build.gradle.kts @@ -16,6 +16,7 @@ android { dependencies { implementation(projects.libraries.architecture) + implementation(projects.libraries.matrix.api) implementation(projects.features.login.api) implementation(projects.tests.testutils) } diff --git a/features/login/test/src/main/kotlin/io/element/android/features/login/test/accesscontrol/FakeAccountProviderAccessControl.kt b/features/login/test/src/main/kotlin/io/element/android/features/login/test/accesscontrol/FakeAccountProviderAccessControl.kt index 9ebd3be7fc..2864669e7f 100644 --- a/features/login/test/src/main/kotlin/io/element/android/features/login/test/accesscontrol/FakeAccountProviderAccessControl.kt +++ b/features/login/test/src/main/kotlin/io/element/android/features/login/test/accesscontrol/FakeAccountProviderAccessControl.kt @@ -8,12 +8,13 @@ package io.element.android.features.login.test.accesscontrol import io.element.android.features.login.api.accesscontrol.AccountProviderAccessControl +import io.element.android.libraries.matrix.api.accountprovider.AccountProvider import io.element.android.tests.testutils.lambda.lambdaError class FakeAccountProviderAccessControl( - private val isAllowedToConnectToAccountProviderResult: (String) -> Boolean = { lambdaError() }, + private val isAllowedToConnectToAccountProviderResult: (AccountProvider) -> Boolean = { lambdaError() }, ) : AccountProviderAccessControl { - override suspend fun isAllowedToConnectToAccountProvider(accountProviderUrl: String): Boolean { - return isAllowedToConnectToAccountProviderResult(accountProviderUrl) + override suspend fun isAllowedToConnectToAccountProvider(accountProvider: AccountProvider): Boolean { + return isAllowedToConnectToAccountProviderResult(accountProvider) } } diff --git a/libraries/matrix/api/src/main/kotlin/io/element/android/libraries/matrix/api/accountprovider/AccountProvider.kt b/libraries/matrix/api/src/main/kotlin/io/element/android/libraries/matrix/api/accountprovider/AccountProvider.kt new file mode 100644 index 0000000000..828676285a --- /dev/null +++ b/libraries/matrix/api/src/main/kotlin/io/element/android/libraries/matrix/api/accountprovider/AccountProvider.kt @@ -0,0 +1,67 @@ +/* + * Copyright (c) 2026 Element Creations Ltd. + * + * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial. + * Please see LICENSE files in the repository root for full details. + */ + +package io.element.android.libraries.matrix.api.accountprovider + +sealed interface AccountProvider { + /** + * An account provider that was input by the user. + */ + data class Generic( + val serverName: String, + ) : AccountProvider + + /** + * An account provider that is provided by the app. + */ + data class Managed( + val serverName: String, + val baseUrl: String, + val canUseServerName: Boolean, + ) : AccountProvider + + fun serverNameOrBaseUrl(): String { + return when (this) { + is Generic -> serverName + is Managed -> if (canUseServerName) serverName else baseUrl + }.sanitized() + } + + fun friendlyServerName(): String { + return when (this) { + is Generic -> serverName + is Managed -> serverName + }.sanitized() + } + + /** + * The user may reach an allowed account provider by either of its identifiers: the server name it is known by + * (what the user types, e.g. `element.io`) or the base url its client API lives at (e.g. `https://element.ems.host`). + */ + fun matches(other: AccountProvider): Boolean { + return serverNameOrBaseUrl() == other.serverNameOrBaseUrl() + } + + /** + * Sanitizes the string with the following rules: + * - Trim any whitespace. + * - Lowercase the string. + * - Removes a https scheme (treating it as implicit). + * - Remove any trailing slashes. + */ + private fun String.sanitized(): String { + return trim() + .lowercase() + // Intentionally continue to show http:// as an indicator (and for history). + .removePrefix("https://") + .removeSuffix("/") + } +} + +val matrixOrgAccountProvider = AccountProvider.Generic( + serverName = "matrix.org", +) diff --git a/libraries/matrix/api/src/test/kotlin/io/element/android/libraries/matrix/api/accountprovider/AccountProviderTest.kt b/libraries/matrix/api/src/test/kotlin/io/element/android/libraries/matrix/api/accountprovider/AccountProviderTest.kt new file mode 100644 index 0000000000..0268eaed2b --- /dev/null +++ b/libraries/matrix/api/src/test/kotlin/io/element/android/libraries/matrix/api/accountprovider/AccountProviderTest.kt @@ -0,0 +1,89 @@ +/* + * Copyright (c) 2026 Element Creations Ltd. + * + * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial. + * Please see LICENSE files in the repository root for full details. + */ + +package io.element.android.libraries.matrix.api.accountprovider + +import com.google.common.truth.Truth.assertThat +import org.junit.Test + +class AccountProviderTest { + @Test + fun `serverNameOrBaseUrl of a generic account provider is the server name the user input`() { + assertThat(AccountProvider.Generic("matrix.org").serverNameOrBaseUrl()).isEqualTo("matrix.org") + } + + @Test + fun `serverNameOrBaseUrl of a managed account provider is its server name when it can be used`() { + val accountProvider = AccountProvider.Managed( + serverName = "element.io", + baseUrl = "https://element.ems.host", + canUseServerName = true, + ) + assertThat(accountProvider.serverNameOrBaseUrl()).isEqualTo("element.io") + } + + @Test + fun `serverNameOrBaseUrl of a managed account provider is its base url when the server name cannot be used`() { + val accountProvider = AccountProvider.Managed( + serverName = "element.io", + baseUrl = "https://element.ems.host", + canUseServerName = false, + ) + assertThat(accountProvider.serverNameOrBaseUrl()).isEqualTo("element.ems.host") + } + + @Test + fun `matrixOrgAccountProvider is known by its server name`() { + assertThat(matrixOrgAccountProvider.serverNameOrBaseUrl()).isEqualTo("matrix.org") + } + + @Test + fun `serverNameOrBaseUrl trims, lowercases and drops the implicit https scheme and a trailing slash`() { + assertThat(AccountProvider.Generic(" MATRIX.org ").serverNameOrBaseUrl()).isEqualTo("matrix.org") + assertThat(AccountProvider.Generic("https://matrix.org").serverNameOrBaseUrl()).isEqualTo("matrix.org") + assertThat(AccountProvider.Generic("https://matrix.org/").serverNameOrBaseUrl()).isEqualTo("matrix.org") + } + + @Test + fun `serverNameOrBaseUrl keeps an explicit http scheme as an indicator`() { + assertThat(AccountProvider.Generic("http://localhost:8080").serverNameOrBaseUrl()).isEqualTo("http://localhost:8080") + } + + @Test + fun `matches ignores the scheme, the case and a trailing slash`() { + val typed = AccountProvider.Generic("Element.io/") + assertThat(typed.matches(AccountProvider.Generic("https://element.io"))).isTrue() + assertThat( + typed.matches( + AccountProvider.Managed(serverName = "element.io", baseUrl = "https://element.ems.host", canUseServerName = true) + ) + ).isTrue() + } + + @Test + fun `matches a managed provider that cannot use its server name only through its base url`() { + val managed = AccountProvider.Managed( + serverName = "element.io", + baseUrl = "https://element.ems.host", + canUseServerName = false, + ) + assertThat(AccountProvider.Generic("element.ems.host").matches(managed)).isTrue() + assertThat(AccountProvider.Generic("element.io").matches(managed)).isFalse() + } + + @Test + fun `matches is false for a different account provider`() { + val typed = AccountProvider.Generic("element.io") + assertThat(typed.matches(AccountProvider.Generic("matrix.org"))).isFalse() + // A managed provider that can use its server name is not reached through its base url. + assertThat( + typed.matches( + AccountProvider.Managed(serverName = "other.io", baseUrl = "https://element.io", canUseServerName = true) + ) + ).isFalse() + } +} diff --git a/libraries/matrix/test/src/main/kotlin/io/element/android/libraries/matrix/test/accountprovider/AccountProviderFixture.kt b/libraries/matrix/test/src/main/kotlin/io/element/android/libraries/matrix/test/accountprovider/AccountProviderFixture.kt new file mode 100644 index 0000000000..3c9cb7033d --- /dev/null +++ b/libraries/matrix/test/src/main/kotlin/io/element/android/libraries/matrix/test/accountprovider/AccountProviderFixture.kt @@ -0,0 +1,28 @@ +/* + * Copyright (c) 2026 Element Creations Ltd. + * + * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial. + * Please see LICENSE files in the repository root for full details. + */ + +package io.element.android.libraries.matrix.test.accountprovider + +import io.element.android.libraries.matrix.api.accountprovider.AccountProvider +import io.element.android.libraries.matrix.test.AN_ACCOUNT_PROVIDER +import io.element.android.libraries.matrix.test.AN_ACCOUNT_PROVIDER_URL + +fun anAccountProviderGeneric( + serverName: String = AN_ACCOUNT_PROVIDER, +) = AccountProvider.Generic( + serverName = serverName, +) + +fun anAccountProviderManaged( + baseUrl: String = AN_ACCOUNT_PROVIDER_URL, + serverName: String = AN_ACCOUNT_PROVIDER, + canUseServerName: Boolean = true, +) = AccountProvider.Managed( + serverName = serverName, + baseUrl = baseUrl, + canUseServerName = canUseServerName, +)