fix: tests

common/session/data/src/commonTest/kotlin/dev/alvr/katana/common/session/data/datastore/SessionDataStoreTest.kt

@@ -8,7 +8,7 @@ import dev.alvr.katana.common.session.data.di.deleteDataStoreFiles
 import dev.alvr.katana.common.session.data.di.testDataStoreModule
 import dev.alvr.katana.common.session.data.models.Session
 import dev.alvr.katana.common.session.domain.models.AnilistToken
-import dev.alvr.katana.core.tests.KoinExtension
+import dev.alvr.katana.core.tests.koinExtension
 import io.kotest.core.spec.style.FreeSpec
 import io.kotest.core.test.TestCase
 import io.kotest.matchers.equals.shouldBeEqual
@@ -55,9 +55,9 @@ internal class SessionDataStoreTest : FreeSpec(), KoinTest {
         }
     }
 
-    override fun extensions() = listOf(KoinExtension(testDataStoreModule()))
-
     override suspend fun beforeEach(testCase: TestCase) {
         deleteDataStoreFiles()
     }
+
+    override fun extensions() = listOf(koinExtension(testDataStoreModule()))
 }

common/session/domain/src/commonTest/kotlin/dev/alvr/katana/common/session/domain/usecases/ClearActiveSessionUseCaseTest.kt

@@ -4,20 +4,27 @@ import arrow.core.left
 import arrow.core.right
 import dev.alvr.katana.common.session.domain.failures.SessionFailure
 import dev.alvr.katana.common.session.domain.repositories.SessionRepository
+import dev.alvr.katana.core.common.coroutines.KatanaDispatcher
 import dev.alvr.katana.core.domain.failures.Failure
 import dev.alvr.katana.core.domain.usecases.invoke
+import dev.alvr.katana.core.tests.di.coreTestsModule
+import dev.alvr.katana.core.tests.koinExtension
 import dev.alvr.katana.core.tests.shouldBeLeft
 import dev.alvr.katana.core.tests.shouldBeRight
 import dev.mokkery.answering.returns
 import dev.mokkery.everySuspend
 import dev.mokkery.mock
 import dev.mokkery.verifySuspend
 import io.kotest.core.spec.style.FreeSpec
+import io.kotest.core.test.TestCase
+import org.koin.test.KoinTest
+import org.koin.test.inject
 
