package com.atlassian.vcache.internal.test;
   
   import com.atlassian.vcache.DirectExternalCache;
   import com.atlassian.vcache.PutPolicy;
   import com.atlassian.vcache.TransactionalExternalCache;
   import org.junit.Test;
   import org.slf4j.Logger;
   import org.slf4j.LoggerFactory;
   
  import java.util.Optional;
  
  import static com.atlassian.vcache.VCacheUtils.fold;
  import static org.hamcrest.CoreMatchers.equalTo;
  import static org.hamcrest.Matchers.is;
  import static org.junit.Assert.assertThat;
  
  /**
   * Base test class for the {@link TransactionalExternalCache}s that rely on external services
   * which could be unreliable. These tests ensure that the behaviour of the cache is reasonable
   * when the external service is unavailable
   */
  public abstract class AbstractUnreliableTransactionalExternalCacheIT extends AbstractTransactionalExternalCacheIT {
      private static final Logger log = LoggerFactory.getLogger(AbstractUnreliableTransactionalExternalCacheIT.class);
  
      // Points to a non-responsive memcached
      protected abstract TransactionalExternalCache<String> offlineCache();
      protected abstract DirectExternalCache<String> offlineDirectCache();
  
      protected abstract void offlineCacheTransactionSync();
      protected abstract void offlineCacheTransactionDiscard();
  
      @Test
      public void getWithSupplier() {
          final String result = fold(cache().get("key", () -> "value"),
                  t -> t,
                  err -> "failed");
  
          assertThat(result, is(equalTo("value")));
      }
  
      @Test
      public void getWithSupplierOfflineClient() {
          final String result = fold(offlineCache().get("key", () -> "value"),
                  t -> t,
                  err -> "failed");
  
          assertThat(result, is(equalTo("failed")));
      }
  
      @Test
      public void putThenSync() {
          cache().put("key", "value", PutPolicy.PUT_ALWAYS);
          cacheTransactionSync();
  
          final Optional<String> result = fold(cache().get("key"),
                  t -> t,
                  err -> Optional.of("failed"));
  
          assertThat(result, is(equalTo(Optional.of("value"))));
      }
  
      @Test
      public void putThenSyncOfflineClient() {
          offlineCache().put("key", "value", PutPolicy.PUT_ALWAYS);
          offlineCacheTransactionSync();
  
          final Optional<String> result = fold(offlineCache().get("key"),
                  t -> t,
                  err -> Optional.of("failed"));
  
          // Sync should fail but not throw an exception - subsequent remote get should fail
          assertThat(result, is(equalTo(Optional.of("failed"))));
      }
  
      @Test
      public void removeThenSync() {
          cache().remove("key");
          cacheTransactionSync();
  
          final Optional<String> result = fold(cache().get("key"),
                  t -> t,
                  err -> Optional.of("failed"));
  
          assertThat(result, is(equalTo(Optional.empty())));
      }
  
      @Test
      public void removeThenSyncOfflineClient() {
          offlineCache().remove("key");
          offlineCacheTransactionSync();
  
          final Optional<String> result = fold(offlineCache().get("key"),
                  t -> t,
                  err -> Optional.of("failed"));
  
          assertThat(result, is(equalTo(Optional.of("failed"))));
      }
  }