BIT-1336: Adding random word username generation (#540)

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

@@ -115,6 +115,28 @@ class GeneratorSdkSourceTest {
             }
         }
 
+    @Suppress("MaxLineLength")
+    @Test
+    fun `generateRandomWordUsername should call SDK and return a Result with the generated email`() =
+        runBlocking {
+            val request = UsernameGeneratorRequest.Word(
+                capitalize = true,
+                includeNumber = true,
+            )
+            val expectedResult = "USER1"
+
+            coEvery {
+                clientGenerators.username(request)
+            } returns expectedResult
+
+            val result = generatorSdkSource.generateRandomWord(request)
+
+            assertEquals(Result.success(expectedResult), result)
+            coVerify {
+                clientGenerators.username(request)
+            }
+        }
+
     @Suppress("MaxLineLength")
     @Test
     fun `generateForwardedServiceEmail should call SDK and return a Result with the generated email`() =

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

@@ -29,6 +29,7 @@ import com.x8bit.bitwarden.data.tools.generator.repository.model.GeneratedForwar
 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.GeneratedPlusAddressedUsernameResult
+import com.x8bit.bitwarden.data.tools.generator.repository.model.GeneratedRandomWordUsernameResult
 import com.x8bit.bitwarden.data.tools.generator.repository.model.PasscodeGenerationOptions
 import com.x8bit.bitwarden.data.vault.datasource.sdk.VaultSdkSource
 import io.mockk.coEvery
@@ -344,6 +345,45 @@ class GeneratorRepositoryTest {
         coVerify { generatorSdkSource.generateCatchAllEmail(request) }
     }
 
+    @Suppress("MaxLineLength")
+    @Test
+    fun `generateRandomWord should return Success with generated email when SDK call is successful`() = runTest {
+        val userId = "testUserId"
+        val request = UsernameGeneratorRequest.Word(
+            capitalize = false,
+            includeNumber = false,
+        )
+        val generatedEmail = "user"
+
+        coEvery { generatorSdkSource.generateRandomWord(request) } returns
+            Result.success(generatedEmail)
+
+        val result = repository.generateRandomWordUsername(request)
+
+        assertEquals(
+            generatedEmail,
+            (result as GeneratedRandomWordUsernameResult.Success).generatedUsername,
+        )
+        coVerify { generatorSdkSource.generateRandomWord(request) }
+    }
+
+    @Test
+    fun `generateRandomWord should return InvalidRequest on SDK failure`() = runTest {
+        val request = UsernameGeneratorRequest.Word(
+            capitalize = false,
+            includeNumber = false,
+        )
+        val exception = RuntimeException("An error occurred")
+        coEvery {
+            generatorSdkSource.generateRandomWord(request)
+        } returns Result.failure(exception)
+
+        val result = repository.generateRandomWordUsername(request)
+
+        assertTrue(result is GeneratedRandomWordUsernameResult.InvalidRequest)
+        coVerify { generatorSdkSource.generateRandomWord(request) }
+    }
+
     @Test
     fun `generateForwardedService should emit Success result and store the generated email`() =
         runTest {

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

@@ -11,6 +11,7 @@ import com.x8bit.bitwarden.data.tools.generator.repository.model.GeneratedForwar
 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.GeneratedPlusAddressedUsernameResult
+import com.x8bit.bitwarden.data.tools.generator.repository.model.GeneratedRandomWordUsernameResult
 import com.x8bit.bitwarden.data.tools.generator.repository.model.PasscodeGenerationOptions
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
@@ -42,6 +43,11 @@ class FakeGeneratorRepository : GeneratorRepository {
             generatedEmailAddress = "user@domain",
         )
 
+    private var generateRandomWordUsernameResult: GeneratedRandomWordUsernameResult =
+        GeneratedRandomWordUsernameResult.Success(
+            generatedUsername = "randomWord",
+        )
+
     private var generateForwardedServiceResult: GeneratedForwardedServiceUsernameResult =
         GeneratedForwardedServiceUsernameResult.Success(
             generatedEmailAddress = "updatedUsername",
@@ -75,6 +81,12 @@ class FakeGeneratorRepository : GeneratorRepository {
         return generateCatchAllEmailResult
     }
 
+    override suspend fun generateRandomWordUsername(
+        randomWordGeneratorRequest: UsernameGeneratorRequest.Word,
+    ): GeneratedRandomWordUsernameResult {
+        return generateRandomWordUsernameResult
+    }
+
     override suspend fun generateForwardedServiceUsername(
         forwardedServiceGeneratorRequest: UsernameGeneratorRequest.Forwarded,
     ): GeneratedForwardedServiceUsernameResult {
@@ -141,4 +153,11 @@ class FakeGeneratorRepository : GeneratorRepository {
     fun setMockCatchAllResult(result: GeneratedCatchAllUsernameResult) {
         generateCatchAllEmailResult = result
     }
+
+    /**
+     * Sets the mock result for the generateRandomWord function.
+     */
+    fun setMockRandomWordResult(result: GeneratedRandomWordUsernameResult) {
+        generateRandomWordUsernameResult = result
+    }
 }

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

@@ -11,6 +11,7 @@ import com.x8bit.bitwarden.data.tools.generator.repository.model.GeneratedCatchA
 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.GeneratedRandomWordUsernameResult
 import com.x8bit.bitwarden.data.tools.generator.repository.model.PasscodeGenerationOptions
 import com.x8bit.bitwarden.data.tools.generator.repository.util.FakeGeneratorRepository
 import com.x8bit.bitwarden.ui.platform.base.BaseViewModelTest
@@ -260,6 +261,29 @@ class GeneratorViewModelTest : BaseViewModelTest() {
             assertEquals(expectedState, viewModel.stateFlow.value)
         }
 
+    @Suppress("MaxLineLength")
+    @Test
+    fun `RegenerateClick for random word username state should update the random word username correctly`() =
+        runTest {
+            val viewModel = createViewModel(randomWordSavedStateHandle)
+
+            fakeGeneratorRepository.setMockRandomWordResult(
+                GeneratedRandomWordUsernameResult.Success("DifferentUsername"),
+            )
+
+            viewModel.actionChannel.trySend(GeneratorAction.RegenerateClick)
+
+            val expectedState =
+                initialCatchAllEmailState.copy(
+                    generatedText = "DifferentUsername",
+                    selectedType = GeneratorState.MainType.Username(
+                        GeneratorState.MainType.Username.UsernameType.RandomWord(),
+                    ),
+                )
+
+            assertEquals(expectedState, viewModel.stateFlow.value)
+        }
+
     @Test
     fun `CopyClick should call setText on ClipboardManager`() {
         val viewModel = createViewModel()