-internal class ClearActiveSessionUseCaseTest : FreeSpec() {
+internal class ClearActiveSessionUseCaseTest : FreeSpec(), KoinTest {
+    private val dispatcher by inject<KatanaDispatcher>()
     private val repo = mock<SessionRepository>()
 
-    private val useCase = ClearActiveSessionUseCase(repo)
+    private lateinit var useCase: ClearActiveSessionUseCase
 
     init {
         "successfully clearing the session" {
@@ -37,4 +44,10 @@ internal class ClearActiveSessionUseCaseTest : FreeSpec() {
             }
         }
     }
+
+    override suspend fun beforeEach(testCase: TestCase) {
+        useCase = ClearActiveSessionUseCase(dispatcher, repo)
+    }
+
+    override fun extensions() = listOf(koinExtension(coreTestsModule))
 }

common/session/domain/src/commonTest/kotlin/dev/alvr/katana/common/session/domain/usecases/DeleteAnilistTokenUseCaseTest.kt

@@ -4,20 +4,27 @@ import arrow.core.left
 import arrow.core.right
 import dev.alvr.katana.common.session.domain.failures.SessionFailure
 import dev.alvr.katana.common.session.domain.repositories.SessionRepository
+import dev.alvr.katana.core.common.coroutines.KatanaDispatcher
 import dev.alvr.katana.core.domain.failures.Failure
 import dev.alvr.katana.core.domain.usecases.invoke
+import dev.alvr.katana.core.tests.di.coreTestsModule
+import dev.alvr.katana.core.tests.koinExtension
 import dev.alvr.katana.core.tests.shouldBeLeft
 import dev.alvr.katana.core.tests.shouldBeRight
 import dev.mokkery.answering.returns
 import dev.mokkery.everySuspend
 import dev.mokkery.mock
 import dev.mokkery.verifySuspend
 import io.kotest.core.spec.style.FreeSpec
+import io.kotest.core.test.TestCase
+import org.koin.test.KoinTest
+import org.koin.test.inject
 
-internal class DeleteAnilistTokenUseCaseTest : FreeSpec() {
+internal class DeleteAnilistTokenUseCaseTest : FreeSpec(), KoinTest {
+    private val dispatcher by inject<KatanaDispatcher>()
     private val repo = mock<SessionRepository>()
 
-    private val useCase = DeleteAnilistTokenUseCase(repo)
+    private lateinit var useCase: DeleteAnilistTokenUseCase
 
     init {
         "successfully deleting the token" {
@@ -37,4 +44,10 @@ internal class DeleteAnilistTokenUseCaseTest : FreeSpec() {
             }
         }
     }
+
+    override suspend fun beforeEach(testCase: TestCase) {
+        useCase = DeleteAnilistTokenUseCase(dispatcher, repo)
+    }
+
+    override fun extensions() = listOf(koinExtension(coreTestsModule))
 }

common/session/domain/src/commonTest/kotlin/dev/alvr/katana/common/session/domain/usecases/GetAnilistTokenUseCaseTest.kt

@@ -4,19 +4,26 @@ import arrow.core.none
 import arrow.core.some
 import dev.alvr.katana.common.session.domain.anilistTokenMock
 import dev.alvr.katana.common.session.domain.repositories.SessionRepository
+import dev.alvr.katana.core.common.coroutines.KatanaDispatcher
 import dev.alvr.katana.core.domain.usecases.invoke
+import dev.alvr.katana.core.tests.di.coreTestsModule
+import dev.alvr.katana.core.tests.koinExtension
 import dev.alvr.katana.core.tests.shouldBeNone
 import dev.alvr.katana.core.tests.shouldBeSome
 import dev.mokkery.answering.returns
 import dev.mokkery.everySuspend
 import dev.mokkery.mock
 import dev.mokkery.verifySuspend
 import io.kotest.core.spec.style.FreeSpec
+import io.kotest.core.test.TestCase
+import org.koin.test.KoinTest
+import org.koin.test.inject
 
-internal class GetAnilistTokenUseCaseTest : FreeSpec() {
+internal class GetAnilistTokenUseCaseTest : FreeSpec(), KoinTest {
+    private val dispatcher by inject<KatanaDispatcher>()
     private val repo = mock<SessionRepository>()
 
-    private val useCase = GetAnilistTokenUseCase(repo)
+    private lateinit var useCase: GetAnilistTokenUseCase
 
     init {
         "successfully getting the token" {
@@ -31,4 +38,10 @@ internal class GetAnilistTokenUseCaseTest : FreeSpec() {
             verifySuspend { repo.getAnilistToken() }
         }
     }
+
+    override suspend fun beforeEach(testCase: TestCase) {
+        useCase = GetAnilistTokenUseCase(dispatcher, repo)
+    }
+
+    override fun extensions() = listOf(koinExtension(coreTestsModule))
 }

common/session/domain/src/commonTest/kotlin/dev/alvr/katana/common/session/domain/usecases/LogOutUseCaseTest.kt

@@ -4,20 +4,27 @@ import arrow.core.left
 import arrow.core.right
 import dev.alvr.katana.common.session.domain.failures.SessionFailure
 import dev.alvr.katana.common.session.domain.repositories.SessionRepository
+import dev.alvr.katana.core.common.coroutines.KatanaDispatcher
 import dev.alvr.katana.core.domain.failures.Failure
 import dev.alvr.katana.core.domain.usecases.invoke
+import dev.alvr.katana.core.tests.di.coreTestsModule
+import dev.alvr.katana.core.tests.koinExtension
 import dev.alvr.katana.core.tests.shouldBeLeft
 import dev.alvr.katana.core.tests.shouldBeRight
 import dev.mokkery.answering.returns
 import dev.mokkery.everySuspend
 import dev.mokkery.mock
 import dev.mokkery.verifySuspend
 import io.kotest.core.spec.style.FreeSpec
+import io.kotest.core.test.TestCase
+import org.koin.test.KoinTest
+import org.koin.test.inject
 
-internal class LogOutUseCaseTest : FreeSpec() {
+internal class LogOutUseCaseTest : FreeSpec(), KoinTest {
+    private val dispatcher by inject<KatanaDispatcher>()
     private val repo = mock<SessionRepository>()
 
-    private val useCase = LogOutUseCase(repo)
+    private lateinit var useCase: LogOutUseCase
 
     init {
         "successfully saving the session" {
@@ -37,4 +44,10 @@ internal class LogOutUseCaseTest : FreeSpec() {
             }
         }
     }
+
+    override suspend fun beforeEach(testCase: TestCase) {
+        useCase = LogOutUseCase(dispatcher, repo)
+    }
+
+    override fun extensions() = listOf(koinExtension(coreTestsModule))
 }

common/session/domain/src/commonTest/kotlin/dev/alvr/katana/common/session/domain/usecases/ObserveActiveSessionUseCaseTest.kt

@@ -5,21 +5,28 @@ import arrow.core.left
 import arrow.core.right
 import dev.alvr.katana.common.session.domain.failures.SessionFailure
 import dev.alvr.katana.common.session.domain.repositories.SessionRepository
+import dev.alvr.katana.core.common.coroutines.KatanaDispatcher
 import dev.alvr.katana.core.domain.usecases.invoke
+import dev.alvr.katana.core.tests.di.coreTestsModule
+import dev.alvr.katana.core.tests.koinExtension
 import dev.alvr.katana.core.tests.shouldBeLeft
 import dev.alvr.katana.core.tests.shouldBeRight
 import dev.mokkery.answering.returns
 import dev.mokkery.every
 import dev.mokkery.mock
 import dev.mokkery.verify
 import io.kotest.core.spec.style.FreeSpec
+import io.kotest.core.test.TestCase
 import kotlin.time.Duration.Companion.seconds
 import kotlinx.coroutines.flow.flowOf
+import org.koin.test.KoinTest
+import org.koin.test.inject
 
-internal class ObserveActiveSessionUseCaseTest : FreeSpec() {
+internal class ObserveActiveSessionUseCaseTest : FreeSpec(), KoinTest {
+    private val dispatcher by inject<KatanaDispatcher>()
     private val repo = mock<SessionRepository>()
 
-    private val useCase = ObserveActiveSessionUseCase(repo)
+    private lateinit var useCase: ObserveActiveSessionUseCase
 
     init {
         "successfully observing the session" {
@@ -59,4 +66,10 @@ internal class ObserveActiveSessionUseCaseTest : FreeSpec() {
             verify { repo.sessionActive }
         }
     }
+
+    override suspend fun beforeEach(testCase: TestCase) {
+        useCase = ObserveActiveSessionUseCase(dispatcher, repo)
+    }
+
+    override fun extensions() = listOf(koinExtension(coreTestsModule))
 }

common/session/domain/src/commonTest/kotlin/dev/alvr/katana/common/session/domain/usecases/SaveAnilistTokenUseCaseTest.kt

@@ -5,19 +5,26 @@ import arrow.core.right
 import dev.alvr.katana.common.session.domain.anilistTokenMock
 import dev.alvr.katana.common.session.domain.failures.SessionFailure
 import dev.alvr.katana.common.session.domain.repositories.SessionRepository
+import dev.alvr.katana.core.common.coroutines.KatanaDispatcher
 import dev.alvr.katana.core.domain.failures.Failure
+import dev.alvr.katana.core.tests.di.coreTestsModule
+import dev.alvr.katana.core.tests.koinExtension
 import dev.alvr.katana.core.tests.shouldBeLeft
 import dev.alvr.katana.core.tests.shouldBeRight
 import dev.mokkery.answering.returns
 import dev.mokkery.everySuspend
 import dev.mokkery.mock
 import dev.mokkery.verifySuspend
 import io.kotest.core.spec.style.FreeSpec
+import io.kotest.core.test.TestCase
+import org.koin.test.KoinTest
+import org.koin.test.inject
 
-internal class SaveAnilistTokenUseCaseTest : FreeSpec() {
+internal class SaveAnilistTokenUseCaseTest : FreeSpec(), KoinTest {
+    private val dispatcher by inject<KatanaDispatcher>()
     private val repo = mock<SessionRepository>()
 
-    private val useCase = SaveSessionUseCase(repo)
+    private lateinit var useCase: SaveSessionUseCase
 
     init {
         "successfully saving the session" {
@@ -37,4 +44,10 @@ internal class SaveAnilistTokenUseCaseTest : FreeSpec() {
             }
         }
     }
+
+    override suspend fun beforeEach(testCase: TestCase) {
+        useCase = SaveSessionUseCase(dispatcher, repo)
+    }
+
+    override fun extensions() = listOf(koinExtension(coreTestsModule))
 }

common/user/data/src/commonTest/kotlin/dev/alvr/katana/common/user/data/di/module.kt

@@ -0,0 +1,18 @@
+package dev.alvr.katana.common.user.data.di
+
+import dev.alvr.katana.common.user.data.managers.UserIdManagerImpl
+import dev.alvr.katana.common.user.domain.managers.UserIdManager
+import dev.alvr.katana.common.user.domain.repositories.UserRepository
+import dev.alvr.katana.common.user.domain.usecases.GetUserIdUseCase
+import dev.alvr.katana.core.tests.di.coreTestsModule
+import org.koin.dsl.module
+
+private val managersModule = module {
+    single<UserIdManager> { (repo: UserRepository) ->
+        UserIdManagerImpl(GetUserIdUseCase(get(), repo))
+    }
+}
+
+internal val fakeCommonUserDataModule = module {
+    includes(coreTestsModule, managersModule)
+}

common/user/data/src/commonTest/kotlin/dev/alvr/katana/common/user/data/managers/UserIdManagerTest.kt

@@ -2,37 +2,41 @@ package dev.alvr.katana.common.user.data.managers
 
 import arrow.core.left
 import arrow.core.right
+import dev.alvr.katana.common.user.data.di.fakeCommonUserDataModule
 import dev.alvr.katana.common.user.domain.failures.UserFailure
 import dev.alvr.katana.common.user.domain.managers.UserIdManager
 import dev.alvr.katana.common.user.domain.models.UserId
 import dev.alvr.katana.common.user.domain.repositories.UserRepository
-import dev.alvr.katana.common.user.domain.usecases.GetUserIdUseCase
-import dev.alvr.katana.core.domain.usecases.invoke
+import dev.alvr.katana.core.tests.koinExtension
 import dev.alvr.katana.core.tests.shouldBeLeft
 import dev.alvr.katana.core.tests.shouldBeRight
 import dev.mokkery.answering.returns
 import dev.mokkery.everySuspend
 import dev.mokkery.mock
 import dev.mokkery.verifySuspend
 import io.kotest.core.spec.style.FreeSpec
+import org.koin.core.parameter.parametersOf
+import org.koin.test.KoinTest
+import org.koin.test.inject
 
-internal class UserIdManagerTest : FreeSpec() {
+internal class UserIdManagerTest : FreeSpec(), KoinTest {
     private val repo = mock<UserRepository>()
 
-    private val useCase = GetUserIdUseCase(repo)
-    private val manager: UserIdManager = UserIdManagerImpl(useCase)
+    private val manager by inject<UserIdManager> { parametersOf(repo) }
 
     init {
         "server return viewer is valid" {
             everySuspend { repo.getUserId() } returns UserId(37_384).right()
             manager.getId().shouldBeRight(37_384)
-            verifySuspend { useCase() }
+            verifySuspend { repo.getUserId() }
         }
 
         "server fails to return something" {
             everySuspend { repo.getUserId() } returns UserFailure.GettingUserId.left()
             manager.getId().shouldBeLeft(UserFailure.GettingUserId)
-            verifySuspend { useCase() }
+            verifySuspend { repo.getUserId() }
         }
     }
+
+    override fun extensions() = listOf(koinExtension(fakeCommonUserDataModule))
 }

common/user/domain/src/commonTest/kotlin/dev/alvr/katana/common/user/domain/usecases/GetUserIdUseCaseTest.kt

@@ -5,20 +5,27 @@ import arrow.core.right
 import dev.alvr.katana.common.user.domain.failures.UserFailure
 import dev.alvr.katana.common.user.domain.repositories.UserRepository
 import dev.alvr.katana.common.user.domain.userIdMock
+import dev.alvr.katana.core.common.coroutines.KatanaDispatcher
 import dev.alvr.katana.core.domain.failures.Failure
 import dev.alvr.katana.core.domain.usecases.invoke
+import dev.alvr.katana.core.tests.di.coreTestsModule
+import dev.alvr.katana.core.tests.koinExtension
 import dev.alvr.katana.core.tests.shouldBeLeft
 import dev.alvr.katana.core.tests.shouldBeRight
 import dev.mokkery.answering.returns
 import dev.mokkery.everySuspend
 import dev.mokkery.mock
 import dev.mokkery.verifySuspend
 import io.kotest.core.spec.style.FreeSpec
+import io.kotest.core.test.TestCase
+import org.koin.test.KoinTest
+import org.koin.test.inject
 
-internal class GetUserIdUseCaseTest : FreeSpec() {
+internal class GetUserIdUseCaseTest : FreeSpec(), KoinTest {
+    private val dispatcher by inject<KatanaDispatcher>()
     private val repo = mock<UserRepository>()
 
-    private val useCase = GetUserIdUseCase(repo)
+    private lateinit var useCase: GetUserIdUseCase
 
     init {
         "successfully getting user id" {
@@ -38,4 +45,10 @@ internal class GetUserIdUseCaseTest : FreeSpec() {
             }
         }
     }
+
+    override suspend fun beforeEach(testCase: TestCase) {
+        useCase = GetUserIdUseCase(dispatcher, repo)
+    }
+
+    override fun extensions() = listOf(koinExtension(coreTestsModule))
 }