Merge pull request #637 from code-payments/feat/testing-support

Feat/testing support

Author: bmc08gt

apps/flipcash/app/src/main/kotlin/com/flipcash/app/inject/DispatcherModule.kt

@@ -0,0 +1,18 @@
+package com.flipcash.app.inject
+
+import com.flipcash.libs.coroutines.DispatcherProvider
+import com.flipcash.app.internal.dispatchers.DefaultDispatcherProvider
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import javax.inject.Singleton
+
+@Module
+@InstallIn(SingletonComponent::class)
+object DispatcherModule {
+
+    @Provides
+    @Singleton
+    fun providesDispatcherProvider(): DispatcherProvider = DefaultDispatcherProvider()
+}

apps/flipcash/app/src/main/kotlin/com/flipcash/app/inject/TimeModule.kt

@@ -0,0 +1,18 @@
+package com.flipcash.app.inject
+
+import com.flipcash.app.core.time.TimeProvider
+import com.flipcash.app.internal.time.SystemTimeProvider
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import javax.inject.Singleton
+
+@Module
+@InstallIn(SingletonComponent::class)
+object TimeModule {
+
+    @Provides
+    @Singleton
+    fun providesTimeProvider(): TimeProvider = SystemTimeProvider()
+}

apps/flipcash/app/src/main/kotlin/com/flipcash/app/internal/dispatchers/DefaultDispatcherProvider.kt

@@ -0,0 +1,11 @@
+package com.flipcash.app.internal.dispatchers
+
+import com.flipcash.libs.coroutines.DispatcherProvider
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.Dispatchers
+
+class DefaultDispatcherProvider : DispatcherProvider {
+    override val Default: CoroutineDispatcher = Dispatchers.Default
+    override val Main: CoroutineDispatcher = Dispatchers.Main
+    override val IO: CoroutineDispatcher = Dispatchers.IO
+}

apps/flipcash/app/src/main/kotlin/com/flipcash/app/internal/time/SystemTimeProvider.kt

@@ -0,0 +1,9 @@
+package com.flipcash.app.internal.time
+
+import com.flipcash.app.core.time.TimeProvider
+import kotlin.time.Clock
+
+class SystemTimeProvider : TimeProvider {
+    override fun now() = Clock.System.now()
+    override fun currentTimeMillis() = System.currentTimeMillis()
+}

apps/flipcash/core/build.gradle.kts

