Merge pull request #132 from googlecodelabs/coroutinesTest

Migrates to coroutines-test

Author: JoseAlcerreca

Diff for: .circleci/config.yml

@@ -4,8 +4,8 @@ config_android:
   - image: circleci/android:api-28
   working_directory: ~/project
   environment:
-    JAVA_TOOL_OPTIONS: -Xmx1024m
-    GRADLE_OPTS: -Dorg.gradle.daemon=false -Dorg.gradle.workers.max=2 -Dkotlin.incremental=false
+    JAVA_TOOL_OPTIONS: "-Xmx1024m -XX:+UnlockExperimentalVMOptions -XX:+UseCGroupMemoryLimitForHeap"
+    GRADLE_OPTS: "-Dorg.gradle.daemon=false -Dorg.gradle.workers.max=2 -Djava.util.concurrent.ForkJoinPool.common.parallelism=2 -Dkotlin.incremental=false"
     TERM: dumb
 setup_ftl:
 - run:
@@ -20,8 +20,8 @@ jobs:
     - image: circleci/android:api-28
     working_directory: ~/project
     environment:
-    - JAVA_TOOL_OPTIONS: -Xmx1024m
-    - GRADLE_OPTS: -Dorg.gradle.daemon=false -Dorg.gradle.workers.max=2 -Dkotlin.incremental=false
+    - JAVA_TOOL_OPTIONS: "-Xmx1024m -XX:+UnlockExperimentalVMOptions -XX:+UseCGroupMemoryLimitForHeap"
+    - GRADLE_OPTS: "-Dorg.gradle.daemon=false -Dorg.gradle.workers.max=2 -Djava.util.concurrent.ForkJoinPool.common.parallelism=2 -Dkotlin.incremental=false"
     - TERM: dumb
     steps:
     - checkout

Diff for: app/build.gradle

