Tests/util (#162)

* util tests

* util tests

* util tests + persistence tests

Corona-Warn-App/src/androidTest/java/de/rki/coronawarnapp/storage/keycache/KeyCacheDaoTest.kt

+package de.rki.coronawarnapp.storage.keycache
+
+import android.content.Context
+import androidx.room.Room
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.google.common.truth.Truth.assertThat
+import de.rki.coronawarnapp.storage.AppDatabase
+import kotlinx.coroutines.runBlocking
+import org.junit.After
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class KeyCacheDaoTest {
+    private lateinit var keyCacheDao: KeyCacheDao
+    private lateinit var db: AppDatabase
+
+    @Before
+    fun setUp() {
+        val context = ApplicationProvider.getApplicationContext<Context>()
+        db = Room.inMemoryDatabaseBuilder(
+            context, AppDatabase::class.java).build()
+        keyCacheDao = db.dateDao()
+    }
+
+    @Test
+    fun testCRDOperations() {
+        runBlocking {
+            val dates = KeyCacheEntity().apply {
+                this.id = "0"
+                this.path = "0"
+                this.type = 0
+            }
+            val hours = KeyCacheEntity().apply {
+                this.id = "1"
+                this.path = "1"
+                this.type = 1
+            }
+
+            assertThat(keyCacheDao.getAllEntries().isEmpty()).isTrue()
+
+            keyCacheDao.insertEntry(dates)
+            keyCacheDao.insertEntry(hours)
+
+            var all = keyCacheDao.getAllEntries()
+
+            assertThat(all.size).isEqualTo(2)
+
+            val selectedDates = keyCacheDao.getDates()
+            assertThat(selectedDates.size).isEqualTo(1)
+            assertThat(selectedDates[0].type).isEqualTo(0)
+            assertThat(selectedDates[0].id).isEqualTo(dates.id)
+
+            val selectedHours = keyCacheDao.getHours()
+            assertThat(selectedHours.size).isEqualTo(1)
+            assertThat(selectedHours[0].type).isEqualTo(1)
+            assertThat(selectedHours[0].id).isEqualTo(hours.id)
+
+            keyCacheDao.clearHours()
+
+            all = keyCacheDao.getAllEntries()
+            assertThat(all.size).isEqualTo(1)
+            assertThat(all[0].type).isEqualTo(0)
+
+            keyCacheDao.insertEntry(hours)
+
+            assertThat(keyCacheDao.getAllEntries().size).isEqualTo(2)
+
+            keyCacheDao.clear()
+
+            assertThat(keyCacheDao.getAllEntries().isEmpty()).isTrue()
+        }
+    }
+
+    @After
+    fun closeDb() {
+        db.close()
+    }
+}

Corona-Warn-App/src/test/java/de/rki/coronawarnapp/storage/keycache/KeyCacheRepositoryTest.kt

+package de.rki.coronawarnapp.storage.keycache
+
+import io.mockk.MockKAnnotations
+import io.mockk.Runs
+import io.mockk.coEvery
+import io.mockk.coVerify
+import io.mockk.coVerifyOrder
+import io.mockk.impl.annotations.MockK
+import io.mockk.just
+import io.mockk.unmockkAll
+import kotlinx.coroutines.runBlocking
+import org.junit.After
+import org.junit.Before
+import org.junit.Test
+import java.net.URI
+
+/**
+ * KeyCacheRepository test.
+ */
+class KeyCacheRepositoryTest {
+
+    @MockK
+    private lateinit var keyCacheDao: KeyCacheDao
+
+    private lateinit var keyCacheRepository: KeyCacheRepository
+
+    @Before
+    fun setUp() {
+        MockKAnnotations.init(this)
+        keyCacheRepository = KeyCacheRepository(keyCacheDao)
+
+        // DAO tests in another test
+        coEvery { keyCacheDao.getAllEntries() } returns listOf()
+        coEvery { keyCacheDao.getHours() } returns listOf()
+        coEvery { keyCacheDao.clear() } just Runs
+        coEvery { keyCacheDao.clearHours() } just Runs
+        coEvery { keyCacheDao.insertEntry(any()) } returns 0
+    }
+
+    /**
+     * Test clear order.
+     */
+    @Test
+    fun testClear() {
+        runBlocking {
+            keyCacheRepository.clear()
+
+            coVerifyOrder {
+                keyCacheDao.getAllEntries()
+
+                keyCacheDao.clear()
+            }
+        }
+
+        runBlocking {
+            keyCacheRepository.clearHours()
+
+            coVerifyOrder {
+                keyCacheDao.getHours()
+
+                keyCacheDao.clearHours()
+            }
+        }
+    }
+
+    /**
+     * Test insert order.
+     */
+    @Test
+    fun testInsert() {
+        runBlocking {
+            keyCacheRepository.createEntry(key = "1", type = KeyCacheRepository.DateEntryType.DAY, uri = URI("1"))
+
+            coVerify {
+                keyCacheDao.insertEntry(any())
+            }
+        }
+    }
+
+    @After
+    fun cleanUp() {
+        unmockkAll()
+    }
+}

Corona-Warn-App/src/test/java/de/rki/coronawarnapp/util/CachedKeyFileHolderTest.kt

+package de.rki.coronawarnapp.util
+
+import android.content.Context
+import de.rki.coronawarnapp.CoronaWarnApplication
+
+import de.rki.coronawarnapp.storage.keycache.KeyCacheRepository
+import io.mockk.MockKAnnotations
+import io.mockk.Runs
+import io.mockk.coEvery
+import io.mockk.coVerifyOrder
+import io.mockk.every
+import io.mockk.impl.annotations.MockK
+import io.mockk.just
+import io.mockk.mockkObject
+import io.mockk.unmockkAll
+import kotlinx.coroutines.runBlocking
+import org.junit.After
+import org.junit.Before
+import org.junit.Test
+import java.util.Date
+
+/**
+ * CachedKeyFileHolder test.
+ */
+class CachedKeyFileHolderTest {
+
+    @MockK
+    private lateinit var keyCacheRepository: KeyCacheRepository
+
+    @MockK
+    private lateinit var context: Context
+
+    @Before
+    fun setUp() {
+        MockKAnnotations.init(this)
+        mockkObject(CoronaWarnApplication.Companion)
+        mockkObject(KeyCacheRepository.Companion)
+        every { CoronaWarnApplication.getAppContext() } returns context
+        every { KeyCacheRepository.getDateRepository(any()) } returns keyCacheRepository
+        mockkObject(CachedKeyFileHolder)
+        coEvery { keyCacheRepository.deleteOutdatedEntries() } just Runs
+    }
+
+    /**
+     * Test call order is correct.
+     */
+    @Test
+    fun testAsyncFetchFiles() {
+        val date = Date()
+
+        coEvery { keyCacheRepository.getDates() } returns listOf()
+        coEvery { keyCacheRepository.getFilesFromEntries() } returns listOf()
+        every { CachedKeyFileHolder["getDatesFromServer"]() } returns arrayListOf<String>()
+
+        runBlocking {
+
+            CachedKeyFileHolder.asyncFetchFiles(date)
+
+            coVerifyOrder {
+                CachedKeyFileHolder.asyncFetchFiles(date)
+                keyCacheRepository.deleteOutdatedEntries()
+                CachedKeyFileHolder["getDatesFromServer"]()
+                CachedKeyFileHolder["getMissingDaysFromDiff"](arrayListOf<String>())
+                keyCacheRepository.getDates()
+                keyCacheRepository.getFilesFromEntries()
+            }
+        }
+    }
+
+    @After
+    fun cleanUp() {
+        unmockkAll()
+    }
+}

Corona-Warn-App/src/test/java/de/rki/coronawarnapp/util/CallHelperTest.kt

+package de.rki.coronawarnapp.util
+
+import de.rki.coronawarnapp.ui.BaseFragment
+import io.mockk.Runs
+import io.mockk.every
+import io.mockk.just
+import io.mockk.mockk
+import io.mockk.verify
+import org.junit.Test
+
+/**
+ * CallHelper test.
+ */
+class CallHelperTest {
+
+    /**
+     * Test activity called.
+     */
+    @Test
+    fun testCall() {
+        val fragment = mockk<BaseFragment>()
+        every { fragment.startActivity(any()) } just Runs
+        CallHelper.call(fragment, "+77777777777")
+        verify(exactly = 1) { fragment.startActivity(any()) }
+    }
+}

Corona-Warn-App/src/test/java/de/rki/coronawarnapp/util/ConnectivityHelperTest.kt

+package de.rki.coronawarnapp.util
+
+import android.bluetooth.BluetoothAdapter
+import android.content.Context
+import android.content.Intent
+import android.net.ConnectivityManager
+import android.net.NetworkRequest
+import io.mockk.MockKAnnotations
+import io.mockk.every
+import io.mockk.impl.annotations.MockK
+import io.mockk.mockk
+import io.mockk.mockkConstructor
+import io.mockk.mockkObject
+import io.mockk.mockkStatic
+import io.mockk.unmockkAll
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+
+/**
+ * ConnectivityHelper test.
+ */
+class ConnectivityHelperTest {
+
+    @MockK
+    private lateinit var bAdapter: BluetoothAdapter
+
+    @MockK
+    private lateinit var context: Context
+
+    @Before
+    fun setUp() {
+        MockKAnnotations.init(this)
+        mockkStatic(BluetoothAdapter::class)
+    }
+
+    /**
+     * Test network callback behavior.
+     */
+    @Test
+    fun testNetworkCallback() {
+        var registered: Boolean? = null
+        var available: Boolean? = null
+        val callback = object : ConnectivityHelper.NetworkCallback() {
+            override fun onNetworkAvailable() {
+                available = true
+            }
+            override fun onNetworkUnavailable() {
+                available = false
+            }
+        }
+        mockkConstructor(NetworkRequest.Builder::class)
+        mockkObject(NetworkRequest.Builder())
+        val request = mockk<NetworkRequest>()
+        val manager = mockk<ConnectivityManager>()
+        every { anyConstructed<NetworkRequest.Builder>().addCapability(any()).addCapability(any()).build() } returns request
+        every { context.getSystemService(Context.CONNECTIVITY_SERVICE) } returns manager
+        every { manager.registerNetworkCallback(any(), callback) } answers { registered = true }
+        every { manager.unregisterNetworkCallback(callback) } answers { registered = false }
+
+        // register
+        ConnectivityHelper.registerNetworkStatusCallback(context, callback)
+
+        assertEquals(registered, true)
+        assertEquals(available, false)
+
+        // network found
+        callback.onAvailable(mockk())
+        assertEquals(available, true)
+
+        // loss of network
+        callback.onLost(mockk())
+        assertEquals(available, false)
+
+        // unregister
+        ConnectivityHelper.unregisterNetworkStatusCallback(context, callback)
+        assertEquals(registered, false)
+    }
+
+    /**
+     * Test bluetooth callback behaviour.
+     */
+    @Test
+    fun testBluetoothCallback() {
+        var registered: Boolean? = null
+        var available: Boolean? = null
+        val callback = object : ConnectivityHelper.BluetoothCallback() {
+            override fun onBluetoothAvailable() {
+                available = true
+            }
+
+            override fun onBluetoothUnavailable() {
+                available = false
+            }
+        }
+
+        val turnOn = mockk<Intent>()
+        every { turnOn.action } returns BluetoothAdapter.ACTION_STATE_CHANGED
+        every { turnOn.getIntExtra(BluetoothAdapter.EXTRA_STATE, any()) } returns BluetoothAdapter.STATE_ON
+
+        val turnOff = mockk<Intent>()
+        every { turnOff.action } returns BluetoothAdapter.ACTION_STATE_CHANGED
+        every { turnOff.getIntExtra(BluetoothAdapter.EXTRA_STATE, any()) } returns BluetoothAdapter.STATE_OFF
+
+        every { BluetoothAdapter.getDefaultAdapter() } returns bAdapter
+        every { context.registerReceiver(any(), any()) } answers {
+            registered = true
+            mockk()
+        }
+        every { context.unregisterReceiver(any()) } answers { registered = false }
+
+        // turned on
+        every { bAdapter.isEnabled } returns true
+
+        // register
+        ConnectivityHelper.registerBluetoothStatusCallback(context, callback)
+
+        assertNotNull(callback.recevier)
+        assertEquals(registered, true)
+        assertEquals(available, true)
+
+        // turned off
+        callback.recevier?.onReceive(context, turnOff)
+        assertEquals(available, false)
+
+        // turned on
+        callback.recevier?.onReceive(context, turnOn)
+        assertEquals(available, true)
+
+        // unregister
+        ConnectivityHelper.unregisterBluetoothStatusCallback(context, callback)
+
+        assertNull(callback.recevier)
+        assertEquals(registered, false)
+    }
+
+    /**
+     * Test bluetooth state.
+     */
+    @Test
+    fun testBluetoothState() {
+        // no bluetooth hardware
+        assertFalse(ConnectivityHelper.isBluetoothEnabled())
+
+        every { BluetoothAdapter.getDefaultAdapter() } returns bAdapter
+
+        // check turned off
+        every { bAdapter.isEnabled } returns false
+        assertFalse(ConnectivityHelper.isBluetoothEnabled())
+
+        // check turned on
+        every { bAdapter.isEnabled } returns true
+        assertTrue(ConnectivityHelper.isBluetoothEnabled())
+    }
+
+    @After
+    fun cleanUp() {
+        unmockkAll()
+    }
+}