Remove runCancellableScopeTest and runCancellableScopeTestWithTestScope, we can use TestScope.backgroundScope instead.

Author: bmarty

libraries/matrix/impl/src/test/kotlin/io/element/android/libraries/matrix/impl/roomdirectory/RustRoomDirectoryListTest.kt

@@ -13,28 +13,28 @@ import io.element.android.libraries.matrix.api.roomdirectory.RoomDirectoryList
 import io.element.android.libraries.matrix.impl.fixtures.factories.aRustRoomDescription
 import io.element.android.libraries.matrix.impl.fixtures.fakes.FakeRoomDirectorySearch
 import io.element.android.libraries.matrix.test.A_ROOM_ID_2
-import io.element.android.tests.testutils.runCancellableScopeTestWithTestScope
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.test.StandardTestDispatcher
 import kotlinx.coroutines.test.TestScope
 import kotlinx.coroutines.test.runCurrent
+import kotlinx.coroutines.test.runTest
 import org.junit.Test
 import org.matrix.rustcomponents.sdk.RoomDirectorySearch
 import org.matrix.rustcomponents.sdk.RoomDirectorySearchEntryUpdate
 
 @OptIn(ExperimentalCoroutinesApi::class)
 class RustRoomDirectoryListTest {
     @Test
-    fun `check that the state emits the expected values`() = runCancellableScopeTestWithTestScope { testScope, cancellableScope ->
+    fun `check that the state emits the expected values`() = runTest {
         val fakeRoomDirectorySearch = FakeRoomDirectorySearch()
         val mapper = RoomDescriptionMapper()
-        val sut = testScope.createRustRoomDirectoryList(
+        val sut = createRustRoomDirectoryList(
             roomDirectorySearch = fakeRoomDirectorySearch,
-            scope = cancellableScope,
+            scope = backgroundScope,
         )
         // Let the mxCallback be ready
-        testScope.runCurrent()
+        runCurrent()
         sut.state.test {
             sut.filter("", 20)
             fakeRoomDirectorySearch.emitResult(

libraries/matrix/impl/src/test/kotlin/io/element/android/libraries/matrix/impl/roomdirectory/RustRoomDirectoryServiceTest.kt

@@ -8,18 +8,18 @@
 package io.element.android.libraries.matrix.impl.roomdirectory
 
 import io.element.android.libraries.matrix.impl.fixtures.fakes.FakeRustClient
-import io.element.android.tests.testutils.runCancellableScopeTestWithTestScope
 import kotlinx.coroutines.test.StandardTestDispatcher
+import kotlinx.coroutines.test.runTest
 import org.junit.Test
 
 class RustRoomDirectoryServiceTest {
     @Test
-    fun test() = runCancellableScopeTestWithTestScope { testScope, cancellableScope ->
+    fun test() = runTest {
         val client = FakeRustClient()
         val sut = RustRoomDirectoryService(
             client = client,
-            sessionDispatcher = StandardTestDispatcher(testScope.testScheduler),
+            sessionDispatcher = StandardTestDispatcher(testScheduler),
         )
-        sut.createRoomDirectoryList(cancellableScope)
+        sut.createRoomDirectoryList(backgroundScope)
     }
 }

libraries/matrix/impl/src/test/kotlin/io/element/android/libraries/matrix/impl/roomlist/RoomListFactoryTest.kt

@@ -9,16 +9,16 @@ package io.element.android.libraries.matrix.impl.roomlist
 
 import io.element.android.libraries.matrix.impl.fixtures.fakes.FakeRustRoomList
 import io.element.android.libraries.matrix.impl.fixtures.fakes.FakeRustRoomListService
-import io.element.android.tests.testutils.runCancellableScopeTest
+import kotlinx.coroutines.test.runTest
 import org.junit.Test
 import kotlin.coroutines.EmptyCoroutineContext
 
 class RoomListFactoryTest {
     @Test
-    fun `createRoomList should work`() = runCancellableScopeTest {
+    fun `createRoomList should work`() = runTest {
         val sut = RoomListFactory(
             innerRoomListService = FakeRustRoomListService(),
-            sessionCoroutineScope = it,
+            sessionCoroutineScope = backgroundScope,
         )
         sut.createRoomList(
             pageSize = 10,

libraries/matrix/impl/src/test/kotlin/io/element/android/libraries/matrix/impl/roomlist/RustRoomListServiceTest.kt

@@ -11,28 +11,28 @@ import com.google.common.truth.Truth.assertThat
 import io.element.android.libraries.matrix.api.roomlist.RoomListService
 import io.element.android.libraries.matrix.impl.fixtures.fakes.FakeRustRoomListService
 import io.element.android.libraries.matrix.impl.room.RoomSyncSubscriber
-import io.element.android.tests.testutils.runCancellableScopeTestWithTestScope
 import io.element.android.tests.testutils.testCoroutineDispatchers
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.test.StandardTestDispatcher
 import kotlinx.coroutines.test.TestScope
 import kotlinx.coroutines.test.runCurrent
+import kotlinx.coroutines.test.runTest
 import org.junit.Test
 import org.matrix.rustcomponents.sdk.RoomListServiceSyncIndicator
 import org.matrix.rustcomponents.sdk.RoomListService as RustRoomListService
 
 @OptIn(ExperimentalCoroutinesApi::class)
 class RustRoomListServiceTest {
     @Test
-    fun `syncIndicator should emit the expected values`() = runCancellableScopeTestWithTestScope { testScope, cancellableScope ->
+    fun `syncIndicator should emit the expected values`() = runTest {
         val roomListService = FakeRustRoomListService()
-        val sut = testScope.createRustRoomListService(
-            sessionCoroutineScope = cancellableScope,
+        val sut = createRustRoomListService(
+            sessionCoroutineScope = backgroundScope,
             roomListService = roomListService,
         )
         // Give time for mxCallback to setup
-        testScope.runCurrent()
+        runCurrent()
         sut.syncIndicator.test {
             assertThat(awaitItem()).isEqualTo(RoomListService.SyncIndicator.Hide)
             roomListService.emitRoomListServiceSyncIndicator(RoomListServiceSyncIndicator.SHOW)

services/analytics/impl/src/test/kotlin/io/element/android/services/analytics/impl/DefaultAnalyticsServiceTest.kt

@@ -24,7 +24,6 @@ import io.element.android.services.analyticsproviders.api.AnalyticsProvider
 import io.element.android.services.analyticsproviders.test.FakeAnalyticsProvider
 import io.element.android.tests.testutils.lambda.lambdaRecorder
 import io.element.android.tests.testutils.lambda.value
-import io.element.android.tests.testutils.runCancellableScopeTest
 import kotlinx.coroutines.CompletableDeferred
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.ExperimentalCoroutinesApi
@@ -37,31 +36,31 @@ import org.junit.Test
 
 class DefaultAnalyticsServiceTest {
     @Test
-    fun `getAvailableAnalyticsProviders return the set of provider`() = runCancellableScopeTest {
+    fun `getAvailableAnalyticsProviders return the set of provider`() = runTest {
         val providers = setOf(
             FakeAnalyticsProvider(name = "provider1", stopLambda = { }),
             FakeAnalyticsProvider(name = "provider2", stopLambda = { }),
         )
         val sut = createDefaultAnalyticsService(
-            coroutineScope = it,
+            coroutineScope = backgroundScope,
             analyticsProviders = providers
         )
         val result = sut.getAvailableAnalyticsProviders()
         assertThat(result).isEqualTo(providers)
     }
 
     @Test
-    fun `when consent is not provided, capture is no op`() = runCancellableScopeTest {
-        val sut = createDefaultAnalyticsService(it)
+    fun `when consent is not provided, capture is no op`() = runTest {
+        val sut = createDefaultAnalyticsService(backgroundScope)
         sut.capture(anEvent)
     }
 
     @Test
-    fun `when consent is provided, capture is sent to the AnalyticsProvider`() = runCancellableScopeTest {
+    fun `when consent is provided, capture is sent to the AnalyticsProvider`() = runTest {
         val initLambda = lambdaRecorder<Unit> { }
         val captureLambda = lambdaRecorder<VectorAnalyticsEvent, Unit> { _ -> }
         val sut = createDefaultAnalyticsService(
-            coroutineScope = it,
+            coroutineScope = backgroundScope,
             analyticsStore = FakeAnalyticsStore(defaultUserConsent = true),
             analyticsProviders = setOf(
                 FakeAnalyticsProvider(
@@ -76,17 +75,17 @@ class DefaultAnalyticsServiceTest {
     }
 
     @Test
-    fun `when consent is not provided, screen is no op`() = runCancellableScopeTest {
-        val sut = createDefaultAnalyticsService(it)
+    fun `when consent is not provided, screen is no op`() = runTest {
+        val sut = createDefaultAnalyticsService(backgroundScope)
         sut.screen(aScreen)
     }
 
     @Test
-    fun `when consent is provided, screen is sent to the AnalyticsProvider`() = runCancellableScopeTest {
+    fun `when consent is provided, screen is sent to the AnalyticsProvider`() = runTest {
         val initLambda = lambdaRecorder<Unit> { }
         val screenLambda = lambdaRecorder<VectorAnalyticsScreen, Unit> { _ -> }
         val sut = createDefaultAnalyticsService(
-            coroutineScope = it,
+            coroutineScope = backgroundScope,
             analyticsStore = FakeAnalyticsStore(defaultUserConsent = true),
             analyticsProviders = setOf(
                 FakeAnalyticsProvider(
@@ -101,17 +100,17 @@ class DefaultAnalyticsServiceTest {
     }
 
     @Test
-    fun `when consent is not provided, trackError is no op`() = runCancellableScopeTest {
-        val sut = createDefaultAnalyticsService(it)
+    fun `when consent is not provided, trackError is no op`() = runTest {
+        val sut = createDefaultAnalyticsService(backgroundScope)
         sut.trackError(anError)
     }
 
     @Test
-    fun `when consent is provided, trackError is sent to the AnalyticsProvider`() = runCancellableScopeTest {
+    fun `when consent is provided, trackError is sent to the AnalyticsProvider`() = runTest {
         val initLambda = lambdaRecorder<Unit> { }
         val trackErrorLambda = lambdaRecorder<Throwable, Unit> { _ -> }
         val sut = createDefaultAnalyticsService(
-            coroutineScope = it,
+            coroutineScope = backgroundScope,
             analyticsStore = FakeAnalyticsStore(defaultUserConsent = true),
             analyticsProviders = setOf(
                 FakeAnalyticsProvider(
@@ -126,10 +125,10 @@ class DefaultAnalyticsServiceTest {
     }
 
     @Test
-    fun `setUserConsent is sent to the store`() = runCancellableScopeTest {
+    fun `setUserConsent is sent to the store`() = runTest {
         val store = FakeAnalyticsStore()
         val sut = createDefaultAnalyticsService(
-            coroutineScope = it,
+            coroutineScope = backgroundScope,
             analyticsStore = store,
         )
         assertThat(store.userConsentFlow.first()).isFalse()
@@ -140,10 +139,10 @@ class DefaultAnalyticsServiceTest {
     }
 
     @Test
-    fun `setAnalyticsId is sent to the store`() = runCancellableScopeTest {
+    fun `setAnalyticsId is sent to the store`() = runTest {
         val store = FakeAnalyticsStore()
         val sut = createDefaultAnalyticsService(
-            coroutineScope = it,
+            coroutineScope = backgroundScope,
             analyticsStore = store,
         )
         assertThat(store.analyticsIdFlow.first()).isEqualTo("")
@@ -154,10 +153,10 @@ class DefaultAnalyticsServiceTest {
     }
 
     @Test
-    fun `setDidAskUserConsent is sent to the store`() = runCancellableScopeTest {
+    fun `setDidAskUserConsent is sent to the store`() = runTest {
         val store = FakeAnalyticsStore()
         val sut = createDefaultAnalyticsService(
-            coroutineScope = it,
+            coroutineScope = backgroundScope,
             analyticsStore = store,
         )
         assertThat(store.didAskUserConsentFlow.first()).isFalse()
@@ -168,26 +167,26 @@ class DefaultAnalyticsServiceTest {
     }
 
     @Test
-    fun `when a session is deleted, the store is reset`() = runCancellableScopeTest {
+    fun `when a session is deleted, the store is reset`() = runTest {
         val resetLambda = lambdaRecorder<Unit> { }
         val store = FakeAnalyticsStore(
             resetLambda = resetLambda,
         )
         val sut = createDefaultAnalyticsService(
-            coroutineScope = it,
+            coroutineScope = backgroundScope,
             analyticsStore = store,
         )
         sut.onSessionDeleted("userId")
         resetLambda.assertions().isCalledOnce()
     }
 
     @Test
-    fun `when reset is invoked, the user consent is reset`() = runCancellableScopeTest {
+    fun `when reset is invoked, the user consent is reset`() = runTest {
         val store = FakeAnalyticsStore(
             defaultDidAskUserConsent = true,
         )
         val sut = createDefaultAnalyticsService(
-            coroutineScope = it,
+            coroutineScope = backgroundScope,
             analyticsStore = store,
         )
         assertThat(store.didAskUserConsentFlow.first()).isTrue()
@@ -196,9 +195,9 @@ class DefaultAnalyticsServiceTest {
     }
 
     @Test
-    fun `when a session is added, nothing happen`() = runCancellableScopeTest {
+    fun `when a session is added, nothing happen`() = runTest {
         val sut = createDefaultAnalyticsService(
-            coroutineScope = it,
+            coroutineScope = backgroundScope,
         )
         sut.onSessionCreated("userId")
     }
@@ -231,10 +230,10 @@ class DefaultAnalyticsServiceTest {
     }
 
     @Test
-    fun `when consent is provided, updateUserProperties is sent to the provider`() = runCancellableScopeTest {
+    fun `when consent is provided, updateUserProperties is sent to the provider`() = runTest {
         val updateUserPropertiesLambda = lambdaRecorder<UserProperties, Unit> { _ -> }
         val sut = createDefaultAnalyticsService(
-            coroutineScope = it,
+            coroutineScope = backgroundScope,
             analyticsProviders = setOf(
                 FakeAnalyticsProvider(
                     initLambda = { },
@@ -248,10 +247,10 @@ class DefaultAnalyticsServiceTest {
     }
 
     @Test
-    fun `when super properties are updated, updateSuperProperties is sent to the provider`() = runCancellableScopeTest {
+    fun `when super properties are updated, updateSuperProperties is sent to the provider`() = runTest {
         val updateSuperPropertiesLambda = lambdaRecorder<SuperProperties, Unit> { _ -> }
         val sut = createDefaultAnalyticsService(
-            coroutineScope = it,
+            coroutineScope = backgroundScope,
             analyticsProviders = setOf(
                 FakeAnalyticsProvider(
                     initLambda = { },