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

Reformat main app and test code (#480)

Browse source
This commit is contained in:
Brian Yencho 2024-01-03 09:06:52 -06:00 • committed by Álison Fernandes
parent 4601f84140
commit d4bab9ed7f
8 changed files with 127 additions and 112 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -5,9 +5,9 @@ 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.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.GeneratedForwardedServiceUsernameResult
import com.x8bit.bitwarden.data.tools.generator.repository.model.PasscodeGenerationOptions
import kotlinx.coroutines.flow.StateFlow

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

@ -13,9 +13,9 @@ import com.x8bit.bitwarden.data.tools.generator.datasource.disk.PasswordHistoryD
import com.x8bit.bitwarden.data.tools.generator.datasource.disk.entity.toPasswordHistory
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.GeneratedForwardedServiceUsernameResult
import com.x8bit.bitwarden.data.tools.generator.repository.model.PasscodeGenerationOptions
import com.x8bit.bitwarden.data.vault.datasource.sdk.VaultSdkSource
import kotlinx.coroutines.CoroutineScope

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

@ -9,9 +9,9 @@ import com.bitwarden.core.PassphraseGeneratorRequest
import com.bitwarden.core.PasswordGeneratorRequest
import com.x8bit.bitwarden.R
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.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
@ -879,6 +879,7 @@ class GeneratorViewModel @Inject constructor(
generateForwardedEmailAlias(selectedType)
}
}
is CatchAllEmail -> {
// TODO: Implement catch all email generation (BIT-1334)
}

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

@ -19,24 +19,28 @@ fun ServiceType.toUsernameGeneratorRequest(): UsernameGeneratorRequest.Forwarded
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),

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

