package com.atlassian.cache.ehcache;
   
   import java.util.Collections;
   import java.util.List;
   import java.util.concurrent.TimeUnit;
   
   import com.atlassian.cache.CacheSettingsBuilder;
   import com.atlassian.cache.ehcache.replication.rmi.RMICacheReplicatorConfigFactory;
   import com.atlassian.cache.ehcache.replication.rmi.RMICacheReplicatorFactory;
  
  import net.sf.ehcache.Ehcache;
  import org.junit.Before;
  import org.junit.Test;
  import org.mockito.ArgumentCaptor;
  import org.mockito.Mock;
  
  import net.sf.ehcache.Cache;
  import net.sf.ehcache.CacheManager;
  import net.sf.ehcache.config.CacheConfiguration;
  import net.sf.ehcache.config.Configuration;
  import net.sf.ehcache.distribution.CacheManagerPeerProvider;
  
  import static com.atlassian.cache.ehcache.EhCacheHelper.PERSISTENCE_STRATEGY;
  import static java.util.Collections.singletonMap;
  import static net.sf.ehcache.config.CacheConfiguration.CacheEventListenerFactoryConfiguration;
  import static net.sf.ehcache.config.CacheConfiguration.DEFAULT_TTI;
  import static net.sf.ehcache.config.CacheConfiguration.DEFAULT_TTL;
  import static org.junit.Assert.assertEquals;
  import static org.junit.Assert.assertFalse;
  import static org.junit.Assert.assertTrue;
  import static org.mockito.Mockito.mock;
  import static org.mockito.Mockito.verify;
  import static org.mockito.Mockito.when;
  import static org.mockito.MockitoAnnotations.initMocks;
  
  public class EhCacheHelperTest
  {
      // Constants
      private static final int MAX_ENTRIES = 10;
      private static final long EXPIRE_AFTER_ACCESS = 20;
      private static final long EXPIRE_AFTER_WRITE = 30;
      private static final String CACHE_NAME = "MyCache";
  
      // Fixture
      private EhCacheHelper helper;
      @Mock private CacheManager mockCacheManager;
      private CacheConfiguration defaultCacheConfiguration;
  
      @Before
      public void setUp()
      {
          initMocks(this);
          this.helper = new EhCacheHelper(new RMICacheReplicatorConfigFactory());
  
          defaultCacheConfiguration = new CacheConfiguration();
          final Configuration configuration = new Configuration();
          configuration.setDefaultCacheConfiguration(defaultCacheConfiguration);
          when(mockCacheManager.getConfiguration()).thenReturn(configuration);
      }
  
      @Test
      public void cacheCreatedWithLimitedParametersShouldHaveExpectedValuesWhenLocalAndRmiSetUp()
      {
          assertCacheCreatedWithLimitedParameters(true, true, false);
      }
      @Test
      public void cacheCreatedWithLimitedParametersShouldHaveExpectedValuesWhenLocalAndRmiNotSetUp()
      {
          assertCacheCreatedWithLimitedParameters(true, false, false);
      }
      @Test
      public void cacheCreatedWithLimitedParametersShouldHaveExpectedValuesWhenNotLocalAndRmiSetUp()
      {
          assertCacheCreatedWithLimitedParameters(false, true, false);
      }
      @Test
      public void selfLoadingCacheCreatedWithLimitedParametersShouldHaveExpectedValuesWhenNotLocalAndRmiSetUp()
      {
          assertCacheCreatedWithLimitedParameters(false, true, true);
      }
      @Test
      public void cacheCreatedWithLimitedParametersShouldHaveExpectedValuesWhenNotLocalAndRmiNotSetUp()
      {
          assertCacheCreatedWithLimitedParameters(false, false, false);
      }
  
      private void assertCacheCreatedWithLimitedParameters(final boolean local, final boolean setUpRmiProvider, final boolean selfLoading)
      {
          // Invoke
          if (setUpRmiProvider)
          {
              setUpCacheManagerPeerProvider();
          }
          final boolean replicateAsynchronously = false;
          final boolean replicateViaCopy = false;
          final CacheConfiguration cache = createCacheWithLimitedParameters(local, replicateAsynchronously, replicateViaCopy, selfLoading);
  
          // Check
          assertEquals(CACHE_NAME, cache.getName());
         assertEquals(0L, cache.getMaxEntriesLocalHeap());
         assertEquals(PERSISTENCE_STRATEGY, cache.getPersistenceConfiguration().getStrategy());
         assertTrue(cache.getStatistics());
         assertEquals(DEFAULT_TTI, cache.getTimeToIdleSeconds());
         assertEquals(DEFAULT_TTL, cache.getTimeToLiveSeconds());
         assertFalse(cache.isEternal());
         @SuppressWarnings("unchecked")
         final List<CacheEventListenerFactoryConfiguration> cacheEventListenerConfigurations = cache.getCacheEventListenerConfigurations();
         if (local || !setUpRmiProvider)
         {
             assertEquals(Collections.<CacheEventListenerFactoryConfiguration>emptyList(), cacheEventListenerConfigurations);
         }
         else {
             assertEquals(1, cacheEventListenerConfigurations.size());
             final CacheEventListenerFactoryConfiguration listenerConfiguration = cacheEventListenerConfigurations.get(0);
             assertEquals(RMICacheReplicatorFactory.class.getName(), listenerConfiguration.getFullyQualifiedClassPath());
             if (!selfLoading && replicateViaCopy)
             {
                 assertTrue(listenerConfiguration.getProperties().contains("replicatePuts=true"));
             }
             else
             {
                 assertTrue(listenerConfiguration.getProperties().contains("replicatePuts=false"));
             }
         }
     }
 
     private void setUpCacheManagerPeerProvider()
     {
         final CacheManagerPeerProvider mockRmiProvider = mock(CacheManagerPeerProvider.class);
         when(mockCacheManager.getCacheManagerPeerProviders()).thenReturn(singletonMap("RMI", mockRmiProvider));
     }
 
     @Test
     public void cacheCreatedWithAllParametersShouldHaveSpecifiedName()
     {
         // Invoke
         final CacheConfiguration cache = createCacheWithAllParameters(MAX_ENTRIES, EXPIRE_AFTER_ACCESS, EXPIRE_AFTER_WRITE);
 
         // Check
         assertEquals(CACHE_NAME, cache.getName());
     }
 
     @Test
     public void cacheCreatedWithAllParametersShouldHaveSpecifiedMaxEntries()
     {
         // Invoke
         final CacheConfiguration cache = createCacheWithAllParameters(MAX_ENTRIES, EXPIRE_AFTER_ACCESS, EXPIRE_AFTER_WRITE);
 
         // Check
         assertEquals(MAX_ENTRIES, cache.getMaxEntriesLocalHeap());
     }
 
     @Test
     public void cacheCreatedWithAllParametersShouldHaveSpecifiedExpireAfterAccess()
     {
         // Invoke
         final CacheConfiguration cache = createCacheWithAllParameters(MAX_ENTRIES, EXPIRE_AFTER_ACCESS, EXPIRE_AFTER_WRITE);
 
         // Check
         assertEquals(EXPIRE_AFTER_ACCESS, cache.getTimeToIdleSeconds());
     }
 
     @Test
     public void cacheCreatedWithAllParametersShouldHaveSpecifiedExpireAfterWrite()
     {
         // Invoke
         final CacheConfiguration cache = createCacheWithAllParameters(MAX_ENTRIES, EXPIRE_AFTER_ACCESS, EXPIRE_AFTER_WRITE);
 
         // Check
         assertEquals(EXPIRE_AFTER_WRITE, cache.getTimeToLiveSeconds());
     }
 
     @Test
     public void cacheShouldDefaultToEHCacheDefaultValues()
     {
         defaultCacheConfiguration.setMaxEntriesLocalHeap(999);
 
         // Invoke
         final CacheConfiguration cache = createCacheWithLimitedParameters(false, false, false,false);
 
         assertEquals(999, cache.getMaxEntriesLocalHeap());
     }
 
     private CacheConfiguration createCacheWithLimitedParameters(
             final boolean local, final boolean replicateAsynchronously, final boolean replicateViaCopy, final boolean selfLoading)
     {
         // Invoke
         CacheSettingsBuilder builder = new CacheSettingsBuilder();
         if (local)
         {
             builder.local();
         }
         else
         {
             builder.remote();
         }
         if (replicateAsynchronously)
         {
             builder.replicateAsynchronously();
         }
         if (replicateViaCopy)
         {
             builder.replicateViaCopy();
         }
 
         helper.getEhcache(CACHE_NAME, mockCacheManager, builder.build(), selfLoading, true);
 
         // Check
         final ArgumentCaptor<? extends Ehcache> cacheCaptor = selfLoading ? ArgumentCaptor.forClass(SynchronizedLoadingCacheDecorator.class) : ArgumentCaptor.forClass(Cache.class);
         verify(mockCacheManager).addCacheIfAbsent(cacheCaptor.capture());
         return cacheCaptor.getValue().getCacheConfiguration();
     }
 
     private CacheConfiguration createCacheWithAllParameters(
             final Integer maxEntries, final Long expireAfterAccess, final Long expireAfterWrite)
     {
         // Invoke
         CacheSettingsBuilder builder = new CacheSettingsBuilder();
         builder.local();
         if (null != maxEntries)
         {
             builder.maxEntries(maxEntries);
         }
         if (null != expireAfterAccess)
         {
             builder.expireAfterAccess(expireAfterAccess, TimeUnit.SECONDS);
         }
         if (null != expireAfterWrite)
         {
             builder.expireAfterWrite(expireAfterWrite, TimeUnit.SECONDS);
         }
 
         helper.getEhcache(
                 CACHE_NAME, mockCacheManager, builder.build(), false, true);
 
         // Check
         final ArgumentCaptor<Cache> cacheCaptor = ArgumentCaptor.forClass(Cache.class);
         verify(mockCacheManager).addCacheIfAbsent(cacheCaptor.capture());
         return cacheCaptor.getValue().getCacheConfiguration();
     }
 
     @Test
     public void cacheShouldBeEternalIfNoExpiryIsSetAndDefaultIsTrue()
     {
         defaultCacheConfiguration.setEternal(true);
         assertEternal(null, null, true);
     }
 
     @Test
     public void cacheShouldNotBeEternalIfNoExpiryIsSetAndDefaultIsFalse()
     {
         defaultCacheConfiguration.setEternal(false);
         assertEternal(null, null, false);
     }
 
     @Test
     public void cacheShouldNotBeEternalIfExpireAfterAccessIsSet()
     {
         defaultCacheConfiguration.setEternal(true);
         assertEternal(200L, null, false);
     }
 
     @Test
     public void cacheShouldNotBeEternalIfExpireAfterWriteIsSet()
     {
         defaultCacheConfiguration.setEternal(true);
         assertEternal(null, 200L, false);
     }
 
     @Test
     public void cacheShouldNotBeEternalIfExpireAfterAccessAndExpireAfterWriteAreSet()
     {
         defaultCacheConfiguration.setEternal(true);
         assertEternal(100L, 200L, false);
     }
 
     private void assertEternal(final Long expireAfterAccess, final Long expireAfterWrite, final boolean expectedValue)
     {
         // Invoke
         final CacheConfiguration configuration =
                 createCacheWithAllParameters(MAX_ENTRIES, expireAfterAccess, expireAfterWrite);
 
         // Check
         assertEquals(expectedValue, configuration.isEternal());
     }
 }