"[Test] Added test dependencies and unit test for cache"

Author: crypticminds

app/src/main/java/com/arcane/coldstorage/MainActivity.kt

@@ -11,7 +11,7 @@ import com.arcane.coldstorage.cache.ImageCache
 import com.arcane.coldstoragecache.callback.OnValueFetchedCallback
 import com.arcane.coldstoragecache.converter.impl.StringToBitmapConverter
 
-class MainActivity : AppCompatActivity(), OnValueFetchedCallback<Any?> {
+class MainActivity : AppCompatActivity(), OnValueFetchedCallback<Bitmap?> {
 
     companion object {
         val URLS = arrayListOf(
@@ -81,7 +81,7 @@ class MainActivity : AppCompatActivity(), OnValueFetchedCallback<Any?> {
      * When the image is downloaded , adding the image to
      * the image view.
      */
-    override fun valueFetched(output: Any?) {
+    override fun valueFetched(output: Bitmap?) {
         imageCache.commitToSharedPref(applicationContext)
         runOnUiThread {
             val outputAsBitmap = output as Bitmap

coldstoragecache/build.gradle

@@ -31,7 +31,15 @@ dependencies {
     implementation 'androidx.appcompat:appcompat:1.1.0'
     implementation 'androidx.core:core-ktx:1.1.0'
     implementation "com.fasterxml.jackson.module:jackson-module-kotlin:2.10.1"
+    // Required -- JUnit 4 framework
     testImplementation 'junit:junit:4.12'
+    // Optional -- Robolectric environment
+    testImplementation 'androidx.test:core:1.2.0'
+    // Optional -- Mockito framework
+    testImplementation 'org.mockito:mockito-core:2.19.0'
+    //mockk library
+    testImplementation "io.mockk:mockk:1.9.3"
+
     androidTestImplementation 'androidx.test.ext:junit:1.1.1'
     androidTestImplementation 'androidx.test.espresso:espresso-core:3.2.0'
     androidTestImplementation 'org.mockito:mockito-core:2.19.0'

coldstoragecache/src/androidTest/java/com/arcane/coldstoragecache/cache/CacheTest.kt

@@ -211,10 +211,10 @@ abstract class Cache {
      * needs to be considered stale.(In milliseconds)
      *
      */
-    fun get(
+    fun <Output> get(
         key: String,
-        onValueFetchedCallback: OnValueFetchedCallback<Any?>,
-        converter: IConverter<Any?>,
+        onValueFetchedCallback: OnValueFetchedCallback<Output?>,
+        converter: IConverter<Output?>,
         timeToLive: Long? = null
     ) {
         thread {
@@ -275,7 +275,7 @@ abstract class Cache {
      *
      * @param timeToLive the time after which the object will be considered stale.
      */
-    fun addToCache(key: String, objectToCache: Any, timeToLive: Long?) {
+    fun addToCache(key: String, objectToCache: Any, timeToLive: Long? = null) {
         val objectAsString = objectMapper.writeValueAsString(objectToCache)
         cache[key] = CachedDataModel(
             objectAsString,

coldstoragecache/src/main/java/com/arcane/coldstoragecache/cache/Cache.kt

@@ -12,7 +12,7 @@ import com.arcane.coldstoragecache.converter.IConverter
  *
  * @author Anurag
  */
-class StringToBitmapConverter : IConverter<Any?> {
+class StringToBitmapConverter : IConverter<Bitmap?> {
 
     /**
      * The function will convert the string stored in the cache

coldstoragecache/src/main/java/com/arcane/coldstoragecache/converter/impl/StringToBitmapConverter.kt

@@ -0,0 +1,130 @@
+package com.arcane.coldstoragecache.cache
+
+import android.content.Context
+import android.content.SharedPreferences
+import android.util.Log
+import com.arcane.coldstoragecache.callback.OnValueFetchedCallback
+import com.arcane.coldstoragecache.model.CachedDataModel
+import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
+import io.mockk.every
+import io.mockk.mockkStatic
+import org.junit.Assert
+import org.junit.Before
+import org.junit.Test
+import org.mockito.Mockito
+
+class CacheTest {
+
+    private lateinit var cacheWithString: Cache
+
+    private val testKey = "key"
+
+
+    @Before
+    fun resetValues() {
+        cacheWithString = CacheWithStringValue()
+        mockkStatic(Log::class)
+        every { Log.v(any(), any()) } returns 0
+        every { Log.d(any(), any()) } returns 0
+        every { Log.i(any(), any()) } returns 0
+        every { Log.e(any(), any()) } returns 0
+    }
+
+    @Test
+    fun testGetFromCacheWithCacheHit() {
+        cacheWithString.addToCache(testKey, "testValue")
+        val onValueFetchedCallback = object : OnValueFetchedCallback<String?> {
+            override fun valueFetched(output: String?) {
+                Assert.assertNotNull(output)
+                Assert.assertEquals(output!!, "testValue")
+            }
+        }
+        cacheWithString.get(testKey, onValueFetchedCallback)
+    }
+
+    @Test
+    fun testGetFromCacheWithCacheMiss() {
+        val onValueFetchedCallback = object : OnValueFetchedCallback<String?> {
+            override fun valueFetched(output: String?) {
+                Assert.assertNotNull(output)
+                Assert.assertEquals(output!!, "key2")
+            }
+        }
+        cacheWithString.get(testKey, onValueFetchedCallback)
+    }
+
+    @Test
+    fun testInitializeMethod() {
+        val allMap = hashMapOf<String, String>()
+        val applicationContext = Mockito.mock(Context::class.java)
+        val sharedPreferences = Mockito.mock(SharedPreferences::class.java)
+        Mockito.`when`(
+            applicationContext.getSharedPreferences(
+                Mockito.anyString(),
+                Mockito.anyInt()
+            )
+        ).thenReturn(sharedPreferences)
+        mockDataInSharedPref(sharedPreferences, allMap)
+        Cache.initialize(applicationContext)
+        Thread.sleep(1000)
+
+        for (i in allMap.keys) {
+            val value = cacheWithString.getWithoutUpdate(i)
+            if (i.contains("Present")) {
+                Assert.assertEquals(i, "TestObject", value)
+            } else {
+                Assert.assertNull(value)
+            }
+
+        }
+    }
+
+
+    private fun mockDataInSharedPref(
+        sharedPreferences: SharedPreferences,
+        allMap: HashMap<String, String>
+    ) {
+
+        val mapper = jacksonObjectMapper()
+        for (i in 1..5) {
+            val cachedDataModel = CachedDataModel(
+                "TestObject",
+                System.currentTimeMillis(), 2000
+            )
+            val modelAsString = mapper.writeValueAsString(cachedDataModel)
+            Mockito.`when`(
+                sharedPreferences.getString(
+                    "Present$i",
+                    ""
+                )
+            ).thenReturn(modelAsString)
+            allMap["Present$i"] = modelAsString
+
+        }
+        for (i in 1..10) {
+            val cachedDataModel = CachedDataModel(
+                "TestObject",
+                System.currentTimeMillis(), 10
+            )
+            val modelAsString = mapper.writeValueAsString(cachedDataModel)
+            Mockito.`when`(
+                sharedPreferences.getString(
+                    "Absent$i",
+                    ""
+                )
+            ).thenReturn(modelAsString)
+            allMap["Absent$i"] = modelAsString
+        }
+        Mockito.`when`(sharedPreferences.all).thenReturn(allMap)
+    }
+
+
+    class CacheWithStringValue : Cache() {
+        override fun update(key: String): String? {
+            return "key2"
+        }
+
+    }
+
+
+}