Merge branch 'newExp'

fikisipi · fikisipi · commit 6f23ea088402 · 2021-04-26T13:57:14.000+02:00
diff --git a/README.md b/README.md
@@ -1,6 +1,6 @@
 ![SmartCache for Retrofit2](logo.png)
 
-## SmartCache - preloaded responses for Retrofit 2 [![Build Status](https://travis-ci.org/dimitrovskif/SmartCache.svg?branch=master)](https://travis-ci.org/dimitrovskif/SmartCache)
+## SmartCache - preloaded responses for Retrofit 2 [![Build Status](https://www.travis-ci.com/fikisipi/SmartCache.svg?branch=master)](https://travis-ci.org/dimitrovskif/SmartCache)
 
 #### This library calls your callback twice: first cached, then fresh data 
 
@@ -12,17 +12,18 @@ Instead of showing an empty screen while waiting for a network response, why not
 
 ### Install and use
 
-1. Gradle installation:
-```groovy
+1. Add SmartCache to Gradle dependencies, and JitPack to repos:
+<pre>
 repositories {
     ...
-    maven { url "https://jitpack.io" }
+    maven { url "https://jitpack.io" } // <b><-- Add this!</b>
 }
     
 dependencies {
-    compile 'com.github.fikisipi:SmartCache:2.9.0'
+    implementation 'com.squareup.retrofit2:retrofit:2.9.0'
+    implementation 'com.github.fikisipi:SmartCache:2.9.0' // <b><-- Add this!</b>
 }
-```
+</pre>
 
 2. Add `SmartCallFactory` to your Retrofit `Builder`:
 <pre>
diff --git a/retrofit-smartcache/build.gradle b/retrofit-smartcache/build.gradle
@@ -29,6 +29,5 @@ dependencies {
     testImplementation 'junit:junit:4.13'
     testImplementation 'com.squareup.okhttp3:mockwebserver:4.9.1'
     implementation 'com.jakewharton:disklrucache:2.0.2'
-    implementation 'com.squareup.retrofit2:retrofit:2.9.0'
-    //compile 'com.google.guava:guava:18.0'
+    implementation 'com.squareup.retrofit2:retrofit:2.9.0+'
 }
