Merge pull request #87 from futuredapp/feature/matsem/GH-80-uc-improvements

matejsemancik · web-flow · commit 9d6c6100c567 · 2024-08-22T12:10:06.000+01:00
GH-80 UseCases: Fix CancellationException handling and add tests
diff --git a/gradle/libs.versions.toml b/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" }
diff --git a/shared/app/build.gradle.kts b/shared/app/build.gradle.kts
@@ -69,8 +69,7 @@ kotlin {
 
         commonTest {
             dependencies {
-                implementation(libs.kotlin.testCommon)
-                implementation(libs.kotlin.testAnnotationsCommon)
+                implementation(libs.kotlin.test)
             }
         }
 
diff --git a/shared/feature/build.gradle.kts b/shared/feature/build.gradle.kts
@@ -60,8 +60,7 @@ kotlin {
 
         commonTest {
             dependencies {
-                implementation(libs.kotlin.testCommon)
-                implementation(libs.kotlin.testAnnotationsCommon)
+                implementation(libs.kotlin.test)
             }
         }
     }
diff --git a/shared/feature/src/commonMain/kotlin/app/futured/kmptemplate/feature/domain/CounterUseCase.kt b/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)
diff --git a/shared/feature/src/commonMain/kotlin/app/futured/kmptemplate/feature/domain/SyncDataUseCase.kt b/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.")
+    }
+}
diff --git a/shared/feature/src/commonMain/kotlin/app/futured/kmptemplate/feature/ui/first/FirstViewModel.kt b/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()
diff --git a/shared/network/graphql/build.gradle.kts b/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)
             }
         }
     }
diff --git a/shared/network/rest/build.gradle.kts b/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)
             }
         }
     }
diff --git a/shared/persistence/build.gradle.kts b/shared/persistence/build.gradle.kts
@@ -35,8 +35,7 @@ kotlin {
 
         commonTest {
             dependencies {
-                implementation(libs.kotlin.testCommon)
-                implementation(libs.kotlin.testAnnotationsCommon)
+                implementation(libs.kotlin.test)
             }
         }
     }
diff --git a/shared/platform/build.gradle.kts b/shared/platform/build.gradle.kts
@@ -29,8 +29,7 @@ kotlin {
 
         commonTest {
             dependencies {
-                implementation(libs.kotlin.testCommon)
-                implementation(libs.kotlin.testAnnotationsCommon)
+                implementation(libs.kotlin.test)
             }
         }
     }
diff --git a/shared/util/build.gradle.kts b/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)
             }
         }
     }
diff --git a/shared/util/src/commonMain/kotlin/app/futured/kmptemplate/util/domain/scope/FlowUseCaseExecutionScope.kt b/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()
                 }
             }