@@ -134,6 +134,7 @@ dependencies {
     androidTestImplementation "junit:junit:$junitVersion"
     androidTestImplementation "org.mockito:mockito-core:$mockitoVersion"
     androidTestImplementation "com.linkedin.dexmaker:dexmaker-mockito:$dexMakerVersion"
+    androidTestImplementation "org.jetbrains.kotlinx:kotlinx-coroutines-test:$coroutinesVersion"
 
     // AndroidX Test - JVM testing
     testImplementation "androidx.test:core-ktx:$androidXTestCoreVersion"

Diff for: app/src/main/java/com/example/android/architecture/blueprints/todoapp/taskdetail/TaskDetailViewModel.kt

@@ -27,6 +27,7 @@ import com.example.android.architecture.blueprints.todoapp.data.Result
 import com.example.android.architecture.blueprints.todoapp.data.Result.Success
 import com.example.android.architecture.blueprints.todoapp.data.Task
 import com.example.android.architecture.blueprints.todoapp.data.source.TasksRepository
+import com.example.android.architecture.blueprints.todoapp.util.EspressoIdlingResource
 import kotlinx.coroutines.launch
 
 /**
@@ -85,34 +86,39 @@ class TaskDetailViewModel(
         }
     }
 
-
-    fun start(taskId: String?) = viewModelScope.launch {
-        if (taskId != null) {
-            _dataLoading.value = true
-            tasksRepository.getTask(taskId, false).let { result ->
-                if (result is Success) {
-                    onTaskLoaded(result.data)
-                } else {
-                    onDataNotAvailable(result)
+    fun start(taskId: String?) {
+        _dataLoading.value = true
+
+        // Espresso does not work well with coroutines yet. See
+        // https://github.com/Kotlin/kotlinx.coroutines/issues/982
+        EspressoIdlingResource.increment() // Set app as busy.
+
+        viewModelScope.launch {
+            if (taskId != null) {
+                tasksRepository.getTask(taskId, false).let { result ->
+                    if (result is Success) {
+                        onTaskLoaded(result.data)
+                    } else {
+                        onDataNotAvailable(result)
+                    }
                 }
             }
+            _dataLoading.value = false
+            EspressoIdlingResource.decrement() // Set app as idle.
         }
     }
 
-
     private fun setTask(task: Task?) {
         this._task.value = task
         _isDataAvailable.value = task != null
     }
 
     private fun onTaskLoaded(task: Task) {
         setTask(task)
-        _dataLoading.value = false
     }
 
     private fun onDataNotAvailable(result: Result<Task>) {
         _task.value = null
-        _dataLoading.value = false
         _isDataAvailable.value = false
     }
 

Diff for: app/src/test/java/com/example/android/architecture/blueprints/todoapp/CoroutinesTestRule.kt renamed to app/src/sharedTest/java/com/example/android/architecture/blueprints/todoapp/MainCoroutineRule.kt

@@ -19,44 +19,46 @@ package com.example.android.architecture.blueprints.todoapp
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.ObsoleteCoroutinesApi
-import kotlinx.coroutines.asCoroutineDispatcher
-import kotlinx.coroutines.test.TestCoroutineContext
+import kotlinx.coroutines.test.TestCoroutineScope
 import kotlinx.coroutines.test.resetMain
 import kotlinx.coroutines.test.setMain
 import org.junit.rules.TestWatcher
 import org.junit.runner.Description
-import java.util.concurrent.Executors
 import kotlin.coroutines.ContinuationInterceptor
 
 /**
- * Sets the main coroutines dispatcher for unit testing.
+ * Sets the main coroutines dispatcher to a [TestCoroutineScope] for unit testing. A
+ * [TestCoroutineScope] provides control over the execution of coroutines.
  *
- * Uses the deprecated TestCoroutineContext if provided. Otherwise it uses a new single thread
- * executor.
- * See https://medium.com/androiddevelopers/easy-coroutines-in-android-viewmodelscope-25bffb605471
- * and https://github.com/Kotlin/kotlinx.coroutines/issues/541
+ * Declare it as a JUnit Rule:
+ *
+ * ```
+ * @get:Rule
+ * var mainCoroutineRule = MainCoroutineRule()
+ * ```
+ *
+ * Use it directly as a [TestCoroutineScope]:
+ *
+ * ```
+ * mainCoroutineRule.pauseDispatcher()
+ * ...
+ * mainCoroutineRule.resumeDispatcher()
+ * ...
+ * mainCoroutineRule.runBlockingTest { }
+ * ...
+ *
+ * ```
  */
-@ObsoleteCoroutinesApi
 @ExperimentalCoroutinesApi
-class ViewModelScopeMainDispatcherRule(
-    private val testContext: TestCoroutineContext? = null
-) : TestWatcher() {
-
-    private val singleThreadExecutor = Executors.newSingleThreadExecutor()
+class MainCoroutineRule : TestWatcher(), TestCoroutineScope by TestCoroutineScope() {
 
     override fun starting(description: Description?) {
         super.starting(description)
-        if (testContext != null) {
-            Dispatchers.setMain(testContext[ContinuationInterceptor] as CoroutineDispatcher)
-        } else {
-            Dispatchers.setMain(singleThreadExecutor.asCoroutineDispatcher())
-        }
+        Dispatchers.setMain(this.coroutineContext[ContinuationInterceptor] as CoroutineDispatcher)
     }
 
     override fun finished(description: Description?) {
         super.finished(description)
-        singleThreadExecutor.shutdownNow()
         Dispatchers.resetMain()
     }
-}
+}

Diff for: app/src/sharedTest/java/com/example/android/architecture/blueprints/todoapp/addedittask/AddEditTaskFragmentTest.kt

@@ -36,8 +36,8 @@ import com.example.android.architecture.blueprints.todoapp.data.source.FakeRepos
 import com.example.android.architecture.blueprints.todoapp.data.source.TasksRepository
 import com.example.android.architecture.blueprints.todoapp.util.ADD_EDIT_RESULT_OK
 import com.example.android.architecture.blueprints.todoapp.util.getTasksBlocking
-import kotlinx.coroutines.ObsoleteCoroutinesApi
-import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.runBlockingTest
 import org.junit.After
 import org.junit.Assert.assertEquals
 import org.junit.Before
@@ -51,11 +51,11 @@ import org.robolectric.annotation.TextLayoutMode
 /**
  * Integration test for the Add Task screen.
  */
-@ObsoleteCoroutinesApi
 @RunWith(AndroidJUnit4::class)
 @MediumTest
 @LooperMode(LooperMode.Mode.PAUSED)
 @TextLayoutMode(TextLayoutMode.Mode.REALISTIC)
+@ExperimentalCoroutinesApi
 class AddEditTaskFragmentTest {
     private lateinit var repository: TasksRepository
 
@@ -66,7 +66,7 @@ class AddEditTaskFragmentTest {
     }
 
     @After
-    fun cleanupDb() = runBlocking {
+    fun cleanupDb() = runBlockingTest {
         ServiceLocator.resetRepository()
     }
 

Diff for: app/src/sharedTest/java/com/example/android/architecture/blueprints/todoapp/data/source/local/TasksDaoTest.kt

@@ -16,26 +16,40 @@
 
 package com.example.android.architecture.blueprints.todoapp.data.source.local
 
+import androidx.arch.core.executor.testing.InstantTaskExecutorRule
 import androidx.room.Room
 import androidx.test.core.app.ApplicationProvider.getApplicationContext
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import androidx.test.filters.SmallTest
+import com.example.android.architecture.blueprints.todoapp.MainCoroutineRule
 import com.example.android.architecture.blueprints.todoapp.data.Task
-import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.runBlockingTest
 import org.hamcrest.CoreMatchers.`is`
 import org.hamcrest.CoreMatchers.notNullValue
 import org.hamcrest.MatcherAssert.assertThat
 import org.junit.After
 import org.junit.Before
+import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
 
+@ExperimentalCoroutinesApi
 @RunWith(AndroidJUnit4::class)
 @SmallTest
 class TasksDaoTest {
 
     private lateinit var database: ToDoDatabase
 
+    // Set the main coroutines dispatcher for unit testing.
+    @ExperimentalCoroutinesApi
+    @get:Rule
+    var mainCoroutineRule = MainCoroutineRule()
+
+    // Executes each task synchronously using Architecture Components.
+    @get:Rule
+    var instantExecutorRule = InstantTaskExecutorRule()
+
     @Before
     fun initDb() {
         // using an in-memory database because the information stored here disappears when the
@@ -50,7 +64,7 @@ class TasksDaoTest {
     fun closeDb() = database.close()
 
     @Test
-    fun insertTaskAndGetById() = runBlocking {
+    fun insertTaskAndGetById() = runBlockingTest {
         // GIVEN - insert a task
         val task = Task("title", "description")
         database.taskDao().insertTask(task)
@@ -67,7 +81,7 @@ class TasksDaoTest {
     }
 
     @Test
-    fun insertTaskReplacesOnConflict() = runBlocking {
+    fun insertTaskReplacesOnConflict() = runBlockingTest {
         // Given that a task is inserted
         val task = Task("title", "description")
         database.taskDao().insertTask(task)
@@ -85,7 +99,7 @@ class TasksDaoTest {
     }
 
     @Test
-    fun insertTaskAndGetTasks() = runBlocking {
+    fun insertTaskAndGetTasks() = runBlockingTest {
         // GIVEN - insert a task
         val task = Task("title", "description")
         database.taskDao().insertTask(task)
@@ -102,7 +116,7 @@ class TasksDaoTest {
     }
 
     @Test
-    fun updateTaskAndGetById() = runBlocking {
+    fun updateTaskAndGetById() = runBlockingTest {
         // When inserting a task
         val originalTask = Task("title", "description")
         database.taskDao().insertTask(originalTask)
@@ -120,7 +134,7 @@ class TasksDaoTest {
     }
 
     @Test
-    fun updateCompletedAndGetById() = runBlocking {
+    fun updateCompletedAndGetById() = runBlockingTest {
         // When inserting a task
         val task = Task("title", "description", true)
         database.taskDao().insertTask(task)
@@ -137,7 +151,7 @@ class TasksDaoTest {
     }
 
     @Test
-    fun deleteTaskByIdAndGettingTasks() = runBlocking {
+    fun deleteTaskByIdAndGettingTasks() = runBlockingTest {
         // Given a task inserted
         val task = Task("title", "description")
         database.taskDao().insertTask(task)
@@ -151,7 +165,7 @@ class TasksDaoTest {
     }
 
     @Test
-    fun deleteTasksAndGettingTasks() = runBlocking {
+    fun deleteTasksAndGettingTasks() = runBlockingTest {
         // Given a task inserted
         database.taskDao().insertTask(Task("title", "description"))
 
@@ -164,7 +178,7 @@ class TasksDaoTest {
     }
 
     @Test
-    fun deleteCompletedTasksAndGettingTasks() = runBlocking {
+    fun deleteCompletedTasksAndGettingTasks() = runBlockingTest {
         // Given a completed task inserted
         database.taskDao().insertTask(Task("completed", "task", true))