stuff

opensrp · sevenreup · Aug 1, 2023 · Apr 26, 2023 · May 26, 2023 · Jun 5, 2023
commit 2a28a52c9e862132c9974281f44a8abd67375aa7
diff --git a/android/engine/src/main/java/org/smartregister/fhircore/engine/auth/AccountAuthenticator.kt b/android/engine/src/main/java/org/smartregister/fhircore/engine/auth/AccountAuthenticator.kt
@@ -35,8 +35,6 @@ import org.smartregister.fhircore.engine.data.remote.shared.TokenAuthenticator
 import org.smartregister.fhircore.engine.data.remote.shared.TokenAuthenticator.Companion.AUTH_TOKEN_TYPE
 import org.smartregister.fhircore.engine.ui.login.LoginActivity
 import org.smartregister.fhircore.engine.util.SecureSharedPreference
-import org.smartregister.fhircore.engine.util.extension.getActivity
-import org.smartregister.fhircore.engine.util.extension.launchActivityWithNoBackStackHistory
 import retrofit2.HttpException
 import timber.log.Timber
 

diff --git a/...e/src/test/java/org/smartregister/fhircore/engine/ui/register/BaseRegisterActivityTest.kt b/...e/src/test/java/org/smartregister/fhircore/engine/ui/register/BaseRegisterActivityTest.kt
@@ -41,9 +41,7 @@ import dagger.hilt.android.testing.HiltAndroidRule
 import dagger.hilt.android.testing.HiltAndroidTest
 import dagger.hilt.android.testing.UninstallModules
 import io.mockk.every
-import io.mockk.just
 import io.mockk.mockk
-import io.mockk.runs
 import io.mockk.spyk
 import io.mockk.verify
 import java.io.InterruptedIOException
