refactor: Add test DI module

Author: ovitrif

app/src/test/java/to/bitkit/androidServices/LightningNodeServiceTest.kt

@@ -12,7 +12,6 @@ import dagger.hilt.android.testing.HiltAndroidRule
 import dagger.hilt.android.testing.HiltAndroidTest
 import dagger.hilt.android.testing.HiltTestApplication
 import dagger.hilt.android.testing.UninstallModules
-import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.runBlocking
 import org.junit.After
@@ -41,10 +40,8 @@ import to.bitkit.CurrentActivity
 import to.bitkit.R
 import to.bitkit.data.AppCacheData
 import to.bitkit.data.CacheStore
-import to.bitkit.di.BgDispatcher
+import to.bitkit.di.DbModule
 import to.bitkit.di.DispatchersModule
-import to.bitkit.di.IoDispatcher
-import to.bitkit.di.UiDispatcher
 import to.bitkit.domain.commands.NotifyPaymentReceived
 import to.bitkit.domain.commands.NotifyPaymentReceivedHandler
 import to.bitkit.models.NewTransactionSheetDetails
@@ -57,48 +54,26 @@ import to.bitkit.services.NodeEventHandler
 import to.bitkit.test.BaseUnitTest
 
 @HiltAndroidTest
-@UninstallModules(DispatchersModule::class)
+@UninstallModules(DispatchersModule::class, DbModule::class)
 @Config(application = HiltTestApplication::class)
 @RunWith(RobolectricTestRunner::class)
 class LightningNodeServiceTest : BaseUnitTest() {
 
-    @get:Rule(order = 0)
-    val mainDispatcherRule = coroutinesTestRule
-
     @get:Rule(order = 1)
     var hiltRule = HiltAndroidRule(this)
 
     @BindValue
-    @JvmField
     val lightningRepo = mock<LightningRepo>()
 
     @BindValue
-    @JvmField
     val walletRepo = mock<WalletRepo>()
 
     @BindValue
-    @JvmField
     val notifyPaymentReceivedHandler = mock<NotifyPaymentReceivedHandler>()
 
     @BindValue
-    @JvmField
     val cacheStore = mock<CacheStore>()
 
-    @BindValue
-    @UiDispatcher
-    @JvmField
-    val uiDispatcher: CoroutineDispatcher = testDispatcher
-
-    @BindValue
-    @BgDispatcher
-    @JvmField
-    val bgDispatcher: CoroutineDispatcher = testDispatcher
-
-    @BindValue
-    @IoDispatcher
-    @JvmField
-    val ioDispatcher: CoroutineDispatcher = testDispatcher
-
     private val handlerCaptor: KArgumentCaptor<NodeEventHandler?> = argumentCaptor()
     private val cacheDataFlow = MutableSharedFlow<AppCacheData>(replay = 1)
     private val context = ApplicationProvider.getApplicationContext<Context>()

app/src/test/java/to/bitkit/di/TestModule.kt

@@ -0,0 +1,56 @@
+package to.bitkit.di
+
+import android.content.Context
+import androidx.room.Room
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.android.qualifiers.ApplicationContext
+import dagger.hilt.components.SingletonComponent
+import dagger.hilt.testing.TestInstallIn
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.UnconfinedTestDispatcher
+import to.bitkit.data.AppDb
+import to.bitkit.data.dao.TransferDao
+import javax.inject.Singleton
+
+@OptIn(ExperimentalCoroutinesApi::class)
+@Module
+@TestInstallIn(
+    components = [SingletonComponent::class],
+    replaces = [DispatchersModule::class, DbModule::class]
+)
+object TestModule {
+
+    @Provides
+    @Singleton
+    @UiDispatcher
+    fun provideUiDispatcher(): CoroutineDispatcher = UnconfinedTestDispatcher()
+
+    @Provides
+    @Singleton
+    @IoDispatcher
+    fun provideIoDispatcher(): CoroutineDispatcher = UnconfinedTestDispatcher()
+
+    @Provides
+    @Singleton
+    @BgDispatcher
+    fun provideBgDispatcher(): CoroutineDispatcher = UnconfinedTestDispatcher()
+
+    @Provides
+    @Singleton
+    fun provideAppDb(
+        @ApplicationContext context: Context,
+    ): AppDb {
+        return Room.inMemoryDatabaseBuilder(
+            context,
+            AppDb::class.java
+        )
+            .allowMainThreadQueries()
+            .build()
+    }
+
+    @Provides
+    @Singleton
+    fun provideTransferDao(db: AppDb): TransferDao = db.transferDao()
+}

app/src/test/java/to/bitkit/test/BaseUnitTest.kt

@@ -11,7 +11,7 @@ import org.junit.Rule
 abstract class BaseUnitTest(
     testDispatcher: TestDispatcher = UnconfinedTestDispatcher()
 ) {
-    @get:Rule
+    @get:Rule(order = 0)
     val coroutinesTestRule = MainDispatcherRule(testDispatcher)
 
     protected val testDispatcher get() = coroutinesTestRule.testDispatcher