test: add unit tests

Author: hoc081098

app/build.gradle

@@ -33,6 +33,12 @@ android {
     buildFeatures {
         viewBinding true
     }
+    testOptions {
+        unitTests {
+            includeAndroidResources = true
+            returnDefaultValues = true
+        }
+    }
 }
 
 dependencies {
@@ -46,6 +52,8 @@ dependencies {
     implementation 'androidx.lifecycle:lifecycle-runtime-ktx:2.5.1'
     implementation 'androidx.navigation:navigation-fragment-ktx:2.5.3'
     implementation 'androidx.navigation:navigation-ui-ktx:2.5.3'
+
+    testImplementation 'org.jetbrains.kotlinx:kotlinx-coroutines-test:1.6.4'
     testImplementation 'junit:junit:4.13.2'
     androidTestImplementation 'androidx.test.ext:junit:1.1.3'
     androidTestImplementation 'androidx.test.espresso:espresso-core:3.4.0'

app/src/main/java/com/hoc081988/democoroutineschannelresult/MainVM.kt

@@ -1,6 +1,7 @@
 package com.hoc081988.democoroutineschannelresult
 
 import android.util.Log
+import androidx.annotation.VisibleForTesting
 import androidx.lifecycle.ViewModel
 import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.flow.Flow
@@ -45,7 +46,7 @@ class MainVM : ViewModel() {
   private val eventChannels: Map<MainSingleEvent.Key<SomeMainSingleEvent>, Channel<SomeMainSingleEvent>> =
     MainSingleEvent.KEYS.associateBy(
       keySelector = { it },
-      valueTransform = { Channel<MainSingleEvent<SomeMainSingleEvent>>(Channel.UNLIMITED) }
+      valueTransform = { Channel(Channel.UNLIMITED) }
     )
 
   fun <T : MainSingleEvent<T>> sendEvent(event: T) {
@@ -61,7 +62,8 @@ class MainVM : ViewModel() {
       .receiveAsFlow()
       .map { it as T }
 
-  override fun onCleared() {
+  @VisibleForTesting(otherwise = VisibleForTesting.NONE)
+  public override fun onCleared() {
     super.onCleared()
     eventChannels.values.forEach { it.close() }
   }

app/src/test/java/com/hoc081988/democoroutineschannelresult/ExampleUnitTest.kt

@@ -0,0 +1,72 @@
+package com.hoc081988.democoroutineschannelresult
+
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.merge
+import kotlinx.coroutines.flow.take
+import kotlinx.coroutines.flow.toList
+import kotlinx.coroutines.test.StandardTestDispatcher
+import kotlinx.coroutines.test.resetMain
+import kotlinx.coroutines.test.runTest
+import kotlinx.coroutines.test.setMain
+import org.junit.After
+import org.junit.Assert
+import org.junit.Before
+import org.junit.Test
+
+@ExperimentalCoroutinesApi
+class MainVMTest {
+  private val testDispatcher = StandardTestDispatcher()
+
+  @Before
+  fun setUp() {
+    Dispatchers.setMain(testDispatcher)
+  }
+
+  @After
+  fun tearDown() {
+    Dispatchers.resetMain()
+  }
+
+  @Test
+  fun bufferEvents() = runTest(testDispatcher) {
+    val vm = MainVM()
+
+    val originalEvents = (0..50).map {
+      val text = it.toString()
+
+      when (it % 3) {
+        0 -> MainSingleEvent.HomeFragmentResult(text)
+        1 -> MainSingleEvent.DashboardFragmentResult(text)
+        else -> MainSingleEvent.HomeDetailsResult(text)
+      }
+    }
+    originalEvents.forEach(vm::sendEvent)
+    delay(100)
+
+    val actualEvents = MainSingleEvent.KEYS.map { vm.receiveEventFlow(it) }
+      .merge()
+      .take(originalEvents.size)
+      .toList()
+
+    Assert.assertEquals(
+      originalEvents.sortedBy { it.hashCode() },
+      actualEvents.sortedBy { it.hashCode() }
+    )
+  }
+
+  @Test
+  fun throwsAfterCleared() = runTest(testDispatcher) {
+    val vm = MainVM()
+    vm.onCleared()
+
+    Assert.assertThrows(Exception::class.java) {
+      vm.sendEvent(MainSingleEvent.HomeFragmentResult("1"))
+    }
+
+    vm.receiveEventFlow(MainSingleEvent.HomeFragmentResult)
+      .toList()
+      .let { Assert.assertTrue(it.isEmpty()) }
+  }
+}