BIT-999: Add UI for Vault Unlock screen (#243)

This commit is contained in:
David Perez
2024-06-20 17:08:07 +01:00
committed by Álison Fernandes
parent 2f525513a2
commit 00e249dab2
8 changed files with 892 additions and 22 deletions
@@ -0,0 +1,163 @@
package com.x8bit.bitwarden.ui.auth.feature.vaultunlock
import androidx.compose.ui.test.assertIsDisplayed
import androidx.compose.ui.test.assertIsEnabled
import androidx.compose.ui.test.assertIsNotEnabled
import androidx.compose.ui.test.onNodeWithText
import androidx.compose.ui.test.performClick
import androidx.compose.ui.test.performScrollTo
import androidx.compose.ui.test.performTextInput
import com.x8bit.bitwarden.data.auth.repository.model.AccountSummary
import com.x8bit.bitwarden.ui.platform.base.BaseComposeTest
import com.x8bit.bitwarden.ui.platform.base.util.asText
import io.mockk.every
import io.mockk.mockk
import io.mockk.verify
import kotlinx.collections.immutable.persistentListOf
import kotlinx.coroutines.flow.MutableSharedFlow
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.update
import org.junit.Before
import org.junit.Test
class VaultUnlockScreenTest : BaseComposeTest() {
private val mutableEventFlow = MutableSharedFlow<VaultUnlockEvent>(
extraBufferCapacity = Int.MAX_VALUE,
)
private val mutableStateFlow = MutableStateFlow(DEFAULT_STATE)
private val viewModel = mockk<VaultUnlockViewModel>(relaxed = true) {
every { eventFlow } returns mutableEventFlow
every { stateFlow } returns mutableStateFlow
}
@Before
fun setUp() {
composeTestRule.setContent {
VaultUnlockScreen(
viewModel = viewModel,
)
}
}
@Test
fun `account icon click should show the account switcher`() {
composeTestRule.onNodeWithText("active@bitwarden.com").assertDoesNotExist()
composeTestRule.onNodeWithText("locked@bitwarden.com").assertDoesNotExist()
composeTestRule.onNodeWithText("Add account").assertDoesNotExist()
composeTestRule.onNodeWithText("AU").performClick()
composeTestRule.onNodeWithText("active@bitwarden.com").assertIsDisplayed()
composeTestRule.onNodeWithText("locked@bitwarden.com").assertIsDisplayed()
composeTestRule.onNodeWithText("Add account").assertIsDisplayed()
}
@Suppress("MaxLineLength")
@Test
fun `account click in the account switcher should send AccountSwitchClick and close switcher`() {
// Open the Account Switcher
composeTestRule.onNodeWithText("AU").performClick()
composeTestRule.onNodeWithText("locked@bitwarden.com").performClick()
verify {
viewModel.trySendAction(VaultUnlockAction.SwitchAccountClick(LOCKED_ACCOUNT_SUMMARY))
}
composeTestRule.onNodeWithText("locked@bitwarden.com").assertDoesNotExist()
}
@Suppress("MaxLineLength")
@Test
fun `add account click in the account switcher should send AddAccountClick and close switcher`() {
// Open the Account Switcher
composeTestRule.onNodeWithText("AU").performClick()
composeTestRule.onNodeWithText("Add account").performClick()
verify { viewModel.trySendAction(VaultUnlockAction.AddAccountClick) }
composeTestRule.onNodeWithText("Add account").assertDoesNotExist()
}
@Test
fun `email state change should update logged in as text`() {
val newEmail = "david@bitwarden.com"
val textBeforeUpdate = "Logged in as ${DEFAULT_STATE.email} on $DEFAULT_ENVIRONMENT_URL."
val textAfterUpdate = "Logged in as $newEmail on $DEFAULT_ENVIRONMENT_URL."
composeTestRule.onNodeWithText(textBeforeUpdate).assertExists()
composeTestRule.onNodeWithText(textAfterUpdate).assertDoesNotExist()
mutableStateFlow.update { it.copy(email = newEmail) }
composeTestRule.onNodeWithText(textBeforeUpdate).assertDoesNotExist()
composeTestRule.onNodeWithText(textAfterUpdate).assertExists()
}
@Test
fun `environment url state change should update logged in as text`() {
val newEnvironmentUrl = "eu.bitwarden.com"
val textBeforeUpdate = "Logged in as ${DEFAULT_STATE.email} on $DEFAULT_ENVIRONMENT_URL."
val textAfterUpdate = "Logged in as ${DEFAULT_STATE.email} on $newEnvironmentUrl."
composeTestRule.onNodeWithText(textBeforeUpdate).assertExists()
composeTestRule.onNodeWithText(textAfterUpdate).assertDoesNotExist()
mutableStateFlow.update { it.copy(environmentUrl = newEnvironmentUrl.asText()) }
composeTestRule.onNodeWithText(textBeforeUpdate).assertDoesNotExist()
composeTestRule.onNodeWithText(textAfterUpdate).assertExists()
}
@Test
fun `password input state change should update unlock button enabled`() {
composeTestRule.onNodeWithText("Unlock").performScrollTo().assertIsNotEnabled()
mutableStateFlow.update { it.copy(passwordInput = "a") }
composeTestRule.onNodeWithText("Unlock").performScrollTo().assertIsEnabled()
}
@Test
fun `unlock click should send UnlockClick action`() {
mutableStateFlow.update { it.copy(passwordInput = "abdc1234") }
composeTestRule
.onNodeWithText("Unlock")
.performScrollTo()
.performClick()
verify { viewModel.trySendAction(VaultUnlockAction.UnlockClick) }
}
@Test
fun `master password change should send PasswordInputChanged action`() {
val input = "abcd1234"
composeTestRule
.onNodeWithText("Master password")
.performScrollTo()
.performTextInput(input)
verify {
viewModel.trySendAction(VaultUnlockAction.PasswordInputChanged(input))
}
}
}
private const val DEFAULT_ENVIRONMENT_URL: String = "vault.bitwarden.com"
private val ACTIVE_ACCOUNT_SUMMARY = AccountSummary(
userId = "activeUserId",
name = "Active User",
email = "active@bitwarden.com",
avatarColorHex = "#aa00aa",
status = AccountSummary.Status.ACTIVE,
)
private val LOCKED_ACCOUNT_SUMMARY = AccountSummary(
userId = "lockedUserId",
name = "Locked User",
email = "locked@bitwarden.com",
avatarColorHex = "#00aaaa",
status = AccountSummary.Status.LOCKED,
)
private val DEFAULT_STATE: VaultUnlockState = VaultUnlockState(
accountSummaries = persistentListOf(
ACTIVE_ACCOUNT_SUMMARY,
LOCKED_ACCOUNT_SUMMARY,
),
avatarColorString = "0000FF",
dialog = null,
email = "bit@bitwarden.com",
environmentUrl = DEFAULT_ENVIRONMENT_URL.asText(),
initials = "AU",
passwordInput = "",
)
@@ -0,0 +1,207 @@
package com.x8bit.bitwarden.ui.auth.feature.vaultunlock
import androidx.lifecycle.SavedStateHandle
import app.cash.turbine.test
import com.x8bit.bitwarden.R
import com.x8bit.bitwarden.data.auth.datasource.disk.model.EnvironmentUrlDataJson
import com.x8bit.bitwarden.data.auth.repository.model.AccountSummary
import com.x8bit.bitwarden.data.platform.repository.EnvironmentRepository
import com.x8bit.bitwarden.data.platform.repository.model.Environment
import com.x8bit.bitwarden.data.platform.repository.util.FakeEnvironmentRepository
import com.x8bit.bitwarden.data.vault.repository.VaultRepository
import com.x8bit.bitwarden.data.vault.repository.model.VaultUnlockResult
import com.x8bit.bitwarden.ui.platform.base.BaseViewModelTest
import com.x8bit.bitwarden.ui.platform.base.util.asText
import io.mockk.coEvery
import io.mockk.coVerify
import io.mockk.every
import io.mockk.mockk
import kotlinx.coroutines.test.runTest
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Test
class VaultUnlockViewModelTest : BaseViewModelTest() {
private val environmentRepository = FakeEnvironmentRepository()
private val vaultRepository = mockk<VaultRepository>()
@Test
fun `initial state should be correct when not set`() {
val viewModel = createViewModel()
assertEquals(DEFAULT_STATE, viewModel.stateFlow.value)
}
@Test
fun `initial state should be correct when set`() {
val state = DEFAULT_STATE.copy(
initials = "WB",
avatarColorString = "00FF00",
)
val viewModel = createViewModel(state = state)
assertEquals(state, viewModel.stateFlow.value)
}
@Test
fun `environment url should update when environment repo emits an update`() {
val viewModel = createViewModel()
assertEquals(DEFAULT_STATE, viewModel.stateFlow.value)
environmentRepository.environment = Environment.SelfHosted(
environmentUrlData = EnvironmentUrlDataJson(base = "https://vault.bitwarden.eu"),
)
assertEquals(
DEFAULT_STATE.copy(environmentUrl = "vault.bitwarden.eu".asText()),
viewModel.stateFlow.value,
)
}
@Test
fun `on AddAccountClick should emit NavigateToLoginScreen`() = runTest {
val viewModel = createViewModel()
viewModel.eventFlow.test {
viewModel.trySendAction(VaultUnlockAction.AddAccountClick)
assertEquals(VaultUnlockEvent.NavigateToLoginScreen, awaitItem())
}
}
@Test
fun `on DismissDialog should clear the dialog state`() = runTest {
val initialState = DEFAULT_STATE.copy(dialog = VaultUnlockState.VaultUnlockDialog.Loading)
val viewModel = createViewModel(state = initialState)
viewModel.trySendAction(VaultUnlockAction.DismissDialog)
assertEquals(
initialState.copy(dialog = null),
viewModel.stateFlow.value,
)
}
@Test
fun `on PasswordInputChanged should update the password input state`() = runTest {
val viewModel = createViewModel()
val password = "abcd1234"
viewModel.trySendAction(VaultUnlockAction.PasswordInputChanged(passwordInput = password))
assertEquals(
DEFAULT_STATE.copy(passwordInput = password),
viewModel.stateFlow.value,
)
}
@Test
fun `on SwitchAccountClick should emit ShowToast`() = runTest {
val viewModel = createViewModel()
val accountSummary = mockk<AccountSummary> {
every { status } returns AccountSummary.Status.ACTIVE
}
viewModel.eventFlow.test {
viewModel.trySendAction(VaultUnlockAction.SwitchAccountClick(accountSummary))
assertEquals(VaultUnlockEvent.ShowToast("Not yet implemented.".asText()), awaitItem())
}
}
@Test
fun `on UnlockClick should display error dialog on AuthenticationError`() = runTest {
val password = "abcd1234"
val initialState = DEFAULT_STATE.copy(passwordInput = password)
val viewModel = createViewModel(state = initialState)
coEvery {
vaultRepository.unlockVaultAndSync(password)
} returns VaultUnlockResult.AuthenticationError
viewModel.trySendAction(VaultUnlockAction.UnlockClick)
assertEquals(
initialState.copy(
dialog = VaultUnlockState.VaultUnlockDialog.Error(
R.string.invalid_master_password.asText(),
),
),
viewModel.stateFlow.value,
)
coVerify {
vaultRepository.unlockVaultAndSync(password)
}
}
@Test
fun `on UnlockClick should display error dialog on GenericError`() = runTest {
val password = "abcd1234"
val initialState = DEFAULT_STATE.copy(passwordInput = password)
val viewModel = createViewModel(state = initialState)
coEvery {
vaultRepository.unlockVaultAndSync(password)
} returns VaultUnlockResult.GenericError
viewModel.trySendAction(VaultUnlockAction.UnlockClick)
assertEquals(
initialState.copy(
dialog = VaultUnlockState.VaultUnlockDialog.Error(
R.string.generic_error_message.asText(),
),
),
viewModel.stateFlow.value,
)
coVerify {
vaultRepository.unlockVaultAndSync(password)
}
}
@Test
fun `on UnlockClick should display error dialog on InvalidStateError`() = runTest {
val password = "abcd1234"
val initialState = DEFAULT_STATE.copy(passwordInput = password)
val viewModel = createViewModel(state = initialState)
coEvery {
vaultRepository.unlockVaultAndSync(password)
} returns VaultUnlockResult.InvalidStateError
viewModel.trySendAction(VaultUnlockAction.UnlockClick)
assertEquals(
initialState.copy(
dialog = VaultUnlockState.VaultUnlockDialog.Error(
R.string.generic_error_message.asText(),
),
),
viewModel.stateFlow.value,
)
coVerify {
vaultRepository.unlockVaultAndSync(password)
}
}
@Test
fun `on UnlockClick should display clear dialog on success`() = runTest {
val password = "abcd1234"
val initialState = DEFAULT_STATE.copy(passwordInput = password)
val viewModel = createViewModel(state = initialState)
coEvery {
vaultRepository.unlockVaultAndSync(password)
} returns VaultUnlockResult.Success
viewModel.trySendAction(VaultUnlockAction.UnlockClick)
assertEquals(
initialState.copy(dialog = null),
viewModel.stateFlow.value,
)
coVerify {
vaultRepository.unlockVaultAndSync(password)
}
}
private fun createViewModel(
state: VaultUnlockState? = DEFAULT_STATE,
environmentRepo: EnvironmentRepository = environmentRepository,
vaultRepo: VaultRepository = vaultRepository,
): VaultUnlockViewModel = VaultUnlockViewModel(
savedStateHandle = SavedStateHandle().apply { set("state", state) },
vaultRepo = vaultRepo,
environmentRepo = environmentRepo,
)
}
private val DEFAULT_STATE: VaultUnlockState = VaultUnlockState(
accountSummaries = emptyList(),
avatarColorString = "0000FF",
email = "bit@bitwarden.com",
initials = "BW",
dialog = null,
environmentUrl = Environment.Us.label,
passwordInput = "",
)
@@ -0,0 +1,39 @@
package com.x8bit.bitwarden.ui.platform.util
import com.x8bit.bitwarden.data.auth.datasource.disk.model.EnvironmentUrlDataJson
import com.x8bit.bitwarden.data.platform.repository.model.Environment
import com.x8bit.bitwarden.ui.platform.base.util.asText
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Test
class EnvironmentExtensionsTest {
@Test
fun `labelOrBaseUrlHost should correctly convert US environment to the correct label`() {
val environment = Environment.Us
assertEquals(
environment.label,
environment.labelOrBaseUrlHost,
)
}
@Test
fun `labelOrBaseUrlHost should correctly convert EU environment to the correct label`() {
val environment = Environment.Eu
assertEquals(
environment.label,
environment.labelOrBaseUrlHost,
)
}
@Suppress("MaxLineLength")
@Test
fun `labelOrBaseUrlHost should correctly convert self hosted environment to the correct label`() {
val environment = Environment.SelfHosted(
environmentUrlData = EnvironmentUrlDataJson(base = "https://vault.bitwarden.com"),
)
assertEquals(
"vault.bitwarden.com".asText(),
environment.labelOrBaseUrlHost,
)
}
}