test(applock): add comprehensive test suite

Author: thoomi

app-common/src/test/kotlin/net/thunderbird/app/common/feature/applock/AppLockActivityLifecycleCallbacksTest.kt

@@ -0,0 +1,59 @@
+package net.thunderbird.app.common.feature.applock
+
+import android.app.Activity
+import android.os.Build
+import androidx.fragment.app.FragmentActivity
+import assertk.assertThat
+import assertk.assertions.isEmpty
+import assertk.assertions.isEqualTo
+import assertk.assertions.single
+import net.thunderbird.core.android.testing.RobolectricTest
+import net.thunderbird.feature.applock.api.AppLockGate
+import org.junit.Test
+import org.robolectric.Robolectric
+import org.robolectric.annotation.Config
+
+@Config(sdk = [Build.VERSION_CODES.TIRAMISU])
+class AppLockActivityLifecycleCallbacksTest : RobolectricTest() {
+
+    @Test
+    fun `should not crash when factory is null`() {
+        val testSubject = AppLockActivityLifecycleCallbacks(gateFactory = null)
+        val activity = Robolectric.buildActivity(FragmentActivity::class.java).create().get()
+
+        testSubject.onActivityCreated(activity, null)
+    }
+
+    @Test
+    fun `should create gate for FragmentActivity`() {
+        val fakeFactory = FakeAppLockGateFactory()
+        val testSubject = AppLockActivityLifecycleCallbacks(gateFactory = fakeFactory)
+        val activity = Robolectric.buildActivity(FragmentActivity::class.java).create().get()
+
+        testSubject.onActivityCreated(activity, null)
+
+        assertThat(fakeFactory.createdActivities).single().isEqualTo(activity)
+    }
+
+    @Test
+    fun `should not create gate for plain Activity`() {
+        val fakeFactory = FakeAppLockGateFactory()
+        val testSubject = AppLockActivityLifecycleCallbacks(gateFactory = fakeFactory)
+        val activity = Robolectric.buildActivity(Activity::class.java).create().get()
+
+        testSubject.onActivityCreated(activity, null)
+
+        assertThat(fakeFactory.createdActivities).isEmpty()
+    }
+
+    private class FakeAppLockGateFactory : AppLockGate.Factory {
+        val createdActivities = mutableListOf<FragmentActivity>()
+
+        override fun create(activity: FragmentActivity): AppLockGate {
+            createdActivities.add(activity)
+            return FakeAppLockGate()
+        }
+    }
+
+    private class FakeAppLockGate : AppLockGate
+}

feature/applock/impl/src/test/kotlin/net/thunderbird/feature/applock/impl/data/AppLockConfigStoreTest.kt

@@ -0,0 +1,66 @@
+package net.thunderbird.feature.applock.impl.data
+
+import android.os.Build
+import androidx.test.core.app.ApplicationProvider
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import assertk.assertions.isFalse
+import assertk.assertions.isTrue
+import net.thunderbird.feature.applock.api.AppLockConfig
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [Build.VERSION_CODES.TIRAMISU])
+class AppLockConfigStoreTest {
+
+    private val testSubject = AppLockConfigStore(ApplicationProvider.getApplicationContext())
+
+    @Test
+    fun `should return default config when nothing is stored`() {
+        val config = testSubject.getConfig()
+
+        assertThat(config.isEnabled).isFalse()
+        assertThat(config.timeoutMillis).isEqualTo(AppLockConfig.DEFAULT_TIMEOUT_MILLIS)
+    }
+
+    @Test
+    fun `should persist and retrieve enabled state`() {
+        testSubject.setConfig(AppLockConfig(isEnabled = true))
+
+        val config = testSubject.getConfig()
+
+        assertThat(config.isEnabled).isTrue()
+    }
+
+    @Test
+    fun `should persist and retrieve timeout`() {
+        testSubject.setConfig(AppLockConfig(timeoutMillis = 60_000L))
+
+        val config = testSubject.getConfig()
+
+        assertThat(config.timeoutMillis).isEqualTo(60_000L)
+    }
+
+    @Test
+    fun `should persist and retrieve full config`() {
+        val expected = AppLockConfig(isEnabled = true, timeoutMillis = 120_000L)
+
+        testSubject.setConfig(expected)
+
+        assertThat(testSubject.getConfig()).isEqualTo(expected)
+    }
+
+    @Test
+    fun `should overwrite previous config`() {
+        testSubject.setConfig(AppLockConfig(isEnabled = true, timeoutMillis = 60_000L))
+        testSubject.setConfig(AppLockConfig(isEnabled = false, timeoutMillis = 30_000L))
+
+        val config = testSubject.getConfig()
+
+        assertThat(config.isEnabled).isFalse()
+        assertThat(config.timeoutMillis).isEqualTo(30_000L)
+    }
+}