release 2.1.97

app/src/test/java/com/example/hpostesting/AssuranceControlsFragmentTest.kt

@@ -0,0 +1,55 @@
+package com.example.hpostesting
+
+import android.content.SharedPreferences
+import com.example.hpostesting.presentation.assurance.AssuranceControlsFragment
+import junit.framework.TestCase.assertEquals
+import org.junit.Before
+import org.junit.Test
+import org.mockito.Mock
+import org.mockito.MockitoAnnotations
+
+class AssuranceControlsFragmentTest {
+    @Mock
+    lateinit var sharedPreferences: SharedPreferences
+
+    private lateinit var assuranceControlsFragment: AssuranceControlsFragment
+
+    @Before
+    fun setUp() {
+        MockitoAnnotations.initMocks(this)
+        assuranceControlsFragment = AssuranceControlsFragment()
+    }
+
+//    @Test
+//    fun testInitViews() {
+//        val fragmentScenario = FragmentScenario.launchInContainer(AssuranceControlsFragment::class.java)
+//
+//        fragmentScenario.onFragment { fragment ->
+//            // Mock the shared preferences
+//            `when`(fragment.requireContext().getSharedPreferences("HEMOCUBE", Context.MODE_PRIVATE)).thenReturn(sharedPreferences)
+//
+//            // Mock the solution spinner selection
+//            fragment.binding.spinnerSolutions.setSelection(1)
+//
+//            // Verify that DataHolder.hemoCubeTestData!!.solution is set correctly
+//            assertEquals("KMnO4", DataHolder.hemoCubeTestData!!.solution)
+//
+//            // You can similarly test other parts of initViews() based on your requirements
+//        }
+//    }
+
+    @Test
+    fun testGetPositionOfValue() {
+        val fragment = AssuranceControlsFragment()
+
+        val testData = listOf("Select solution", "KMnO4", "Tartrazine", "AR", "HB", "Blood")
+
+        // Test a value that exists in the list
+        val positionKMnO4 = fragment.getPositionOfValue("KMnO4", testData)
+        assertEquals(1, positionKMnO4)
+
+        // Test a value that does not exist in the list
+        val positionNonExistent = fragment.getPositionOfValue("NonExistent", testData)
+        assertEquals(0, positionNonExistent)
+    }
+}

app/src/test/java/com/example/hpostesting/DeviceProvisionViewModelTest.kt

@@ -0,0 +1,83 @@
+package com.example.hpostesting
+
+import androidx.arch.core.executor.testing.InstantTaskExecutorRule
+import androidx.lifecycle.Observer
+import com.example.hpostesting.data.Result
+import com.example.hpostesting.data.model.deviceprovision.DeviceProvisionRequest
+import com.example.hpostesting.data.model.deviceprovision.DeviceProvisionResponse
+import com.example.hpostesting.data.repository.Repository
+import com.example.hpostesting.presentation.deviceprovision.DeviceProvisionViewModel
+import com.example.hpostesting.util.TestCoroutineRule
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.runBlockingTest
+import org.junit.After
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.mockito.Mock
+import org.mockito.Mockito
+import org.mockito.MockitoAnnotations
+
+@ExperimentalCoroutinesApi
+class DeviceProvisionViewModelTest {
+
+    // Rule to make LiveData updates instant
+    @get:Rule
+    val instantExecutorRule = InstantTaskExecutorRule()
+
+    // Rule for testing coroutines
+    @get:Rule
+    val coroutineRule = TestCoroutineRule()
+
+    // Mocks
+    @Mock
+    private lateinit var databaseRepository: Repository
+
+    @Mock
+    private lateinit var deviceProvisionObserver: Observer<Result<DeviceProvisionResponse>>
+
+    // Class under test
+    private lateinit var viewModel: DeviceProvisionViewModel
+
+    @Before
+    fun setUp() {
+        MockitoAnnotations.openMocks(this)
+        viewModel = DeviceProvisionViewModel(databaseRepository)
+        viewModel.deviceProvisionResponse.observeForever(deviceProvisionObserver)
+    }
+
+    @After
+    fun tearDown() {
+        viewModel.deviceProvisionResponse.removeObserver(deviceProvisionObserver)
+    }
+
+    @Test
+    fun `deviceProvision success`() = coroutineRule.runBlockingTest {
+        // Arrange
+        val deviceProvisionRequest = DeviceProvisionRequest(/* provide necessary parameters */)
+        val expectedResult = Result.Success(DeviceProvisionResponse(/* provide necessary response data */))
+        Mockito.`when`(databaseRepository.deviceProvision(deviceProvisionRequest)).thenReturn(expectedResult)
+
+        // Act
+        viewModel.deviceProvision(deviceProvisionRequest)
+
+        // Assert
+//        Mockito.verify(deviceProvisionObserver, Mockito.timeout(1000)).onChanged(Result.Loading())
+        Mockito.verify(deviceProvisionObserver, Mockito.timeout(1000)).onChanged(expectedResult)
+    }
+
+    @Test
+    fun `deviceProvision error`() = coroutineRule.runBlockingTest {
+        // Arrange
+        val deviceProvisionRequest = DeviceProvisionRequest(/* provide necessary parameters */)
+        val expectedError = Result.Error(Exception("Test error"))
+        Mockito.`when`(databaseRepository.deviceProvision(deviceProvisionRequest)).thenReturn(expectedError)
+
+        // Act
+        viewModel.deviceProvision(deviceProvisionRequest)
+
+        // Assert
+//        Mockito.verify(deviceProvisionObserver, Mockito.timeout(1000)).onChanged(Result.Loading())
+        Mockito.verify(deviceProvisionObserver, Mockito.timeout(1000)).onChanged(expectedError)
+    }
+}

