package com.atlassian.cache.hazelcast;
   
   import java.util.concurrent.ExecutorService;
   import java.util.concurrent.Executors;
   
   import com.atlassian.cache.CacheLoader;
   
   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.invocation.InvocationOnMock;
  import org.mockito.junit.MockitoJUnit;
  import org.mockito.junit.MockitoRule;
  import org.mockito.stubbing.Answer;
  
  import static org.junit.Assert.assertEquals;
  import static org.mockito.Mockito.when;
  
  
  public class CacheVersionAwareCacheLoaderTest
  {
      @ClassRule
      public static InitOnceHazelcastCluster cluster = InitOnceHazelcastCluster.getInstance();
  
      @Rule
      public MockitoRule mockitoRule = MockitoJUnit.rule();
  
      @Mock
      private CacheLoader<String, String> delegate;
  
      private ExecutorService executorService;
      private CacheVersionAwareCacheLoader<String, String> cacheLoader;
      private CacheVersion cacheVersion;
  
      @Before
      public void setUp() throws Exception
      {
          cacheVersion = new CacheVersion(cluster.getNode(0), "mock");
          executorService = Executors.newSingleThreadExecutor();
          cacheLoader = new CacheVersionAwareCacheLoader(delegate, cacheVersion);
      }
  
      @After
      public void tearDown() throws Exception
      {
          executorService.shutdownNow();
      }
  
      @Test
      public void shouldLoadValues()
      {
          when(delegate.load("key")).thenReturn("value");
  
          assertEquals("value", cacheLoader.load("key"));
      }
  
      @Test
      public void shouldLoadValuesAfterInvalidation()
      {
          when(delegate.load("key")).thenReturn("value");
  
          cacheVersion.incrementAndGet();
  
          assertEquals("value", cacheLoader.load("key"));
      }
  
      @Test
      public void shouldReloadValuesWhenInvalidating()
      {
          when(delegate.load("key")).then(invalidateAllAndReturnInvalid()).thenReturn("value");
  
          assertEquals("value", cacheLoader.load("key"));
      }
  
      private Answer<String> invalidateAllAndReturnInvalid()
      {
          return new Answer<String>()
          {
              @Override
              public String answer(InvocationOnMock invocationOnMock) throws Throwable
              {
                  cacheVersion.incrementAndGet();
                  return "invalid";
              }
          };
      }
  }