Introduce LoadingStrategy.CacheOnly

README.md

@@ -21,9 +21,9 @@ And then to the module level `build.gradle.kts`:
 
 ```
 dependencies {
-    implementation 'com.revolut.rxdata:dod:1.5.16'
-    implementation 'com.revolut.rxdata:core:1.5.16'
-    implementation 'com.revolut.rxdata:scheduler:1.5.16'
+    implementation 'com.revolut.rxdata:dod:1.5.17'
+    implementation 'com.revolut.rxdata:core:1.5.17'
+    implementation 'com.revolut.rxdata:scheduler:1.5.17'
 }
 ```
 

dfd/gradle.properties

@@ -1,5 +1,5 @@
 POM_ARTIFACT_ID=dfd
-VERSION_NAME=1.5.16
+VERSION_NAME=1.5.17
 POM_NAME=dfd
 POM_PACKAGING=jar
 GROUP=com.revolut.flowdata

dod-wrapper/gradle.properties

@@ -1,5 +1,5 @@
 POM_ARTIFACT_ID=dod-wrapper
-VERSION_NAME=1.5.16
+VERSION_NAME=1.5.17
 POM_NAME=dod-wrapper
 POM_PACKAGING=jar
 GROUP=com.revolut.rxdata

dod/gradle.properties

@@ -1,5 +1,5 @@
 POM_ARTIFACT_ID=dod
-VERSION_NAME=1.5.16
+VERSION_NAME=1.5.17
 POM_NAME=dod
 POM_PACKAGING=jar
 GROUP=com.revolut.rxdata

dod/src/main/java/com/revolut/rxdata/dod/DataObservableDelegate.kt

