Unit Testing Channels & Flows - Droidcon Americas

Mohit Sarveiya Unit Testing Kotlin Channels & Flows @heyitsmohit

Unit Testing Channels & Flows • Testing Flows • Errors
• Delays • Dispatcher Utilities • Common Testing Problems • Testing inside Coroutines Lib

Flow of locations

flowOfLocations: Flow<Location> .filter { it.locationType "== LocationType.RESTAURANT } .map {
it.name }

flowOfLocations: Flow<Location> .filter { ""... } .map { ""... }
.flatmap { ""... }

.flatmap { ""... } How do we test this flow?

Kotlin/kotlinx.coroutines Code ! Issues Pull Requests kotlinx-coroutines-core 2,093 commits 4c28f942
13 hours ago Kotlinx-coroutines-debug Kotlinx-coroutines-test reactive js benchmarks

Kotlin/kotlinx.coroutines Code ! Issues Pull Requests kotlinx-coroutines-core 2,093 commits 4c28f942
13 hours ago Kotlinx-coroutines-debug Kotlinx-coroutines-test reactive js benchmarks Testing Module

Kotlin/kotlinx.coroutines Code ! Issues Pull Requests README.md Module Kotlin-coroutines-test Test
utilities for kotlinx.coroutines dependencies { testImplementation ‘org.jetbrains.kotlinx:kotlinx-coroutines-test:1.4.1' }

@Test fun `should get locations`() { }

@Test fun `should get locations`() = runBlockingTest { } Creates
a coroutine

@Test fun `should get locations`() = runBlockingTest { } Test
Scope

Scope + Test Dispatcher

Scope + Test Dispatcher What is executed in this coroutine?

Scope + Test Dispatcher

.flatmap { ""... }

@Test fun `should get locations`() = runBlockingTest { val flowOfLocations
= mockFlow() val locations: List<Location> = flowOfLocations.toList() } Mockito or create Fake

= mockFlow() val locations: List<Location> = flowOfLocations.toList() }

@Test fun `should get locations`() = runBlockingTest { val locations:
List<Location> = flowOfLocations.toList() }

List<Location> = flowOfLocations.toList() locations shouldContainAll listOf(location1, location2, location3) }

= mockFlow() val locations: List<Location> = flowOfLocations.toList() locations shouldContainAll listOf(location1, location2, location3) }

List<Location> = flowOfLocations.toList() locations shouldContainAll listOf(location1, location2, location3) } How does this work?

fun runBlockingTest(testBody) { val scope = TestCoroutineScope(safeContext) val deferred =
scope.async { scope.testBody() } deferred.getCompletionExceptionOrNull()"?.let { throw it } scope.cleanupTestCoroutines() if (hasActiveJobs()) { throw UncompletedCoroutinesError("Test finished with active jobs: $endingJobs") } } Our test to run

scope.async { scope.testBody() } dispatcher.advanceUntilIdle() deferred.getCompletionExceptionOrNull()"?.let { throw it } scope.cleanupTestCoroutines() if (activeJobs()).isNotEmpty()) { throw UncompletedCoroutinesError("Test finished with active jobs") } } Setup

scope.async { scope.testBody() } dispatcher.advanceUntilIdle() deferred.getCompletionExceptionOrNull()"?.let { throw it } scope.cleanupTestCoroutines() if (activeJobs()).isNotEmpty()) { throw UncompletedCoroutinesError("Test finished with active jobs") } } Setup Run Test

scope.async { scope.testBody() } dispatcher.advanceUntilIdle() deferred.getCompletionExceptionOrNull()"?.let { throw it } scope.cleanupTestCoroutines() if (activeJobs()).isNotEmpty()) { throw UncompletedCoroutinesError("Test finished with active jobs") } } Setup Run Test Cleanup

= mockFlow() val locations: List<Location> = flowOfLocations.toList() locations shouldContainAll listOf(location1, location2, location3) }

= mockFlow() val locations: List<Location> = flowOfLocations.toList() locations shouldContainAll listOf(location1, location2, location3) } Better way to collect from Flows?

cashApp/turbine Code ! Issues Pull Requests Turbine Small testing library
for kotlinx.coroutines Flow. testImplementation 'app.cash.turbine:turbine:0.2.1'

Flow to test How Turbine Works

Channel (Unlimited) How Turbine Works

Channel Send Receive

Channel Types • Unlimited • Buffered • Rendezvous • Broadcast
Channel [Obsolete]

How Turbine Works Channel (Unlimited) Event

sealed class Event<out T> { object Complete data class Error(""...)
data class Item(val value: T) } How Turbine Works Channel (Unlimited) Event

