WIP: Upgrade coroutines to 1.6.1

Author: steve-the-edwards

gradle/libs.versions.toml

@@ -49,7 +49,7 @@ kotest = "5.1.0"
 kotlin = "1.6.10"
 
 kotlinx-binary-compatibility = "0.6.0"
-kotlinx-coroutines = "1.5.1"
+kotlinx-coroutines = "1.6.1"
 # The 1.5.1 test artifact is jvm-only. The commonTest module should use 1.6.1.
 kotlinx-coroutines-test-common = "1.6.1"
 kotlinx-serialization-json = "1.3.2"

workflow-testing/src/test/java/com/squareup/workflow1/WorkerTest.kt

@@ -3,14 +3,16 @@
 package com.squareup.workflow1
 
 import com.squareup.workflow1.testing.test
+import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.flow.flowOn
-import kotlinx.coroutines.test.TestCoroutineDispatcher
+import kotlinx.coroutines.test.StandardTestDispatcher
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertNotSame
 import kotlin.test.assertTrue
 
 /** Worker tests that use the [Worker.test] function. Core tests are in the core module. */
+@OptIn(ExperimentalCoroutinesApi::class)
 internal class WorkerTest {
 
   private class ExpectedException : RuntimeException()
@@ -119,7 +121,7 @@ internal class WorkerTest {
   }
 
   @Test fun `timer emits and finishes after delay`() {
-    val testDispatcher = TestCoroutineDispatcher()
+    val testDispatcher = StandardTestDispatcher()
     val worker = Worker.timer(1000)
       // Run the timer on the test dispatcher so we can control time.
       .transform { it.flowOn(testDispatcher) }
@@ -128,11 +130,13 @@ internal class WorkerTest {
       assertNoOutput()
       assertNotFinished()
 
-      testDispatcher.advanceTimeBy(999)
+      testDispatcher.scheduler.advanceTimeBy(999)
+      testDispatcher.scheduler.runCurrent()
       assertNoOutput()
       assertNotFinished()
 
-      testDispatcher.advanceTimeBy(1)
+      testDispatcher.scheduler.advanceTimeBy(1)
+      testDispatcher.scheduler.runCurrent()
       assertEquals(Unit, nextOutput())
       assertFinished()
     }

workflow-testing/src/test/java/com/squareup/workflow1/testing/RenderIdempotencyCheckerTest.kt

@@ -8,9 +8,8 @@ import com.squareup.workflow1.stateless
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers.Unconfined
 import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.Job
 import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.test.TestCoroutineScope
+import kotlinx.coroutines.test.TestScope
 import kotlin.test.Test
 import kotlin.test.assertEquals
 
@@ -26,8 +25,7 @@ class RenderIdempotencyCheckerTest {
       rootRenders++
       renderChild(leafWorkflow)
     }
-    val scope = TestCoroutineScope(Job())
-      .apply { pauseDispatcher() }
+    val scope = TestScope()
 
     renderWorkflowIn(
       rootWorkflow, scope, MutableStateFlow(Unit), interceptors = listOf(RenderIdempotencyChecker)

workflow-ui/compose/src/androidTest/java/com/squareup/workflow1/ui/compose/RenderAsStateTest.kt

@@ -33,7 +33,10 @@ import kotlinx.coroutines.Job
 import kotlinx.coroutines.awaitCancellation
 import kotlinx.coroutines.isActive
 import kotlinx.coroutines.job
-import kotlinx.coroutines.test.TestCoroutineScope
+import kotlinx.coroutines.test.TestScope
+import kotlinx.coroutines.test.UnconfinedTestDispatcher
+import kotlinx.coroutines.test.advanceUntilIdle
+import kotlinx.coroutines.test.runTest
 import okio.ByteString
 import okio.ByteString.Companion.decodeBase64
 import org.junit.Rule
@@ -236,21 +239,15 @@ internal class RenderAsStateTest {
 
   @Test fun renderingIsAvailableImmediatelyWhenWorkflowScopeUsesDifferentDispatcher() {
     val workflow = Workflow.rendering("hello")
-    val scope = TestCoroutineScope()
+    val scope = TestScope()
 
-    // Ensure the workflow runtime won't actually run aside from the synchronous first pass.
-    scope.pauseDispatcher()
-
-    try {
-      composeRule.setContent {
-        val initialRendering = workflow.renderAsState(
-          props = Unit, onOutput = {},
-          scope = scope
-        )
-        assertThat(initialRendering.value).isNotNull()
-      }
-    } finally {
-      scope.cleanupTestCoroutines()
+    composeRule.setContent {
+      val initialRendering = workflow.renderAsState(
+        props = Unit,
+        onOutput = {},
+        scope = scope
+      )
+      assertThat(initialRendering.value).isNotNull()
     }
   }
 
@@ -262,11 +259,11 @@ internal class RenderAsStateTest {
         awaitCancellation()
       }
     }
-    val scope = TestCoroutineScope()
+    val scope = TestScope(UnconfinedTestDispatcher())
 
     class CancelCompositionException : RuntimeException()
 
-    try {
+    scope.runTest {
       assertFailsWith<CancelCompositionException> {
         composeRule.setContent {
           workflow.renderAsState(props = Unit, onOutput = {}, scope = scope)
@@ -275,22 +272,18 @@ internal class RenderAsStateTest {
       }
 
       composeRule.runOnIdle {
-        scope.advanceUntilIdle()
-
         assertThat(innerJob).isNotNull()
         assertThat(innerJob!!.isCancelled).isTrue()
       }
-    } finally {
-      scope.cleanupTestCoroutines()
     }
   }
 
   @Test fun workflowScopeIsNotCancelledWhenRemovedFromComposition() {
     val workflow = Workflow.stateless<Unit, Nothing, Unit> {}
-    val scope = TestCoroutineScope(Job())
+    val scope = TestScope()
     var shouldRunWorkflow by mutableStateOf(true)
 
-    try {
+    scope.runTest {
       composeRule.setContent {
         if (shouldRunWorkflow) {
           workflow.renderAsState(props = Unit, onOutput = {}, scope = scope)
@@ -307,8 +300,6 @@ internal class RenderAsStateTest {
         scope.advanceUntilIdle()
         assertThat(scope.isActive).isTrue()
       }
-    } finally {
-      scope.cleanupTestCoroutines()
     }
   }
 

workflow-ui/core-android/src/test/java/com/squareup/workflow1/ui/ViewLaunchWhenAttachedTest.kt

@@ -13,8 +13,10 @@ import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.job
 import kotlinx.coroutines.suspendCancellableCoroutine
-import kotlinx.coroutines.test.TestCoroutineDispatcher
+import kotlinx.coroutines.test.StandardTestDispatcher
+import kotlinx.coroutines.test.UnconfinedTestDispatcher
 import kotlinx.coroutines.test.resetMain
+import kotlinx.coroutines.test.runTest
 import kotlinx.coroutines.test.setMain
 import org.junit.After
 import org.junit.Before
@@ -34,26 +36,22 @@ import org.mockito.kotlin.whenever
 @OptIn(ExperimentalCoroutinesApi::class, WorkflowUiExperimentalApi::class)
 internal class ViewLaunchWhenAttachedTest {
 
-  private val dispatcher = TestCoroutineDispatcher()
   private val view = mockView()
   private val onAttachStateChangeListener = argumentCaptor<OnAttachStateChangeListener>()
 
   @Before
   fun setUp() {
-    Dispatchers.setMain(dispatcher)
+    Dispatchers.setMain(StandardTestDispatcher())
   }
 
   @After fun tearDown() {
-    dispatcher.cleanupTestCoroutines()
     Dispatchers.resetMain()
   }
 
-  @Test fun `launchWhenAttached launches synchronously when already attached`() {
+  @Test fun `launchWhenAttached launches synchronously when already attached`() = runTest {
     var innerJob: Job? = null
     var started = false
     mockAttachedToWindow(view, true)
-    // Pause the dispatcher to verify that the coroutine is started synchronously.
-    dispatcher.pauseDispatcher()
 
     // Action: launch a coroutine!
     view.launchWhenAttached {
@@ -74,9 +72,8 @@ internal class ViewLaunchWhenAttachedTest {
     assertThat(innerJob!!.isCancelled).isTrue()
   }
 
-  @Test fun `launchWhenAttached cancels when detached while launching`() {
+  @Test fun `launchWhenAttached cancels when detached while launching`() = runTest {
     mockAttachedToWindow(view, true)
-    dispatcher.pauseDispatcher()
 
     // Action: launch a coroutine!
     view.launchWhenAttached {
@@ -88,7 +85,7 @@ internal class ViewLaunchWhenAttachedTest {
     }
   }
 
-  @Test fun `launchWhenAttached launches when attached later`() {
+  @Test fun `launchWhenAttached launches when attached later`() = runTest {
     var innerJob: Job? = null
     mockAttachedToWindow(view, false)
 
@@ -99,14 +96,14 @@ internal class ViewLaunchWhenAttachedTest {
       }
     }
 
-    dispatcher.advanceUntilIdle()
+    testScheduler.advanceUntilIdle()
     assertThat(innerJob).isNull()
 
     verify(view).setTag(isA(), isA<OnAttachStateChangeListener>())
 
     // Action: attach view!
     performViewAttach()
-    dispatcher.advanceUntilIdle()
+    testScheduler.advanceUntilIdle()
     assertThat(innerJob).isNotNull()
     assertThat(innerJob!!.isActive).isTrue()
 
@@ -115,7 +112,7 @@ internal class ViewLaunchWhenAttachedTest {
     assertThat(innerJob!!.isCancelled).isTrue()
   }
 
-  @Test fun `launchWhenAttached launches when reattached`() {
+  @Test fun `launchWhenAttached launches when reattached`() = runTest {
     var innerJob: Job? = null
     mockAttachedToWindow(view, true)
 
@@ -131,7 +128,7 @@ internal class ViewLaunchWhenAttachedTest {
     }
 
     // The coroutine shouldn't have started since the view is detached.
-    dispatcher.advanceUntilIdle()
+    testScheduler.advanceUntilIdle()
     assertThat(innerJob).isNull()
 
     // Action: re-attach view!
@@ -144,7 +141,7 @@ internal class ViewLaunchWhenAttachedTest {
     assertThat(innerJob!!.isActive).isTrue()
   }
 
-  @Test fun `launchWhenAttached coroutine is child of ViewTreeLifecycleOwner`() {
+  @Test fun `launchWhenAttached coroutine is child of ViewTreeLifecycleOwner`() = runTest {
     var innerJob: Job? = null
     mockAttachedToWindow(view, true)
 
@@ -154,6 +151,7 @@ internal class ViewLaunchWhenAttachedTest {
         innerJob = continuation.context.job
       }
     }
+    testScheduler.advanceUntilIdle()
 
     assertThat(innerJob!!.isActive).isTrue()
 
@@ -164,7 +162,7 @@ internal class ViewLaunchWhenAttachedTest {
     assertThat(innerJob!!.isCancelled).isTrue()
   }
 
-  @Test fun `launchWhenAttached includes view classname in coroutine name`() {
+  @Test fun `launchWhenAttached includes view classname in coroutine name`() = runTest {
     var coroutineName: String? = null
     mockAttachedToWindow(view, true)
 
@@ -178,7 +176,7 @@ internal class ViewLaunchWhenAttachedTest {
     assertThat(coroutineName).contains("${view.hashCode()}")
   }
 
-  @Test fun `launchWhenAttached includes view id name in coroutine name`() {
+  @Test fun `launchWhenAttached includes view id name in coroutine name`() = runTest {
     var coroutineName: String? = null
     mockAttachedToWindow(view, true)
     whenever(view.resources.getResourceEntryName(anyInt())).thenReturn("fnord")
@@ -191,7 +189,7 @@ internal class ViewLaunchWhenAttachedTest {
     assertThat(coroutineName).contains("fnord")
   }
 
-  @Test fun `launchWhenAttached tolerates garbage ids`() {
+  @Test fun `launchWhenAttached tolerates garbage ids`() = runTest {
     var coroutineName: String? = null
     mockAttachedToWindow(view, true)
     whenever(view.resources.getResourceEntryName(anyInt())).thenThrow(NotFoundException())
@@ -224,7 +222,7 @@ internal class ViewLaunchWhenAttachedTest {
     return mock<View>(defaultAnswer = RETURNS_DEEP_STUBS).also {
       mockTags(it)
       mockAttachedToWindow(it)
-      ViewTreeLifecycleOwner.set(it, TestLifecycleOwner(coroutineDispatcher = dispatcher))
+      ViewTreeLifecycleOwner.set(it, TestLifecycleOwner(coroutineDispatcher = UnconfinedTestDispatcher()))
     }
   }