Home | History | Annotate | Download | only in dependency 
      1 package org.robolectric.internal.dependency;
      2 
      3 import static org.junit.Assert.assertEquals;
      4 import static org.mockito.Mockito.any;
      5 import static org.mockito.Mockito.mock;
      6 import static org.mockito.Mockito.never;
      7 import static org.mockito.Mockito.verify;
      8 import static org.mockito.Mockito.when;
      9 
     10 import java.io.Serializable;
     11 import java.net.MalformedURLException;
     12 import java.net.URL;
     13 import java.util.HashMap;
     14 import java.util.Map;
     15 import org.junit.Before;
     16 import org.junit.Rule;
     17 import org.junit.Test;
     18 import org.junit.rules.TemporaryFolder;
     19 import org.junit.runner.RunWith;
     20 import org.junit.runners.JUnit4;
     21 import org.junit.runners.model.InitializationError;
     22 import org.robolectric.internal.dependency.CachedDependencyResolver.Cache;
     23 import org.robolectric.internal.dependency.CachedDependencyResolver.CacheNamingStrategy;
     24 import org.robolectric.internal.dependency.CachedDependencyResolver.CacheValidationStrategy;
     25 
     26 @RunWith(JUnit4.class)
     27 public class CachedDependencyResolverTest {
     28   @Rule public TemporaryFolder temporaryFolder = new TemporaryFolder();
     29   private static final String CACHE_NAME = "someName";
     30   private DependencyResolver internalResolver = mock(DependencyResolver.class);
     31   private CacheNamingStrategy cacheNamingStrategy = new CacheNamingStrategy() {
     32     @Override
     33     public String getName(String prefix, DependencyJar... dependencies) {
     34       return CACHE_NAME;
     35     }
     36   };
     37   private CacheValidationStrategy cacheValidationStrategy = new CacheValidationStrategy() {
     38     @Override
     39     public boolean isValid(URL url) {
     40       return true;
     41     }
     42 
     43     @Override
     44     public boolean isValid(URL[] urls) {
     45       return true;
     46     }
     47   };
     48 
     49   private URL url;
     50   private Cache cache = new CacheStub();
     51   private DependencyJar[] dependencies = new DependencyJar[]{
     52       createDependency("group1", "artifact1"),
     53       createDependency("group2", "artifact2"),
     54   };
     55   private DependencyJar dependency = dependencies[0];
     56 
     57   @Before
     58   public void setUp() throws InitializationError, MalformedURLException {
     59     url = new URL("http://localhost");
     60   }
     61 
     62   @Test
     63   public void getLocalArtifactUrl_shouldWriteLocalArtifactUrlWhenCacheMiss() throws Exception{
     64     DependencyResolver res = createResolver();
     65 
     66     when(internalResolver.getLocalArtifactUrl(dependency)).thenReturn(url);
     67 
     68     URL url = res.getLocalArtifactUrl(dependency);
     69 
     70     assertEquals(this.url, url);
     71     assertCacheContents(url);
     72   }
     73 
     74   @Test
     75   public void getLocalArtifactUrl_shouldReadLocalArtifactUrlFromCacheIfExists() throws Exception {
     76     DependencyResolver res = createResolver();
     77     cache.write(CACHE_NAME, url);
     78 
     79     URL url = res.getLocalArtifactUrl(dependency);
     80 
     81     verify(internalResolver, never()).getLocalArtifactUrl(dependency);
     82 
     83     assertEquals(this.url, url);
     84   }
     85 
     86   @Test
     87   public void getLocalArtifactUrl_whenCacheInvalid_shouldFetchDependencyInformation() {
     88     CacheValidationStrategy failStrategy = mock(CacheValidationStrategy.class);
     89     when(failStrategy.isValid(any(URL.class))).thenReturn(false);
     90 
     91     DependencyResolver res = new CachedDependencyResolver(internalResolver, cache, cacheNamingStrategy, failStrategy);
     92     cache.write(CACHE_NAME, this.url);
     93 
     94     res.getLocalArtifactUrl(dependency);
     95 
     96     verify(internalResolver).getLocalArtifactUrl(dependency);
     97   }
     98 
     99   private void assertCacheContents(URL url) {
    100     assertEquals(url, cache.load(CACHE_NAME, URL.class));
    101   }
    102 
    103   private DependencyResolver createResolver() {
    104     return new CachedDependencyResolver(internalResolver, cache, cacheNamingStrategy, cacheValidationStrategy);
    105   }
    106 
    107   private DependencyJar createDependency(final String groupId, final String artifactId) {
    108     return new DependencyJar(groupId, artifactId, null, "") {
    109 
    110       @Override
    111       public boolean equals(Object o) {
    112         if(!(o instanceof DependencyJar)) return false;
    113 
    114         DependencyJar d = (DependencyJar) o;
    115 
    116         return this.getArtifactId().equals(d.getArtifactId()) && this.getGroupId().equals(groupId);
    117       }
    118 
    119       @Override
    120       public int hashCode() {
    121         return 31 * getArtifactId().hashCode() + getGroupId().hashCode();
    122       }
    123     };
    124   }
    125 
    126   private static class CacheStub implements CachedDependencyResolver.Cache {
    127     private Map<String, Serializable> map = new HashMap<>();
    128 
    129     @SuppressWarnings("unchecked")
    130     @Override
    131     public <T extends Serializable> T load(String id, Class<T> type) {
    132       Serializable o = map.get(id);
    133 
    134       return o != null && o.getClass() == type ? (T) o : null;
    135     }
    136 
    137     @Override
    138     public <T extends Serializable> boolean write(String id, T object) {
    139       map.put(id, object);
    140       return true;
    141     }
    142   }
    143 }
    144