Handle SSO prevalidation and custom tab launch (#743)

This commit is contained in:
Sean Weiser
2024-06-20 17:08:07 +01:00
committed by Álison Fernandes
parent 0422d3fdd8
commit 30ab22f826
20 changed files with 602 additions and 22 deletions
@@ -5,6 +5,7 @@ import com.x8bit.bitwarden.data.auth.datasource.network.model.GetTokenResponseJs
import com.x8bit.bitwarden.data.auth.datasource.network.model.KdfTypeJson
import com.x8bit.bitwarden.data.auth.datasource.network.model.KeyConnectorUserDecryptionOptionsJson
import com.x8bit.bitwarden.data.auth.datasource.network.model.MasterPasswordPolicyOptionsJson
import com.x8bit.bitwarden.data.auth.datasource.network.model.PrevalidateSsoResponseJson
import com.x8bit.bitwarden.data.auth.datasource.network.model.RefreshTokenResponseJson
import com.x8bit.bitwarden.data.auth.datasource.network.model.TrustedDeviceUserDecryptionOptionsJson
import com.x8bit.bitwarden.data.auth.datasource.network.model.UserDecryptionOptionsJson
@@ -82,6 +83,24 @@ class IdentityServiceTest : BaseServiceTest() {
assertEquals(Result.success(INVALID_LOGIN), result)
}
@Test
fun `prevalidateSso when response is success should return PrevalidateSsoResponseJson`() =
runTest {
val organizationId = "organizationId"
server.enqueue(MockResponse().setResponseCode(200).setBody(PREVALIDATE_SSO_JSON))
val result = identityService.prevalidateSso(organizationId)
assertEquals(Result.success(PREVALIDATE_SSO_BODY), result)
}
@Test
fun `prevalidateSso when response is an error should return an error`() =
runTest {
val organizationId = "organizationId"
server.enqueue(MockResponse().setResponseCode(400))
val result = identityService.prevalidateSso(organizationId)
assertTrue(result.isFailure)
}
@Suppress("MaxLineLength")
@Test
fun `refreshTokenSynchronously when response is success should return RefreshTokenResponseJson`() {
@@ -105,6 +124,16 @@ class IdentityServiceTest : BaseServiceTest() {
}
}
private const val PREVALIDATE_SSO_JSON = """
{
"token": "2ff00750-e2d6-47a6-ae54-67b981e78030"
}
"""
private val PREVALIDATE_SSO_BODY = PrevalidateSsoResponseJson(
token = "2ff00750-e2d6-47a6-ae54-67b981e78030",
)
private const val REFRESH_TOKEN_JSON = """
{
"access_token": "accessToken",
@@ -12,6 +12,7 @@ import com.x8bit.bitwarden.data.auth.datasource.disk.util.FakeAuthDiskSource
import com.x8bit.bitwarden.data.auth.datasource.network.model.GetTokenResponseJson
import com.x8bit.bitwarden.data.auth.datasource.network.model.KdfTypeJson
import com.x8bit.bitwarden.data.auth.datasource.network.model.PreLoginResponseJson
import com.x8bit.bitwarden.data.auth.datasource.network.model.PrevalidateSsoResponseJson
import com.x8bit.bitwarden.data.auth.datasource.network.model.RefreshTokenResponseJson
import com.x8bit.bitwarden.data.auth.datasource.network.model.RegisterRequestJson
import com.x8bit.bitwarden.data.auth.datasource.network.model.RegisterResponseJson
@@ -32,6 +33,7 @@ import com.x8bit.bitwarden.data.auth.repository.model.DeleteAccountResult
import com.x8bit.bitwarden.data.auth.repository.model.KnownDeviceResult
import com.x8bit.bitwarden.data.auth.repository.model.LoginResult
import com.x8bit.bitwarden.data.auth.repository.model.PasswordStrengthResult
import com.x8bit.bitwarden.data.auth.repository.model.PrevalidateSsoResult
import com.x8bit.bitwarden.data.auth.repository.model.RegisterResult
import com.x8bit.bitwarden.data.auth.repository.model.SwitchAccountResult
import com.x8bit.bitwarden.data.auth.repository.model.UserOrganizations
@@ -1020,6 +1022,37 @@ class AuthRepositoryTest {
}
}
@Test
fun `prevalidateSso Failure should return Failure `() = runTest {
val organizationId = "organizationid"
val throwable = Throwable()
coEvery {
identityService.prevalidateSso(organizationId)
} returns Result.failure(throwable)
val result = repository.prevalidateSso(organizationId)
assertEquals(PrevalidateSsoResult.Failure, result)
}
@Test
fun `prevalidateSso Success with a blank token should return Failure`() = runTest {
val organizationId = "organizationid"
coEvery {
identityService.prevalidateSso(organizationId)
} returns Result.success(PrevalidateSsoResponseJson(token = ""))
val result = repository.prevalidateSso(organizationId)
assertEquals(PrevalidateSsoResult.Failure, result)
}
@Test
fun `prevalidateSso Success with a valid token should return Success`() = runTest {
val organizationId = "organizationid"
coEvery {
identityService.prevalidateSso(organizationId)
} returns Result.success(PrevalidateSsoResponseJson(token = "token"))
val result = repository.prevalidateSso(organizationId)
assertEquals(PrevalidateSsoResult.Success(token = "token"), result)
}
@Suppress("MaxLineLength")
@Test
fun `logout for the active account should call logout on the UserLogoutManager and clear the user's in memory vault data`() {
@@ -9,6 +9,37 @@ import org.junit.jupiter.api.Assertions.assertNull
class SsoUtilsTest {
@Test
fun `generateUriForSso should generate the correct URI`() {
val identityBaseUrl = "https://identity.bitwarden.com"
val organizationIdentifier = "Test Organization"
val token = "Test Token"
val state = "test_state"
val codeVerifier = "test_code_verifier"
val uri = generateUriForSso(
identityBaseUrl = identityBaseUrl,
organizationIdentifier = organizationIdentifier,
token = token,
state = state,
codeVerifier = codeVerifier,
)
assertEquals(
"https://identity.bitwarden.com/connect/authorize" +
"?client_id=mobile" +
"&redirect_uri=bitwarden%3A%2F%2Fsso-callback" +
"&response_type=code" +
"&scope=api%20offline_access" +
"&state=test_state" +
"&code_challenge=Qq1fGD0HhxwbmeMrqaebgn1qhvKeguQPXqLdpmixaM4=" +
"&code_challenge_method=S256" +
"&response_mode=query" +
"&domain_hint=Test+Organization" +
"&ssoToken=Test+Token",
uri,
)
}
@Test
fun `getSsoCallbackResult should return null when data is null`() {
val intent = mockk<Intent> {
@@ -7,6 +7,39 @@ import org.junit.jupiter.api.Assertions.assertNull
import org.junit.jupiter.api.Test
class EnvironmentUrlsDataJsonExtensionsTest {
@Test
fun `baseIdentityUrl should return identity if value is present`() {
assertEquals(
DEFAULT_CUSTOM_ENVIRONMENT_URL_DATA.baseIdentityUrl,
"identity",
)
}
@Test
fun `baseIdentityUrl should return base value if identity is null`() {
assertEquals(
DEFAULT_CUSTOM_ENVIRONMENT_URL_DATA
.copy(identity = null)
.baseIdentityUrl,
"base/identity",
)
}
@Test
fun `baseIdentityUrl should return default url if base is empty and identity is null`() {
val expectedUrl = "https://identity.bitwarden.com"
assertEquals(
expectedUrl,
DEFAULT_CUSTOM_ENVIRONMENT_URL_DATA
.copy(
base = "",
identity = null,
)
.baseIdentityUrl,
)
}
@Test
fun `baseWebVaultUrlOrNull should return webVault when populated`() {
val result = DEFAULT_CUSTOM_ENVIRONMENT_URL_DATA.baseWebVaultUrlOrNull
@@ -0,0 +1,43 @@
package com.x8bit.bitwarden.data.tools.generator.repository.util
import com.bitwarden.generators.PasswordGeneratorRequest
import com.x8bit.bitwarden.data.tools.generator.repository.GeneratorRepository
import com.x8bit.bitwarden.data.tools.generator.repository.model.GeneratedPasswordResult
import com.x8bit.bitwarden.data.tools.generator.repository.utils.generateRandomString
import io.mockk.coEvery
import io.mockk.coVerify
import io.mockk.mockk
import kotlinx.coroutines.test.runTest
import org.junit.jupiter.api.Test
class GeneratorRepositoryExtensionsTest {
private val generatorRepository: GeneratorRepository = mockk {
coEvery {
generatePassword(any(), any())
} returns GeneratedPasswordResult.Success("abc")
}
@Test
fun `generateRandomString should call generatePassword with the correct parameters`() =
runTest {
generatorRepository.generateRandomString(64)
coVerify(exactly = 1) {
generatorRepository.generatePassword(
passwordGeneratorRequest = PasswordGeneratorRequest(
lowercase = true,
uppercase = true,
numbers = true,
special = false,
length = 64.toUByte(),
avoidAmbiguous = false,
minLowercase = null,
minUppercase = null,
minNumber = null,
minSpecial = null,
),
shouldSave = false,
)
}
}
}
@@ -1,5 +1,6 @@
package com.x8bit.bitwarden.ui.auth.feature.enterprisesignon
import android.net.Uri
import androidx.compose.ui.test.assert
import androidx.compose.ui.test.assertIsDisplayed
import androidx.compose.ui.test.assertTextEquals
@@ -14,8 +15,11 @@ import androidx.compose.ui.test.performTextInput
import com.x8bit.bitwarden.data.platform.repository.util.bufferedMutableSharedFlow
import com.x8bit.bitwarden.ui.platform.base.BaseComposeTest
import com.x8bit.bitwarden.ui.platform.base.util.asText
import com.x8bit.bitwarden.ui.platform.manager.intent.IntentManager
import io.mockk.every
import io.mockk.just
import io.mockk.mockk
import io.mockk.runs
import io.mockk.verify
import junit.framework.TestCase.assertTrue
import kotlinx.coroutines.flow.MutableStateFlow
@@ -32,12 +36,17 @@ class EnterpriseSignOnScreenTest : BaseComposeTest() {
every { stateFlow } returns mutableStateFlow
}
private val intentManager: IntentManager = mockk {
every { startCustomTabsActivity(any()) } just runs
}
@Before
fun setup() {
composeTestRule.setContent {
EnterpriseSignOnScreen(
onNavigateBack = { onNavigateBackCalled = true },
viewModel = viewModel,
intentManager = intentManager,
)
}
}
@@ -84,6 +93,15 @@ class EnterpriseSignOnScreenTest : BaseComposeTest() {
assertTrue(onNavigateBackCalled)
}
@Test
fun `NavigateToSsoLogin should call startCustomTabsActivity`() {
val ssoUri = Uri.parse("https://identity.bitwarden.com/sso-test")
mutableEventFlow.tryEmit(EnterpriseSignOnEvent.NavigateToSsoLogin(ssoUri))
verify(exactly = 1) {
intentManager.startCustomTabsActivity(ssoUri)
}
}
@Test
fun `error dialog should be shown or hidden according to the state`() {
composeTestRule.onNode(isDialog()).assertDoesNotExist()
@@ -1,19 +1,57 @@
package com.x8bit.bitwarden.ui.auth.feature.enterprisesignon
import android.net.Uri
import androidx.lifecycle.SavedStateHandle
import app.cash.turbine.test
import com.x8bit.bitwarden.R
import com.x8bit.bitwarden.data.auth.repository.AuthRepository
import com.x8bit.bitwarden.data.auth.repository.model.PrevalidateSsoResult
import com.x8bit.bitwarden.data.auth.repository.util.SsoCallbackResult
import com.x8bit.bitwarden.data.auth.repository.util.generateUriForSso
import com.x8bit.bitwarden.data.platform.manager.util.FakeNetworkConnectionManager
import com.x8bit.bitwarden.data.platform.repository.EnvironmentRepository
import com.x8bit.bitwarden.data.platform.repository.util.FakeEnvironmentRepository
import com.x8bit.bitwarden.data.platform.repository.util.bufferedMutableSharedFlow
import com.x8bit.bitwarden.data.tools.generator.repository.GeneratorRepository
import com.x8bit.bitwarden.data.tools.generator.repository.util.FakeGeneratorRepository
import com.x8bit.bitwarden.ui.platform.base.BaseViewModelTest
import com.x8bit.bitwarden.ui.platform.base.util.asText
import io.mockk.coEvery
import io.mockk.every
import io.mockk.mockk
import io.mockk.mockkStatic
import io.mockk.unmockkStatic
import kotlinx.coroutines.test.runTest
import org.junit.jupiter.api.AfterEach
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test
class EnterpriseSignOnViewModelTest : BaseViewModelTest() {
private val mutableSsoCallbackResultFlow = bufferedMutableSharedFlow<SsoCallbackResult>()
private val authRepository: AuthRepository = mockk {
every { ssoCallbackResultFlow } returns mutableSsoCallbackResultFlow
}
private val environmentRepository: EnvironmentRepository = FakeEnvironmentRepository()
private val generatorRepository: GeneratorRepository = FakeGeneratorRepository()
private val savedStateHandle = SavedStateHandle()
@BeforeEach
fun setUp() {
mockkStatic(::generateUriForSso)
mockkStatic(Uri::parse)
}
@AfterEach
fun tearDown() {
unmockkStatic(::generateUriForSso)
unmockkStatic(Uri::parse)
}
@Test
fun `initial state should be correct when not pulling from handle`() = runTest {
val viewModel = createViewModel()
@@ -47,18 +85,70 @@ class EnterpriseSignOnViewModelTest : BaseViewModelTest() {
@Suppress("MaxLineLength")
@Test
fun `LogInClick with valid organization should emit ShowToast, show a loading dialog, and then hide the dialog`() =
fun `LogInClick with valid organization and failed prevalidation should emit ShowToast, show a loading dialog, and then show an error`() =
runTest {
val state = DEFAULT_STATE.copy(orgIdentifierInput = "Test")
val organizationId = "Test"
val state = DEFAULT_STATE.copy(orgIdentifierInput = organizationId)
coEvery {
authRepository.prevalidateSso(organizationId)
} returns PrevalidateSsoResult.Failure
val viewModel = createViewModel(state)
viewModel.actionChannel.trySend(EnterpriseSignOnAction.LogInClick)
viewModel.stateFlow.test {
assertEquals(state, awaitItem())
viewModel.actionChannel.trySend(EnterpriseSignOnAction.LogInClick)
assertEquals(
state.copy(
dialogState = EnterpriseSignOnState.DialogState.Loading(
R.string.logging_in.asText(),
),
),
awaitItem(),
)
assertEquals(
state.copy(
dialogState = EnterpriseSignOnState.DialogState.Error(
message = R.string.login_sso_error.asText(),
),
),
awaitItem(),
)
}
viewModel.eventFlow.test {
assertEquals(
EnterpriseSignOnEvent.ShowToast("Not yet implemented."),
awaitItem(),
)
}
}
@Suppress("MaxLineLength")
@Test
fun `LogInClick with valid organization and successful prevalidation should emit ShowToast, show a loading dialog, hide a loading dialog, and then emit NavigateToSsoLogin`() =
runTest {
val organizationId = "Test"
val state = DEFAULT_STATE.copy(orgIdentifierInput = organizationId)
coEvery {
authRepository.prevalidateSso(organizationId)
} returns PrevalidateSsoResult.Success(token = "token")
val ssoUri: Uri = mockk()
every {
generateUriForSso(any(), any(), any(), any(), any())
} returns "https://identity.bitwarden.com/sso-test"
every {
Uri.parse("https://identity.bitwarden.com/sso-test")
} returns ssoUri
val viewModel = createViewModel(state)
viewModel.stateFlow.test {
assertEquals(state, awaitItem())
viewModel.actionChannel.trySend(EnterpriseSignOnAction.LogInClick)
assertEquals(
state.copy(
dialogState = EnterpriseSignOnState.DialogState.Loading(
@@ -73,6 +163,16 @@ class EnterpriseSignOnViewModelTest : BaseViewModelTest() {
awaitItem(),
)
}
viewModel.eventFlow.test {
assertEquals(
EnterpriseSignOnEvent.ShowToast("Not yet implemented."),
awaitItem(),
)
assertEquals(
EnterpriseSignOnEvent.NavigateToSsoLogin(ssoUri),
awaitItem(),
)
}
}
@Suppress("MaxLineLength")
@@ -183,6 +283,9 @@ class EnterpriseSignOnViewModelTest : BaseViewModelTest() {
),
isNetworkConnected: Boolean = true,
): EnterpriseSignOnViewModel = EnterpriseSignOnViewModel(
authRepository = authRepository,
environmentRepository = environmentRepository,
generatorRepository = generatorRepository,
networkConnectionManager = FakeNetworkConnectionManager(isNetworkConnected),
savedStateHandle = savedStateHandle,
)