diff --git a/retrofit-smartcache/src/main/java/dimitrovskif/smartcache/SmartCallFactory.java b/retrofit-smartcache/src/main/java/dimitrovskif/smartcache/SmartCallFactory.java
@@ -23,7 +23,7 @@
 public class SmartCallFactory extends CallAdapter.Factory {
     private final CachingSystem cachingSystem;
     private final Executor asyncExecutor;
-    private final CachingSystem.RequestFilter requestFilter;
+    private CachingSystem.RequestFilter requestFilter;
 
     public static final CachingSystem.RequestFilter CACHE_GET_REQUESTS = new CachingSystem.RequestFilter() {
         @Override
@@ -50,6 +50,10 @@ public static SmartCallFactory createBasic(Context ctx) {
         return new SmartCallFactory(BasicCaching.buildFromContext(ctx));
     }
 
+    public static SmartCallFactory createBasic(Context ctx, CachingSystem.RequestFilter requestFilter) {
+        return new SmartCallFactory(BasicCaching.buildFromContext(ctx), new AndroidExecutor(), requestFilter);
+    }
+
     @Override
     public CallAdapter<?, ?> get(final Type returnType, final Annotation[] annotations,
                                  final Retrofit retrofit) {
diff --git a/retrofit-smartcache/src/test/java/dimitrovskif/smartcache/CallbackTest.java b/retrofit-smartcache/src/test/java/dimitrovskif/smartcache/CallbackTest.java
@@ -1,5 +1,7 @@
 package dimitrovskif.smartcache;
 
+import org.junit.After;
+import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
 
@@ -33,25 +35,38 @@ private CallAdapter.Factory buildSmartCacheFactory(){
         return factory;
     }
 
+    private DemoService demoService = null;
+    private Logger log = null;
+
+    @Before
+    public void setUp() {
+        Retrofit r = new Retrofit.Builder()
+                .baseUrl(server.url("/"))
+                .addConverterFactory(new ToStringConverterFactory())
+                .addCallAdapterFactory(buildSmartCacheFactory())
+                .build();
+        this.demoService = r.create(DemoService.class);
+        log = Logger.getLogger("test_logger");
+    }
+
+    @After
+    public void tearDown() {
+        this.demoService = null;
+    }
+
     @Rule public final MockWebServer server = new MockWebServer();
+
     @Test
-    public void dispatch_isGood() throws Exception{
+    public void simpleNetworkTest() throws Exception {
         /* Set up the mock webserver */
         MockResponse resp = new MockResponse();
         resp.setBody("VERY_BASIC_BODY");
         server.enqueue(resp);
         server.enqueue(resp.clone());
 
-        Retrofit r = new Retrofit.Builder()
-                .baseUrl(server.url("/"))
-                .addConverterFactory(new ToStringConverterFactory())
-                .addCallAdapterFactory(buildSmartCacheFactory())
-                .build();
-        DemoService demoService = r.create(DemoService.class);
-
 
         final Logger log = Logger.getLogger("test_logger");
-        final CountDownLatch latch = new CountDownLatch(1);
+        final CountDownLatch latch = new CountDownLatch(2);
         final AtomicReference<Response<String>> responseRef = new AtomicReference<>();
         demoService.getHome().enqueue(new Callback<String>() {
             @Override
@@ -66,54 +81,99 @@ public void onFailure(Call<String> call, Throwable t) {
                 fail("Failure executing the request.");
             }
         });
-        assertTrue(latch.await(1, TimeUnit.SECONDS));
+        latch.await(1, TimeUnit.SECONDS);
+        assertEquals(latch.getCount(), 1);
         assertEquals(responseRef.get().body(), "VERY_BASIC_BODY");
-        final CountDownLatch latch2 = new CountDownLatch(2);
-        final AtomicReference<Response<String>> response2Ref = new AtomicReference<>();
+        assertTrue("No network flag on response.", SmartCache.isResponseFromNetwork(responseRef.get()));
+    }
+
+    @Test
+    public void twoTestCheck() throws Exception{
+        /* Set up the mock webserver */
+        MockResponse resp = new MockResponse();
+        resp.setBody("VERY_BASIC_BODY");
+        server.enqueue(resp);
+        server.enqueue(resp.clone());
+
+        final CountDownLatch latch = new CountDownLatch(2);
+        final AtomicReference<Response<String>> responseRef = new AtomicReference<>();
         demoService.getHome().enqueue(new Callback<String>() {
             @Override
             public void onResponse(Call<String> call, Response<String> response) {
-                latch2.countDown();
-                if(latch2.getCount() == 1){ // the cache hit one.
-                    log.info("Got a response. Should be a cache hit.");
-                    response2Ref.set(response);
-                }else{ // the network one.
-                    log.info("Got a response. Should be a real network hit.");
-                    assertEquals(response.body(), response2Ref.get().body());
-                }
+                log.info("Got a response in pass #1 in twoTestCheck() call.");
+                responseRef.set(response);
+                latch.countDown();
             }
 
             @Override
             public void onFailure(Call<String> call, Throwable t) {
                 fail("Failure executing the request.");
             }
         });
-        assertTrue(latch2.await(1, TimeUnit.SECONDS));
+        latch.await(1, TimeUnit.SECONDS);
+        assertEquals(latch.getCount(), 1);
+        assertEquals(responseRef.get().body(), "VERY_BASIC_BODY");
+        assertTrue("Response isn't from network.", SmartCache.isResponseFromNetwork(responseRef.get()));
 
-        server.enqueue(resp.clone());
+        final CountDownLatch doubleLatch = new CountDownLatch(2);
+        final AtomicReference<Response<String>> secondTestResponse = new AtomicReference<>();
+        final AtomicReference<Response<String>> secondTestResponse2 = new AtomicReference<>();
 
-        final CountDownLatch latch3 = new CountDownLatch(2);
-        final AtomicInteger postResponses = new AtomicInteger(0);
-        // final AtomicReference<Response<String>> response3Ref = new AtomicReference<>();
-        demoService.postHome().enqueue(new Callback<String>() {
+        demoService.getHome().enqueue(new Callback<String>() {
             @Override
             public void onResponse(Call<String> call, Response<String> response) {
-                log.info("Got post response");
-                postResponses.incrementAndGet();
-                latch3.countDown();
+                doubleLatch.countDown();
+                if(doubleLatch.getCount() == 1){
+                    secondTestResponse.set(response);
+                    log.info("Got a response in pass #2 in twoTestCheck() call. [latch = 1]");
+                } else { // the network one.
+                    secondTestResponse2.set(response);
+                    log.info("Got a response in pass #2 in twoTestCheck() call. [latch = 2]");
+                }
             }
 
             @Override
             public void onFailure(Call<String> call, Throwable t) {
                 fail("Failure executing the request.");
             }
         });
-        latch3.await(1, TimeUnit.SECONDS);
-        assertEquals(1, postResponses.get());
 
+        assertTrue(doubleLatch.await(1, TimeUnit.SECONDS));
+        Response<String> resp1 = secondTestResponse.get();
+        Response<String> resp2 = secondTestResponse2.get();
+
+        assertNotNull(resp1);
+        assertNotNull(resp2);
+
+        assertFalse(SmartCache.isResponseFromNetwork(secondTestResponse.get()));
+        assertTrue(SmartCache.isResponseFromNetwork(secondTestResponse2.get()));
+    }
+
+    @Test
+    public void testDisabledCache() throws Exception {
+        MockResponse resp = new MockResponse();
+        resp.setBody("VERY_BASIC_BODY");
+        server.enqueue(resp);
         server.enqueue(resp.clone());
 
-        assertTrue("Synchronous call works.", demoService.getHome().execute().body().length() > 0);
+        for(int i = 0; i < 2; i++) {
+            log.info("Doing disabled test cache twice. i=" + String.valueOf(i));
+            CountDownLatch latch = new CountDownLatch(2);
+            demoService.postHome().enqueue(new Callback<String>() {
+                @Override
+                public void onResponse(Call<String> call, Response<String> response) {
+                    latch.countDown();
+                    log.info("Got a response in testDisabledCache()");
+                }
+
+                @Override
+                public void onFailure(Call<String> call, Throwable t) {
+                    log.warning("Got a failure in testDisabledCache()");
+                }
+            });
+            latch.await(1, TimeUnit.SECONDS);
+            assertEquals(latch.getCount(), 1);
+        }
     }
 
     static class MainThreadExecutor implements Executor{

Original file line number	Diff line number	Diff line change
`@@ -29,6 +29,5 @@ dependencies {`
`29`	`29`	`testImplementation 'junit:junit:4.13'`
`30`	`30`	`testImplementation 'com.squareup.okhttp3:mockwebserver:4.9.1'`
`31`	`31`	`implementation 'com.jakewharton:disklrucache:2.0.2'`
`32`		`- implementation 'com.squareup.retrofit2:retrofit:2.9.0'`
`33`		`- //compile 'com.google.guava:guava:18.0'`
	`32`	`+ implementation 'com.squareup.retrofit2:retrofit:2.9.0+'`
`34`	`33`	`}`