package com.atlassian.vcache.internal.test;
   
   import com.atlassian.vcache.ChangeRate;
   import com.atlassian.vcache.ExternalCacheSettings;
   import com.atlassian.vcache.ExternalCacheSettingsBuilder;
   import com.atlassian.vcache.PutPolicy;
   import com.atlassian.vcache.StableReadExternalCache;
   import org.junit.Before;
   import org.junit.Test;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import java.time.Duration;
  import java.util.Collections;
  import java.util.Map;
  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 StableReadExternalCache}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 AbstractUnreliableStableReadExternalCacheIT extends AbstractStableReadExternalCacheIT {
      private static final Logger log = LoggerFactory.getLogger(AbstractUnreliableStableReadExternalCacheIT.class);
      private static final String CACHE_NAME = "kids_hobbies.offline";
  
      private StableReadExternalCache<String> offlineCache;
  
      protected abstract StableReadExternalCache<String> createOfflineCache(String name, ExternalCacheSettings settings, Duration lockTimeout);
  
      protected StableReadExternalCache<String> createOfflineCache(String name, ExternalCacheSettings settings) {
          return createOfflineCache(name, settings, Duration.ofSeconds(2));
      }
  
      @Before
      public void ensureOfflineCache() {
          final ExternalCacheSettings settings = new ExternalCacheSettingsBuilder()
                  .entryGrowthRateHint(ChangeRate.LOW_CHANGE)
                  .entryCountHint(5)
                  .defaultTtl(Duration.ofMinutes(5))
                  .dataChangeRateHint(ChangeRate.HIGH_CHANGE)
                  .build();
          offlineCache = createOfflineCache(CACHE_NAME, settings);
      }
  
      @Test
      public void getOperation() {
          final Optional<String> result = fold(offlineCache.get("key"),
                  t -> t,
                  err -> Optional.of("failed"));
  
          assertThat(result, is(equalTo(Optional.of("failed"))));
      }
  
      @Test
      public void getWithSupplierOperation() {
          final String result = fold(offlineCache.get("key", () -> "value"),
                  t -> t,
                  err -> "failed");
  
          assertThat(result, is(equalTo("failed")));
      }
  
      @Test
      public void getBulkOperation() {
          final Map<String, Optional<String>> result = fold(offlineCache.getBulk("key1", "key2"),
                  t -> t,
                  err -> Collections.emptyMap());
  
          assertThat(result, is(equalTo(Collections.emptyMap())));
      }
  
      @Test
      public void putOperation() {
          final boolean result = fold(offlineCache.put("key", "value", PutPolicy.PUT_ALWAYS),
                  t -> t,
                  err -> false);
  
          assertThat(result, is(equalTo(false)));
      }
  
      @Test
      public void removeOperation() {
          // Just make sure no exceptions are thrown
          fold(offlineCache.remove("key"),
                  t -> t,
                  err -> null);
      }
  
      @Test
      public void removeAllOperation() {
          // Just make sure no exceptions are thrown
          fold(offlineCache.removeAll(),
                  t -> t,
                 err -> null);
     }
 }