Unit testing viewModel that uses StateFlow and Coroutines

Question

Kotlin 1.4.21

I have a very simple ViewModel that uses coroutine and stateFlow. However, the unit test will fail as the stateFlow doesn't seem to get updated.

I think its because the test will finish before the stateFlow is updated.

expected not to be empty

This is my ViewModel under test

class TrendingSearchViewModel @Inject constructor(
    private val loadTrendingSearchUseCase: LoadTrendingSearchUseCase,
    private val coroutineDispatcher: CoroutineDispatcherProvider
) : ViewModel() {

    private val trendingSearchMutableStateFlow = MutableStateFlow<List<String>>(emptyList())
    val trendingSearchStateFlow = trendingSearchMutableStateFlow.asStateFlow()

    fun getTrendingSearch() {
        viewModelScope.launch(coroutineDispatcher.io()) {
            try {
                trendingSearchMutableStateFlow.value = loadTrendingSearchUseCase.execute()
            } catch (exception: Exception) {
                Timber.e(exception, "trending ${exception.localizedMessage}")
            }
        }
    }
}

This is my actual test class, I have tried different things to get it to work

class TrendingSearchViewModelTest {
    private val loadTrendingSearchUseCase: LoadTrendingSearchUseCase = mock()
    private val coroutineDispatcherProvider = CoroutineDispatcherProviderImp()
    private lateinit var trendingSearchViewModel: TrendingSearchViewModel

    @Before
    fun setUp() {
        trendingSearchViewModel = TrendingSearchViewModel(
            loadTrendingSearchUseCase,
            coroutineDispatcherProvider
        )
    }

    @Test
    fun `should get trending search suggestions`() {
        runBlocking {
            // Arrange
            val trending1 = UUID.randomUUID().toString()
            val trending2 = UUID.randomUUID().toString()
            val trending3 = UUID.randomUUID().toString()

            whenever(loadTrendingSearchUseCase.execute()).thenReturn(listOf(trending1, trending2, trending3))

            val job = launch {
                trendingSearchViewModel.trendingSearchStateFlow.value
            }

            // Act
            trendingSearchViewModel.getTrendingSearch()

            // Assert
            val result = trendingSearchViewModel.trendingSearchStateFlow.value
            assertThat(result).isNotEmpty()

            job.cancel()
        }
    }
}

This is the usecase I am mocking in the test:

class LoadTrendingSearchUseCaseImp @Inject constructor(
    private val searchCriteriaProvider: SearchCriteriaProvider,
    private val coroutineDispatcherProvider: CoroutineDispatcherProvider
) : LoadTrendingSearchUseCase {

    override suspend fun execute(): List<String> {
        return withContext(coroutineDispatcherProvider.io()) {
            searchCriteriaProvider.provideTrendingSearch().trendingSearches
        }
    }
}

Just in case its needed this is my interface:

interface CoroutineDispatcherProvider {
    fun io(): CoroutineDispatcher = Dispatchers.IO
    fun default(): CoroutineDispatcher = Dispatchers.Default
    fun main(): CoroutineDispatcher = Dispatchers.Main
    fun immediate(): CoroutineDispatcher = Dispatchers.Main.immediate
    fun unconfined(): CoroutineDispatcher = Dispatchers.Unconfined
}

class CoroutineDispatcherProviderImp @Inject constructor() : CoroutineDispatcherProvider

Hey, have a look here stackoverflow.com/a/72854091/5040556

Daniele
– Daniele

2022-07-04 08:55:55 +00:00
Commented Jul 4, 2022 at 8:55 — Daniele
– Daniele, Commented Jul 4, 2022 at 8:55

Antimonit · Accepted Answer · 2023-10-08 06:16:33Z

1

I think this library https://github.com/cashapp/turbine by Jake Wharton will be of great help in the future when you need more complex scenarios.

What I think is happening is that in fragment you are calling .collect { } and that is ensuring the flow is started. Check the Terminal operator definition: Terminal operators on flows are suspending functions that start a collection of the flow. https://kotlinlang.org/docs/flow.html#terminal-flow-operators

This is not true for sharedFlow, which might be configured to be started eagerly.

So to solve your issue, you might just call

val job = launch {
    trendingSearchViewModel.trendingSearchStateFlow.collect()
}

edited Oct 8, 2023 at 6:16

Antimonit

3,27929 silver badges37 bronze badges

answered Mar 9, 2022 at 8:42

Simon Harvan

7016 silver badges21 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

ant2009 · Accepted Answer · 2022-03-09 15:54:10Z

0

This is what worked for me:

@Test
fun `should get trending search suggestions`() {
    runBlockingTest {
        // Arrange
        val trending1 = UUID.randomUUID().toString()
        val trending2 = UUID.randomUUID().toString()
        val trending3 = UUID.randomUUID().toString()
        val listOfTrending = listOf(trending1, trending2, trending3)

        whenever(loadTrendingSearchUseCase.execute()).thenReturn(listOfTrending)

        /* List to collect the results */
        val listOfEmittedResult = mutableListOf<List<String>>()
        val job = launch {
            trendingSearchViewModel.trendingSearchStateFlow.toList(listOfEmittedResult)
        }

        // Act
        trendingSearchViewModel.getTrendingSearch()

        // Assert
        assertThat(listOfEmittedResult).isNotEmpty()
        verify(loadTrendingSearchUseCase).execute()

        job.cancel()
    }
}

answered Mar 9, 2022 at 15:54

ant2009

22.7k168 gold badges440 silver badges652 bronze badges

1 Comment

Karan_Rana Over a year ago

What if I used a StateFlow in the ViewModel which is created using a StateIn operator? which means there is no other operation on the flow inside the view model but rather it is just a downward stream of data from the repo to the compose screen.

Collectives™ on Stack Overflow

Unit testing viewModel that uses StateFlow and Coroutines

2 Answers 2

Comments

1 Comment

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

1 Comment

Your Answer

Sign up or log in

Post as a guest

Linked

Related