@@ -7,6 +7,9 @@ android {
 }
 
 dependencies {
+    testImplementation(kotlin("test"))
+    testImplementation(libs.bundles.unit.testing)
+
     implementation(libs.androidx.browser)
 
     implementation(libs.kotlinx.serialization.core)

apps/flipcash/core/src/main/kotlin/com/flipcash/app/core/time/FakeTimeProvider.kt

@@ -0,0 +1,13 @@
+package com.flipcash.app.core.time
+
+import kotlin.time.Clock
+import kotlin.time.Duration
+import kotlin.time.Instant
+
+class FakeTimeProvider(
+    private var currentTime: Instant = Clock.System.now()
+) : TimeProvider {
+    override fun now(): Instant = currentTime
+    fun advanceBy(duration: Duration) { currentTime += duration }
+    fun setTime(instant: Instant) { currentTime = instant }
+}

apps/flipcash/core/src/main/kotlin/com/flipcash/app/core/time/TimeProvider.kt

@@ -0,0 +1,8 @@
+package com.flipcash.app.core.time
+
+import kotlin.time.Instant
+
+interface TimeProvider {
+    fun now(): Instant
+    fun currentTimeMillis(): Long = now().toEpochMilliseconds()
+}

apps/flipcash/core/src/test/kotlin/com/flipcash/app/core/MainCoroutineRule.kt

@@ -0,0 +1,24 @@
+package com.flipcash.app.core
+
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.StandardTestDispatcher
+import kotlinx.coroutines.test.TestDispatcher
+import kotlinx.coroutines.test.resetMain
+import kotlinx.coroutines.test.setMain
+import org.junit.rules.TestWatcher
+import org.junit.runner.Description
+
+@OptIn(ExperimentalCoroutinesApi::class)
+class MainCoroutineRule(
+    val dispatcher: TestDispatcher = StandardTestDispatcher()
+) : TestWatcher() {
+
+    override fun starting(description: Description) {
+        Dispatchers.setMain(dispatcher)
+    }
+
+    override fun finished(description: Description) {
+        Dispatchers.resetMain()
+    }
+}

apps/flipcash/core/src/test/kotlin/com/flipcash/app/core/dispatchers/TestDispatcherProvider.kt

@@ -0,0 +1,14 @@
+package com.flipcash.app.core.dispatchers
+
+import com.flipcash.libs.coroutines.DispatcherProvider
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.test.StandardTestDispatcher
+import kotlinx.coroutines.test.TestDispatcher
+
+class TestDispatcherProvider(
+    val testDispatcher: TestDispatcher = StandardTestDispatcher()
+) : DispatcherProvider {
+    override val Default: CoroutineDispatcher get() = testDispatcher
+    override val Main: CoroutineDispatcher get() = testDispatcher
+    override val IO: CoroutineDispatcher get() = testDispatcher
+}

apps/flipcash/core/src/test/kotlin/com/flipcash/app/core/time/FakeTimeProviderTest.kt

@@ -0,0 +1,69 @@
+package com.flipcash.app.core.time
+
+import org.junit.Test
+import kotlin.test.assertEquals
+import kotlin.time.Duration.Companion.milliseconds
+import kotlin.time.Duration.Companion.minutes
+import kotlin.time.Duration.Companion.seconds
+import kotlin.time.Instant
+
+class FakeTimeProviderTest {
+
+    @Test
+    fun `now returns start time initially`() {
+        val startTime = Instant.fromEpochMilliseconds(1_000_000L)
+        val provider = FakeTimeProvider(startTime)
+
+        assertEquals(startTime, provider.now())
+    }
+
+    @Test
+    fun `currentTimeMillis returns epoch millis of now`() {
+        val startTime = Instant.fromEpochMilliseconds(1_000_000L)
+        val provider = FakeTimeProvider(startTime)
+
+        assertEquals(1_000_000L, provider.currentTimeMillis())
+    }
+
+    @Test
+    fun `advanceBy moves time forward`() {
+        val startTime = Instant.fromEpochMilliseconds(0L)
+        val provider = FakeTimeProvider(startTime)
+
+        provider.advanceBy(5.seconds)
+
+        assertEquals(5_000L, provider.currentTimeMillis())
+    }
+
+    @Test
+    fun `advanceBy accumulates across multiple calls`() {
+        val startTime = Instant.fromEpochMilliseconds(0L)
+        val provider = FakeTimeProvider(startTime)
+
+        provider.advanceBy(1.minutes)
+        provider.advanceBy(30.seconds)
+
+        assertEquals(90_000L, provider.currentTimeMillis())
+    }
+
+    @Test
+    fun `setTime overrides current time`() {
+        val provider = FakeTimeProvider(Instant.fromEpochMilliseconds(0L))
+        val newTime = Instant.fromEpochMilliseconds(999_999L)
+
+        provider.setTime(newTime)
+
+        assertEquals(newTime, provider.now())
+        assertEquals(999_999L, provider.currentTimeMillis())
+    }
+
+    @Test
+    fun `advanceBy works after setTime`() {
+        val provider = FakeTimeProvider(Instant.fromEpochMilliseconds(0L))
+
+        provider.setTime(Instant.fromEpochMilliseconds(10_000L))
+        provider.advanceBy(500.milliseconds)
+
+        assertEquals(10_500L, provider.currentTimeMillis())
+    }
+}