diff --git a/Corona-Warn-App/src/androidTest/java/de/rki/coronawarnapp/storage/keycache/KeyCacheDaoTest.kt b/Corona-Warn-App/src/androidTest/java/de/rki/coronawarnapp/storage/keycache/KeyCacheDaoTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..fbbe1a3039e29ce31099996baf1a3f6e24c3589e
--- /dev/null
+++ b/Corona-Warn-App/src/androidTest/java/de/rki/coronawarnapp/storage/keycache/KeyCacheDaoTest.kt
@@ -0,0 +1,81 @@
+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()
+ }
+}
diff --git a/Corona-Warn-App/src/test/java/de/rki/coronawarnapp/storage/keycache/KeyCacheRepositoryTest.kt b/Corona-Warn-App/src/test/java/de/rki/coronawarnapp/storage/keycache/KeyCacheRepositoryTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..ce1c1fa67bb58461bf2e043b828529892509d3d8
--- /dev/null
+++ b/Corona-Warn-App/src/test/java/de/rki/coronawarnapp/storage/keycache/KeyCacheRepositoryTest.kt
@@ -0,0 +1,84 @@
+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()
+ }
+}
diff --git a/Corona-Warn-App/src/test/java/de/rki/coronawarnapp/util/CachedKeyFileHolderTest.kt b/Corona-Warn-App/src/test/java/de/rki/coronawarnapp/util/CachedKeyFileHolderTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..8985994fe0cff07d41b67d6e1a944fa532add3f5
--- /dev/null
+++ b/Corona-Warn-App/src/test/java/de/rki/coronawarnapp/util/CachedKeyFileHolderTest.kt
@@ -0,0 +1,74 @@
+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()
+ }
+}
diff --git a/Corona-Warn-App/src/test/java/de/rki/coronawarnapp/util/CallHelperTest.kt b/Corona-Warn-App/src/test/java/de/rki/coronawarnapp/util/CallHelperTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..7b581d0e55af657c3fa98d68e9e67061b9f60614
--- /dev/null
+++ b/Corona-Warn-App/src/test/java/de/rki/coronawarnapp/util/CallHelperTest.kt
@@ -0,0 +1,26 @@
+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()) }
+ }
+}
diff --git a/Corona-Warn-App/src/test/java/de/rki/coronawarnapp/util/ConnectivityHelperTest.kt b/Corona-Warn-App/src/test/java/de/rki/coronawarnapp/util/ConnectivityHelperTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..aaee12ffe4eaf14c9ed5fc75e8837b6d19425f59
--- /dev/null
+++ b/Corona-Warn-App/src/test/java/de/rki/coronawarnapp/util/ConnectivityHelperTest.kt
@@ -0,0 +1,165 @@
+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()
+ }
+}