app/src/test/java/com/example/hpostesting/DiagnosticsViewModelTest.kt

@@ -0,0 +1,86 @@
+package com.example.hpostesting
+
+import androidx.arch.core.executor.testing.InstantTaskExecutorRule
+import androidx.lifecycle.Observer
+import com.example.hpostesting.data.model.Response
+import com.example.hpostesting.data.model.diagnostics.DiagnosticsData
+import com.example.hpostesting.data.repository.Repository
+import com.example.hpostesting.presentation.diagnostics.DiagnosticsViewModel
+import io.mockk.coEvery
+import io.mockk.mockk
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.test.TestCoroutineDispatcher
+import kotlinx.coroutines.test.TestCoroutineScope
+import kotlinx.coroutines.test.runBlockingTest
+import kotlinx.coroutines.test.setMain
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.mockito.Mock
+import org.mockito.MockitoAnnotations
+
+@ExperimentalCoroutinesApi
+class DiagnosticsViewModelTest {
+
+    // Use this rule to swap the background executor used by the Architecture Components
+    @get:Rule
+    var instantTaskExecutorRule = InstantTaskExecutorRule()
+
+    // Use this dispatcher to control execution of coroutines in tests
+    private val testDispatcher = TestCoroutineDispatcher()
+
+    // Use this scope to control the execution of coroutines in tests
+    private val testCoroutineScope = TestCoroutineScope(testDispatcher)
+
+    // Mock Repository
+    private val mockRepository = mockk<Repository>()
+
+    // Mock Observer for LiveData
+    @Mock
+    private lateinit var mockObserver: Observer<String>
+
+    // Subject under test
+    private lateinit var diagnosticsViewModel: DiagnosticsViewModel
+
+    @Before
+    fun setup() {
+        // Initialize mocks
+        MockitoAnnotations.openMocks(this)
+
+        // Create the ViewModel with the mock repository and set the coroutine dispatcher
+        diagnosticsViewModel = DiagnosticsViewModel(repository = mockRepository)
+//        diagnosticsViewModel.viewModelScope = testCoroutineScope
+
+        // Observe the LiveData
+//        diagnosticsViewModel.fireBaseUpload.observeForever(mockObserver)
+
+        Dispatchers.setMain(TestCoroutineDispatcher())
+    }
+
+    @Test
+    fun `test addDiagnosticsDataToDb success`() = runBlocking {
+        // Given
+        val diagnosticsData = mockk<DiagnosticsData>()
+        coEvery { mockRepository.addDiagnostics(diagnosticsData) } returns Response.Success("Success")
+
+        // When
+        diagnosticsViewModel.addDiagnosticsDataToDb(diagnosticsData)
+
+        // Then
+        assert(diagnosticsViewModel.fireBaseUpload.value == "Success")
+    }
+
+    @Test
+    fun `addDiagnosticsDataToDb error`() = testCoroutineScope.runBlockingTest {
+        // Given
+        coEvery { mockRepository.addDiagnostics(any()) } returns Response.Error(Exception("Test error"))
+
+        // When
+        diagnosticsViewModel.addDiagnosticsDataToDb(mockk())
+
+        // Then
+        assert(diagnosticsViewModel.fireBaseUpload.value == "Error")
+    }
+}