package com.atlassian.cache.ehcache;
   
   import java.util.Collections;
   import java.util.List;
   import java.util.concurrent.TimeUnit;
   
   import com.atlassian.cache.CacheSettingsBuilder;
   
   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 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;
  
  /**
   * Unit test of {@link EhCacheHelper}.
   *
   * @since 2.0
   */
  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();
  
          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 CacheConfiguration cache = createCacheWithLimitedParameters(local, false, false, 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)
             {
                 assertTrue(listenerConfiguration.getProperties().contains("replicatePuts=false"));
             }
             else
             {
                 assertTrue(listenerConfiguration.getProperties().contains("replicatePuts=true"));
             }
         }
     }
 
     private void setUpCacheManagerPeerProvider() {
         final CacheManagerPeerProvider mockRmiProvider = mock(CacheManagerPeerProvider.class);
         when(mockCacheManager.getCacheManagerPeerProvider("RMI")).thenReturn(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<Cache> cacheCaptor = 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());
     }
 }