data class Item(val value: T): Event() How Turbine Works Channel
(Unlimited)

object Complete: Event() How Turbine Works Channel (Unlimited)

Exception data class Error(""...): Event() How Turbine Works Channel (Unlimited)

object Complete: Event() How Turbine Works Channel (Unlimited) How do
I query items in channels?

interface FlowTurbine<T> { val timeout: Duration fun expectNoEvents() suspend fun
expectItem(): T fun expectError(): Throwable suspend fun expectComplete() } API to query Channel How Turbine Works

expectItem(): T fun expectError(): Throwable suspend fun expectComplete() } Verify duration of emission How Turbine Works

expectItem(): T fun expectError(): Throwable suspend fun expectComplete() } Verify no emissions How Turbine Works

expectItem(): T fun expectError(): Throwable suspend fun expectComplete() } Verify item emitted How Turbine Works

expectItem(): T fun expectError(): Throwable suspend fun expectComplete() } Verify error occurred How Turbine Works

expectItem(): T fun expectError(): Throwable suspend fun expectComplete() } Verify all items emitted How Turbine Works

expectItem(): T fun expectError(): Throwable suspend fun expectComplete() } How Turbine Works

How Turbine Works suspend fun <T> Flow<T>.test(""...) { coroutineScope {
} Create a coroutine

val events = Channel<Event<T">>(UNLIMITED) } Channel of events

val events = Channel<Event<T">>(UNLIMITED) launch { } }

val events = Channel<Event<T">>(UNLIMITED) launch { collect { item "-> events.send(Event.Item(item)) } } Store emissions

How Turbine Works suspend fun <T> Flow<T>.test( validate: suspend FlowTurbine<T>.()
"-> Unit ) { coroutineScope { val events = Channel<Event<T">>(UNLIMITED) launch { try { collect { ""... } } catch { events.send(Event.Error) API

List<Location> = flowOfLocations.toList() locations shouldContainAll listOf(location1, location2, location3) } How do we use Turbine?

Channel (Unlimited) Testing With Turbine Location Data

Channel (Unlimited) Testing With Turbine Query Channel in test

@Test fun `should get locations`() = runBlockingTest { flowOfLocations.test {
expectItem() shouldBeEqualTo location1 expectItem() shouldBeEqualTo location2 expectItem() shouldBeEqualTo location3 expectComplete() } } Read items into Channel

expectItem() shouldBeEqualTo location1 expectItem() shouldBeEqualTo location2 expectItem() shouldBeEqualTo location3 expectComplete() } } Get first emitted item

expectItem() shouldBeEqualTo location1 expectItem() shouldBeEqualTo location2 expectItem() shouldBeEqualTo location3 expectComplete() } } Assertion

expectItem() shouldBeEqualTo location1 expectItem() shouldBeEqualTo location2 expectItem() shouldBeEqualTo location3 expectComplete() } } Get 1st, 2nd, 3rd item

Channel (Unlimited) Testing With Turbine Verify Flow completed

expectItem() shouldBeEqualTo location1 expectItem() shouldBeEqualTo location2 expectItem() shouldBeEqualTo location3 expectComplete() } } Verify flow completed

expectItem() shouldBeEqualTo location1 expectItem() shouldBeEqualTo location2 expectItem() shouldBeEqualTo location3 expectComplete() } }

Channel (Unlimited) Testing With Turbine Miss verifying emission?

expectItem() shouldBeEqualTo location1 expectItem() shouldBeEqualTo location2 expectComplete() } } Missed varying location 3

expectItem() shouldBeEqualTo location1 expectItem() shouldBeEqualTo location2 expectComplete() } } LocationRepoTest.kt Run: LocationRepoTest.kt should get locations app.cash.turbine.AssertionError: Expected complete but found Item(Location(…))

Channel (Unlimited) Testing With Turbine Miss a Flow completed

expectItem() shouldBeEqualTo location1 expectItem() shouldBeEqualTo location2 expectItem() shouldBeEqualTo location3 } } LocationRepoTests.kt Run: LocationRepoTests should get locations app.cash.turbine.AssertionError: Unconsumed events found: - Complete

expectItem() shouldBeEqualTo location1 expectItem() shouldBeEqualTo location2 expectItem() shouldBeEqualTo location3 expectComplete() } }

.flatMap { ""... } Exception

.flatMap { ""... } .onCompletion { ""... } Complete on error

Exception data class Error(""...): Event() How Turbine Works Channel (Unlimited)

