mirrors/bitwarden-android
1
0
Fork 0
mirror of https://github.com/bitwarden/android.git synced 2025-02-16 20:09:59 +03:00
Code Issues Projects Releases Packages Wiki Activity

BIT-1330, BIT-1331: Implementation to use sdk for forwarded service email generation (#470)

Browse source
This commit is contained in:
joshua-livefront 2024-01-02 16:40:39 -05:00 • committed by Álison Fernandes
parent da365acfee
commit fb891df03b
12 changed files with 356 additions and 4 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
app/src/main/java/com/x8bit/bitwarden/data/tools/generator/datasource/sdk/GeneratorSdkSource.kt
View file

@ -2,6 +2,7 @@ package com.x8bit.bitwarden.data.tools.generator.datasource.sdk
import com.bitwarden.core.PassphraseGeneratorRequest
import com.bitwarden.core.PasswordGeneratorRequest
import com.bitwarden.core.UsernameGeneratorRequest
/**
* Source of password generation functionality from the Bitwarden SDK.
@ -17,4 +18,11 @@ interface GeneratorSdkSource {
* Generates a passphrase returning a [String] wrapped in a [Result].
*/
suspend fun generatePassphrase(request: PassphraseGeneratorRequest): Result<String>
/**
* Generates a forwarded service email returning a [String] wrapped in a [Result].
*/
suspend fun generateForwardedServiceEmail(
request: UsernameGeneratorRequest.Forwarded,
): Result<String>
}

7
app/src/main/java/com/x8bit/bitwarden/data/tools/generator/datasource/sdk/GeneratorSdkSourceImpl.kt
View file

@ -2,6 +2,7 @@ package com.x8bit.bitwarden.data.tools.generator.datasource.sdk
import com.bitwarden.core.PassphraseGeneratorRequest
import com.bitwarden.core.PasswordGeneratorRequest
import com.bitwarden.core.UsernameGeneratorRequest
import com.bitwarden.sdk.ClientGenerators
/**
@ -24,4 +25,10 @@ class GeneratorSdkSourceImpl(
): Result<String> = runCatching {
clientGenerator.passphrase(request)
}
override suspend fun generateForwardedServiceEmail(
request: UsernameGeneratorRequest.Forwarded,
): Result<String> = runCatching {
clientGenerator.username(request)
}
}

9
app/src/main/java/com/x8bit/bitwarden/data/tools/generator/repository/GeneratorRepository.kt
View file

@ -3,9 +3,11 @@ package com.x8bit.bitwarden.data.tools.generator.repository
import com.bitwarden.core.PassphraseGeneratorRequest
import com.bitwarden.core.PasswordGeneratorRequest
import com.bitwarden.core.PasswordHistoryView
import com.bitwarden.core.UsernameGeneratorRequest
import com.x8bit.bitwarden.data.platform.repository.model.LocalDataState
import com.x8bit.bitwarden.data.tools.generator.repository.model.GeneratedPassphraseResult
import com.x8bit.bitwarden.data.tools.generator.repository.model.GeneratedPasswordResult
import com.x8bit.bitwarden.data.tools.generator.repository.model.GeneratedForwardedServiceUsernameResult
import com.x8bit.bitwarden.data.tools.generator.repository.model.PasscodeGenerationOptions
import kotlinx.coroutines.flow.StateFlow
@ -36,6 +38,13 @@ interface GeneratorRepository {
passphraseGeneratorRequest: PassphraseGeneratorRequest,
): GeneratedPassphraseResult
/**
* Attempt to generate a forwarded service username.
*/
suspend fun generateForwardedServiceUsername(
forwardedServiceGeneratorRequest: UsernameGeneratorRequest.Forwarded,
): GeneratedForwardedServiceUsernameResult
/**
* Get the [PasscodeGenerationOptions] for the current user.
*/

15
app/src/main/java/com/x8bit/bitwarden/data/tools/generator/repository/GeneratorRepositoryImpl.kt
View file