@@ -107,10 +107,14 @@ class DataObservableDelegate<Params : Any, Domain : Any> constructor(
             val memCache = fromMemory(params)
             val memoryIsEmpty = memCache == null
             val subject = subject(params)
-            val loading = loadingStrategy.refreshMemory
-                    || memoryIsEmpty
-                    || failedNetworkRequests.containsKey(params)
-                    || (memoryCacheIsFromStorage[params] == true && loadingStrategy.refreshStorage)
+            val hasFailedNetworkRequest = failedNetworkRequests.containsKey(params)
+            val memCacheFromStorage = memoryCacheIsFromStorage[params] == true
+            val loading = when (loadingStrategy) {
+                LoadingStrategy.Auto -> memoryIsEmpty || memCacheFromStorage || hasFailedNetworkRequest
+                LoadingStrategy.CacheOnly -> false
+                LoadingStrategy.ForceReload -> true
+                LoadingStrategy.LazyReload -> memoryIsEmpty || hasFailedNetworkRequest
+            }
 
             val observable: Observable<Data<Domain>> = if (memCache != null) {
                 concat(
@@ -125,7 +129,12 @@ class DataObservableDelegate<Params : Any, Domain : Any> constructor(
             } else {
                 sharedStorageRequest.getOrLoad(params)
                     .flatMapObservable { cached ->
-                        val needToFetchFromNetwork = loadingStrategy.refreshStorage || cached.content == null
+                        val needToFetchFromNetwork = when (loadingStrategy) {
+                            LoadingStrategy.Auto -> true
+                            LoadingStrategy.CacheOnly -> false
+                            LoadingStrategy.ForceReload -> true
+                            LoadingStrategy.LazyReload -> cached.content == null
+                        }
                         val cachedObservable = if (needToFetchFromNetwork) {
                             just(cached)
                         } else {

dod/src/main/java/com/revolut/rxdata/dod/LoadingStrategy.kt

@@ -2,35 +2,26 @@ package com.revolut.rxdata.dod
 
 /**
  * [DataObservableDelegate] observation loading strategy
- *
- * @param refreshMemory - if true data will be fetched from network even if there is something in the memory
- * @param refreshStorage - if true data will be fetched from network even if there is something in the storage
  */
-sealed class LoadingStrategy(
-    internal val refreshMemory: Boolean,
-    internal val refreshStorage: Boolean,
-) {
+sealed class LoadingStrategy {
+
     /**
      * data will be fetched from the Network even if the data exists in the cache
      */
-    object ForceReload: LoadingStrategy(
-        refreshMemory = true,
-        refreshStorage = true,
-    )
+    object ForceReload: LoadingStrategy()
 
     /**
      * data will not be fetched from the Network if the data exists in the memory cache
      */
-    object Auto: LoadingStrategy(
-        refreshMemory = false,
-        refreshStorage = true,
-    )
+    object Auto: LoadingStrategy()
 
     /**
      * data will not be fetched from the Network if the data exists in the cache memory or storage
      */
-    object LazyReload: LoadingStrategy(
-        refreshMemory = false,
-        refreshStorage = false,
-    )
+    object LazyReload: LoadingStrategy()
+
+    /**
+     * data will not be fetched from the Network even if there is no data in the cache
+     */
+    object CacheOnly : LoadingStrategy()
 }

dod/src/test/java/com/revolut/rxdata/dod/DataObservableDelegateTest.kt

@@ -939,4 +939,58 @@ class DataObservableDelegateTest : BaseDataObservableDelegateTest() {
 
         verify(fromNetwork, times(0)).invoke(eq(params))
     }
+
+    @Test
+    fun `WHEN fromMemory has value AND LoadingStrategy is CacheOnly THEN subscriber receives memory value AND network request not triggered `() {
+        memCache[params] = cachedDomain
+
+        val testObserver =
+            dataObservableDelegate.observe(params = params, loadingStrategy = LoadingStrategy.CacheOnly).test()
+
+        testObserver.assertValueCount(1)
+        testObserver.assertValueAt(0, Data(content = cachedDomain, error = null, loading = false))
+
+        ioScheduler.triggerActions()
+
+        verifyNoMoreInteractions(fromNetwork)
+    }
+
+    @Test
+    fun `WHEN fromMemory returns null, fromStorage has value AND LoadingStrategy is CacheOnly THEN subscriber receives storage value AND network request not triggered `() {
+        whenever(fromMemory.invoke(eq(params))).thenReturn(null)
+        storage[params] = cachedDomain
+
+        val testObserver =
+            dataObservableDelegate.observe(params = params, loadingStrategy = LoadingStrategy.CacheOnly).test()
+
+        testObserver.assertValueCount(1)
+        testObserver.assertValueAt(0, Data(content = null, error = null, loading = true))
+        ioScheduler.triggerActions()
+
+        testObserver.assertValueCount(2)
+        testObserver.assertValueAt(1, Data(content = cachedDomain, error = null, loading = false))
+
+        ioScheduler.triggerActions()
+
+        verifyNoMoreInteractions(fromNetwork)
+    }
+
+    @Test
+    fun `WHEN fromMemory returns null, fromStorage returns null AND LoadingStrategy is CacheOnly THEN subscriber does not receive value AND network request not triggered`() {
+        whenever(fromNetwork.invoke(eq(params))).thenReturn(null)
+        whenever(fromMemory.invoke(eq(params))).thenReturn(null)
+        val testObserver =
+            dataObservableDelegate.observe(params = params, loadingStrategy = LoadingStrategy.CacheOnly).test()
+
+        testObserver.assertValueCount(1)
+        testObserver.assertValueAt(0, Data(content = null, error = null, loading = true))
+        ioScheduler.triggerActions()
+
+        testObserver.assertValueCount(2)
+        testObserver.assertValueAt(1, Data(content = null, error = null, loading = false))
+
+        ioScheduler.triggerActions()
+
+        verifyNoMoreInteractions(fromNetwork)
+    }
 }

flow-extensions/gradle.properties

@@ -1,5 +1,5 @@
 POM_ARTIFACT_ID=extensions
-VERSION_NAME=1.5.16
+VERSION_NAME=1.5.17
 POM_NAME=flow-core
 POM_PACKAGING=jar
 GROUP=com.revolut.flowdata

model/gradle.properties

@@ -1,5 +1,5 @@
 POM_ARTIFACT_ID=model
-VERSION_NAME=1.5.16
+VERSION_NAME=1.5.17
 POM_NAME=data
 POM_PACKAGING=jar
 GROUP=com.revolut.data

rx-extensions/gradle.properties

@@ -1,5 +1,5 @@
 POM_ARTIFACT_ID=extensions
-VERSION_NAME=1.5.16
+VERSION_NAME=1.5.17
 POM_NAME=core
 POM_PACKAGING=jar
 GROUP=com.revolut.rxdata

scheduler/gradle.properties

@@ -1,5 +1,5 @@
 POM_ARTIFACT_ID=scheduler
-VERSION_NAME=1.5.16
+VERSION_NAME=1.5.17
 POM_NAME=scheduler
 POM_PACKAGING=aar
 GROUP=com.revolut.rxdata