Kotlin Coroutines: Testing and Best Practices
In this article, we’ll explore how to test Kotlin coroutines and discuss best practices for making coroutine testing and debugging easier.
What is Kotlin Playground?
Kotlin Playground is an online editor that allows you to run Kotlin code directly in your browser. It’s a great way to quickly test your ideas without opening Android Studio or another code editor.
Testing Advanced Coroutines
We’ll take a look at how to test normal suspend functions, how to switch/inject test dispatchers, and how to test launch/async, Job/SupervisorJob, and flows.
Testing Normal Suspend Functions
Let’s start by defining a suspend function so that we’ll have something to write our tests against. We can use the assertTrue function provided by kotlin.test to assert that the variable we pass in is true; otherwise, it throws an exception.
Switching/Injecting Test Dispatchers
It’s not good practice to hardcode dispatchers in your code. Whenever possible, you should accept the dispatcher as a parameter in your class. This way, the scope can be injected during testing.
Testing Launch/Async
Launch and async are probably among the most used features in Compose, especially for Android developers. To test them, we can define a simple function that saves some state. We can’t call a suspend function since we don’t have a scope in our Activity or Fragment. But, using coroutines can help us avoid blocking the main thread, which can occur when we save things to the backend.
Testing Job/SupervisorJob
Next, let’s explore how to test Jobs. If you use the GlobalScope, it’s very difficult to test your code because you can’t replace or mock that. Also, since you can’t cancel the GlobalScope, if you use it, you basically lose control over the job. Instead, we’ll define a custom scope for our tests that we can control if needed.
Testing Flows
To test flows, we’ll start by adding a new import. Then, we can create a function called observeData that just returns a flow. In our main method, we can use the assertEquals function to compare the expected value and the actual value.
Strategies to Improve Testing
Now that we have a better understanding of how to test advanced coroutines, let’s look at some strategies to make coroutine testing and debugging easier:
- Naming your CoroutineScope: If you have a lot of coroutine scopes, it might be difficult to debug them because they are all using a naming convention similar to @coroutine#1, @coroutine#2, etc. To make debugging easier, we can add CoroutineName(…) to the CoroutineScope.
- Following Coroutines Best Practices: To make testing easier, follow these coroutines best practices:
- Inject dispatchers into your classes: Avoid hardcoding the dispatcher in your classes. Injecting it simplifies testing by allowing you to replace them.
- Avoid GlobalScope: It makes testing very hard, and that by itself is already a good reason to avoid it. It also makes it more difficult to control the lifecycle of your jobs.
Conclusion
In this article, we explored how to use the Kotlin Playground to test coroutines. We also looked at some coroutines concepts like CoroutineContext and Flow. Finally, we discussed some strategies to make testing easier. Now it’s your turn; the best way to learn something is by practicing. See you next time!