package com.atlassian.vcache.internal.guava;
   
   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 com.google.common.cache.Cache;
  import com.google.common.cache.CacheBuilder;
  import org.junit.Before;
  
  import java.time.Duration;
  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 GuavaTransactionalExternalCacheIT 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 GuavaTransactionalExternalCache<String> cache;
      private TransactionalExternalCache<String> wrappedcache;
      private GuavaDirectExternalCache<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 Cache<String, IdentifiedData> delegate = CacheBuilder.newBuilder()
                  .maximumSize(1_000)
                  .expireAfterWrite(60, TimeUnit.SECONDS)
                  .build();
  
          cache = new GuavaTransactionalExternalCache<>(
                  CACHE_NAME,
                  delegate,
                  () -> requestContext,
                  keyGenerator,
                  marshalling,
                  new DefaultTransactionControlManager(metricsCollector, context -> {
                  }),
                  metricsCollector,
                  Duration.ofSeconds(1));
          wrappedcache = metricsCollector.wrap(cache);
  
          directCache = new GuavaDirectExternalCache<>(
                  CACHE_NAME,
                  delegate,
                  () -> requestContext,
                  keyGenerator,
                  marshalling,
                  Duration.ofSeconds(1));
  
          // Start from a clean slate
          final CompletionStage<Void> rm = directCache.removeAll();
          assertThat(rm, successful());
      }
  }