@ -76,95 +76,103 @@ class GeneratorRepositoryTest {
@Suppress("MaxLineLength")
@Test
fun `generatePassword should emit Success result and store the generated password when shouldSave is true`() = runTest {
val fixedInstant = Instant.parse("2021-01-01T00:00:00Z")
fun `generatePassword should emit Success result and store the generated password when shouldSave is true`() =
runTest {
val fixedInstant = Instant.parse("2021-01-01T00:00:00Z")
mockkStatic(Instant::class)
every { Instant.now() } returns fixedInstant
mockkStatic(Instant::class)
every { Instant.now() } returns fixedInstant
val userId = "testUserId"
val request = PasswordGeneratorRequest(
lowercase = true,
uppercase = true,
numbers = true,
special = true,
length = 12.toUByte(),
avoidAmbiguous = false,
minLowercase = null,
minUppercase = null,
minNumber = null,
minSpecial = null,
)
val generatedPassword = "GeneratedPassword123!"
val encryptedPasswordHistory =
PasswordHistory(password = generatedPassword, lastUsedDate = Instant.now())
coEvery { authDiskSource.userState?.activeUserId } returns userId
coEvery { generatorSdkSource.generatePassword(request) } returns
Result.success(generatedPassword)
coEvery { vaultSdkSource.encryptPasswordHistory(any()) } returns
Result.success(encryptedPasswordHistory)
coEvery { passwordHistoryDiskSource.insertPasswordHistory(any()) } just runs
val result = repository.generatePassword(request, true)
assertEquals(generatedPassword, (result as GeneratedPasswordResult.Success).generatedString)
coVerify { generatorSdkSource.generatePassword(request) }
coVerify {
passwordHistoryDiskSource.insertPasswordHistory(
encryptedPasswordHistory.toPasswordHistoryEntity(userId),
val userId = "testUserId"
val request = PasswordGeneratorRequest(
lowercase = true,
uppercase = true,
numbers = true,
special = true,
length = 12.toUByte(),
avoidAmbiguous = false,
minLowercase = null,
minUppercase = null,
minNumber = null,
minSpecial = null,
)
val generatedPassword = "GeneratedPassword123!"
val encryptedPasswordHistory =
PasswordHistory(password = generatedPassword, lastUsedDate = Instant.now())
coEvery { authDiskSource.userState?.activeUserId } returns userId
coEvery { generatorSdkSource.generatePassword(request) } returns
Result.success(generatedPassword)
coEvery { vaultSdkSource.encryptPasswordHistory(any()) } returns
Result.success(encryptedPasswordHistory)
coEvery { passwordHistoryDiskSource.insertPasswordHistory(any()) } just runs
val result = repository.generatePassword(request, true)
assertEquals(
generatedPassword,
(result as GeneratedPasswordResult.Success).generatedString,
)
coVerify { generatorSdkSource.generatePassword(request) }
coVerify {
passwordHistoryDiskSource.insertPasswordHistory(
encryptedPasswordHistory.toPasswordHistoryEntity(userId),
)
}
}
}
@Suppress("MaxLineLength")
@Test
fun `generatePassword should emit Success result but not store the generated password when shouldSave is false`() = runTest {
val fixedInstant = Instant.parse("2021-01-01T00:00:00Z")
fun `generatePassword should emit Success result but not store the generated password when shouldSave is false`() =
runTest {
val fixedInstant = Instant.parse("2021-01-01T00:00:00Z")
mockkStatic(Instant::class)
every { Instant.now() } returns fixedInstant
mockkStatic(Instant::class)
every { Instant.now() } returns fixedInstant
val userId = "testUserId"
val request = PasswordGeneratorRequest(
lowercase = true,
uppercase = true,
numbers = true,
special = true,
length = 12.toUByte(),
avoidAmbiguous = false,
minLowercase = null,
minUppercase = null,
minNumber = null,
minSpecial = null,
)
val generatedPassword = "GeneratedPassword123!"
val encryptedPasswordHistory =
PasswordHistory(password = generatedPassword, lastUsedDate = Instant.now())
val userId = "testUserId"
val request = PasswordGeneratorRequest(
lowercase = true,
uppercase = true,
numbers = true,
special = true,
length = 12.toUByte(),
avoidAmbiguous = false,
minLowercase = null,
minUppercase = null,
minNumber = null,
minSpecial = null,
)
val generatedPassword = "GeneratedPassword123!"
val encryptedPasswordHistory =
PasswordHistory(password = generatedPassword, lastUsedDate = Instant.now())
coEvery { authDiskSource.userState?.activeUserId } returns userId
coEvery { authDiskSource.userState?.activeUserId } returns userId
coEvery { generatorSdkSource.generatePassword(request) } returns
Result.success(generatedPassword)
coEvery { generatorSdkSource.generatePassword(request) } returns
Result.success(generatedPassword)
coEvery { vaultSdkSource.encryptPasswordHistory(any()) } returns
Result.success(encryptedPasswordHistory)
coEvery { vaultSdkSource.encryptPasswordHistory(any()) } returns
Result.success(encryptedPasswordHistory)
coEvery { passwordHistoryDiskSource.insertPasswordHistory(any()) } just runs
coEvery { passwordHistoryDiskSource.insertPasswordHistory(any()) } just runs
val result = repository.generatePassword(request, false)
val result = repository.generatePassword(request, false)
assertEquals(generatedPassword, (result as GeneratedPasswordResult.Success).generatedString)
coVerify { generatorSdkSource.generatePassword(request) }
assertEquals(
generatedPassword,
(result as GeneratedPasswordResult.Success).generatedString,
)
coVerify { generatorSdkSource.generatePassword(request) }
coVerify(exactly = 0) {
passwordHistoryDiskSource.insertPasswordHistory(any())
coVerify(exactly = 0) {
passwordHistoryDiskSource.insertPasswordHistory(any())
}
}
}
@Test
fun `generatePassword should emit InvalidRequest result when SDK throws exception`() = runTest {
@ -232,7 +240,6 @@ class GeneratorRepositoryTest {
}
}
@Suppress("MaxLineLength")
@Test
fun `generatePassphrase should emit InvalidRequest result when SDK throws exception`() =
runTest {
@ -253,47 +260,49 @@ 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,
)
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"
val generatedEmail = "generated@email.com"
coEvery { authDiskSource.userState?.activeUserId } returns userId
coEvery { generatorSdkSource.generateForwardedServiceEmail(request) } returns
Result.success(generatedEmail)
coEvery { authDiskSource.userState?.activeUserId } returns userId
coEvery { generatorSdkSource.generateForwardedServiceEmail(request) } returns
Result.success(generatedEmail)
val result = repository.generateForwardedServiceUsername(request)
val result = repository.generateForwardedServiceUsername(request)
assertEquals(
generatedEmail,
(result as GeneratedForwardedServiceUsernameResult.Success).generatedEmailAddress,
)
coVerify { generatorSdkSource.generateForwardedServiceEmail(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)
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)
val result = repository.generateForwardedServiceUsername(request)
assertTrue(result is GeneratedForwardedServiceUsernameResult.InvalidRequest)
coVerify { generatorSdkSource.generateForwardedServiceEmail(request) }
}
assertTrue(result is GeneratedForwardedServiceUsernameResult.InvalidRequest)
coVerify { generatorSdkSource.generateForwardedServiceEmail(request) }
}
@Test
fun `getPasscodeGenerationOptions should return options when available`() = runTest {

2
app/src/test/java/com/x8bit/bitwarden/ui/platform/base/util/FakePermissionManager.kt
View file

@ -41,6 +41,6 @@ class FakePermissionManager : PermissionsManager {
override fun shouldShouldRequestPermissionRationale(
permission: String,
): Boolean {
return shouldShowRequestRationale
return shouldShowRequestRationale
}
}

2
app/src/test/java/com/x8bit/bitwarden/ui/tools/feature/generator/passwordhistory/PasswordHistoryViewModelTest.kt
View file

@ -2,9 +2,9 @@ package com.x8bit.bitwarden.ui.tools.feature.generator.passwordhistory
import app.cash.turbine.test
import com.bitwarden.core.PasswordHistoryView
import com.x8bit.bitwarden.R
import com.x8bit.bitwarden.data.platform.repository.model.LocalDataState
import com.x8bit.bitwarden.data.tools.generator.repository.util.FakeGeneratorRepository
import com.x8bit.bitwarden.R
import com.x8bit.bitwarden.ui.platform.base.BaseViewModelTest
import com.x8bit.bitwarden.ui.platform.base.util.asText
import com.x8bit.bitwarden.ui.tools.feature.generator.util.toFormattedPattern

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

@ -2,8 +2,8 @@ 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
import org.junit.jupiter.api.Test
internal class ServiceTypeExtensionsTest {
@ -21,7 +21,8 @@ internal class ServiceTypeExtensionsTest {
apiToken = "testToken",
domain = "test.com",
baseUrl = "http://test.com",
), request.service,
),
request.service,
)
assertEquals(null, request.website)
}