Tests/util (#167)

* util tests

* util tests

* util tests + persistence tests

* more persistence tests

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

+package de.rki.coronawarnapp.storage
+
+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 kotlinx.coroutines.runBlocking
+import org.junit.After
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/**
+ * ExposureSummaryDao test.
+ */
+@RunWith(AndroidJUnit4::class)
+class ExposureSummaryDaoTest {
+    private lateinit var dao: ExposureSummaryDao
+    private lateinit var db: AppDatabase
+
+    @Before
+    fun setUp() {
+        val context = ApplicationProvider.getApplicationContext<Context>()
+        db = Room.inMemoryDatabaseBuilder(
+            context, AppDatabase::class.java).build()
+        dao = db.exposureSummaryDao()
+    }
+
+    /**
+     * Test Create / Read DB operations.
+     */
+    @Test
+    fun testCROperations() {
+        runBlocking {
+            val testEntity1 = ExposureSummaryEntity().apply {
+                this.daysSinceLastExposure = 1
+                this.matchedKeyCount = 1
+                this.maximumRiskScore = 1
+                this.summationRiskScore = 1
+            }
+
+            val testEntity2 = ExposureSummaryEntity().apply {
+                this.daysSinceLastExposure = 2
+                this.matchedKeyCount = 2
+                this.maximumRiskScore = 2
+                this.summationRiskScore = 2
+            }
+
+            assertThat(dao.getExposureSummaryEntities().isEmpty()).isTrue()
+
+            val id1 = dao.insertExposureSummaryEntity(testEntity1)
+            var selectAll = dao.getExposureSummaryEntities()
+            var selectLast = dao.getLatestExposureSummary()
+            assertThat(dao.getExposureSummaryEntities().isEmpty()).isFalse()
+            assertThat(selectAll.size).isEqualTo(1)
+            assertThat(selectAll[0].id).isEqualTo(id1)
+            assertThat(selectLast).isNotNull()
+            assertThat(selectLast?.id).isEqualTo(id1)
+
+            val id2 = dao.insertExposureSummaryEntity(testEntity2)
+            selectAll = dao.getExposureSummaryEntities()
+            selectLast = dao.getLatestExposureSummary()
+            assertThat(selectAll.isEmpty()).isFalse()
+            assertThat(selectAll.size).isEqualTo(2)
+            assertThat(selectLast).isNotNull()
+            assertThat(selectLast?.id).isEqualTo(id2)
+        }
+    }
+
+    @After
+    fun closeDb() {
+        db.close()
+    }
+}

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

@@ -12,6 +12,9 @@ import org.junit.Before
 import org.junit.Test
 import org.junit.runner.RunWith
 
+/**
+ * KeyCacheDao test.
+ */
 @RunWith(AndroidJUnit4::class)
 class KeyCacheDaoTest {
     private lateinit var keyCacheDao: KeyCacheDao
@@ -25,6 +28,9 @@ class KeyCacheDaoTest {
         keyCacheDao = db.dateDao()
     }
 
+    /**
+     * Test Create / Read / Delete DB operations.
+     */
     @Test
     fun testCRDOperations() {
         runBlocking {

Corona-Warn-App/src/androidTest/java/de/rki/coronawarnapp/storage/tracing/TracingIntervalDaoTest.kt

+package de.rki.coronawarnapp.storage.tracing
+
+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
+import java.util.Date
+
+/**
+ * TracingIntervalDao test.
+ */
+@RunWith(AndroidJUnit4::class)
+class TracingIntervalDaoTest {
+    private lateinit var dao: TracingIntervalDao
+    private lateinit var db: AppDatabase
+
+    @Before
+    fun setUp() {
+        val context = ApplicationProvider.getApplicationContext<Context>()
+        db = Room.inMemoryDatabaseBuilder(
+            context, AppDatabase::class.java).build()
+        dao = db.tracingIntervalDao()
+    }
+
+    /**
+     * Test Create / Read / Delete DB operations.
+     */
+    @Test
+    fun testCRDOperations() {
+        runBlocking {
+            val oneDay = 24 * 60 * 60 * 1000
+            val today = Date().time
+            val testEntity = TracingIntervalEntity().apply {
+                // minus 1 day
+                this.from = today - oneDay
+                this.to = today
+            }
+
+            assertThat(dao.getAllIntervals().isEmpty()).isTrue()
+
+            dao.insertInterval(testEntity)
+
+            var select = dao.getAllIntervals()
+            assertThat(select.isEmpty()).isFalse()
+            assertThat(select.size).isEqualTo(1)
+            assertThat(select[0].from).isEqualTo(today - oneDay)
+            assertThat(select[0].to).isEqualTo(today)
+
+            dao.deleteOutdatedIntervals(today - 1)
+
+            select = dao.getAllIntervals()
+            assertThat(select.isEmpty()).isFalse()
+            assertThat(select.size).isEqualTo(1)
+
+            dao.deleteOutdatedIntervals(today + 1)
+            select = dao.getAllIntervals()
+            assertThat(select.isEmpty()).isTrue()
+        }
+    }
+
+    @After
+    fun closeDb() {
+        db.close()
+    }
+}

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

+package de.rki.coronawarnapp.storage
+
+import com.google.android.gms.nearby.exposurenotification.ExposureSummary
+import io.mockk.MockKAnnotations
+import io.mockk.coEvery
+import io.mockk.coVerify
+import io.mockk.every
+import io.mockk.impl.annotations.MockK
+import io.mockk.mockk
+import io.mockk.unmockkAll
+import kotlinx.coroutines.runBlocking
+import org.junit.After
+import org.junit.Before
+import org.junit.Test
+
+/**
+ * ExposureSummaryRepository test.
+ */
+class ExposureSummaryRepositoryTest {
+
+    @MockK
+    private lateinit var dao: ExposureSummaryDao
+    private lateinit var repository: ExposureSummaryRepository
+
+    @Before
+    fun setUp() {
+        MockKAnnotations.init(this)
+        repository = ExposureSummaryRepository(dao)
+
+        coEvery { dao.getExposureSummaryEntities() } returns listOf()
+        coEvery { dao.getLatestExposureSummary() } returns null
+        coEvery { dao.insertExposureSummaryEntity(any()) } returns 0
+    }
+
+    /**
+     * Test DAO is called.
+     */
+    @Test
+    fun testGet() {
+        runBlocking {
+            repository.getExposureSummaryEntities()
+
+            coVerify {
+                dao.getExposureSummaryEntities()
+            }
+        }
+    }
+
+    /**
+     * Test DAO is called.
+     */
+    @Test
+    fun testGetLatest() {
+        runBlocking {
+            repository.getLatestExposureSummary()
+
+            coVerify {
+                dao.getLatestExposureSummary()
+            }
+        }
+    }
+
+    /**
+     * Test DAO is called.
+     */
+    @Test
+    fun testInsert() {
+        val es = mockk<ExposureSummary>()
+        every { es.attenuationDurationsInMinutes } returns intArrayOf(0)
+        every { es.daysSinceLastExposure } returns 1
+        every { es.matchedKeyCount } returns 1
+        every { es.maximumRiskScore } returns 0
+        every { es.summationRiskScore } returns 0
+
+        runBlocking {
+            repository.insertExposureSummaryEntity(es)
+
+            coVerify {
+                dao.insertExposureSummaryEntity(any())
+            }
+        }
+    }
+
+    @After
+    fun cleanUp() {
+        unmockkAll()
+    }
+}

Corona-Warn-App/src/test/java/de/rki/coronawarnapp/storage/tracing/TracingIntervalRepositoryTest.kt

+package de.rki.coronawarnapp.storage.tracing
+
+import io.mockk.MockKAnnotations
+import io.mockk.Runs
+import io.mockk.coEvery
+import io.mockk.coVerify
+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.util.Date
+
+/**
+ * TracingIntervalRepository test.
+ */
+class TracingIntervalRepositoryTest {
+
+    @MockK
+    private lateinit var dao: TracingIntervalDao
+    private lateinit var repository: TracingIntervalRepository
+
+    @Before
+    fun setUp() {
+        MockKAnnotations.init(this)
+        repository = TracingIntervalRepository(dao)
+
+        coEvery { dao.deleteOutdatedIntervals(any()) } just Runs
+        coEvery { dao.insertInterval(any()) } just Runs
+        coEvery { dao.getAllIntervals() } returns listOf()
+    }
+
+    /**
+     * Test DAO is called.
+     */
+    @Test
+    fun testCreate() {
+        val today = Date().time
+
+        runBlocking {
+            repository.createInterval(today - 1, today)
+
+            coVerify {
+                dao.insertInterval(any())
+            }
+        }
+    }
+
+    /**
+     * Test DAO is called.
+     */
+    @Test
+    fun testGet() {
+        runBlocking {
+            repository.getIntervals()
+
+            coVerify {
+                dao.deleteOutdatedIntervals(any())
+                dao.getAllIntervals()
+            }
+        }
+    }
+
+    @After
+    fun cleanUp() {
+        unmockkAll()
+    }
+}