BIT-1334: Adding generation for catch all email usernames (#538)

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

@@ -93,6 +93,28 @@ class GeneratorSdkSourceTest {
             }
         }
 
+    @Suppress("MaxLineLength")
+    @Test
+    fun `generateCatchAllEmail should call SDK and return a Result with the generated email`() =
+        runBlocking {
+            val request = UsernameGeneratorRequest.Catchall(
+                type = AppendType.Random,
+                domain = "domain",
+            )
+            val expectedResult = "user@domain"
+
+            coEvery {
+                clientGenerators.username(request)
+            } returns expectedResult
+
+            val result = generatorSdkSource.generateCatchAllEmail(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

@@ -24,6 +24,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.GeneratedCatchAllUsernameResult
 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
@@ -303,6 +304,46 @@ class GeneratorRepositoryTest {
         coVerify { generatorSdkSource.generatePlusAddressedEmail(request) }
     }
 
+    @Suppress("MaxLineLength")
+    @Test
+    fun `generateCatchAllEmail should return Success with generated email when SDK call is successful`() = runTest {
+        val userId = "testUserId"
+        val request = UsernameGeneratorRequest.Catchall(
+            type = AppendType.Random,
+            domain = "domain",
+        )
+        val generatedEmail = "user@domain"
+
+        coEvery { generatorSdkSource.generateCatchAllEmail(request) } returns
+            Result.success(generatedEmail)
+
+        val result = repository.generateCatchAllEmail(request)
+
+        assertEquals(
+            generatedEmail,
+            (result as GeneratedCatchAllUsernameResult.Success).generatedEmailAddress,
+        )
+        coVerify { generatorSdkSource.generateCatchAllEmail(request) }
+    }
+
+    @Suppress("MaxLineLength")
+    @Test
+    fun `generateCatchAllEmail should return InvalidRequest on SDK failure`() = runTest {
+        val request = UsernameGeneratorRequest.Catchall(
+            type = AppendType.Random,
+            domain = "user@domain",
+        )
+        val exception = RuntimeException("An error occurred")
+        coEvery {
+            generatorSdkSource.generateCatchAllEmail(request)
+        } returns Result.failure(exception)
+
+        val result = repository.generateCatchAllEmail(request)
+
+        assertTrue(result is GeneratedCatchAllUsernameResult.InvalidRequest)
+        coVerify { generatorSdkSource.generateCatchAllEmail(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

@@ -6,6 +6,7 @@ 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.GeneratedCatchAllUsernameResult
 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
@@ -36,6 +37,11 @@ class FakeGeneratorRepository : GeneratorRepository {
             generatedEmailAddress = "email+abcd1234@address.com",
         )
 
+    private var generateCatchAllEmailResult: GeneratedCatchAllUsernameResult =
+        GeneratedCatchAllUsernameResult.Success(
+            generatedEmailAddress = "user@domain",
+        )
+
     private var generateForwardedServiceResult: GeneratedForwardedServiceUsernameResult =
         GeneratedForwardedServiceUsernameResult.Success(
             generatedEmailAddress = "updatedUsername",
@@ -63,6 +69,12 @@ class FakeGeneratorRepository : GeneratorRepository {
         return generatePlusAddressedEmailResult
     }
 
+    override suspend fun generateCatchAllEmail(
+        catchAllEmailGeneratorRequest: UsernameGeneratorRequest.Catchall,
+    ): GeneratedCatchAllUsernameResult {
+        return generateCatchAllEmailResult
+    }
+
     override suspend fun generateForwardedServiceUsername(
         forwardedServiceGeneratorRequest: UsernameGeneratorRequest.Forwarded,
     ): GeneratedForwardedServiceUsernameResult {
@@ -122,4 +134,11 @@ class FakeGeneratorRepository : GeneratorRepository {
     fun setMockGenerateForwardedServiceResult(result: GeneratedForwardedServiceUsernameResult) {
         generateForwardedServiceResult = result
     }
+
+    /**
+     * Sets the mock result for the generateCatchAll function.
+     */
+    fun setMockCatchAllResult(result: GeneratedCatchAllUsernameResult) {
+        generateCatchAllEmailResult = result
+    }
 }

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

@@ -7,6 +7,7 @@ import com.x8bit.bitwarden.data.auth.repository.AuthRepository
 import com.x8bit.bitwarden.data.auth.repository.model.UserState
 import com.x8bit.bitwarden.data.platform.manager.clipboard.BitwardenClipboardManager
 import com.x8bit.bitwarden.data.platform.repository.model.Environment
+import com.x8bit.bitwarden.data.tools.generator.repository.model.GeneratedCatchAllUsernameResult
 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
@@ -235,6 +236,30 @@ class GeneratorViewModelTest : BaseViewModelTest() {
             assertEquals(expectedState, viewModel.stateFlow.value)
         }
 
+    @Test
+    fun `RegenerateClick for catch all email state should update the catch all email correctly`() =
+        runTest {
+            val viewModel = createViewModel(catchAllEmailSavedStateHandle)
+
+            fakeGeneratorRepository.setMockCatchAllResult(
+                GeneratedCatchAllUsernameResult.Success("DifferentUsername"),
+            )
+
+            viewModel.actionChannel.trySend(GeneratorAction.RegenerateClick)
+
+            val expectedState =
+                initialCatchAllEmailState.copy(
+                    generatedText = "DifferentUsername",
+                    selectedType = GeneratorState.MainType.Username(
+                        GeneratorState.MainType.Username.UsernameType.CatchAllEmail(
+                            domainName = "defaultDomain",
+                        ),
+                    ),
+                )
+
+            assertEquals(expectedState, viewModel.stateFlow.value)
+        }
+
     @Test
     fun `CopyClick should call setText on ClipboardManager`() {
         val viewModel = createViewModel()