package com.atlassian.vcache.internal.test;
   
   import java.util.Map;
   import java.util.Optional;
   import java.util.concurrent.CompletableFuture;
   import javax.annotation.Nonnull;
   
   import com.atlassian.vcache.DirectExternalCache;
   import com.atlassian.vcache.PutPolicy;
  import com.atlassian.vcache.TransactionalExternalCache;
  
  import com.google.common.collect.Maps;
  import org.junit.Rule;
  import org.junit.Test;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import static com.atlassian.vcache.internal.test.CompletableFutureSuccessful.successful;
  import static com.atlassian.vcache.internal.test.CompletableFutureSuccessful.successfulWith;
  import static org.hamcrest.MatcherAssert.assertThat;
  import static org.hamcrest.Matchers.containsInAnyOrder;
  import static org.hamcrest.Matchers.is;
  
  /**
   * Base test class for the {@link com.atlassian.vcache.TransactionalExternalCache}.
   */
  public abstract class AbstractTransactionalExternalCacheIT
  {
      protected static final String CACHE_NAME = "fragileSting";
      private static final Logger log = LoggerFactory.getLogger(AbstractStableReadExternalCacheIT.class);
  
      @Rule
      public LoggingTestWatcher watcher = new LoggingTestWatcher(log);
  
      @Nonnull
      protected abstract TransactionalExternalCache<String> cache();
      @Nonnull
      protected abstract DirectExternalCache<String> directCache();
      protected abstract void directCacheRefresh();
      protected abstract void cacheTransactionSync();
  
      @Test
      public void put_get_sync_successful()
      {
          cache().put("claira", "dancing", PutPolicy.PUT_ALWAYS);
  
          final CompletableFuture<Optional<String>> get1 = cache().get("claira");
  
          assertThat(get1, successfulWith(is(Optional.of("dancing"))));
  
          // Now use the directCache to verify no data has been written
          directCacheRefresh();
          final CompletableFuture<Optional<String>> get2 = directCache().get("claira");
  
          assertThat(get2, successfulWith(is(Optional.empty())));
  
          // Now sync the changes
          cacheTransactionSync();
  
          // And check the changes are now visible
          directCacheRefresh();
          final CompletableFuture<Optional<String>> get3 = directCache().get("claira");
  
          assertThat(get3, successfulWith(is(Optional.of("dancing"))));
      }
  
      @Test
      public void put_get_sync_unsuccessful() throws Exception
      {
          cache().put("claira", "dancing", PutPolicy.ADD_ONLY); // Must be ADD_ONLY
  
          final CompletableFuture<Optional<String>> get1 = cache().get("claira");
  
          assertThat(get1, successfulWith(is(Optional.of("dancing"))));
  
          // Now use the directCache to verify no data has been written
          directCacheRefresh();
          final CompletableFuture<Optional<String>> get2 = directCache().get("claira");
  
          assertThat(get2, successfulWith(is(Optional.empty())));
  
          // Now add values to the backing cache using the directCache
          final CompletableFuture<Map<String, String>> get3 =
                  directCache().getBulk(keys -> Maps.asMap(keys, k -> k + "-1"), "claira", "josephine");
  
          assertThat(get3, successful());
          assertThat(get3.get().keySet(), containsInAnyOrder("claira", "josephine"));
          assertThat(get3.get().values(), containsInAnyOrder("claira-1", "josephine-1"));
  
          // Now sync the changes
          cacheTransactionSync();
  
          // And check the cache is empty
          directCacheRefresh();
          final CompletableFuture<Map<String, Optional<String>>> get4 = directCache().getBulk("claira", "josephine");
  
          assertThat(get4, successful());
          assertThat(get4.get().keySet(), containsInAnyOrder("claira", "josephine"));
          assertThat(get4.get().values(), containsInAnyOrder(Optional.empty(), Optional.empty()));
     }
 
     @Test
     public void getBulk_getBulkFunction_directPut_sync() throws Exception
     {
         final CompletableFuture<Boolean> put1 = directCache().put("claira", "dancing", PutPolicy.PUT_ALWAYS);
 
         assertThat(put1, successful());
 
         final CompletableFuture<Map<String, Optional<String>>> get1 = cache().getBulk("claira", "josephine");
 
         assertThat(get1, successful());
         assertThat(get1.get().keySet(), containsInAnyOrder("claira", "josephine"));
         assertThat(get1.get().values(), containsInAnyOrder(Optional.of("dancing"), Optional.empty()));
 
         final CompletableFuture<Map<String, String>> get2 =
                 cache().getBulk(keys -> Maps.asMap(keys, k -> "football"), "claira", "josephine");
 
         assertThat(get2, successful());
         assertThat(get2.get().keySet(), containsInAnyOrder("claira", "josephine"));
         assertThat(get2.get().values(), containsInAnyOrder("dancing", "football"));
 
         // Now add an entry to the backend cache for "josephine" and verify one does not exist yet
         directCacheRefresh();
         final CompletableFuture<Boolean> put2 = directCache().put("josephine", "soccer", PutPolicy.ADD_ONLY);
 
         assertThat(put2, successfulWith(is(true)));
 
         cacheTransactionSync();
 
         // Now verify nothing in the cache, due to panic when added josephine
         directCacheRefresh();
         final CompletableFuture<Map<String, Optional<String>>> get3 = directCache().getBulk("claira", "josephine");
 
         assertThat(get3, successful());
         assertThat(get3.get().keySet(), containsInAnyOrder("claira", "josephine"));
         assertThat(get3.get().values(), containsInAnyOrder(Optional.empty(), Optional.empty()));
     }
 
     @Test
     public void put_get_remove_get()
     {
         cache().put("nirvana", "shotgun", PutPolicy.PUT_ALWAYS);
 
         final CompletableFuture<Optional<String>> get1 = cache().get("nirvana");
 
         assertThat(get1, successfulWith(is(Optional.of("shotgun"))));
 
         cache().remove("a", "b", "nirvana");
 
         final CompletableFuture<Optional<String>> get2 = cache().get("nirvana");
 
         assertThat(get2, successfulWith(is(Optional.empty())));
     }
 
     @Test
     public void getSupplier_removeAll_get()
     {
         final CompletableFuture<String> get1 = cache().get("vienna", () -> "sandwiches");
 
         assertThat(get1, successfulWith(is("sandwiches")));
 
         cache().removeAll();
 
         final CompletableFuture<Optional<String>> get2 = cache().get("vienna");
 
         assertThat(get2, successfulWith(is(Optional.empty())));
     }
 }