val events = Channel<Event<T">>(UNLIMITED) launch { try { collect { ""... } } catch { events.send(Event.Error(""...)) } } Send error to Channel

@Test fun `should handle exception`() = runBlockingTest { flowOfLocations.test {
expectError() } } Throwable

.flatMap { ""... } Better way to handle Exception?

.flatMap { ""... } .catch { ""... } Catch Exception

.flatMap { ""... } .catch { this: FlowCollector } Allow you to emit from catch

.flatMap { ""... } .catch { throwable "-> } Exception

Code ! Issues Pull Requests Jetbrains/kotlin stdlib/src/kotlin/util/Result.kt inline class Result(val
value: Any?) { val isSuccess: Boolean val isFailure: Boolean }

flowOfLocations: Flow<Result> .filter { ""... } .map { ""... }
.flatMap { ""... } .catch { throwable "-> emit(Result.failure(throwable)) } Emit result

flowOfLocations .filter { ""... } .map { ""... } .flatMap
{ ""... } .catch { ""... } Go to Catch when exception occurs

flowOfLocations .collect { result "-> result.isFailure }

Error stored as item data class Item(throwable): Event() How Turbine
Works Channel (Unlimited)

@Test fun `should handle exception`() = runBlockingTest { flowOfLocations.test {
expectItem().isFailure } } Verify Failure

@Test fun `should handle data updates`() = runBlockingTest { processData()
} suspend fun processData() { delay(1000) calculate() }

} suspend fun processData() { delay(1000) calculate() } How does this work in a test?

scope.async { scope.testBody() } dispatcher.advanceUntilIdle() deferred.getCompletionExceptionOrNull()"?.let { throw it } scope.cleanupTestCoroutines() if (activeJobs()).isNotEmpty()) { throw UncompletedCoroutinesError("Test finished with active jobs") } } Run Test Advance virtual time

} suspend fun processData() { delay(1000) calculate() } Advance virtual time until idle

performAssertions() } suspend fun CoroutineScope.processData() { launch { delay(1000) calculate() } } Creating a new coroutine

performAssertions() } suspend fun CoroutineScope.processData() { launch { delay(1000) calculate() } } How is the delay handled?

performAssertions() } suspend fun CoroutineScope.processData() { launch { delay(1000) calculate() } } SUSPEND

performAssertions() } suspend fun CoroutineScope.processData() { launch { delay(1000) calculate() } } Continue execution

scope.async { scope.testBody() } dispatcher.advanceUntilIdle() deferred.getCompletionExceptionOrNull()"?.let { throw it } scope.cleanupTestCoroutines() if (activeJobs()).isNotEmpty()) { throw UncompletedCoroutinesError("Test finished with active jobs") } } Run Test Advance virtual time

performAssertions() } suspend fun CoroutineScope.processData() { launch { delay(1000) calculate() } } Proceed forward to calculate

performAssertions() } suspend fun CoroutineScope.processData() { launch { delay(1000) calculate() } } How do I control this delay?

interface DelayController { fun advanceTimeBy(delayTimeMillis: Long) fun advanceUntilIdle(): Long fun
pauseDispatcher() fun runCurrent() } Delay Utilities

advanceTimeBy(1000) performAssertions() } suspend fun CoroutineScope.processData() { launch { delay(1000) calculate() } } Advance virtual time

advanceTimeBy(1000) performAssertions() } suspend fun CoroutineScope.processData() { launch { delay(1000) calculate() } } Perform calculation

advanceTimeBy(1000) performAssertions() } suspend fun CoroutineScope.processData() { launch { delay(1000) calculate() } } Perform assertions

.flatmap { ""... } Exception

.flatmap { ""... } Retry?

.flatmap { ""... } .retry { delay(2000) ""... } Retry extension

.flatmap { ""... } .retry(1) { delay(2000) ""... } # of retries

.flatmap { ""... } .retry(1) { delay(2000) ""... } Delay before retrying

.flatmap { ""... } .retry(1) { delay(2000) ""... } Retry flow operators

.flatmap { ""... } .retry(1) { delay(2000) ""... } .flowOn(dispatcher) Flow on Dispatcher Run on Dispatcher

.flatmap { ""... } .retry(1) { delay(2000) ""... } .flowOn(dispatcher) How do you test this?

@Test fun `should retry twice`() = runBlockingTest { }

val testCoroutineDispatcher = TestCoroutineDispatcher() @Test fun `should retry twice`() =
runBlockingTest { }

.flatmap { ""... } .retry(1) { delay(2000) ""... } .flowOn(testCoroutineDispatcher) Run on test dispatcher

