test intro ViewModel

Author: pablobaldez

Diff for: features/finances/impl/src/main/kotlin/br/com/mob1st/features/finances/impl/domain/usecases/StartBuilderStepUseCase.kt

@@ -17,7 +17,6 @@ internal class StartBuilderStepUseCase(
     private val categorySuggestionRepository: CategorySuggestionRepository,
     private val categoryFactory: Category.Factory,
 ) {
-
     /**
      * Prefills the categories for the given [step] if it didn't have any.
      * @param step The step to start the builder.

Diff for: features/finances/impl/src/main/kotlin/br/com/mob1st/features/finances/impl/ui/builder/intro/BuilderIntroViewModel.kt

@@ -19,21 +19,21 @@ import kotlinx.coroutines.flow.update
 internal class BuilderIntroViewModel private constructor(
     private val startBuilderStep: StartBuilderStepUseCase,
     private val router: BuilderRouter,
-    private val delegate: ConsumableDelegate<BuilderIntroConsumables>,
+    private val consumableDelegate: ConsumableDelegate<BuilderIntroConsumables>,
 ) : ViewModel(),
     UiStateOutputManager<BuilderIntroUiState>,
-    ConsumableManager<BuilderIntroConsumables> by delegate {
+    ConsumableManager<BuilderIntroConsumables> by consumableDelegate {
     constructor(
         startBuilderStep: StartBuilderStepUseCase,
         router: BuilderRouter,
     ) : this(
         startBuilderStep = startBuilderStep,
         router = router,
-        delegate = ConsumableDelegate(BuilderIntroConsumables()),
+        consumableDelegate = ConsumableDelegate(BuilderIntroConsumables()),
     )
 
     private val isLoadingState = MutableStateFlow(false)
-    private val errorHandler = delegate.errorHandler {
+    private val errorHandler = consumableDelegate.errorHandler {
         handleError(it)
     }
 
@@ -44,9 +44,12 @@ internal class BuilderIntroViewModel private constructor(
     fun start() = launchIn(errorHandler) {
         isLoadingState.value = true
         val step = BudgetBuilder.firstStep()
-        startBuilderStep(step)
-        isLoadingState.value = false
-        delegate.update {
+        try {
+            startBuilderStep(step)
+        } finally {
+            isLoadingState.value = false
+        }
+        consumableDelegate.update {
             it.copy(route = router.send(step))
         }
     }

Diff for: features/finances/impl/src/test/kotlin/br/com/mob1st/features/finances/impl/ui/builder/intro/BuilderIntroViewModelTest.kt

@@ -0,0 +1,111 @@
+package br.com.mob1st.features.finances.impl.ui.builder.intro
+
+import app.cash.turbine.test
+import app.cash.turbine.turbineScope
+import br.com.mob1st.features.finances.impl.domain.entities.BudgetBuilder
+import br.com.mob1st.features.finances.impl.domain.usecases.StartBuilderStepUseCase
+import br.com.mob1st.features.finances.impl.ui.builder.navigation.BuilderRoute
+import br.com.mob1st.features.finances.impl.ui.builder.navigation.BuilderRouter
+import br.com.mob1st.features.utils.errors.CommonError
+import br.com.mob1st.tests.featuresutils.MainDispatcherTestExtension
+import io.kotest.property.Arb
+import io.kotest.property.arbitrary.bind
+import io.kotest.property.arbitrary.next
+import io.mockk.coEvery
+import io.mockk.every
+import io.mockk.mockk
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.test.runTest
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.extension.ExtendWith
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+@ExtendWith(MainDispatcherTestExtension::class)
+internal class BuilderIntroViewModelTest {
+    private lateinit var startBuilderStep: StartBuilderStepUseCase
+    private lateinit var router: BuilderRouter
+
+    @BeforeEach
+    fun setUp() {
+        startBuilderStep = mockk(relaxed = true)
+        router = mockk()
+    }
+
+    @Test
+    fun `WHEN get initial state THEN assert loading is false`() = runTest {
+        val viewModel = initViewModel()
+        turbineScope {
+            val receiveUiState = viewModel.uiStateOutput.testIn(backgroundScope)
+            val receiveConsumables = viewModel.consumableUiState.testIn(backgroundScope)
+            assertEquals(
+                BuilderIntroUiState(false),
+                receiveUiState.awaitItem(),
+            )
+            assertEquals(
+                BuilderIntroConsumables(),
+                receiveConsumables.awaitItem(),
+            )
+        }
+    }
+
+    @Test
+    fun `GIVEN a long step start WHEN start THEN assert loading is displayed`() = runTest {
+        val completedDeferred = CompletableDeferred<Unit>()
+        coEvery { startBuilderStep(any()) } coAnswers {
+            completedDeferred.await()
+        }
+        val viewModel = initViewModel()
+        viewModel.start()
+        viewModel.uiStateOutput.test {
+            val state = awaitItem()
+            assertTrue(state.isLoading)
+        }
+    }
+
+    @Test
+    fun `GIVEN a failure to step start WHEN start THEN assert error is displayed And loading is hidden`() = runTest {
+        coEvery { startBuilderStep(any()) } throws Exception()
+        val viewModel = initViewModel()
+        viewModel.start()
+        turbineScope {
+            val receiveUiState = viewModel.uiStateOutput.testIn(backgroundScope)
+            val receiveConsumables = viewModel.consumableUiState.testIn(backgroundScope)
+            assertEquals(
+                BuilderIntroUiState(false),
+                receiveUiState.awaitItem(),
+            )
+            assertEquals(
+                BuilderIntroConsumables(error = CommonError.Unknown),
+                receiveConsumables.awaitItem(),
+            )
+        }
+    }
+
+    @Test
+    fun `GIVEN a initial action WHEN start THEN assert first step is used And router send it`() = runTest {
+        val step = BudgetBuilder.firstStep()
+        val route = Arb.bind<BuilderRoute>().next()
+        every { router.send(step) } returns route
+        val viewModel = initViewModel()
+        viewModel.start()
+        turbineScope {
+            val receiveUiState = viewModel.uiStateOutput.testIn(backgroundScope)
+            val receiveConsumables = viewModel.consumableUiState.testIn(backgroundScope)
+            assertEquals(
+                BuilderIntroUiState(false),
+                receiveUiState.awaitItem(),
+            )
+            assertEquals(
+                BuilderIntroConsumables(route = route),
+                receiveConsumables.awaitItem(),
+            )
+        }
+    }
+
+    private fun initViewModel() = BuilderIntroViewModel(
+        startBuilderStep = startBuilderStep,
+        router = router,
+    )
+}