Add screen and view model tests

2 files changed, 197 insertions, 0 deletions

diff --git a/android/app/src/androidTest/kotlin/net/mullvad/mullvadvpn/compose/screen/SettingsScreenTest.kt b/android/app/src/androidTest/kotlin/net/mullvad/mullvadvpn/compose/screen/SettingsScreenTest.kt
new file mode 100644
index 0000000000..5ed9ac1c8a
--- /dev/null
+++ b/android/app/src/androidTest/kotlin/net/mullvad/mullvadvpn/compose/screen/SettingsScreenTest.kt
@@ -0,0 +1,55 @@
+package net.mullvad.mullvadvpn.compose.screen
+
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.ui.test.junit4.createComposeRule
+import androidx.compose.ui.test.onNodeWithText
+import io.mockk.MockKAnnotations
+import net.mullvad.mullvadvpn.compose.state.SettingsUiState
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+
+class SettingsScreenTest {
+    @get:Rule val composeTestRule = createComposeRule()
+
+    @Before
+    fun setup() {
+        MockKAnnotations.init(this)
+    }
+
+    @Test
+    @OptIn(ExperimentalMaterial3Api::class)
+    fun testLoggedInState() {
+        // Arrange
+        composeTestRule.setContent {
+            SettingsScreen(
+                uiState =
+                    SettingsUiState(appVersion = "", isLoggedIn = true, isUpdateAvailable = true)
+            )
+        }
+        // Assert
+        composeTestRule.apply {
+            onNodeWithText("VPN settings").assertExists()
+            onNodeWithText("Split tunneling").assertExists()
+            onNodeWithText("App version").assertExists()
+        }
+    }
+
+    @Test
+    @OptIn(ExperimentalMaterial3Api::class)
+    fun testLoggedOutState() {
+        // Arrange
+        composeTestRule.setContent {
+            SettingsScreen(
+                uiState =
+                    SettingsUiState(appVersion = "", isLoggedIn = false, isUpdateAvailable = true)
+            )
+        }
+        // Assert
+        composeTestRule.apply {
+            onNodeWithText("VPN settings").assertDoesNotExist()
+            onNodeWithText("Split tunneling").assertDoesNotExist()
+            onNodeWithText("App version").assertExists()
+        }
+    }
+}
diff --git a/android/app/src/test/kotlin/net/mullvad/mullvadvpn/viewmodel/SettingsViewModelTest.kt b/android/app/src/test/kotlin/net/mullvad/mullvadvpn/viewmodel/SettingsViewModelTest.kt
new file mode 100644
index 0000000000..8f32ddcc8e
--- /dev/null
+++ b/android/app/src/test/kotlin/net/mullvad/mullvadvpn/viewmodel/SettingsViewModelTest.kt
@@ -0,0 +1,142 @@
+package net.mullvad.mullvadvpn.viewmodel
+
+import androidx.lifecycle.viewModelScope
+import app.cash.turbine.test
+import io.mockk.every
+import io.mockk.mockk
+import io.mockk.mockkStatic
+import io.mockk.unmockkAll
+import kotlin.test.assertEquals
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.test.runTest
+import net.mullvad.mullvadvpn.TestCoroutineRule
+import net.mullvad.mullvadvpn.model.DeviceState
+import net.mullvad.mullvadvpn.repository.DeviceRepository
+import net.mullvad.mullvadvpn.ui.VersionInfo
+import net.mullvad.mullvadvpn.ui.serviceconnection.AppVersionInfoCache
+import net.mullvad.mullvadvpn.ui.serviceconnection.ServiceConnectionContainer
+import net.mullvad.mullvadvpn.ui.serviceconnection.ServiceConnectionManager
+import net.mullvad.mullvadvpn.ui.serviceconnection.ServiceConnectionState
+import net.mullvad.mullvadvpn.util.appVersionCallbackFlow
+import org.junit.After
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+
+class SettingsViewModelTest {
+    @get:Rule val testCoroutineRule = TestCoroutineRule()
+
+    private val mockDeviceRepository: DeviceRepository = mockk()
+    private val mockServiceConnectionManager: ServiceConnectionManager = mockk()
+    private lateinit var mockAppVersionInfoCache: AppVersionInfoCache
+    private val mockServiceConnectionContainer: ServiceConnectionContainer = mockk()
+
+    private val serviceConnectionState =
+        MutableStateFlow<ServiceConnectionState>(ServiceConnectionState.Disconnected)
+    private val versionInfo =
+        MutableStateFlow(
+            VersionInfo(
+                currentVersion = null,
+                upgradeVersion = null,
+                isOutdated = false,
+                isSupported = false
+            )
+        )
+
+    private lateinit var viewModel: SettingsViewModel
+
+    @Before
+    fun setUp() {
+        mockkStatic(CACHE_EXTENSION_CLASS)
+        val deviceState = MutableStateFlow<DeviceState>(DeviceState.LoggedOut)
+        mockAppVersionInfoCache =
+            mockk<AppVersionInfoCache>().apply {
+                every { appVersionCallbackFlow() } returns versionInfo
+            }
+
+        every { mockServiceConnectionManager.connectionState } returns serviceConnectionState
+        every { mockServiceConnectionContainer.appVersionInfoCache } returns mockAppVersionInfoCache
+        every { mockDeviceRepository.deviceState } returns deviceState
+        every { mockAppVersionInfoCache.onUpdate = any() } answers {}
+
+        viewModel =
+            SettingsViewModel(
+                deviceRepository = mockDeviceRepository,
+                serviceConnectionManager = mockServiceConnectionManager
+            )
+    }
+
+    @After
+    fun tearDown() {
+        viewModel.viewModelScope.coroutineContext.cancel()
+        unmockkAll()
+    }
+
+    @Test
+    fun test_device_state_default_state() = runTest {
+        // Act, Assert
+        viewModel.uiState.test { assertEquals(false, awaitItem().isLoggedIn) }
+    }
+
+    @Test
+    fun test_device_state_supported_version_state() = runTest {
+        // Arrange
+        val versionInfoTestItem =
+            VersionInfo(
+                currentVersion = "1.0",
+                upgradeVersion = "1.0",
+                isOutdated = false,
+                isSupported = true
+            )
+
+        // Act, Assert
+        viewModel.uiState.test {
+            serviceConnectionState.value =
+                ServiceConnectionState.ConnectedReady(mockServiceConnectionContainer)
+            versionInfo.value = versionInfoTestItem
+            val result = awaitItem()
+            assertEquals(false, result.isUpdateAvailable)
+        }
+    }
+
+    @Test
+    fun test_device_state_unsupported_version_state() = runTest {
+        // Arrange
+        every { mockAppVersionInfoCache.isSupported } returns false
+        every { mockAppVersionInfoCache.isOutdated } returns false
+        every { mockAppVersionInfoCache.version } returns ""
+
+        // Act, Assert
+        viewModel.uiState.test {
+            awaitItem()
+
+            serviceConnectionState.value =
+                ServiceConnectionState.ConnectedReady(mockServiceConnectionContainer)
+            val result = awaitItem()
+            assertEquals(true, result.isUpdateAvailable)
+        }
+    }
+
+    @Test
+    fun test_device_state_outdated_version_state() = runTest {
+        // Arrange
+        every { mockAppVersionInfoCache.isSupported } returns true
+        every { mockAppVersionInfoCache.isOutdated } returns true
+        every { mockAppVersionInfoCache.version } returns ""
+
+        // Act, Assert
+        viewModel.uiState.test {
+            awaitItem()
+
+            serviceConnectionState.value =
+                ServiceConnectionState.ConnectedReady(mockServiceConnectionContainer)
+            val result = awaitItem()
+            assertEquals(true, result.isUpdateAvailable)
+        }
+    }
+
+    companion object {
+        private const val CACHE_EXTENSION_CLASS = "net.mullvad.mullvadvpn.util.CacheExtensionsKt"
+    }
+}