Add unit tests

plugins/source/build.gradle.kts

@@ -22,6 +22,8 @@ dependencies {
     implementation(project(":core:ui"))
     implementation(project(":core:utils"))
 
+    testImplementation(Libs.AndroidX.Work.testing)
+
     testImplementation(project(":shared:tests"))
 
     kapt(Libs.Dagger.compiler)

plugins/source/src/main/kotlin/app/aaps/plugins/source/XdripSourcePlugin.kt

@@ -1,6 +1,7 @@
 package app.aaps.plugins.source
 
 import android.content.Context
+import android.os.Bundle
 import androidx.work.WorkerParameters
 import androidx.work.workDataOf
 import app.aaps.core.interfaces.logging.AAPSLogger
@@ -77,6 +78,20 @@ class XdripSourcePlugin @Inject constructor(
         @Inject lateinit var dataWorkerStorage: DataWorkerStorage
         @Inject lateinit var uel: UserEntryLogger
 
+        fun getSensorStartTime(bundle: Bundle): Long? {
+            val now = dateUtil.now()
+            var sensorStartTime: Long? = if (sp.getBoolean(R.string.key_xdrip_log_ns_sensor_change, false)) {
+                bundle.getLong(Intents.EXTRA_SENSOR_STARTED_AT, 0)
+            } else {
+                null
+            }
+            // check start time validity
+            sensorStartTime?.let {
+                if (abs(it - now) > T.months(1).msecs() || it > now) sensorStartTime = null
+            }
+            return sensorStartTime
+        }
+
         override suspend fun doWorkAndLog(): Result {
             var ret = Result.success()
 
@@ -97,16 +112,7 @@ class XdripSourcePlugin @Inject constructor(
                         ?: ""
                 )
             )
-            val now = dateUtil.now()
+            val sensorStartTime = getSensorStartTime(bundle)
-            var sensorStartTime: Long? = if (sp.getBoolean(R.string.key_xdrip_log_ns_sensor_change, false)) {
-                bundle.getLong(Intents.EXTRA_SENSOR_STARTED_AT, 0)
-            } else {
-                null
-            }
-            // check start time validity
-            sensorStartTime?.let {
-                if (abs(it - now) > T.months(1).msecs() || it > now) sensorStartTime = null
-            }
             repository.runTransactionForResult(CgmSourceTransaction(glucoseValues, emptyList(), sensorStartTime))
                 .doOnError {
                     aapsLogger.error(LTag.DATABASE, "Error while saving values from Xdrip", it)

plugins/source/src/test/kotlin/app/aaps/plugins/source/XdripSourcePluginTest.kt

@@ -1,25 +1,115 @@
 package app.aaps.plugins.source
 
+import android.content.Context
+import android.os.Bundle
+import androidx.work.WorkerFactory
+import androidx.work.WorkerParameters
+import androidx.work.testing.TestListenableWorkerBuilder
+import app.aaps.core.interfaces.receivers.Intents
 import app.aaps.core.interfaces.resources.ResourceHelper
+import app.aaps.core.interfaces.utils.DateUtil
+import app.aaps.core.interfaces.utils.T
+import app.aaps.core.interfaces.sharedPreferences.SP
+import app.aaps.core.utils.receivers.DataWorkerStorage
+import app.aaps.shared.impl.utils.DateUtilImpl
+import app.aaps.shared.tests.BundleMock
 import app.aaps.shared.tests.TestBase
 import com.google.common.truth.Truth.assertThat
 import dagger.android.AndroidInjector
+import dagger.android.HasAndroidInjector
 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
 import org.mockito.Mock
+import org.mockito.Mockito.`when`
 
 class XdripSourcePluginTest : TestBase() {
 
-    private lateinit var xdripSourcePlugin: XdripSourcePlugin
+    abstract class ContextWithInjector : Context(), HasAndroidInjector
 
+    private lateinit var xdripSourcePlugin: XdripSourcePlugin
+    private lateinit var dateUtil: DateUtil
+    private lateinit var dataWorkerStorage: DataWorkerStorage
+
+    private val injector = HasAndroidInjector {
+        AndroidInjector {
+            if (it is XdripSourcePlugin.XdripSourceWorker) {
+                it.dataWorkerStorage = dataWorkerStorage
+                it.dateUtil = dateUtil
+                it.sp = sp
+            }
+        }
+    }
+
+    @Mock lateinit var sp: SP
     @Mock lateinit var rh: ResourceHelper
+    @Mock lateinit var context: ContextWithInjector
 
     @BeforeEach
     fun setup() {
-        xdripSourcePlugin = XdripSourcePlugin({ AndroidInjector { } }, rh, aapsLogger)
+        `when`(context.applicationContext).thenReturn(context)
+        `when`(context.androidInjector()).thenReturn(injector.androidInjector())
+        xdripSourcePlugin = XdripSourcePlugin(injector, rh, aapsLogger)
+        dateUtil = DateUtilImpl(context)
+        dataWorkerStorage = DataWorkerStorage(context)
+    }
+
+    private fun prepareWorker(
+        sensorStartTime: Long? = dateUtil.now(),
+        logNsSensorChange: Boolean = true,
+    ): Pair<Bundle, XdripSourcePlugin.XdripSourceWorker> {
+        val bundle = BundleMock.mock()
+        sensorStartTime?.let { bundle.putLong(Intents.EXTRA_SENSOR_STARTED_AT, sensorStartTime) }
+        `when`(sp.getBoolean(R.string.key_xdrip_log_ns_sensor_change, false)).thenReturn(logNsSensorChange)
+
+        lateinit var worker: XdripSourcePlugin.XdripSourceWorker
+        TestListenableWorkerBuilder<XdripSourcePlugin.XdripSourceWorker>(context)
+            .setWorkerFactory(object: WorkerFactory() {
+                override fun createWorker(appContext: Context, workerClassName: String, workerParameters: WorkerParameters): XdripSourcePlugin.XdripSourceWorker {
+                    worker = XdripSourcePlugin.XdripSourceWorker(context, workerParameters)
+                    return worker
+                }
+            })
+            .setInputData(dataWorkerStorage.storeInputData(bundle, Intents.ACTION_NEW_BG_ESTIMATE)).build()
+
+        return Pair(bundle, worker)
     }
 
     @Test fun advancedFilteringSupported() {
         assertThat(xdripSourcePlugin.advancedFilteringSupported()).isFalse()
     }
+
+    @Test fun getSensorStartTime_withoutValue_returnsNull() {
+        val (bundle, worker) = prepareWorker(sensorStartTime = null)
+
+        val result = worker.getSensorStartTime(bundle)
+
+        assertThat(result).isNull()
+    }
+
+    @Test fun getSensorStartTime_withSettingDisabled_returnsNull() {
+        val sensorStartTime = dateUtil.now()
+        val (bundle, worker) = prepareWorker(sensorStartTime = sensorStartTime, logNsSensorChange = false)
+
+        val result = worker.getSensorStartTime(bundle)
+
+        assertThat(result).isNull()
+    }
+
+    @Test fun getSensorStartTime_withRecentValue_returnsStartTime() {
+        val sensorStartTime = dateUtil.now()
+        val (bundle, worker) = prepareWorker(sensorStartTime = sensorStartTime)
+
+        val result = worker.getSensorStartTime(bundle)
+
+        assertThat(result).isEqualTo(sensorStartTime)
+    }
+
+    @Test fun getSensorStartTime_withOldValue_returnsNull() {
+        val sensorStartTime = dateUtil.now() - T.months(2).msecs()
+        val (bundle, worker) = prepareWorker(sensorStartTime = sensorStartTime)
+
+        val result = worker.getSensorStartTime(bundle)
+
+        assertThat(result).isNull()
+    }
 }