mirror of
https://github.com/bitwarden/android.git
synced 2026-11-19 17:40:12 -06:00
BIT-1560: Successfully login with device (#892)
This commit is contained in:
committed by
Álison Fernandes
parent
2127dcbb1d
commit
087018bd26
@@ -2,6 +2,7 @@ package com.x8bit.bitwarden.data.auth.repository
|
||||
|
||||
import app.cash.turbine.test
|
||||
import com.bitwarden.core.AuthRequestResponse
|
||||
import com.bitwarden.core.InitUserCryptoMethod
|
||||
import com.bitwarden.core.RegisterKeyResponse
|
||||
import com.bitwarden.core.UpdatePasswordResponse
|
||||
import com.bitwarden.crypto.HashPurpose
|
||||
@@ -1226,6 +1227,344 @@ class AuthRepositoryTest {
|
||||
assertEquals(LoginResult.Error(errorMessage = null), result)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `login with device get token fails should return Error with no message`() = runTest {
|
||||
coEvery {
|
||||
identityService.getToken(
|
||||
email = EMAIL,
|
||||
authModel = IdentityTokenAuthModel.AuthRequest(
|
||||
username = EMAIL,
|
||||
authRequestId = DEVICE_REQUEST_ID,
|
||||
accessCode = DEVICE_ACCESS_CODE,
|
||||
),
|
||||
captchaToken = null,
|
||||
uniqueAppId = UNIQUE_APP_ID,
|
||||
)
|
||||
} returns Throwable("Fail").asFailure()
|
||||
val result = repository.login(
|
||||
email = EMAIL,
|
||||
requestId = DEVICE_REQUEST_ID,
|
||||
accessCode = DEVICE_ACCESS_CODE,
|
||||
asymmetricalKey = DEVICE_ASYMMETRICAL_KEY,
|
||||
requestPrivateKey = DEVICE_REQUEST_PRIVATE_KEY,
|
||||
masterPasswordHash = PASSWORD_HASH,
|
||||
captchaToken = null,
|
||||
)
|
||||
assertEquals(LoginResult.Error(errorMessage = null), result)
|
||||
assertEquals(AuthState.Unauthenticated, repository.authStateFlow.value)
|
||||
coVerify {
|
||||
identityService.getToken(
|
||||
email = EMAIL,
|
||||
authModel = IdentityTokenAuthModel.AuthRequest(
|
||||
username = EMAIL,
|
||||
authRequestId = DEVICE_REQUEST_ID,
|
||||
accessCode = DEVICE_ACCESS_CODE,
|
||||
),
|
||||
captchaToken = null,
|
||||
uniqueAppId = UNIQUE_APP_ID,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `login with device get token returns Invalid should return Error with correct message`() =
|
||||
runTest {
|
||||
coEvery {
|
||||
identityService.getToken(
|
||||
email = EMAIL,
|
||||
authModel = IdentityTokenAuthModel.AuthRequest(
|
||||
username = EMAIL,
|
||||
authRequestId = DEVICE_REQUEST_ID,
|
||||
accessCode = DEVICE_ACCESS_CODE,
|
||||
),
|
||||
captchaToken = null,
|
||||
uniqueAppId = UNIQUE_APP_ID,
|
||||
)
|
||||
} returns GetTokenResponseJson
|
||||
.Invalid(
|
||||
errorModel = GetTokenResponseJson.Invalid.ErrorModel(
|
||||
errorMessage = "mock_error_message",
|
||||
),
|
||||
)
|
||||
.asSuccess()
|
||||
|
||||
val result = repository.login(
|
||||
email = EMAIL,
|
||||
requestId = DEVICE_REQUEST_ID,
|
||||
accessCode = DEVICE_ACCESS_CODE,
|
||||
asymmetricalKey = DEVICE_ASYMMETRICAL_KEY,
|
||||
requestPrivateKey = DEVICE_REQUEST_PRIVATE_KEY,
|
||||
masterPasswordHash = PASSWORD_HASH,
|
||||
captchaToken = null,
|
||||
)
|
||||
assertEquals(LoginResult.Error(errorMessage = "mock_error_message"), result)
|
||||
assertEquals(AuthState.Unauthenticated, repository.authStateFlow.value)
|
||||
coVerify {
|
||||
identityService.getToken(
|
||||
email = EMAIL,
|
||||
authModel = IdentityTokenAuthModel.AuthRequest(
|
||||
username = EMAIL,
|
||||
authRequestId = DEVICE_REQUEST_ID,
|
||||
accessCode = DEVICE_ACCESS_CODE,
|
||||
),
|
||||
captchaToken = null,
|
||||
uniqueAppId = UNIQUE_APP_ID,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
@Suppress("MaxLineLength")
|
||||
fun `login with device get token succeeds should return Success, update AuthState, update stored keys, and sync`() =
|
||||
runTest {
|
||||
val successResponse = GET_TOKEN_RESPONSE_SUCCESS
|
||||
coEvery {
|
||||
identityService.getToken(
|
||||
email = EMAIL,
|
||||
authModel = IdentityTokenAuthModel.AuthRequest(
|
||||
username = EMAIL,
|
||||
authRequestId = DEVICE_REQUEST_ID,
|
||||
accessCode = DEVICE_ACCESS_CODE,
|
||||
),
|
||||
captchaToken = null,
|
||||
uniqueAppId = UNIQUE_APP_ID,
|
||||
)
|
||||
} returns successResponse.asSuccess()
|
||||
coEvery { vaultRepository.syncIfNecessary() } just runs
|
||||
every {
|
||||
GET_TOKEN_RESPONSE_SUCCESS.toUserState(
|
||||
previousUserState = null,
|
||||
environmentUrlData = EnvironmentUrlDataJson.DEFAULT_US,
|
||||
)
|
||||
} returns SINGLE_USER_STATE_1
|
||||
coEvery {
|
||||
vaultRepository.unlockVault(
|
||||
userId = USER_ID_1,
|
||||
email = EMAIL,
|
||||
kdf = ACCOUNT_1.profile.toSdkParams(),
|
||||
privateKey = successResponse.privateKey,
|
||||
organizationKeys = null,
|
||||
initUserCryptoMethod = InitUserCryptoMethod.AuthRequest(
|
||||
requestPrivateKey = DEVICE_REQUEST_PRIVATE_KEY,
|
||||
protectedUserKey = DEVICE_ASYMMETRICAL_KEY,
|
||||
),
|
||||
)
|
||||
} returns VaultUnlockResult.Success
|
||||
val result = repository.login(
|
||||
email = EMAIL,
|
||||
requestId = DEVICE_REQUEST_ID,
|
||||
accessCode = DEVICE_ACCESS_CODE,
|
||||
asymmetricalKey = DEVICE_ASYMMETRICAL_KEY,
|
||||
requestPrivateKey = DEVICE_REQUEST_PRIVATE_KEY,
|
||||
masterPasswordHash = PASSWORD_HASH,
|
||||
captchaToken = null,
|
||||
)
|
||||
assertEquals(LoginResult.Success, result)
|
||||
assertEquals(AuthState.Authenticated(ACCESS_TOKEN), repository.authStateFlow.value)
|
||||
fakeAuthDiskSource.assertPrivateKey(
|
||||
userId = USER_ID_1,
|
||||
privateKey = "privateKey",
|
||||
)
|
||||
fakeAuthDiskSource.assertUserKey(
|
||||
userId = USER_ID_1,
|
||||
userKey = "key",
|
||||
)
|
||||
coVerify {
|
||||
identityService.getToken(
|
||||
email = EMAIL,
|
||||
authModel = IdentityTokenAuthModel.AuthRequest(
|
||||
username = EMAIL,
|
||||
authRequestId = DEVICE_REQUEST_ID,
|
||||
accessCode = DEVICE_ACCESS_CODE,
|
||||
),
|
||||
captchaToken = null,
|
||||
uniqueAppId = UNIQUE_APP_ID,
|
||||
)
|
||||
vaultRepository.syncIfNecessary()
|
||||
vaultRepository.unlockVault(
|
||||
userId = USER_ID_1,
|
||||
email = EMAIL,
|
||||
kdf = ACCOUNT_1.profile.toSdkParams(),
|
||||
privateKey = successResponse.privateKey,
|
||||
organizationKeys = null,
|
||||
initUserCryptoMethod = InitUserCryptoMethod.AuthRequest(
|
||||
requestPrivateKey = DEVICE_REQUEST_PRIVATE_KEY,
|
||||
protectedUserKey = DEVICE_ASYMMETRICAL_KEY,
|
||||
),
|
||||
)
|
||||
}
|
||||
assertEquals(
|
||||
SINGLE_USER_STATE_1,
|
||||
fakeAuthDiskSource.userState,
|
||||
)
|
||||
verify { settingsRepository.setDefaultsIfNecessary(userId = USER_ID_1) }
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `login with device get token returns captcha request should return CaptchaRequired`() =
|
||||
runTest {
|
||||
coEvery {
|
||||
identityService.getToken(
|
||||
email = EMAIL,
|
||||
authModel = IdentityTokenAuthModel.AuthRequest(
|
||||
username = EMAIL,
|
||||
authRequestId = DEVICE_REQUEST_ID,
|
||||
accessCode = DEVICE_ACCESS_CODE,
|
||||
),
|
||||
captchaToken = null,
|
||||
uniqueAppId = UNIQUE_APP_ID,
|
||||
)
|
||||
} returns GetTokenResponseJson.CaptchaRequired(CAPTCHA_KEY).asSuccess()
|
||||
val result = repository.login(
|
||||
email = EMAIL,
|
||||
requestId = DEVICE_REQUEST_ID,
|
||||
accessCode = DEVICE_ACCESS_CODE,
|
||||
asymmetricalKey = DEVICE_ASYMMETRICAL_KEY,
|
||||
requestPrivateKey = DEVICE_REQUEST_PRIVATE_KEY,
|
||||
masterPasswordHash = PASSWORD_HASH,
|
||||
captchaToken = null,
|
||||
)
|
||||
assertEquals(LoginResult.CaptchaRequired(CAPTCHA_KEY), result)
|
||||
assertEquals(AuthState.Unauthenticated, repository.authStateFlow.value)
|
||||
coVerify {
|
||||
identityService.getToken(
|
||||
email = EMAIL,
|
||||
authModel = IdentityTokenAuthModel.AuthRequest(
|
||||
username = EMAIL,
|
||||
authRequestId = DEVICE_REQUEST_ID,
|
||||
accessCode = DEVICE_ACCESS_CODE,
|
||||
),
|
||||
captchaToken = null,
|
||||
uniqueAppId = UNIQUE_APP_ID,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `login with device get token returns two factor request should return TwoFactorRequired`() =
|
||||
runTest {
|
||||
coEvery {
|
||||
identityService.getToken(
|
||||
email = EMAIL,
|
||||
authModel = IdentityTokenAuthModel.AuthRequest(
|
||||
username = EMAIL,
|
||||
authRequestId = DEVICE_REQUEST_ID,
|
||||
accessCode = DEVICE_ACCESS_CODE,
|
||||
),
|
||||
captchaToken = null,
|
||||
uniqueAppId = UNIQUE_APP_ID,
|
||||
)
|
||||
} returns GetTokenResponseJson
|
||||
.TwoFactorRequired(TWO_FACTOR_AUTH_METHODS_DATA, null, null)
|
||||
.asSuccess()
|
||||
val result = repository.login(
|
||||
email = EMAIL,
|
||||
requestId = DEVICE_REQUEST_ID,
|
||||
accessCode = DEVICE_ACCESS_CODE,
|
||||
asymmetricalKey = DEVICE_ASYMMETRICAL_KEY,
|
||||
requestPrivateKey = DEVICE_REQUEST_PRIVATE_KEY,
|
||||
masterPasswordHash = PASSWORD_HASH,
|
||||
captchaToken = null,
|
||||
)
|
||||
assertEquals(LoginResult.TwoFactorRequired, result)
|
||||
assertEquals(
|
||||
repository.twoFactorResponse,
|
||||
GetTokenResponseJson.TwoFactorRequired(TWO_FACTOR_AUTH_METHODS_DATA, null, null),
|
||||
)
|
||||
assertEquals(AuthState.Unauthenticated, repository.authStateFlow.value)
|
||||
coVerify {
|
||||
identityService.getToken(
|
||||
email = EMAIL,
|
||||
authModel = IdentityTokenAuthModel.AuthRequest(
|
||||
username = EMAIL,
|
||||
authRequestId = DEVICE_REQUEST_ID,
|
||||
accessCode = DEVICE_ACCESS_CODE,
|
||||
),
|
||||
captchaToken = null,
|
||||
uniqueAppId = UNIQUE_APP_ID,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `login with device two factor with remember saves two factor auth token`() = runTest {
|
||||
// Attempt a normal login with a two factor error first, so that the auth
|
||||
// data will be cached.
|
||||
coEvery {
|
||||
identityService.getToken(
|
||||
email = EMAIL,
|
||||
authModel = IdentityTokenAuthModel.AuthRequest(
|
||||
username = EMAIL,
|
||||
authRequestId = DEVICE_REQUEST_ID,
|
||||
accessCode = DEVICE_ACCESS_CODE,
|
||||
),
|
||||
captchaToken = null,
|
||||
uniqueAppId = UNIQUE_APP_ID,
|
||||
)
|
||||
} returns GetTokenResponseJson
|
||||
.TwoFactorRequired(TWO_FACTOR_AUTH_METHODS_DATA, null, null)
|
||||
.asSuccess()
|
||||
val firstResult = repository.login(
|
||||
email = EMAIL,
|
||||
requestId = DEVICE_REQUEST_ID,
|
||||
accessCode = DEVICE_ACCESS_CODE,
|
||||
asymmetricalKey = DEVICE_ASYMMETRICAL_KEY,
|
||||
requestPrivateKey = DEVICE_REQUEST_PRIVATE_KEY,
|
||||
masterPasswordHash = PASSWORD_HASH,
|
||||
captchaToken = null,
|
||||
)
|
||||
assertEquals(LoginResult.TwoFactorRequired, firstResult)
|
||||
coVerify {
|
||||
identityService.getToken(
|
||||
email = EMAIL,
|
||||
authModel = IdentityTokenAuthModel.AuthRequest(
|
||||
username = EMAIL,
|
||||
authRequestId = DEVICE_REQUEST_ID,
|
||||
accessCode = DEVICE_ACCESS_CODE,
|
||||
),
|
||||
captchaToken = null,
|
||||
uniqueAppId = UNIQUE_APP_ID,
|
||||
)
|
||||
}
|
||||
|
||||
// Login with two factor data.
|
||||
val successResponse = GET_TOKEN_RESPONSE_SUCCESS.copy(
|
||||
twoFactorToken = "twoFactorTokenToStore",
|
||||
)
|
||||
coEvery {
|
||||
identityService.getToken(
|
||||
email = EMAIL,
|
||||
authModel = IdentityTokenAuthModel.AuthRequest(
|
||||
username = EMAIL,
|
||||
authRequestId = DEVICE_REQUEST_ID,
|
||||
accessCode = DEVICE_ACCESS_CODE,
|
||||
),
|
||||
captchaToken = null,
|
||||
uniqueAppId = UNIQUE_APP_ID,
|
||||
twoFactorData = TWO_FACTOR_DATA,
|
||||
)
|
||||
} returns successResponse.asSuccess()
|
||||
coEvery { vaultRepository.syncIfNecessary() } just runs
|
||||
every {
|
||||
successResponse.toUserState(
|
||||
previousUserState = null,
|
||||
environmentUrlData = EnvironmentUrlDataJson.DEFAULT_US,
|
||||
)
|
||||
} returns SINGLE_USER_STATE_1
|
||||
val finalResult = repository.login(
|
||||
email = EMAIL,
|
||||
password = null,
|
||||
twoFactorData = TWO_FACTOR_DATA,
|
||||
captchaToken = null,
|
||||
)
|
||||
assertEquals(LoginResult.Success, finalResult)
|
||||
assertNull(repository.twoFactorResponse)
|
||||
fakeAuthDiskSource.assertTwoFactorToken(
|
||||
email = EMAIL,
|
||||
twoFactorToken = "twoFactorTokenToStore",
|
||||
)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `SSO login get token fails should return Error with no message`() = runTest {
|
||||
coEvery {
|
||||
@@ -3441,6 +3780,10 @@ class AuthRepositoryTest {
|
||||
private const val SSO_CODE = "ssoCode"
|
||||
private const val SSO_CODE_VERIFIER = "ssoCodeVerifier"
|
||||
private const val SSO_REDIRECT_URI = "bitwarden://sso-test"
|
||||
private const val DEVICE_ACCESS_CODE = "accessCode"
|
||||
private const val DEVICE_REQUEST_ID = "authRequestId"
|
||||
private const val DEVICE_ASYMMETRICAL_KEY = "asymmetricalKey"
|
||||
private const val DEVICE_REQUEST_PRIVATE_KEY = "requestPrivateKey"
|
||||
|
||||
private const val DEFAULT_KDF_ITERATIONS = 600000
|
||||
private const val ENCRYPTED_USER_KEY = "encryptedUserKey"
|
||||
|
||||
+1
@@ -178,4 +178,5 @@ private val DEFAULT_STATE = LoginWithDeviceState(
|
||||
isResendNotificationLoading = false,
|
||||
),
|
||||
dialogState = null,
|
||||
loginData = null,
|
||||
)
|
||||
|
||||
+223
-7
@@ -7,11 +7,15 @@ import com.x8bit.bitwarden.R
|
||||
import com.x8bit.bitwarden.data.auth.repository.AuthRepository
|
||||
import com.x8bit.bitwarden.data.auth.repository.model.AuthRequest
|
||||
import com.x8bit.bitwarden.data.auth.repository.model.CreateAuthRequestResult
|
||||
import com.x8bit.bitwarden.data.auth.repository.model.LoginResult
|
||||
import com.x8bit.bitwarden.data.auth.repository.util.CaptchaCallbackTokenResult
|
||||
import com.x8bit.bitwarden.data.platform.repository.util.bufferedMutableSharedFlow
|
||||
import com.x8bit.bitwarden.ui.platform.base.BaseViewModelTest
|
||||
import com.x8bit.bitwarden.ui.platform.base.util.asText
|
||||
import io.mockk.awaits
|
||||
import io.mockk.coEvery
|
||||
import io.mockk.coVerify
|
||||
import io.mockk.just
|
||||
import io.mockk.mockk
|
||||
import io.mockk.verify
|
||||
import kotlinx.coroutines.test.runTest
|
||||
@@ -23,10 +27,13 @@ class LoginWithDeviceViewModelTest : BaseViewModelTest() {
|
||||
|
||||
private val mutableCreateAuthRequestWithUpdatesFlow =
|
||||
bufferedMutableSharedFlow<CreateAuthRequestResult>()
|
||||
private val mutableCaptchaTokenResultFlow =
|
||||
bufferedMutableSharedFlow<CaptchaCallbackTokenResult>()
|
||||
private val authRepository = mockk<AuthRepository> {
|
||||
coEvery {
|
||||
createAuthRequestWithUpdates(EMAIL)
|
||||
} returns mutableCreateAuthRequestWithUpdatesFlow
|
||||
coEvery { captchaTokenResultFlow } returns mutableCaptchaTokenResultFlow
|
||||
}
|
||||
|
||||
@Test
|
||||
@@ -128,22 +135,221 @@ class LoginWithDeviceViewModelTest : BaseViewModelTest() {
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `on createAuthRequestWithUpdates Success received should show content`() {
|
||||
fun `on createAuthRequestWithUpdates Success and login success should update the state`() =
|
||||
runTest {
|
||||
coEvery {
|
||||
authRepository.login(
|
||||
email = EMAIL,
|
||||
requestId = DEFAULT_LOGIN_DATA.requestId,
|
||||
accessCode = DEFAULT_LOGIN_DATA.accessCode,
|
||||
asymmetricalKey = DEFAULT_LOGIN_DATA.asymmetricalKey,
|
||||
requestPrivateKey = DEFAULT_LOGIN_DATA.privateKey,
|
||||
masterPasswordHash = DEFAULT_LOGIN_DATA.masterPasswordHash,
|
||||
captchaToken = null,
|
||||
)
|
||||
} returns LoginResult.Success
|
||||
val viewModel = createViewModel()
|
||||
viewModel.stateFlow.test {
|
||||
assertEquals(DEFAULT_STATE, awaitItem())
|
||||
mutableCreateAuthRequestWithUpdatesFlow.tryEmit(
|
||||
CreateAuthRequestResult.Success(AUTH_REQUEST, AUTH_REQUEST_RESPONSE),
|
||||
)
|
||||
assertEquals(
|
||||
DEFAULT_STATE.copy(
|
||||
viewState = DEFAULT_CONTENT_VIEW_STATE.copy(
|
||||
fingerprintPhrase = "",
|
||||
),
|
||||
loginData = DEFAULT_LOGIN_DATA,
|
||||
dialogState = LoginWithDeviceState.DialogState.Loading(
|
||||
message = R.string.logging_in.asText(),
|
||||
),
|
||||
),
|
||||
awaitItem(),
|
||||
)
|
||||
assertEquals(
|
||||
DEFAULT_STATE.copy(
|
||||
viewState = DEFAULT_CONTENT_VIEW_STATE.copy(
|
||||
fingerprintPhrase = "",
|
||||
),
|
||||
dialogState = null,
|
||||
loginData = DEFAULT_LOGIN_DATA,
|
||||
),
|
||||
awaitItem(),
|
||||
)
|
||||
}
|
||||
|
||||
coVerify(exactly = 1) {
|
||||
authRepository.login(
|
||||
email = EMAIL,
|
||||
requestId = AUTH_REQUEST.id,
|
||||
accessCode = AUTH_REQUEST_RESPONSE.accessCode,
|
||||
asymmetricalKey = requireNotNull(AUTH_REQUEST.key),
|
||||
requestPrivateKey = AUTH_REQUEST_RESPONSE.privateKey,
|
||||
masterPasswordHash = AUTH_REQUEST.masterPasswordHash,
|
||||
captchaToken = null,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
@Suppress("MaxLineLength")
|
||||
@Test
|
||||
fun `on createAuthRequestWithUpdates Success and login two factor required should emit NavigateToTwoFactorLogin`() =
|
||||
runTest {
|
||||
coEvery {
|
||||
authRepository.login(
|
||||
email = EMAIL,
|
||||
requestId = DEFAULT_LOGIN_DATA.requestId,
|
||||
accessCode = DEFAULT_LOGIN_DATA.accessCode,
|
||||
asymmetricalKey = DEFAULT_LOGIN_DATA.asymmetricalKey,
|
||||
requestPrivateKey = DEFAULT_LOGIN_DATA.privateKey,
|
||||
masterPasswordHash = DEFAULT_LOGIN_DATA.masterPasswordHash,
|
||||
captchaToken = null,
|
||||
)
|
||||
} returns LoginResult.TwoFactorRequired
|
||||
val viewModel = createViewModel()
|
||||
viewModel.eventFlow.test {
|
||||
mutableCreateAuthRequestWithUpdatesFlow.tryEmit(
|
||||
CreateAuthRequestResult.Success(AUTH_REQUEST, AUTH_REQUEST_RESPONSE),
|
||||
)
|
||||
assertEquals(
|
||||
LoginWithDeviceEvent.NavigateToTwoFactorLogin(emailAddress = EMAIL),
|
||||
awaitItem(),
|
||||
)
|
||||
}
|
||||
|
||||
coVerify(exactly = 1) {
|
||||
authRepository.login(
|
||||
email = EMAIL,
|
||||
requestId = AUTH_REQUEST.id,
|
||||
accessCode = AUTH_REQUEST_RESPONSE.accessCode,
|
||||
asymmetricalKey = requireNotNull(AUTH_REQUEST.key),
|
||||
requestPrivateKey = AUTH_REQUEST_RESPONSE.privateKey,
|
||||
masterPasswordHash = AUTH_REQUEST.masterPasswordHash,
|
||||
captchaToken = null,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `on createAuthRequestWithUpdates Success and login error should should update the state`() =
|
||||
runTest {
|
||||
coEvery {
|
||||
authRepository.login(
|
||||
email = EMAIL,
|
||||
requestId = DEFAULT_LOGIN_DATA.requestId,
|
||||
accessCode = DEFAULT_LOGIN_DATA.accessCode,
|
||||
asymmetricalKey = DEFAULT_LOGIN_DATA.asymmetricalKey,
|
||||
requestPrivateKey = DEFAULT_LOGIN_DATA.privateKey,
|
||||
masterPasswordHash = DEFAULT_LOGIN_DATA.masterPasswordHash,
|
||||
captchaToken = null,
|
||||
)
|
||||
} returns LoginResult.Error(null)
|
||||
val viewModel = createViewModel()
|
||||
viewModel.eventFlow.test {
|
||||
viewModel.stateFlow.test {
|
||||
assertEquals(DEFAULT_STATE, awaitItem())
|
||||
mutableCreateAuthRequestWithUpdatesFlow.tryEmit(
|
||||
CreateAuthRequestResult.Success(AUTH_REQUEST, AUTH_REQUEST_RESPONSE),
|
||||
)
|
||||
assertEquals(
|
||||
DEFAULT_STATE.copy(
|
||||
viewState = DEFAULT_CONTENT_VIEW_STATE.copy(
|
||||
fingerprintPhrase = "",
|
||||
),
|
||||
loginData = DEFAULT_LOGIN_DATA,
|
||||
dialogState = LoginWithDeviceState.DialogState.Loading(
|
||||
message = R.string.logging_in.asText(),
|
||||
),
|
||||
),
|
||||
awaitItem(),
|
||||
)
|
||||
assertEquals(
|
||||
DEFAULT_STATE.copy(
|
||||
viewState = DEFAULT_CONTENT_VIEW_STATE.copy(
|
||||
fingerprintPhrase = "",
|
||||
),
|
||||
dialogState = LoginWithDeviceState.DialogState.Error(
|
||||
title = R.string.an_error_has_occurred.asText(),
|
||||
message = R.string.generic_error_message.asText(),
|
||||
),
|
||||
loginData = DEFAULT_LOGIN_DATA,
|
||||
),
|
||||
awaitItem(),
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
coVerify(exactly = 1) {
|
||||
authRepository.login(
|
||||
email = EMAIL,
|
||||
requestId = AUTH_REQUEST.id,
|
||||
accessCode = AUTH_REQUEST_RESPONSE.accessCode,
|
||||
asymmetricalKey = requireNotNull(AUTH_REQUEST.key),
|
||||
requestPrivateKey = AUTH_REQUEST_RESPONSE.privateKey,
|
||||
masterPasswordHash = AUTH_REQUEST.masterPasswordHash,
|
||||
captchaToken = null,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `on captchaTokenResultFlow missing token should should display error dialog`() = runTest {
|
||||
val viewModel = createViewModel()
|
||||
assertEquals(DEFAULT_STATE, viewModel.stateFlow.value)
|
||||
mutableCreateAuthRequestWithUpdatesFlow.tryEmit(
|
||||
CreateAuthRequestResult.Success(AUTH_REQUEST, AUTH_REQUEST_RESPONSE),
|
||||
)
|
||||
mutableCaptchaTokenResultFlow.tryEmit(CaptchaCallbackTokenResult.MissingToken)
|
||||
assertEquals(
|
||||
DEFAULT_STATE.copy(
|
||||
viewState = DEFAULT_CONTENT_VIEW_STATE.copy(
|
||||
fingerprintPhrase = "",
|
||||
dialogState = LoginWithDeviceState.DialogState.Error(
|
||||
title = R.string.log_in_denied.asText(),
|
||||
message = R.string.captcha_failed.asText(),
|
||||
),
|
||||
),
|
||||
viewModel.stateFlow.value,
|
||||
)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `on captchaTokenResultFlow success should update the token`() = runTest {
|
||||
val captchaToken = "captchaToken"
|
||||
val initialState = DEFAULT_STATE.copy(loginData = DEFAULT_LOGIN_DATA)
|
||||
coEvery {
|
||||
authRepository.login(
|
||||
email = EMAIL,
|
||||
requestId = DEFAULT_LOGIN_DATA.requestId,
|
||||
accessCode = DEFAULT_LOGIN_DATA.accessCode,
|
||||
asymmetricalKey = DEFAULT_LOGIN_DATA.asymmetricalKey,
|
||||
requestPrivateKey = DEFAULT_LOGIN_DATA.privateKey,
|
||||
masterPasswordHash = DEFAULT_LOGIN_DATA.masterPasswordHash,
|
||||
captchaToken = captchaToken,
|
||||
)
|
||||
} just awaits
|
||||
val viewModel = createViewModel(initialState)
|
||||
viewModel.stateFlow.test {
|
||||
assertEquals(initialState, awaitItem())
|
||||
mutableCaptchaTokenResultFlow.tryEmit(CaptchaCallbackTokenResult.Success(captchaToken))
|
||||
assertEquals(
|
||||
initialState.copy(
|
||||
loginData = DEFAULT_LOGIN_DATA.copy(captchaToken = captchaToken),
|
||||
dialogState = LoginWithDeviceState.DialogState.Loading(
|
||||
message = R.string.logging_in.asText(),
|
||||
),
|
||||
),
|
||||
awaitItem(),
|
||||
)
|
||||
}
|
||||
|
||||
coVerify(exactly = 1) {
|
||||
authRepository.login(
|
||||
email = EMAIL,
|
||||
requestId = AUTH_REQUEST.id,
|
||||
accessCode = AUTH_REQUEST_RESPONSE.accessCode,
|
||||
asymmetricalKey = requireNotNull(AUTH_REQUEST.key),
|
||||
requestPrivateKey = AUTH_REQUEST_RESPONSE.privateKey,
|
||||
masterPasswordHash = AUTH_REQUEST.masterPasswordHash,
|
||||
captchaToken = captchaToken,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `on createAuthRequestWithUpdates Error received should show content with error dialog`() {
|
||||
val viewModel = createViewModel()
|
||||
@@ -229,6 +435,7 @@ private val DEFAULT_STATE = LoginWithDeviceState(
|
||||
emailAddress = EMAIL,
|
||||
viewState = DEFAULT_CONTENT_VIEW_STATE,
|
||||
dialogState = null,
|
||||
loginData = null,
|
||||
)
|
||||
|
||||
private val AUTH_REQUEST = AuthRequest(
|
||||
@@ -251,3 +458,12 @@ private val AUTH_REQUEST_RESPONSE = AuthRequestResponse(
|
||||
accessCode = "accessCode",
|
||||
fingerprint = "fingerprint",
|
||||
)
|
||||
|
||||
private val DEFAULT_LOGIN_DATA = LoginWithDeviceState.LoginData(
|
||||
accessCode = "accessCode",
|
||||
requestId = "1",
|
||||
masterPasswordHash = "verySecureHash",
|
||||
asymmetricalKey = "public",
|
||||
privateKey = "private_key",
|
||||
captchaToken = null,
|
||||
)
|
||||
|
||||
Reference in New Issue
Block a user