Testing Android Flows in ViewModel with Turbine | by Tomáš Repčík | June 2023

As it is not uncommon these days, the proper structure ought to comprise decoupled layers. The communication between the layers between them is finished by thread or in our case thread in Android. To make our options excellent, we should always create checks round each part and ViewModel isn’t any exception. The extra channels the ViewModel comprises, the more durable it’s to say its complexity. The states ought to be emitted in a managed method somewhat than chaotically.

The whole lot will likely be executed with out checking the gadget, so there isn’t a want to attach the telephone.

These are the required Android dependencies required within the app construct.gradle to experiment:

The article will comply with a easy ViewModel with a StateFlow (please use a circulate or every other channel), which carries all the data for any view. The ViewModel makes use of an interface to simulate the repository, which works for a very long time in the actual utility.

Since, the plan is to create unit checks – the checks do not care concerning the particular implementation within the repository, as it will likely be mocked. Unit checks will take a look at the logic of the ViewModel, not the repository. It will stop the take a look at instances for the ViewModel from failing, regardless that the checks for the repository might fail. The checks will present you present issues.

The applying receives an occasion, launches the job, and goes by a collection of occasions. Sealed states are used to make the most of the entire checklist of states. All it does is reduce the place for errors and attainable logic issues.

If the state carries some knowledge, use knowledge class , as a result of the take a look at can seamlessly examine the obtained state and the anticipated state. Android Studio will even create a comparability perform for the info layer, if wanted. The category will merely end in an error each time as a result of the hash codes of the 2 completely different variations won’t be the identical.

Preliminary take a look at case

With the ViewModel ready, let’s create our first unit take a look at of checking our default state in StateFlow. ViewModel waits for occasions, so anticipated state is Ready. Right here is the referral code:

There’s lots happening there, so let’s clarify it step-by-step:

1. First, the dependencies required by our ViewModel must be outlined. We now have an interface HeavyComputationTemplatelogic abstraction for the ViewModel. Since it’s an interface, the dependency will be mocked by annotation @Mock And mock() proper from the beginning with none particular implementations or stubs.
2. After initializing the dependencies, the ViewModel will be instantiated utilizing the mannequin. (sut — the system below take a look at — the objective of the take a look at)
3. @Earlier than outline the code to run every time earlier than testing. We would like a brand new occasion of ViewModel.
4. Mock courses are carried out with numerous habits that’s specified through the take a look at run to realize the required habits. To wash them, reset assertion is used to scrub the mock of all stubs.
5. Assert the ViewModel’s StateFlow that it comprises the anticipated state.

Strive operating it as a take a look at and if the inexperienced verify mark seems, the next checks will be carried out.

I wish to create first take a look at for sophistication default setup. It might function proof of excellent class initialization/it simplifies preliminary debugging of dependencies.

Check a StateFlow

Let’s create a take a look at to launch a compute job with an anticipated end in string type that the appliance will obtain as a state.

1. runTest does the verify in its coroutine, more often than not does the identical job as runBlocking . If there are not any modifications, it will likely be ignored delay inside coroutine. This leads to speedy execution of checks with out ready for outcomes. The take a look at is run on a single thread, so any little one coroutine will all the time run on the identical thread if it’s not outlined in any other case.
2. .stub put together faux to count on name on itself. If the simulated enter doesn’t correspond to the enter throughout code execution within the take a look at, an error will likely be thrown. (Do not attempt to repair it by enabling default inputs within the class). The mock technique is suspended, that is why onBlocking used – if there was no droop technique it might be on.
3. circulate.take a look at{} create a lambda the place the stream will likely be examined. On this lambda physique, the take a look at checks the requested habits by calling the suitable strategies and ready for the required states.
4. awaitItem, because it says, waits for the next merchandise from the stream. It might take some time to execute the code and emit new state within the stream. The take a look at ought to examine the contents of the states and whether or not they’re within the right order. awaitItem returns the results of the stream, so be happy to say correctness as wanted.

This code seems right because it progresses from Ready ARRIVE Working comply with Completed standing with consequence and again Ready. Nevertheless, the next error pops up:

The module can’t be initialized with the Most important Dispatcher. To check Dispatcher.setMain from take a look at module kotlinx-coroutines can be utilized java.lang.IllegalStateException: Module with Most important Dispatcher did not initialize. To check, Dispatchers.setMain can be utilized from kotlinx-coroutines-test module

In our code, the appliance refers back to the fundamental thread by calling Dispatchers.Most important. Nevertheless, the unit take a look at doesn’t present any fundamental thread. There is no one. To get round it, the primary thread will be simulated by setting the take a look at dispatcher as the primary dispatcher for the coroutines. It should be referred to as earlier than the take a look at is executed and dealt with after the take a look at is completed as follows:

After including the take a look at dispatcher, the take a look at will run with a inexperienced verify mark.

Check a number of StateFlows

First, the ViewModel should comprise one other StateFlow. Merely put, the ViewModel will personal two similar StateFlows. The roles are run asynchronously on the identical thread. All different features are the identical as earlier than.

Turbine API utilization will change now as a result of the take a look at must course of two threads on the similar time.

The unique format of the take a look at stays the identical. Nevertheless, StateFlow isn’t examined through lambda. Creating lambdas for a number of states will result in chaotic code. Each state that must be examined in a take a look at case can construct a receiver. The receiver must run in some coroutine scope. It’s solved utilizing runTest provides us platform scope to run coroutines checks.

The take a look at can then carry out some motion to name the required features and look ahead to the occasions to return from the ViewModel in a stateful, asserted and in contrast with the required expectations.

DO remember to abort or full the streams on the finish of the take a look at. In any other case the take a look at will dangle/timeout will trigger the take a look at to fail.

With the appropriate simulation technique and the appropriate degree of abstraction, turbine might help you take a look at ViewModels all through. Moreover, it’s a lot simpler to know the code if states signify the actual state, which is remodeled into the person interface. Make the code as verbose as attainable to make your life and the lives of others simpler. Moreover, testing uncovers many issues earlier than they go into manufacturing.

Thanks for studying! Do not forget to clap and comply with for extra content material!