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.memory.MemoryCacheManager;
   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.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 org.junit.Before;
  
  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 LegacyTransactionalExternalCacheIT extends AbstractTransactionalExternalCacheIT {
      private RequestContext requestContext = new DefaultRequestContext("tenant-id");
      private CacheFactory cacheFactory = new MemoryCacheManager();
      private Sha1ExternalCacheKeyGenerator keyGenerator = new Sha1ExternalCacheKeyGenerator("it-test");
      private Optional<MarshallingPair<String>> marshaller = Optional.of(StringMarshalling.pair());
      private final MetricsCollector metricsCollector = new DefaultMetricsCollector(() -> requestContext);
  
      private LegacyTransactionalExternalCache<String> cache;
      private LegacyDirectExternalCache<String> directCache;
  
      @Override
      protected TransactionalExternalCache<String> cache() {
          return cache;
      }
  
      @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();
      }
  
      @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,
                  marshaller,
                  new DefaultTransactionControlManager(metricsCollector, context -> {}),
                  new LegacyServiceSettingsBuilder().build(),
                  metricsCollector);
  
          directCache = new LegacyDirectExternalCache<>(
                  delegate,
                  () -> requestContext,
                  keyGenerator,
                  marshaller,
                  new LegacyServiceSettingsBuilder().build());
  
          // Start from a clean slate
          final CompletionStage<Void> rm = directCache.removeAll();
          assertThat(rm, successful());
      }
  }