Unit Testing the CalculatorStoreFactory (from the website tutorial)... ???

[michaelr-tradesy]

Hi...

My apologies in advance for submitting a new issue. I felt that this is the best way to contact you and collaboratively provide insight on approaching the topic at hand...

After following the instructions and information provided on this website in order to build the calculator mobile app, I now want to write unit tests against the CalculatorStoreFactory, in order to confirm that for each Event dispatched, that the desired Result / Model is eventually returned.

Currently, I am only able to write unit tests in order to validate the initial Result / Model.

Do you have any suggestions on approaches in order to achieve this?

[arkivanov]

Converted to discussion.

[michaelr-tradesy]

Thanks, and my apologies for posting this to the wrong section. The very fast response made me nervous.

[arkivanov]

Hello and thanks for the question. Are you using Reaktive or coroutines? Could you please provide the complete code of the CalculatorStore which you are testing?

[arkivanov]

Thanks. One more question, are you writing Android only or multiplatform?

[michaelr-tradesy]

Currently, I'm only targeting the Android platform.

[arkivanov]

Thanks! You should supply main and calculation context to the store as follows:

@ExperimentalStateKeeperApi
internal class CalculatorStoreFactory(
    private val storeFactory: StoreFactory,
    private val mainContext: CoroutineContext = Dispatchers.Main,
    private val calculationContext: CoroutineContext = Dispatchers.Default
) {

    // Omitted code

    private inner class BootstrapperImpl : SuspendBootstrapper<Action>(mainContext = mainContext) {
        override suspend fun bootstrap() {
            val sum = withContext(calculationContext) { (1L..1000000.toLong()).sum() }
            dispatch(Action.SetValue(sum))
        }
    }

    private inner class ExecutorImpl : SuspendExecutor<Intent, Action, State, Result, Label>(mainContext = mainContext) {
        // Omitted code

        private suspend fun sum(n: Int) {
            val sum = withContext(calculationContext) { (1L..n.toLong()).sum() }
            dispatch(Result.Value(sum))
        }
    }

    // Omitted code
}

And here is the test:

class CalculatorStoreTest {

    @BeforeTest
    fun before() {
        isAssertOnMainThreadEnabled = false
    }

    @AfterTest
    fun after() {
        isAssertOnMainThreadEnabled = true
    }

    @Test
    fun WHEN_created_THEN_initial_value_calculated() {
        val store = store()

        assertEquals(INITIAL_VALUE, store.state.value)
    }

    @Test
    fun WHEN_Intent_increment_THEN_value_incremented_by_one() {
        val store = store()

        store.accept(Intent.Increment)

        assertEquals(INITIAL_VALUE + 1, store.state.value)
    }

    @Test
    fun WHEN_Intent_decrement_THEN_value_decremented_by_one() {
        val store = store()

        store.accept(Intent.Decrement)

        assertEquals(INITIAL_VALUE - 1, store.state.value)
    }

    @Test
    fun WHEN_Intent_sum_5_THEN_value_is_15() {
        val store = store()

        store.accept(Intent.Sum(n = 5))

        assertEquals(15, store.state.value)
    }

    private fun store(): CalculatorStore =
        CalculatorStoreFactory(
            storeFactory = DefaultStoreFactory,
            mainContext = Dispatchers.Unconfined,
            calculationContext = Dispatchers.Unconfined
        ).create(
            stateKeeper = null
        )

    private companion object {
        private const val INITIAL_VALUE = 500000500000
    }
}

[arkivanov]

Since you are using only Android, you can use TestCoroutineDispatcher instead of Unconfined. It will allow you to control the execution by manually triggering the dispatcher. E.g. you will be able to verify that the value is 0 right after creation, and then trigger the dispatcher and verify that the value is calculated. But it is only available for JVM now, so can't be used to test multiplatform code.

[michaelr-tradesy]

Wow! That's fast...

That was all I needed to do. I didn't have to mock anything. That's crazy! You probably don't want to see the direction I was heading. It was terrible.

I had to add one small statement in order for those unit tests to successfully execute, because my threads weren't being executed. For example (in the most simple example):

@Test
    fun WHEN_Intent_decrement_THEN_value_decremented_by_one() {
        isAssertOnMainThreadEnabled = false
        Dispatchers.setMain(coroutineDispatcher)

        val store = store()

        store.accept(CalculatorStore.Intent.Decrement)

        assertEquals(INITIAL_VALUE - 1, store.state.value)
     
        Dispatchers.resetMain()
        coroutineDispatcher.cleanupTestCoroutines()
        isAssertOnMainThreadEnabled = true
    }

I cannot thank you enough for doing me a great favor! You have given me much needed ammunition to present both projects I have developed using your framework to my team. Thank you again and have a great night!