@ -3,6 +3,7 @@ package com.x8bit.bitwarden.data.tools.generator.repository
import com.bitwarden.core.PassphraseGeneratorRequest
import com.bitwarden.core.PasswordGeneratorRequest
import com.bitwarden.core.PasswordHistoryView
import com.bitwarden.core.UsernameGeneratorRequest
import com.x8bit.bitwarden.data.auth.datasource.disk.AuthDiskSource
import com.x8bit.bitwarden.data.platform.manager.dispatcher.DispatcherManager
import com.x8bit.bitwarden.data.platform.repository.model.LocalDataState
@ -14,6 +15,7 @@ import com.x8bit.bitwarden.data.tools.generator.datasource.disk.entity.toPasswor
import com.x8bit.bitwarden.data.tools.generator.datasource.sdk.GeneratorSdkSource
import com.x8bit.bitwarden.data.tools.generator.repository.model.GeneratedPassphraseResult
import com.x8bit.bitwarden.data.tools.generator.repository.model.GeneratedPasswordResult
import com.x8bit.bitwarden.data.tools.generator.repository.model.GeneratedForwardedServiceUsernameResult
import com.x8bit.bitwarden.data.tools.generator.repository.model.PasscodeGenerationOptions
import com.x8bit.bitwarden.data.vault.datasource.sdk.VaultSdkSource
import kotlinx.coroutines.CoroutineScope
@ -120,6 +122,19 @@ class GeneratorRepositoryImpl(
onFailure = { GeneratedPassphraseResult.InvalidRequest },
)
override suspend fun generateForwardedServiceUsername(
forwardedServiceGeneratorRequest: UsernameGeneratorRequest.Forwarded,
): GeneratedForwardedServiceUsernameResult =
generatorSdkSource.generateForwardedServiceEmail(forwardedServiceGeneratorRequest)
.fold(
onSuccess = { generatedEmail ->
GeneratedForwardedServiceUsernameResult.Success(generatedEmail)
},
onFailure = {
GeneratedForwardedServiceUsernameResult.InvalidRequest
},
)
override fun getPasscodeGenerationOptions(): PasscodeGenerationOptions? {
val userId = authDiskSource.userState?.activeUserId
return userId?.let { generatorDiskSource.getPasscodeGenerationOptions(it) }

18
app/src/main/java/com/x8bit/bitwarden/data/tools/generator/repository/model/GeneratedForwardedServiceUsernameResult.kt Normal file
View file

@ -0,0 +1,18 @@
package com.x8bit.bitwarden.data.tools.generator.repository.model
/**
* Represents the outcome of a generator operation.
*/
sealed class GeneratedForwardedServiceUsernameResult {
/**
* Operation succeeded with a value.
*/
data class Success(
val generatedEmailAddress: String,
) : GeneratedForwardedServiceUsernameResult()
/**
* There was an error during the operation.
*/
data object InvalidRequest : GeneratedForwardedServiceUsernameResult()
}

58
app/src/main/java/com/x8bit/bitwarden/ui/tools/feature/generator/GeneratorViewModel.kt
View file

@ -11,6 +11,7 @@ import com.x8bit.bitwarden.R
import com.x8bit.bitwarden.data.tools.generator.repository.GeneratorRepository
import com.x8bit.bitwarden.data.tools.generator.repository.model.GeneratedPassphraseResult
import com.x8bit.bitwarden.data.tools.generator.repository.model.GeneratedPasswordResult
import com.x8bit.bitwarden.data.tools.generator.repository.model.GeneratedForwardedServiceUsernameResult
import com.x8bit.bitwarden.data.tools.generator.repository.model.PasscodeGenerationOptions
import com.x8bit.bitwarden.ui.platform.base.BaseViewModel
import com.x8bit.bitwarden.ui.platform.base.util.Text
@ -29,6 +30,7 @@ import com.x8bit.bitwarden.ui.tools.feature.generator.GeneratorState.MainType.Us
import com.x8bit.bitwarden.ui.tools.feature.generator.GeneratorState.MainType.Username.UsernameType.ForwardedEmailAlias.ServiceType.SimpleLogin
import com.x8bit.bitwarden.ui.tools.feature.generator.GeneratorState.MainType.Username.UsernameType.PlusAddressedEmail
import com.x8bit.bitwarden.ui.tools.feature.generator.GeneratorState.MainType.Username.UsernameType.RandomWord
import com.x8bit.bitwarden.ui.tools.feature.generator.util.toUsernameGeneratorRequest
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.Job
import kotlinx.coroutines.flow.launchIn
@ -109,6 +111,10 @@ class GeneratorViewModel @Inject constructor(
handleUpdateGeneratedPassphraseResult(action)
}
is GeneratorAction.Internal.UpdateGeneratedUsernameResult -> {
handleUpdateGeneratedUsernameResult(action)
}
is GeneratorAction.MainType.Username.UsernameTypeOptionSelect -> {
handleUsernameTypeOptionSelect(action)
}
@ -291,7 +297,7 @@ class GeneratorViewModel @Inject constructor(
private fun handleRegenerationClick() {
// Go through the update process with the current state to trigger a
// regeneration of the generated text for the same state.
updateGeneratorMainType { mutableStateFlow.value.selectedType }
updateGeneratorMainType(isManualRegeneration = true) { mutableStateFlow.value.selectedType }
}
private fun handleCopyClick() {
@ -330,6 +336,22 @@ class GeneratorViewModel @Inject constructor(
}
}
private fun handleUpdateGeneratedUsernameResult(
action: GeneratorAction.Internal.UpdateGeneratedUsernameResult,
) {
when (val result = action.result) {
is GeneratedForwardedServiceUsernameResult.Success -> {
mutableStateFlow.update {
it.copy(generatedText = result.generatedEmailAddress)
}
}
GeneratedForwardedServiceUsernameResult.InvalidRequest -> {
sendEvent(GeneratorEvent.ShowSnackbar(R.string.an_error_has_occurred.asText()))
}
}
}
//endregion Generated Field Handlers
//region Main Type Option Handlers
@ -829,6 +851,7 @@ class GeneratorViewModel @Inject constructor(
//region Utility Functions
private inline fun updateGeneratorMainType(
isManualRegeneration: Boolean = false,
crossinline block: (GeneratorState.MainType) -> GeneratorState.MainType?,
) {
val currentSelectedType = mutableStateFlow.value.selectedType
@ -850,13 +873,34 @@ class GeneratorViewModel @Inject constructor(
}
}
is Username -> {
// TODO: Generate different username types. Plus addressed email: BIT-655
is Username -> when (val selectedType = updatedMainType.selectedType) {
is ForwardedEmailAlias -> {
if (isManualRegeneration) {
generateForwardedEmailAlias(selectedType)
}
}
is CatchAllEmail -> {
// TODO: Implement catch all email generation (BIT-1334)
}
is PlusAddressedEmail -> {
// TODO: Implement plus addressed email generation (BIT-1335)
}
is RandomWord -> {
// TODO: Implement random word generation (BIT-1336)
}
}
}
}
}
private suspend fun generateForwardedEmailAlias(alias: ForwardedEmailAlias) {
val request = alias.selectedServiceType?.toUsernameGeneratorRequest() ?: return
val result = generatorRepository.generateForwardedServiceUsername(request)
sendAction(GeneratorAction.Internal.UpdateGeneratedUsernameResult(result))
}
private inline fun updateGeneratorMainTypePasscode(
crossinline block: (Passcode) -> Passcode,
) {
@ -1391,6 +1435,7 @@ data class GeneratorState(
data class AddyIo(
val apiAccessToken: String = "",
val domainName: String = "",
val baseUrl: String = "",
) : ServiceType(), Parcelable {
override val displayStringResId: Int
get() = ServiceTypeOption.ADDY_IO.labelRes
@ -1823,6 +1868,13 @@ sealed class GeneratorAction {
data class UpdateGeneratedPassphraseResult(
val result: GeneratedPassphraseResult,
) : Internal()
/**
* Indicates a generated text update is received.
*/
data class UpdateGeneratedUsernameResult(
val result: GeneratedForwardedServiceUsernameResult,
) : Internal()
}
}

47
app/src/main/java/com/x8bit/bitwarden/ui/tools/feature/generator/util/ServiceTypeExtensions.kt Normal file
View file

@ -0,0 +1,47 @@
package com.x8bit.bitwarden.ui.tools.feature.generator.util
import com.bitwarden.core.ForwarderServiceType
import com.bitwarden.core.UsernameGeneratorRequest
import com.x8bit.bitwarden.ui.tools.feature.generator.GeneratorState.MainType.Username.UsernameType.ForwardedEmailAlias.ServiceType
/**
* Converts a [ServiceType] to a [UsernameGeneratorRequest.Forwarded].
*/
fun ServiceType.toUsernameGeneratorRequest(): UsernameGeneratorRequest.Forwarded {
return when (this) {
is ServiceType.AddyIo -> {
UsernameGeneratorRequest.Forwarded(
service = ForwarderServiceType.AddyIo(
apiToken = this.apiAccessToken,
domain = this.domainName,
baseUrl = this.baseUrl,
),
website = null,
)
}
is ServiceType.DuckDuckGo -> {
UsernameGeneratorRequest.Forwarded(
service = ForwarderServiceType.DuckDuckGo(token = this.apiKey),
website = null,
)
}
is ServiceType.FirefoxRelay -> {
UsernameGeneratorRequest.Forwarded(
service = ForwarderServiceType.Firefox(apiToken = this.apiAccessToken),
website = null,
)
}
is ServiceType.FastMail -> {
UsernameGeneratorRequest.Forwarded(
service = ForwarderServiceType.Fastmail(apiToken = this.apiKey),
website = null,
)
}
is ServiceType.SimpleLogin -> {
UsernameGeneratorRequest.Forwarded(
service = ForwarderServiceType.SimpleLogin(apiKey = this.apiKey),
website = null,
)
}
}
}

25
app/src/test/java/com/x8bit/bitwarden/data/tools/generator/datasource/sdk/GeneratorSdkSourceTest.kt
View file

@ -1,7 +1,9 @@
package com.x8bit.bitwarden.data.tools.generator.datasource.sdk
import com.bitwarden.core.ForwarderServiceType
import com.bitwarden.core.PassphraseGeneratorRequest
import com.bitwarden.core.PasswordGeneratorRequest
import com.bitwarden.core.UsernameGeneratorRequest
import com.bitwarden.sdk.ClientGenerators
import io.mockk.coEvery
import io.mockk.coVerify
@ -67,4 +69,27 @@ class GeneratorSdkSourceTest {
clientGenerators.passphrase(request)
}
}
@Suppress("MaxLineLength")
@Test
fun `generateForwardedServiceEmail should call SDK and return a Result with the generated email`() =
runBlocking {
val request = UsernameGeneratorRequest.Forwarded(
service = ForwarderServiceType.DuckDuckGo(token = "testToken"),
website = null,
)
val expectedResult = "generated@email.com"
coEvery {
clientGenerators.username(request)
} returns expectedResult
val result = generatorSdkSource.generateForwardedServiceEmail(request)
assertEquals(Result.success(expectedResult), result)
coVerify {
clientGenerators.username(request)
}
}
}

45
app/src/test/java/com/x8bit/bitwarden/data/tools/generator/repository/GeneratorRepositoryTest.kt
View file

@ -1,10 +1,12 @@
package com.x8bit.bitwarden.data.tools.generator.repository
import app.cash.turbine.test
import com.bitwarden.core.ForwarderServiceType
import com.bitwarden.core.PassphraseGeneratorRequest
import com.bitwarden.core.PasswordGeneratorRequest
import com.bitwarden.core.PasswordHistory
import com.bitwarden.core.PasswordHistoryView
import com.bitwarden.core.UsernameGeneratorRequest
import com.x8bit.bitwarden.data.auth.datasource.disk.AuthDiskSource
import com.x8bit.bitwarden.data.auth.datasource.disk.model.AccountJson
import com.x8bit.bitwarden.data.auth.datasource.disk.model.EnvironmentUrlDataJson
@ -21,6 +23,7 @@ import com.x8bit.bitwarden.data.tools.generator.datasource.disk.PasswordHistoryD
import com.x8bit.bitwarden.data.tools.generator.datasource.disk.entity.PasswordHistoryEntity
import com.x8bit.bitwarden.data.tools.generator.datasource.disk.entity.toPasswordHistoryEntity
import com.x8bit.bitwarden.data.tools.generator.datasource.sdk.GeneratorSdkSource
import com.x8bit.bitwarden.data.tools.generator.repository.model.GeneratedForwardedServiceUsernameResult
import com.x8bit.bitwarden.data.tools.generator.repository.model.GeneratedPassphraseResult
import com.x8bit.bitwarden.data.tools.generator.repository.model.GeneratedPasswordResult
import com.x8bit.bitwarden.data.tools.generator.repository.model.PasscodeGenerationOptions
@ -250,6 +253,48 @@ class GeneratorRepositoryTest {
coVerify { generatorSdkSource.generatePassphrase(request) }
}
@Suppress("MaxLineLength")
@Test
fun `generateForwardedService should emit Success result and store the generated email`() = runTest {
val userId = "testUserId"
val request = UsernameGeneratorRequest.Forwarded(
service = ForwarderServiceType.DuckDuckGo(
token = "testToken",
),
website = null,
)
val generatedEmail = "generated@email.com"
coEvery { authDiskSource.userState?.activeUserId } returns userId
coEvery { generatorSdkSource.generateForwardedServiceEmail(request) } returns
Result.success(generatedEmail)
val result = repository.generateForwardedServiceUsername(request)
assertEquals(
generatedEmail,
(result as GeneratedForwardedServiceUsernameResult.Success).generatedEmailAddress,
)
coVerify { generatorSdkSource.generateForwardedServiceEmail(request) }
}
@Suppress("MaxLineLength")
@Test
fun `generateForwardedService should emit InvalidRequest result when SDK throws exception`() = runTest {
val request = UsernameGeneratorRequest.Forwarded(
service = ForwarderServiceType.DuckDuckGo(token = "testToken"),
website = null,
)
val exception = RuntimeException("An error occurred")
coEvery { generatorSdkSource.generateForwardedServiceEmail(request) } returns Result.failure(exception)
val result = repository.generateForwardedServiceUsername(request)
assertTrue(result is GeneratedForwardedServiceUsernameResult.InvalidRequest)
coVerify { generatorSdkSource.generateForwardedServiceEmail(request) }
}
@Test
fun `getPasscodeGenerationOptions should return options when available`() = runTest {
val userId = "activeUserId"

20
app/src/test/java/com/x8bit/bitwarden/data/tools/generator/repository/util/FakeGeneratorRepository.kt
View file

@ -3,8 +3,10 @@ package com.x8bit.bitwarden.data.tools.generator.repository.util
import com.bitwarden.core.PassphraseGeneratorRequest
import com.bitwarden.core.PasswordGeneratorRequest
import com.bitwarden.core.PasswordHistoryView
import com.bitwarden.core.UsernameGeneratorRequest
import com.x8bit.bitwarden.data.platform.repository.model.LocalDataState
import com.x8bit.bitwarden.data.tools.generator.repository.GeneratorRepository
import com.x8bit.bitwarden.data.tools.generator.repository.model.GeneratedForwardedServiceUsernameResult
import com.x8bit.bitwarden.data.tools.generator.repository.model.GeneratedPassphraseResult
import com.x8bit.bitwarden.data.tools.generator.repository.model.GeneratedPasswordResult
import com.x8bit.bitwarden.data.tools.generator.repository.model.PasscodeGenerationOptions
@ -28,6 +30,11 @@ class FakeGeneratorRepository : GeneratorRepository {
private val mutablePasswordHistoryStateFlow =
MutableStateFlow<LocalDataState<List<PasswordHistoryView>>>(LocalDataState.Loading)
private var generateForwardedServiceResult: GeneratedForwardedServiceUsernameResult =
GeneratedForwardedServiceUsernameResult.Success(
generatedEmailAddress = "updatedUsername",
)
override val passwordHistoryStateFlow: StateFlow<LocalDataState<List<PasswordHistoryView>>>
get() = mutablePasswordHistoryStateFlow
@ -44,6 +51,12 @@ class FakeGeneratorRepository : GeneratorRepository {
return generatePassphraseResult
}
override suspend fun generateForwardedServiceUsername(
forwardedServiceGeneratorRequest: UsernameGeneratorRequest.Forwarded,
): GeneratedForwardedServiceUsernameResult {
return generateForwardedServiceResult
}
override fun getPasscodeGenerationOptions(): PasscodeGenerationOptions? {
return passcodeGenerationOptions
}
@ -90,4 +103,11 @@ class FakeGeneratorRepository : GeneratorRepository {
fun emitPasswordHistoryState(state: LocalDataState<List<PasswordHistoryView>>) {
mutablePasswordHistoryStateFlow.value = state
}
/**
* Sets the mock result for the generateForwardedService function.
*/
fun setMockGenerateForwardedServiceResult(result: GeneratedForwardedServiceUsernameResult) {
generateForwardedServiceResult = result
}
}

44
app/src/test/java/com/x8bit/bitwarden/ui/tools/feature/generator/GeneratorViewModelTest.kt
View file

@ -3,6 +3,7 @@ package com.x8bit.bitwarden.ui.tools.feature.generator
import androidx.lifecycle.SavedStateHandle
import app.cash.turbine.test
import com.x8bit.bitwarden.R
import com.x8bit.bitwarden.data.tools.generator.repository.model.GeneratedForwardedServiceUsernameResult
import com.x8bit.bitwarden.data.tools.generator.repository.model.GeneratedPassphraseResult
import com.x8bit.bitwarden.data.tools.generator.repository.model.GeneratedPasswordResult
import com.x8bit.bitwarden.data.tools.generator.repository.model.PasscodeGenerationOptions
@ -942,6 +943,12 @@ class GeneratorViewModelTest : BaseViewModelTest() {
.ADDY_IO,
)
fakeGeneratorRepository.setMockGenerateForwardedServiceResult(
GeneratedForwardedServiceUsernameResult.Success(
generatedEmailAddress = "defaultForwardedEmailAlias",
),
)
viewModel.actionChannel.trySend(action)
val expectedState = defaultForwardedEmailAliasState.copy(
@ -989,6 +996,12 @@ class GeneratorViewModelTest : BaseViewModelTest() {
accessToken = newAccessToken,
)
fakeGeneratorRepository.setMockGenerateForwardedServiceResult(
GeneratedForwardedServiceUsernameResult.Success(
generatedEmailAddress = "defaultAddyIo",
),
)
viewModel.actionChannel.trySend(action)
val expectedState = defaultAddyIoState.copy(
@ -1006,7 +1019,6 @@ class GeneratorViewModelTest : BaseViewModelTest() {
),
),
)
assertEquals(expectedState, viewModel.stateFlow.value)
}
@ -1023,6 +1035,12 @@ class GeneratorViewModelTest : BaseViewModelTest() {
domain = newDomainName,
)
fakeGeneratorRepository.setMockGenerateForwardedServiceResult(
GeneratedForwardedServiceUsernameResult.Success(
generatedEmailAddress = "defaultAddyIo",
),
)
viewModel.actionChannel.trySend(action)
val expectedState = defaultAddyIoState.copy(
@ -1067,6 +1085,12 @@ class GeneratorViewModelTest : BaseViewModelTest() {
apiKey = newApiKey,
)
fakeGeneratorRepository.setMockGenerateForwardedServiceResult(
GeneratedForwardedServiceUsernameResult.Success(
generatedEmailAddress = "defaultDuckDuckGo",
),
)
viewModel.actionChannel.trySend(action)
val expectedState = defaultDuckDuckGoState.copy(
@ -1111,6 +1135,12 @@ class GeneratorViewModelTest : BaseViewModelTest() {
apiKey = newApiKey,
)
fakeGeneratorRepository.setMockGenerateForwardedServiceResult(
GeneratedForwardedServiceUsernameResult.Success(
generatedEmailAddress = "defaultFastMail",
),
)
viewModel.actionChannel.trySend(action)
val expectedState = defaultFastMailState.copy(
@ -1156,6 +1186,12 @@ class GeneratorViewModelTest : BaseViewModelTest() {
accessToken = newAccessToken,
)
fakeGeneratorRepository.setMockGenerateForwardedServiceResult(
GeneratedForwardedServiceUsernameResult.Success(
generatedEmailAddress = "defaultFirefoxRelay",
),
)
viewModel.actionChannel.trySend(action)
val expectedState = defaultFirefoxRelayState.copy(
@ -1201,6 +1237,12 @@ class GeneratorViewModelTest : BaseViewModelTest() {
apiKey = newApiKey,
)
fakeGeneratorRepository.setMockGenerateForwardedServiceResult(
GeneratedForwardedServiceUsernameResult.Success(
generatedEmailAddress = "defaultSimpleLogin",
),
)
viewModel.actionChannel.trySend(action)
val expectedState = defaultSimpleLoginState.copy(

64
app/src/test/java/com/x8bit/bitwarden/ui/tools/feature/generator/util/ServiceTypeExtensionsTest.kt Normal file
View file

@ -0,0 +1,64 @@
package com.x8bit.bitwarden.ui.tools.feature.generator.util
import com.bitwarden.core.ForwarderServiceType
import com.x8bit.bitwarden.ui.tools.feature.generator.GeneratorState.MainType.Username.UsernameType.ForwardedEmailAlias.ServiceType
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.Assertions.assertEquals
internal class ServiceTypeExtensionsTest {
@Test
fun `toUsernameGeneratorRequest for AddyIo returns correct request`() {
val addyIoServiceType = ServiceType.AddyIo(
apiAccessToken = "testToken",
domainName = "test.com",
baseUrl = "http://test.com",
)
val request = addyIoServiceType.toUsernameGeneratorRequest()
assertEquals(
ForwarderServiceType.AddyIo(
apiToken = "testToken",
domain = "test.com",
baseUrl = "http://test.com",
), request.service,
)
assertEquals(null, request.website)
}
@Test
fun `toUsernameGeneratorRequest for DuckDuckGo returns correct request`() {
val duckDuckGoServiceType = ServiceType.DuckDuckGo(apiKey = "testKey")
val request = duckDuckGoServiceType.toUsernameGeneratorRequest()
assertEquals(ForwarderServiceType.DuckDuckGo("testKey"), request.service)
assertEquals(null, request.website)
}
@Test
fun `toUsernameGeneratorRequest for FirefoxRelay returns correct request`() {
val firefoxRelayServiceType = ServiceType.FirefoxRelay(apiAccessToken = "testToken")
val request = firefoxRelayServiceType.toUsernameGeneratorRequest()
assertEquals(ForwarderServiceType.Firefox(apiToken = "testToken"), request.service)
assertEquals(null, request.website)
}
@Test
fun `toUsernameGeneratorRequest for FastMail returns correct request`() {
val fastMailServiceType = ServiceType.FastMail(apiKey = "testKey")
val request = fastMailServiceType.toUsernameGeneratorRequest()
assertEquals(ForwarderServiceType.Fastmail(apiToken = "testKey"), request.service)
assertEquals(null, request.website)
}
@Test
fun `toUsernameGeneratorRequest for SimpleLogin returns correct request`() {
val simpleLoginServiceType = ServiceType.SimpleLogin(apiKey = "testKey")
val request = simpleLoginServiceType.toUsernameGeneratorRequest()
assertEquals(ForwarderServiceType.SimpleLogin(apiKey = "testKey"), request.service)
assertEquals(null, request.website)
}
}