@@ -118,7 +116,7 @@ class BaseRegisterActivityTest : ActivityRobolectricTest() {
     every { secureSharedPreference.retrieveSessionUsername() } returns "demo"
     every { secureSharedPreference.retrieveCredentials() } returns FakeModel.authCredentials
     every { secureSharedPreference.deleteCredentials() } returns Unit
-    every { accountAuthenticator.logout(any()) } returns  Unit
+    every { accountAuthenticator.logout(any()) } returns Unit
 
     ApplicationProvider.getApplicationContext<Context>().apply { setTheme(R.style.AppTheme) }
 

diff --git a/android/quest/src/main/java/org/smartregister/fhircore/quest/ui/main/AppMainViewModel.kt b/android/quest/src/main/java/org/smartregister/fhircore/quest/ui/main/AppMainViewModel.kt
@@ -96,9 +96,10 @@ constructor(
 
   fun onEvent(event: AppMainEvent) {
     when (event) {
-      is AppMainEvent.Logout -> accountAuthenticator.logout {
-        event.context.getActivity()?.launchActivityWithNoBackStackHistory<LoginActivity>()
-      }
+      is AppMainEvent.Logout ->
+        accountAuthenticator.logout {
+          event.context.getActivity()?.launchActivityWithNoBackStackHistory<LoginActivity>()
+        }
       is AppMainEvent.SwitchLanguage -> {
         sharedPreferencesHelper.write(SharedPreferenceKey.LANG.name, event.language.tag)
         event.context.run {

diff --git a/android/quest/src/test/java/org/smartregister/fhircore/quest/CqlContentTest.kt b/android/quest/src/test/java/org/smartregister/fhircore/quest/CqlContentTest.kt
@@ -20,93 +20,106 @@ import ca.uhn.fhir.context.FhirContext
 import ca.uhn.fhir.context.FhirVersionEnum
 import com.google.android.fhir.FhirEngine
 import com.google.android.fhir.logicalId
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
 import io.mockk.coEvery
 import io.mockk.coVerify
+import io.mockk.every
 import io.mockk.just
 import io.mockk.mockk
 import io.mockk.runs
 import io.mockk.slot
-import io.mockk.spyk
 import kotlinx.coroutines.runBlocking
 import org.cqframework.cql.cql2elm.CqlTranslator
 import org.cqframework.cql.cql2elm.FhirLibrarySourceProvider
 import org.cqframework.cql.cql2elm.LibraryManager
 import org.hl7.fhir.r4.model.Bundle
+import org.hl7.fhir.r4.model.DataRequirement
 import org.hl7.fhir.r4.model.Library
 import org.hl7.fhir.r4.model.Observation
 import org.hl7.fhir.r4.model.Patient
 import org.hl7.fhir.r4.model.Resource
 import org.hl7.fhir.r4.model.ResourceType
 import org.junit.Assert
+import org.junit.Before
+import org.junit.Rule
 import org.junit.Test
 import org.smartregister.fhircore.engine.cql.LibraryEvaluator
 import org.smartregister.fhircore.engine.data.local.DefaultRepository
-import org.smartregister.fhircore.engine.util.DefaultDispatcherProvider
 import org.smartregister.fhircore.quest.robolectric.RobolectricTest
 
+@HiltAndroidTest
 class CqlContentTest : RobolectricTest() {
+  @get:Rule
+  var hiltRule = HiltAndroidRule(this)
   val fhirContext: FhirContext = FhirContext.forCached(FhirVersionEnum.R4)
   val parser = fhirContext.newJsonParser()!!
   val evaluator = LibraryEvaluator().apply { initialize() }
 
+  @Before
+  fun setUp() {
+    hiltRule.inject()
+  }
+
   @Test
   fun runCqlLibraryTestForPqMedication() {
     val resourceDir = "cql/pq-medication"
     val cql = "$resourceDir/cql.txt".readFile()
 
     val cqlElm = toJsonElm(cql).readStringToBase64Encoded()
     val cqlLibrary =
-      parser.parseResource(
-        "$resourceDir/library.json".readFile().replace("#library-elm.json", cqlElm)
-      ) as
-        Library
+            parser.parseResource(
+                    "$resourceDir/library.json".readFile().replace("#library-elm.json", cqlElm)
+            ) as
+                    Library
 
     println(cqlLibrary.convertToString(false) as String)
 
     val fhirHelpersLibrary = "cql-common/helper.json".parseSampleResourceFromFile() as Library
 
     val patient =
-      "patient-registration-questionnaire/sample/patient.json".parseSampleResourceFromFile() as
-        Patient
+            "patient-registration-questionnaire/sample/patient.json".parseSampleResourceFromFile() as
+                    Patient
     val dataBundle =
-      Bundle().apply {
-        // output of test results extraction is input of this cql
-        "test-results-questionnaire/sample"
-          .readDir()
-          .map { it.parseSampleResource() as Resource }
-          .forEach { addEntry().apply { resource = it } }
-
-        // output of test results cql is also added to input of this cql
-        "cql/test-results/sample".readDir().map { it.parseSampleResource() as Resource }.forEach {
-          addEntry().apply { resource = it }
-        }
-      }
+            Bundle().apply {
+              // output of test results extraction is input of this cql
+              "test-results-questionnaire/sample"
+                      .readDir()
+                      .map { it.parseSampleResource() as Resource }
+                      .forEach { addEntry().apply { resource = it } }
+
+              // output of test results cql is also added to input of this cql
+              "cql/test-results/sample".readDir().map { it.parseSampleResource() as Resource }.forEach {
+                addEntry().apply { resource = it }
+              }
+            }
 
     val fhirEngine = mockk<FhirEngine>()
-    val defaultRepository = spyk(DefaultRepository(fhirEngine, DefaultDispatcherProvider()))
+    val defaultRepository = mockk<DefaultRepository>()
 
     coEvery { fhirEngine.get(ResourceType.Library, cqlLibrary.logicalId) } returns cqlLibrary
     coEvery { fhirEngine.get(ResourceType.Library, fhirHelpersLibrary.logicalId) } returns
-      fhirHelpersLibrary
+            fhirHelpersLibrary
+    every { defaultRepository.fhirEngine } returns fhirEngine
     coEvery { defaultRepository.save(any()) } just runs
     coEvery { defaultRepository.search(any()) } returns listOf()
 
     val result = runBlocking {
       evaluator.runCqlLibrary(
-        cqlLibrary.logicalId,
-        patient,
-        dataBundle.apply {
-          this.entry.removeIf { it.resource.resourceType == ResourceType.Patient }
-        },
-        defaultRepository,
-        true
+              cqlLibrary.logicalId,
+              patient,
+              dataBundle.apply {
+                this.entry.removeIf { it.resource.resourceType == ResourceType.Patient }
+              },
+              defaultRepository,
+              true
       )
     }
 
     assertOutput(
-      "$resourceDir/output_medication_request.json",
-      result,
-      ResourceType.MedicationRequest
+            "$resourceDir/output_medication_request.json",
+            result,
+            ResourceType.MedicationRequest
     )
 
     coVerify { defaultRepository.save(any()) }
@@ -119,58 +132,58 @@ class CqlContentTest : RobolectricTest() {
 
     val cqlElm = toJsonElm(cql).readStringToBase64Encoded()
     val cqlLibrary =
-      parser.parseResource(
-        "$resourceDir/library.json".readFile().replace("#library-elm.json", cqlElm)
-      ) as
-        Library
+            parser.parseResource(
+                    "$resourceDir/library.json".readFile().replace("#library-elm.json", cqlElm)
+            ) as
+                    Library
 
     println(cqlLibrary.convertToString(false) as String)
 
     val fhirHelpersLibrary = "cql-common/helper.json".parseSampleResourceFromFile() as Library
 
     val patient =
-      "patient-registration-questionnaire/sample/patient.json".parseSampleResourceFromFile() as
-        Patient
+            "patient-registration-questionnaire/sample/patient.json".parseSampleResourceFromFile() as
+                    Patient
     val dataBundle =
-      Bundle().apply {
-        // output of test results extraction is input of this cql
-        "test-results-questionnaire/sample"
-          .readDir()
-          .map { it.parseSampleResource() as Resource }
-          .forEach { addEntry().apply { resource = it } }
-      }
+            Bundle().apply {
+              // output of test results extraction is input of this cql
+              "test-results-questionnaire/sample"
+                      .readDir()
+                      .map { it.parseSampleResource() as Resource }
+                      .forEach { addEntry().apply { resource = it } }
+            }
 
     val fhirEngine = mockk<FhirEngine>()
-    val defaultRepository = spyk(DefaultRepository(fhirEngine, DefaultDispatcherProvider()))
+    val defaultRepository = mockk<DefaultRepository>()
 
     coEvery { fhirEngine.get(ResourceType.Library, cqlLibrary.logicalId) } returns cqlLibrary
     coEvery { fhirEngine.get(ResourceType.Library, fhirHelpersLibrary.logicalId) } returns
-      fhirHelpersLibrary
+            fhirHelpersLibrary
     coEvery { defaultRepository.save(any()) } just runs
     coEvery { defaultRepository.search(any()) } returns listOf()
 
     val result = runBlocking {
       evaluator.runCqlLibrary(
-        cqlLibrary.logicalId,
-        patient,
-        dataBundle.apply {
-          this.entry.removeIf { it.resource.resourceType == ResourceType.Patient }
-        },
-        defaultRepository,
-        true
+              cqlLibrary.logicalId,
+              patient,
+              dataBundle.apply {
+                this.entry.removeIf { it.resource.resourceType == ResourceType.Patient }
+              },
+              defaultRepository,
+              true
       )
     }
 
     assertOutput("$resourceDir/sample/output_condition.json", result, ResourceType.Condition)
     assertOutput(
-      "$resourceDir/sample/output_service_request.json",
-      result,
-      ResourceType.ServiceRequest
+            "$resourceDir/sample/output_service_request.json",
+            result,
+            ResourceType.ServiceRequest
     )
     assertOutput(
-      "$resourceDir/sample/output_diagnostic_report.json",
-      result,
-      ResourceType.DiagnosticReport
+            "$resourceDir/sample/output_diagnostic_report.json",
+            result,
+            ResourceType.DiagnosticReport
     )
 
     coVerify(exactly = 3) { defaultRepository.save(any()) }
@@ -183,32 +196,34 @@ class CqlContentTest : RobolectricTest() {
 
     val cqlElm = toJsonElm(cql).readStringToBase64Encoded()
     val cqlLibrary =
-      parser.parseResource(
-        "$resourceDir/library.json".readFile().replace("#library-elm.json", cqlElm)
-      ) as
-        Library
+            parser.parseResource(
+                    "$resourceDir/library.json".readFile().replace("#library-elm.json", cqlElm)
+            ) as
+                    Library
 
     println(cqlLibrary.convertToString(false) as String)
 
     val fhirHelpersLibrary = "cql-common/helper.json".parseSampleResourceFromFile() as Library
 
     val dataBundle =
-      Bundle().apply {
-        addEntry().apply {
-          // questionnaire-response of test results is input of this cql
-          resource =
-            "test-results-questionnaire/questionnaire-response.json".parseSampleResourceFromFile() as
-              Resource
-        }
-      }
+            Bundle().apply {
+              addEntry().apply {
+                // questionnaire-response of test results is input of this cql
+                resource =
+                        "test-results-questionnaire/questionnaire-response.json".parseSampleResourceFromFile() as
+                                Resource
+              }
+            }
 
     val fhirEngine = mockk<FhirEngine>()
-    val defaultRepository = spyk(DefaultRepository(fhirEngine, DefaultDispatcherProvider()))
+    val defaultRepository = mockk<DefaultRepository>()
 
     coEvery { fhirEngine.get(ResourceType.Library, cqlLibrary.logicalId) } returns cqlLibrary
     coEvery { fhirEngine.get(ResourceType.Library, fhirHelpersLibrary.logicalId) } returns
-      fhirHelpersLibrary
+            fhirHelpersLibrary
+    every { defaultRepository.fhirEngine } returns fhirEngine
     coEvery { defaultRepository.save(any()) } just runs
+    coEvery { defaultRepository.search(any<DataRequirement>()) } returns listOf()
 
     val result = runBlocking {
       evaluator.runCqlLibrary(cqlLibrary.logicalId, null, dataBundle, defaultRepository)
@@ -218,23 +233,23 @@ class CqlContentTest : RobolectricTest() {
 
     Assert.assertTrue(result.contains("OUTPUT -> Correct Result"))
     Assert.assertTrue(
-      result.contains(
-        "OUTPUT -> \nDetails:\n" +
-          "Value (3.0) is in Normal G6PD Range 0-3\n" +
-          "Value (11.0) is in Normal Haemoglobin Range 8-12"
-      )
+            result.contains(
+                    "OUTPUT -> \nDetails:\n" +
+                            "Value (3.0) is in Normal G6PD Range 0-3\n" +
+                            "Value (11.0) is in Normal Haemoglobin Range 8-12"
+            )
     )
 
     val observationSlot = slot<Observation>()
     coVerify { defaultRepository.save(capture(observationSlot)) }
 
     Assert.assertEquals(
-      "QuestionnaireResponse/TEST_QUESTIONNAIRE_RESPONSE",
-      observationSlot.captured.focusFirstRep.reference
+            "QuestionnaireResponse/TEST_QUESTIONNAIRE_RESPONSE",
+            observationSlot.captured.focusFirstRep.reference
     )
     Assert.assertEquals(
-      "Correct Result",
-      observationSlot.captured.valueCodeableConcept.codingFirstRep.display
+            "Correct Result",
+            observationSlot.captured.valueCodeableConcept.codingFirstRep.display
     )
     Assert.assertEquals("Device Operation", observationSlot.captured.code.codingFirstRep.display)
   }
@@ -244,7 +259,7 @@ class CqlContentTest : RobolectricTest() {
     libraryManager.librarySourceLoader.registerProvider(FhirLibrarySourceProvider())
 
     val translator: CqlTranslator =
-      CqlTranslator.fromText(cql, evaluator.modelManager, libraryManager)
+            CqlTranslator.fromText(cql, evaluator.modelManager, libraryManager)
 
     return translator.toJxson().also { println(it.replace("\n", "").replace("   ", "")) }
   }
@@ -254,12 +269,12 @@ class CqlContentTest : RobolectricTest() {
 
     val expectedResource = resource.parseSampleResourceFromFile().convertToString(true)
     val cqlResultStr =
-      cqlResult.find { it.startsWith("OUTPUT") && it.contains("\"resourceType\":\"$type\"") }!!
-        .replaceTimePart()
+            cqlResult.find { it.startsWith("OUTPUT") && it.contains("\"resourceType\":\"$type\"") }!!
+                    .replaceTimePart()
 
     println(cqlResultStr)
     println(expectedResource as String)
 
     Assert.assertTrue(cqlResultStr.contains("OUTPUT -> $expectedResource"))
   }
-}
+}