package com.atlassian.cache.hazelcast;
   
   import com.atlassian.cache.Cache;
   import com.atlassian.cache.CacheFactory;
   import com.atlassian.cache.CacheLoader;
   import com.atlassian.cache.CacheSettings;
   import com.atlassian.cache.CacheSettingsBuilder;
   import com.atlassian.cache.CachedReference;
   import com.atlassian.cache.ManagedCache;
  import com.atlassian.cache.Supplier;
  
  import org.junit.After;
  import org.junit.Before;
  import org.junit.ClassRule;
  import org.junit.Rule;
  import org.junit.Test;
  import org.mockito.Mock;
  import org.mockito.junit.MockitoJUnit;
  import org.mockito.junit.MockitoRule;
  
  import static org.hamcrest.CoreMatchers.equalTo;
  import static org.hamcrest.MatcherAssert.assertThat;
  import static org.mockito.ArgumentMatchers.any;
  import static org.mockito.ArgumentMatchers.anyString;
  import static org.mockito.ArgumentMatchers.eq;
  import static org.mockito.Mockito.mock;
  import static org.mockito.Mockito.times;
  import static org.mockito.Mockito.verify;
  import static org.mockito.Mockito.verifyNoMoreInteractions;
  import static org.mockito.Mockito.when;
  import static org.mockito.Mockito.withSettings;
  
  @SuppressWarnings("rawtypes")  // mocks
  public class HazelcastLocalCacheTest
  {
      @ClassRule
      public static InitOnceHazelcastCluster cluster = InitOnceHazelcastCluster.getInstance();
  
      @Rule
      public MockitoRule mockitoRule = MockitoJUnit.rule();
  
      @Mock
      private CacheFactory localFactory;
      private Cache cache;
      private CachedReference cachedReference;
      private HazelcastCacheManager cacheManager;
  
      @Before
      public void setup()
      {
          cache = mock(Cache.class, withSettings().extraInterfaces(ManagedCache.class));
          cachedReference = mock(CachedReference.class, withSettings().extraInterfaces(ManagedCache.class));
          when(localFactory.getCache(anyString(), any(CacheLoader.class), any(CacheSettings.class)))
                  .thenReturn(cache);
          when(localFactory.getCachedReference(anyString(), any(Supplier.class), any(CacheSettings.class)))
                  .thenReturn(cachedReference);
  
          cacheManager = new HazelcastCacheManager(cluster.getNode(0), localFactory, HazelcastTestSupport.getDefaultsProvider());
          cacheManager.init();
      }
  
      @After
      public void tearDown()
      {
          cacheManager.destroy();
      }
  
      @Test
      public void testLocalCacheDelegatedToLocalFactory()
      {
          CacheLoader loader = mock(CacheLoader.class);
          assertThat(cacheManager.getCache("test", loader, new CacheSettingsBuilder().local().build()), equalTo(cache));
  
          // the cacheManager should keep track of the created Cache instance and not call the localFactory again
          assertThat(cacheManager.getCache("test"), equalTo(cache));
  
          verify(localFactory).getCache(eq("test"), eq(loader), any(CacheSettings.class));
          verifyNoMoreInteractions(localFactory);
      }
  
      @Test
      public void testLocalCachedReferenceDelegatedToLocalFactory()
      {
          Supplier supplier = mock(Supplier.class);
          assertThat(cacheManager.getCachedReference("test", supplier, new CacheSettingsBuilder().local().build()), equalTo(cachedReference));
  
          // the cacheManager call the localFactory again when a new reference is requested
          assertThat(cacheManager.getCachedReference("test", supplier, new CacheSettingsBuilder().local().build()), equalTo(cachedReference));
  
          verify(localFactory, times(2)).getCachedReference(eq("test"), eq(supplier), any(CacheSettings.class));
          verifyNoMoreInteractions(localFactory);
      }
  }