val testCoroutineDispatcher = TestCoroutineDispatcher() @Test fun `should retry twice`() =
testCoroutineDispatcher.runBlockingTest { } Use dispatcher in test

fun TestCoroutineDispatcher.runBlockingTest( block: suspend TestCoroutineScope.() "-> Unit ) = runBlockingTest(this,
block) Extension on dispatcher

@Test fun `should retry twice`() = testCoroutineDispatcher.runBlockingTest { } flowOfLocations.test
{ } Start Collecting from Flow

.flatmap { ""... } .retry(1) { delay(2000) ""... } .flowOn(dispatcher) Call operators

.flatmap { ""... } .retry(1) { delay(2000) ""... } .flowOn(dispatcher) Exception

.flatmap { ""... } .retry(1) { delay(2000) ""... } .flowOn(dispatcher) Delay

{ advanceTimeBy(2000) "// perform assertions } Advance virtual time

.flatmap { ""... } .retry(1) { delay(2000) ""... } .flowOn(dispatcher) Retry Flow

{ advanceTimeBy(2000) "// perform assertions } Perform assertion

View View Model State

class MyViewModel(): ViewModel() { } Jetpack View Model

val ViewModel.viewModelScope: CoroutineScope get() { return setTagIfAbsent(JOB_KEY, CloseableCoroutineScope( SupervisorJob() +
Dispatchers.Main.immediate) ) } Main Dispatcher

class MyViewModel(): ViewModel() { val states = MutableStateFlow(State()) } State
Flow

class MyViewModel(): ViewModel() { val states = MutableStateFlow(State()) fun updateState()
{ flowOfData .map { mapToState(data) } .onEach { state "-> states.value = state } .launchIn(viewModelScope) } }

{ flowOfData .map { mapToState(data) } .collect { state "-> states.value = state } "// logic after collect will run after it finishes } } Suspending

{ flowOfData .map { mapToState(data) } .onEach { state "-> states.value = state } .launchIn(viewModelScope) } } How do we test this flow?

@Test fun `should get data`() = runBlockingTest { mockDataFlow() viewModel.updateState()
viewModel.states.test { expectItem().data shouldBe state } }

@Test fun `should get data`() = runBlockingTest { mockDataFlow() viewModel.updateState()
viewModel.states.test { expectItem().data shouldBe state } } ViewModelTest.kt Run: ViewModelTest should get data Module with the Main dispatcher had failed to initialize. For tests Dispatchers.setMain from kotlinx-coroutines-test module can be used

val ViewModel.viewModelScope: CoroutineScope get() { return setTagIfAbsent(JOB_KEY, CloseableCoroutineScope( SupervisorJob() +
Dispatchers.Main.immediate) ) } Main Dispatcher

val dispatcher = TestCoroutineDispatcher() @Before fun setUp() { Dispatchers.setMain(dispatcher) }
@After fun tearDown() { Dispatchers.resetMain() } Set Main Dispatcher

val dispatcher = TestCoroutineDispatcher() @Before fun setUp() { Dispatchers.setMain(dispatcher) }
@After fun tearDown() { Dispatchers.resetMain() } Reset Main Dispatcher

class CoroutineTestRule(testDispatcher) : TestWatcher() { override fun starting(description) { Dispatchers.setMain(testDispatcher)
} override fun finished(description) { Dispatchers.resetMain() testDispatcher.cleanupTestCoroutines() } }

@get:Rule val testRule = CoroutineTestRule() @Test fun `should get data`()
= runBlockingTest { mockDataFlow() viewModel.updateState() viewModel.states.test { expectItem().data shouldBe state } }

@get:Rule val testRule = CoroutineTestRule() @Test fun `should get data`()
= runBlockingTest { mockDataFlow() viewModel.updateState() viewModel.states.test { expectItem().data shouldBe state } } ViewModelTest.kt Run: ViewModelTest should get data

scope.async { scope.testBody() } dispatcher.advanceUntilIdle() deferred.getCompletionExceptionOrNull()"?.let { throw it } scope.cleanupTestCoroutines() if (activeJobs()).isNotEmpty()) { throw UncompletedCoroutinesError("Test finished with active jobs") } } Cleanup Job is Active

Active Job Causes • Coroutine is Suspended • Channel usage
• Delays

val channel = Channel<Event>() Active Jobs Rendezvous Channel

val channel = Channel<Event>() Active Jobs Send Receive

val channel = Channel<Event>() Active Jobs fun CoroutineScope.channelSend() { launch
{ channel.send(Event()) } ""... } Send events

val channel = Channel<Event>() Active Jobs suspend fun processEvents() {
channel.consumeAsFlow().collect { event "-> ""... } } Process event

Active Jobs @Test fun `should process event`() = runBlockingTest {
sendEvent() } Coroutine

sendEvent() } channel.send(LocationEvent()) Coroutine

sendEvent() } channel.send(LocationEvent()) Coroutine Rendezvous Channel

sendEvent() } channel.send(LocationEvent()) Coroutine SUSPENDED

sendEvent() } Tests.kt Run: Tests should process event Test finished with active jobs: ["Coroutine#2":StandaloneCoroutine{Active}]

sendEvent() processEvents() }

Delay Active Jobs @Test fun `should process event`() = runBlockingTest
{ sendEvent() } suspend fun CoroutineScope.sendEvent() { launch(testCoroutineDispatcher) { delay(1000) ""... } } Delay

@Test fun `should process event`() = runBlockingTest { sendEvent() }
suspend fun CoroutineScope.sendEvent() { launch(testCoroutineDispatcher) { delay(1000) ""... } } Delay Active Jobs Tests.kt Run: Tests should process event Test finished with active jobs: ["Coroutine#2":StandaloneCoroutine{Active}]

Delay Active Jobs @Test fun `should process event`() = runBlockingTest
{ sendEvent() testCoroutineDispatcher.advanceTimeBy(1000) } suspend fun CoroutineScope.sendEvent() { launch(testCoroutineDispatcher) { delay(1000) ""... } } Advance virtual time

Testing inside Coroutines Lib • Learn Coroutines from tests inside
lib • Multiplatform testing - JS, JVM and Native

@Test fun testCancelJobImpl() = runTest { val parent = launch
{ expect(1) val child = Job(coroutineContext[Job]) expect(2) child.cancel() child.join() expect(3) } parent.join() finish(4) }

class JobBasicCancellationTest : TestBase() { @Test fun testCancelJobImpl() { }
} Defines utilities

class JobBasicCancellationTest : TestBase() { @Test fun testCancelJobImpl() { }
} Test parent job is not cancelled

{ expect(1) val child = Job(coroutineContext[Job]) expect(2) child.cancel() child.join() expect(3) } parent.join() finish(4) } Launch coroutine

{ expect(1) val child = Job(coroutineContext[Job]) expect(2) child.cancel() child.join() expect(3) } parent.join() finish(4) } Child coroutine Job

{ expect(1) val child = Job(coroutineContext[Job]) expect(2) child.cancel() child.join() expect(3) } parent.join() finish(4) } Cancel the job

{ expect(1) val child = Job(coroutineContext[Job]) expect(2) child.cancel() child.join() expect(3) } parent.join() finish(4) } Verify order of execution Verify completion

expect open class TestBase { fun error(message, cause) fun expect(index:
Int) fun finish(index: Int) fun runTest( block: suspend CoroutineScope.() "-> Unit ) }

JVM JS Native Common TestBase.kt TestBase.kt TestBase.kt TestBase.kt

actual fun runTest( block: suspend CoroutineScope.() "-> Unit ) {
runBlocking( block = block, context = CoroutineExceptionHandler { ""... }) }

Int) fun finish(index: Int) fun runTest( block: suspend CoroutineScope.() "-> Unit ) } How does this work?

private var actionIndex = AtomicInteger() actual fun expect(index: Int) {
val wasIndex = actionIndex.incrementAndGet() check(index "== wasIndex) { “Expecting action index $index but it is actually $wasIndex" } }

Int) fun finish(index: Int) fun runTest( block: suspend CoroutineScope.() "-> Unit ) } How does this work?

private var finished = AtomicBoolean() actual fun finish(index: Int) {
expect(index) check(!finished.getAndSet(true)) { "Should call 'finish(""...)' at most once" } }

https:"//codingwithmohit.com/coroutines/unit-testing-delays-errors-retries-with-kotlin-flows/ Unit Testing

https:"//codingwithmohit.com/coroutines/kotlin-coroutine-lib-testing/ Unit Testing

Resources • Unit Testing Delays, Errors & Retries with Kotlin
Flows https:"//codingwithmohit.com/coroutines/unit-testing-delays- errors-retries-with-kotlin-flows/ • Multiplatform Testing pattern inside Coroutine Lib https:"//codingwithmohit.com/coroutines/kotlin-coroutine-lib-testing/

Thank You! @heyitsmohit www.codingwithmohit.com

Unit Testing Channels & Flows - Droidcon Americas

Unit Testing Channels & Flows - Droidcon Americas

More Decks by Mohit S

Other Decks in Technology

Featured

Transcript