diff --git a/shared/util/src/commonMain/kotlin/app/futured/kmptemplate/util/domain/scope/SingleUseCaseExecutionScope.kt b/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(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.
diff --git a/shared/util/src/commonTest/kotlin/app/futured/kmptemplate/util/domain/UseCaseExecutionScopeTest.kt b/shared/util/src/commonTest/kotlin/app/futured/kmptemplate/util/domain/UseCaseExecutionScopeTest.kt
diff --git a/shared/util/src/commonTest/kotlin/app/futured/kmptemplate/util/domain/base/BaseUseCaseExecutionScopeTest.kt b/shared/util/src/commonTest/kotlin/app/futured/kmptemplate/util/domain/base/BaseUseCaseExecutionScopeTest.kt
diff --git a/shared/util/src/commonTest/kotlin/app/futured/kmptemplate/util/domain/usecases/TestFailureFlowUseCase.kt b/shared/util/src/commonTest/kotlin/app/futured/kmptemplate/util/domain/usecases/TestFailureFlowUseCase.kt
diff --git a/shared/util/src/commonTest/kotlin/app/futured/kmptemplate/util/domain/usecases/TestFailureUseCase.kt b/shared/util/src/commonTest/kotlin/app/futured/kmptemplate/util/domain/usecases/TestFailureUseCase.kt
diff --git a/shared/util/src/commonTest/kotlin/app/futured/kmptemplate/util/domain/usecases/TestFlowUseCase.kt b/shared/util/src/commonTest/kotlin/app/futured/kmptemplate/util/domain/usecases/TestFlowUseCase.kt
diff --git a/shared/util/src/commonTest/kotlin/app/futured/kmptemplate/util/domain/usecases/TestUseCase.kt b/shared/util/src/commonTest/kotlin/app/futured/kmptemplate/util/domain/usecases/TestUseCase.kt

Original file line number	Diff line number	Diff line change
`@@ -69,8 +69,7 @@ kotlin {`
`69`	`69`
`70`	`70`	`commonTest {`
`71`	`71`	`dependencies {`
`72`		`- implementation(libs.kotlin.testCommon)`
`73`		`- implementation(libs.kotlin.testAnnotationsCommon)`
	`72`	`+ implementation(libs.kotlin.test)`
`74`	`73`	`}`
`75`	`74`	`}`
`76`	`75`
Original file line number	Diff line number	Diff line change
`@@ -60,8 +60,7 @@ kotlin {`
`60`	`60`
`61`	`61`	`commonTest {`
`62`	`62`	`dependencies {`
`63`		`- implementation(libs.kotlin.testCommon)`
`64`		`- implementation(libs.kotlin.testAnnotationsCommon)`
	`63`	`+ implementation(libs.kotlin.test)`
`65`	`64`	`}`
`66`	`65`	`}`
`67`	`66`	`}`
Original file line number	Diff line number	Diff line change
`@@ -42,8 +42,7 @@ kotlin {`
`42`	`42`
`43`	`43`	`commonTest {`
`44`	`44`	`dependencies {`
`45`		`- implementation(libs.kotlin.testCommon)`
`46`		`- implementation(libs.kotlin.testAnnotationsCommon)`
	`45`	`+ implementation(libs.kotlin.test)`
`47`	`46`	`}`
`48`	`47`	`}`
`49`	`48`	`}`
Original file line number	Diff line number	Diff line change
`@@ -57,8 +57,7 @@ kotlin {`
`57`	`57`
`58`	`58`	`commonTest {`
`59`	`59`	`dependencies {`
`60`		`- implementation(libs.kotlin.testCommon)`
`61`		`- implementation(libs.kotlin.testAnnotationsCommon)`
	`60`	`+ implementation(libs.kotlin.test)`
`62`	`61`	`}`
`63`	`62`	`}`
`64`	`63`	`}`
Original file line number	Diff line number	Diff line change
`@@ -35,8 +35,7 @@ kotlin {`
`35`	`35`
`36`	`36`	`commonTest {`
`37`	`37`	`dependencies {`
`38`		`- implementation(libs.kotlin.testCommon)`
`39`		`- implementation(libs.kotlin.testAnnotationsCommon)`
	`38`	`+ implementation(libs.kotlin.test)`
`40`	`39`	`}`
`41`	`40`	`}`
`42`	`41`	`}`
Original file line number	Diff line number	Diff line change
`@@ -29,8 +29,7 @@ kotlin {`
`29`	`29`
`30`	`30`	`commonTest {`
`31`	`31`	`dependencies {`
`32`		`- implementation(libs.kotlin.testCommon)`
`33`		`- implementation(libs.kotlin.testAnnotationsCommon)`
	`32`	`+ implementation(libs.kotlin.test)`
`34`	`33`	`}`
`35`	`34`	`}`
`36`	`35`	`}`
Original file line number	Diff line number	Diff line change
`@@ -32,8 +32,8 @@ kotlin {`
`32`	`32`
`33`	`33`	`commonTest {`
`34`	`34`	`dependencies {`
`35`		`- implementation(libs.kotlin.testCommon)`
`36`		`- implementation(libs.kotlin.testAnnotationsCommon)`
	`35`	`+ implementation(libs.kotlin.test)`
	`36`	`+ implementation(libs.kotlinx.coroutines.test)`
`37`	`37`	`}`
`38`	`38`	`}`
`39`	`39`	`}`
Original file line number	Diff line number	Diff line change
`@@ -55,10 +55,12 @@ interface FlowUseCaseExecutionScope : CoroutineScopeOwner {`
`55`	`55`	`error is CancellationException -> {`
`56`	`56`	`// ignore this exception`
`57`	`57`	`}`
	`58`	`+`
`58`	`59`	`error != null -> {`
`59`		`- // UseCaseErrorHandler.globalOnErrorLogger(error) todo`
	`60`	`+ UseCaseErrorHandler.globalOnErrorLogger(error)`
`60`	`61`	`flowUseCaseConfig.onError(error)`
`61`	`62`	`}`
	`63`	`+`
`62`	`64`	`else -> flowUseCaseConfig.onComplete()`
`63`	`65`	`}`
`64`	`66`	`}`
`@@ -101,10 +103,12 @@ interface FlowUseCaseExecutionScope : CoroutineScopeOwner {`
`101`	`103`	`error is CancellationException -> {`
`102`	`104`	`// ignore this exception`
`103`	`105`	`}`
	`106`	`+`
`104`	`107`	`error != null -> {`
`105`		`- // UseCaseErrorHandler.globalOnErrorLogger(error) todo`
	`108`	`+ UseCaseErrorHandler.globalOnErrorLogger(error)`
`106`	`109`	`flowUseCaseConfig.onError(error)`
`107`	`110`	`}`
	`111`	`+`
`108`	`112`	`else -> flowUseCaseConfig.onComplete()`
`109`	`113`	`}`
`110`	`114`	`}`