GH-80 UseCases: Fix CancellationException handling and add tests

gradle/libs.versions.toml

@@ -71,6 +71,7 @@ koin-ksp-compiler = { group = "io.insert-koin", name = "koin-ksp-compiler", vers
 
 # KotlinX
 kotlinx-coroutines-core = { group = "org.jetbrains.kotlinx", name = "kotlinx-coroutines-core", version.ref = "kotlinx-coroutines" }
+kotlinx-coroutines-test = { group = "org.jetbrains.kotlinx", name = "kotlinx-coroutines-test", version.ref = "kotlinx-coroutines" }
 kotlinx-immutableCollections = { group = "org.jetbrains.kotlinx", name = "kotlinx-collections-immutable", version.ref = "kotlinx-immutableCollections" }
 kotlinx-serialization-json = { group = "org.jetbrains.kotlinx", name = "kotlinx-serialization-json", version.ref = "kotlinx-serialization" }
 kotlinx-dateTime = { module = "org.jetbrains.kotlinx:kotlinx-datetime", version.ref = "kotlinx-dateTime" }
@@ -86,8 +87,7 @@ decompose-compose-ext = { group = "com.arkivanov.decompose", name = "extensions-
 essenty = { group = "com.arkivanov.essenty", name = "lifecycle", version.ref = "essenty" }
 
 # Testing
-kotlin-testCommon = { group = "org.jetbrains.kotlin", name = "kotlin-test-common", version.ref = "kotlin" }
-kotlin-testAnnotationsCommon = { group = "org.jetbrains.kotlin", name = "kotlin-test-annotations-common", version.ref = "kotlin" }
+kotlin-test = { group = "org.jetbrains.kotlin", name = "kotlin-test", version.ref = "kotlin" }
 androidx-junit = { group = "androidx.test.ext", name = "junit", version.ref = "junit" }
 androidx-espresso-core = { group = "androidx.test.espresso", name = "espresso-core", version.ref = "espressoCore" }
 androidx-uiautomator = { group = "androidx.test.uiautomator", name = "uiautomator", version.ref = "uiautomator" }

shared/app/build.gradle.kts

@@ -69,8 +69,7 @@ kotlin {
 
         commonTest {
             dependencies {
-                implementation(libs.kotlin.testCommon)
-                implementation(libs.kotlin.testAnnotationsCommon)
+                implementation(libs.kotlin.test)
             }
         }
 

shared/feature/build.gradle.kts

@@ -60,8 +60,7 @@ kotlin {
 
         commonTest {
             dependencies {
-                implementation(libs.kotlin.testCommon)
-                implementation(libs.kotlin.testAnnotationsCommon)
+                implementation(libs.kotlin.test)
             }
         }
     }

shared/feature/src/commonMain/kotlin/app/futured/kmptemplate/feature/domain/CounterUseCase.kt

@@ -0,0 +1,24 @@
+package app.futured.kmptemplate.feature.domain
+
+import app.futured.kmptemplate.util.domain.FlowUseCase
+import kotlinx.coroutines.currentCoroutineContext
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.isActive
+import org.koin.core.annotation.Factory
+import kotlin.time.Duration
+
+@Factory
+internal class CounterUseCase : FlowUseCase<CounterUseCaseArgs, Long>() {
+
+    override fun build(args: CounterUseCaseArgs): Flow<Long> = flow {
+        var counter = 0L
+        while (currentCoroutineContext().isActive) {
+            emit(counter++)
+            delay(args.interval)
+        }
+    }
+}
+
+internal data class CounterUseCaseArgs(val interval: Duration)

shared/feature/src/commonMain/kotlin/app/futured/kmptemplate/feature/domain/SyncDataUseCase.kt

@@ -0,0 +1,15 @@
+package app.futured.kmptemplate.feature.domain
+
+import app.futured.kmptemplate.util.domain.UseCase
+import kotlinx.coroutines.delay
+import org.koin.core.annotation.Factory
+import kotlin.time.Duration.Companion.seconds
+
+@Factory
+internal class SyncDataUseCase : UseCase<Unit, Nothing>() {
+
+    override suspend fun build(args: Unit): Nothing {
+        delay(10.seconds)
+        error("Jokes on you, there's no data to be fetched in here.")
+    }
+}

shared/feature/src/commonMain/kotlin/app/futured/kmptemplate/feature/ui/first/FirstViewModel.kt

@@ -1,44 +1,62 @@
 package app.futured.kmptemplate.feature.ui.first
 
+import app.futured.kmptemplate.feature.domain.CounterUseCase
+import app.futured.kmptemplate.feature.domain.CounterUseCaseArgs
+import app.futured.kmptemplate.feature.domain.SyncDataUseCase
 import app.futured.kmptemplate.feature.navigation.signedin.tab.b.TabBNavigator
 import app.futured.kmptemplate.resources.MR
 import app.futured.kmptemplate.util.arch.SharedViewModel
 import app.futured.kmptemplate.util.ext.update
 import co.touchlab.kermit.Logger
 import dev.icerock.moko.resources.desc.ResourceFormatted
 import dev.icerock.moko.resources.desc.StringDesc
-import kotlin.time.Duration.Companion.milliseconds
-import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.isActive
 import org.koin.core.annotation.Factory
+import kotlin.time.Duration.Companion.milliseconds
 
 @Factory
 internal class FirstViewModel(
     private val tabBNavigator: TabBNavigator,
+    private val syncDataUseCase: SyncDataUseCase,
+    private val counterUseCase: CounterUseCase,
 ) : SharedViewModel<FirstViewState, FirstUiEvent>(),
     FirstScreen.Actions {
 
+    private val logger: Logger = Logger.withTag("FirstViewModel")
+
     override val viewState: MutableStateFlow<FirstViewState> = MutableStateFlow(FirstViewState())
 
     init {
-        launchWithHandler {
-            var counter = 0
-            while (isActive) {
-                update(viewState) {
-                    copy(
-                        text = StringDesc.ResourceFormatted(stringRes = MR.strings.first_screen_text, 1, counter++),
-                    )
-                }
-
-                if (counter == 10) {
-                    Logger.withTag("FirstViewmodel").d { "Counter reached 10" }
-                    sendUiEvent(FirstUiEvent.ShowToast("Counter reached 10 🎉"))
-                }
-
-                delay(200.milliseconds)
+        syncData()
+        observeCounter()
+    }
+
+    private fun syncData() = syncDataUseCase.execute {
+        onError { error ->
+            logger.e(error) { error.message.toString() }
+        }
+    }
+
+    private fun observeCounter() = counterUseCase.execute(CounterUseCaseArgs(interval = 200.milliseconds)) {
+        onNext { count ->
+            updateCount(count)
+
+            if (count == 10L) {
+                logger.d { "Conter reached 10" }
+                sendUiEvent(FirstUiEvent.ShowToast("Counter reached 10 🎉"))
             }
         }
+        onError { error ->
+            logger.e(error) { "Counter error" }
+        }
+    }
+
+    private fun updateCount(count: Long) {
+        update(viewState) {
+            copy(
+                text = StringDesc.ResourceFormatted(stringRes = MR.strings.first_screen_text, 1, count),
+            )
+        }
     }
 
     override fun onBack() = tabBNavigator.pop()

shared/network/graphql/build.gradle.kts

@@ -42,8 +42,7 @@ kotlin {
 
         commonTest {
             dependencies {
-                implementation(libs.kotlin.testCommon)
-                implementation(libs.kotlin.testAnnotationsCommon)
+                implementation(libs.kotlin.test)
             }
         }
     }

shared/network/rest/build.gradle.kts

@@ -57,8 +57,7 @@ kotlin {
 
         commonTest {
             dependencies {
-                implementation(libs.kotlin.testCommon)
-                implementation(libs.kotlin.testAnnotationsCommon)
+                implementation(libs.kotlin.test)
             }
         }
     }

shared/persistence/build.gradle.kts

@@ -35,8 +35,7 @@ kotlin {
 
         commonTest {
             dependencies {
-                implementation(libs.kotlin.testCommon)
-                implementation(libs.kotlin.testAnnotationsCommon)
+                implementation(libs.kotlin.test)
             }
         }
     }

shared/platform/build.gradle.kts

@@ -29,8 +29,7 @@ kotlin {
 
         commonTest {
             dependencies {
-                implementation(libs.kotlin.testCommon)
-                implementation(libs.kotlin.testAnnotationsCommon)
+                implementation(libs.kotlin.test)
             }
         }
     }

shared/util/build.gradle.kts

@@ -32,8 +32,8 @@ kotlin {
 
         commonTest {
             dependencies {
-                implementation(libs.kotlin.testCommon)
-                implementation(libs.kotlin.testAnnotationsCommon)
+                implementation(libs.kotlin.test)
+                implementation(libs.kotlinx.coroutines.test)
             }
         }
     }

shared/util/src/commonMain/kotlin/app/futured/kmptemplate/util/domain/scope/FlowUseCaseExecutionScope.kt

@@ -55,10 +55,12 @@ interface FlowUseCaseExecutionScope : CoroutineScopeOwner {
                     error is CancellationException -> {
                         // ignore this exception
                     }
+
                     error != null -> {
-                        // UseCaseErrorHandler.globalOnErrorLogger(error) todo
+                        UseCaseErrorHandler.globalOnErrorLogger(error)
                         flowUseCaseConfig.onError(error)
                     }
+
                     else -> flowUseCaseConfig.onComplete()
                 }
             }
@@ -101,10 +103,12 @@ interface FlowUseCaseExecutionScope : CoroutineScopeOwner {
                     error is CancellationException -> {
                         // ignore this exception
                     }
+
                     error != null -> {
-                        // UseCaseErrorHandler.globalOnErrorLogger(error) todo
+                        UseCaseErrorHandler.globalOnErrorLogger(error)
                         flowUseCaseConfig.onError(error)
                     }
+
                     else -> flowUseCaseConfig.onComplete()
                 }
             }

shared/util/src/commonMain/kotlin/app/futured/kmptemplate/util/domain/scope/SingleUseCaseExecutionScope.kt

@@ -3,11 +3,10 @@ package app.futured.kmptemplate.util.domain.scope
 import app.futured.kmptemplate.util.domain.UseCase
 import app.futured.kmptemplate.util.domain.error.UseCaseErrorHandler
 import kotlinx.coroutines.CancellationException
-import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.CoroutineStart
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.async
 import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
 
 interface SingleUseCaseExecutionScope : CoroutineScopeOwner {
 
@@ -47,13 +46,20 @@ interface SingleUseCaseExecutionScope : CoroutineScopeOwner {
         }
 
         useCaseConfig.onStart()
-        deferred = viewModelScope.async(start = CoroutineStart.LAZY) {
-            buildOnBg(args, getWorkerDispatcher())
-        }
+        deferred = viewModelScope
+            .async(context = getWorkerDispatcher(), start = CoroutineStart.LAZY) {
+                build(args)
+            }
             .also {
-                viewModelScope.launch {
-                    kotlin.runCatching { it.await() }
-                        .fold(useCaseConfig.onSuccess, useCaseConfig.onError)
+                viewModelScope.launch(Dispatchers.Main) {
+                    try {
+                        useCaseConfig.onSuccess(it.await())
+                    } catch (cancellation: CancellationException) {
+                        // do nothing - this is normal way of suspend function interruption
+                    } catch (error: Throwable) {
+                        UseCaseErrorHandler.globalOnErrorLogger(error)
+                        useCaseConfig.onError.invoke(error)
+                    }
                 }
             }
     }
@@ -79,12 +85,12 @@ interface SingleUseCaseExecutionScope : CoroutineScopeOwner {
         if (cancelPrevious) {
             deferred?.cancel()
         }
+
         return try {
-            val newDeferred = viewModelScope.async(start = CoroutineStart.LAZY) {
-                buildOnBg(args, getWorkerDispatcher())
-            }.also {
-                deferred = it
-            }
+            val newDeferred = viewModelScope.async(getWorkerDispatcher(), CoroutineStart.LAZY) {
+                build(args)
+            }.also { deferred = it }
+
             Result.success(newDeferred.await())
         } catch (exception: CancellationException) {
             throw exception
@@ -93,11 +99,6 @@ interface SingleUseCaseExecutionScope : CoroutineScopeOwner {
         }
     }
 
-    private suspend fun <ARGS, T : Any?> UseCase<ARGS, T>.buildOnBg(
-        args: ARGS,
-        workerDispatcher: CoroutineDispatcher,
-    ) = withContext(workerDispatcher) { build(args) }
-
     /**
      * Holds references to lambdas and some basic configuration
      * used to process results of Coroutine use case.