package com.atlassian.vcache.internal.legacy;
   
   import com.atlassian.cache.Cache;
   import com.atlassian.cache.CacheFactory;
   import com.atlassian.cache.CacheSettings;
   import com.atlassian.cache.CacheSettingsBuilder;
   import com.atlassian.cache.ehcache.EhCacheManager;
   import com.atlassian.cache.ehcache.replication.rmi.RMICacheReplicatorConfigFactory;
   import com.atlassian.marshalling.api.MarshallingPair;
  import com.atlassian.marshalling.jdk.StringMarshalling;
  import com.atlassian.vcache.DirectExternalCache;
  import com.atlassian.vcache.TransactionalExternalCache;
  import com.atlassian.vcache.internal.RequestContext;
  import com.atlassian.vcache.internal.RequestMetrics;
  import com.atlassian.vcache.internal.core.DefaultRequestContext;
  import com.atlassian.vcache.internal.core.DefaultTransactionControlManager;
  import com.atlassian.vcache.internal.core.Sha1ExternalCacheKeyGenerator;
  import com.atlassian.vcache.internal.core.cas.IdentifiedData;
  import com.atlassian.vcache.internal.core.metrics.DefaultMetricsCollector;
  import com.atlassian.vcache.internal.core.metrics.MetricsCollector;
  import com.atlassian.vcache.internal.test.AbstractTransactionalExternalCacheIT;
  import net.sf.ehcache.CacheManager;
  import org.junit.Before;
  import org.junit.Ignore;
  
  import java.util.Optional;
  import java.util.concurrent.CompletionStage;
  import java.util.concurrent.TimeUnit;
  
  import static com.atlassian.vcache.internal.test.CompletionStageSuccessful.successful;
  import static org.hamcrest.MatcherAssert.assertThat;
  
  public class LegacyTransactionalExternalCacheEhcacheIT extends AbstractTransactionalExternalCacheIT {
      private RequestContext requestContext = new DefaultRequestContext(() -> "tenant-id");
      private Sha1ExternalCacheKeyGenerator keyGenerator = new Sha1ExternalCacheKeyGenerator("it-test");
      private Optional<MarshallingPair<String>> marshalling = Optional.of(StringMarshalling.pair());
      private final MetricsCollector metricsCollector = new DefaultMetricsCollector(() -> requestContext);
  
      private CacheFactory cacheFactory;
      {
          final CacheManager rawEhcache = CacheManager.create();
          // Make sure we are not getting old caches for our test.
          rawEhcache.removeAllCaches();
  
          cacheFactory = new EhCacheManager(rawEhcache, new RMICacheReplicatorConfigFactory(), null);
      }
  
      private LegacyTransactionalExternalCache<String> cache;
      private TransactionalExternalCache<String> wrappedCache;
      private LegacyDirectExternalCache<String> directCache;
  
      @Override
      protected TransactionalExternalCache<String> cache() {
          return wrappedCache;
      }
  
      @Override
      protected DirectExternalCache<String> directCache() {
          return directCache;
      }
  
      @Override
      protected void directCacheRefresh() {
          // nothing to do
      }
  
      @Override
      protected void cacheTransactionSync() {
          cache.transactionSync();
      }
  
      @Override
      protected void cacheTransactionDiscard() {
          cache.transactionDiscard();
      }
  
      @Override
      protected RequestMetrics requestMetrics() {
          return metricsCollector.obtainRequestMetrics(requestContext);
      }
  
      @Before
      public void ensureCache() {
          final CacheSettings legacySettings = new CacheSettingsBuilder()
                  .remote()
                  .maxEntries(1000)
                  .expireAfterWrite(60, TimeUnit.SECONDS)
                  .build();
  
          final Cache<String, IdentifiedData> delegate = cacheFactory.getCache(CACHE_NAME, null, legacySettings);
          cache = new LegacyTransactionalExternalCache<>(
                  delegate,
                  () -> requestContext,
                  keyGenerator,
                  marshalling,
                  new DefaultTransactionControlManager(metricsCollector, context -> {}),
                  new LegacyServiceSettingsBuilder().enableAvoidCasOperations().build(),
                  metricsCollector);
          wrappedCache = metricsCollector.wrap(cache);
 
         directCache = new LegacyDirectExternalCache<>(
                 delegate,
                 () -> requestContext,
                 keyGenerator,
                 marshalling,
                 new LegacyServiceSettingsBuilder().enableAvoidCasOperations().build());
 
         // Start from a clean slate
         final CompletionStage<Void> rm = directCache.removeAll();
         assertThat(rm, successful());
     }
 
     @Ignore("CAS operations not supported")
     @Override
     public void put_get_sync_unsuccessful2() throws Exception {
     }
 
     @Ignore("CAS operations not supported")
     @Override
     public void getBulk_getBulkFunction_directPut_sync() throws Exception {
     }
 }