package com.atlassian.vcache.internal.redis;
   
   import com.atlassian.marshalling.jdk.StringMarshalling;
   import com.atlassian.vcache.ChangeRate;
   import com.atlassian.vcache.DirectExternalCache;
   import com.atlassian.vcache.ExternalCacheSettings;
   import com.atlassian.vcache.ExternalCacheSettingsBuilder;
   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.metrics.DefaultMetricsCollector;
  import com.atlassian.vcache.internal.core.metrics.MetricsCollector;
  import com.atlassian.vcache.internal.test.AbstractTransactionalExternalCacheIT;
  import org.junit.Before;
  import org.junit.BeforeClass;
  import redis.clients.jedis.JedisPool;
  import redis.clients.jedis.JedisPoolConfig;
  
  import java.io.IOException;
  import java.net.URI;
  import java.net.URISyntaxException;
  import java.time.Duration;
  import java.util.concurrent.CompletionStage;
  
  import static com.atlassian.vcache.internal.test.CompletionStageSuccessful.successful;
  import static org.hamcrest.MatcherAssert.assertThat;
  
  public class RedisTransactionalExternalCacheIT extends AbstractTransactionalExternalCacheIT {
      private static JedisPool jedisPool;
  
      private final RequestContext requestContext = new DefaultRequestContext("txn-it-test");
      private final MetricsCollector metricsCollector = new DefaultMetricsCollector(() -> requestContext);
  
      private RedisTransactionalExternalCache<String> cache;
      private RedisDirectExternalCache<String> directCache;
  
      @Override
      protected TransactionalExternalCache<String> cache() {
          return cache;
      }
  
      @Override
      protected DirectExternalCache<String> directCache() {
          return directCache;
      }
  
      @Override
      protected void directCacheRefresh() {
          directCache.refreshCacheVersion();
      }
  
      @Override
      protected void cacheTransactionSync() {
          cache.transactionSync();
      }
  
      @Override
      protected void cacheTransactionDiscard() {
          cache.transactionDiscard();
      }
  
      @BeforeClass
      public static void init_client() throws IOException, URISyntaxException {
          final JedisPoolConfig poolConfig = new JedisPoolConfig();
          poolConfig.setMaxTotal(1); // only allow one connection to check for connection leaks
          jedisPool = new JedisPool(poolConfig, new URI(System.getProperty("redis.svr")));
      }
  
      @Before
      public void ensureCache() {
          final ExternalCacheSettings settings = new ExternalCacheSettingsBuilder()
                  .entryGrowthRateHint(ChangeRate.LOW_CHANGE)
                  .entryCountHint(5)
                  .defaultTtl(Duration.ofMinutes(10))
                  .dataChangeRateHint(ChangeRate.HIGH_CHANGE)
                  .build();
          cache = new RedisTransactionalExternalCache<>(
                  jedisPool::getResource,
                  () -> requestContext,
                  new Sha1ExternalCacheKeyGenerator("it-test"),
                  CACHE_NAME,
                  StringMarshalling.pair(),
                  settings,
                  new DefaultTransactionControlManager(metricsCollector, context -> {}),
                  metricsCollector);
  
          directCache = new RedisDirectExternalCache<>(
                  jedisPool::getResource,
                  () -> requestContext,
                  new Sha1ExternalCacheKeyGenerator("it-test"),
                  CACHE_NAME,
                  StringMarshalling.pair(),
                  settings);
  
          // Start from a clean slate
          final CompletionStage<Void> rm = directCache.removeAll();
          assertThat(rm, successful());
     }
 }