package com.atlassian.vcache.internal.test;
   
   import com.atlassian.vcache.ChangeRate;
   import com.atlassian.vcache.DirectExternalCache;
   import com.atlassian.vcache.ExternalCacheSettings;
   import com.atlassian.vcache.ExternalCacheSettingsBuilder;
   import com.atlassian.vcache.IdentifiedValue;
   import com.atlassian.vcache.PutPolicy;
   import org.junit.Before;
  import org.junit.Test;
  
  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.MatcherAssert.assertThat;
  import static org.hamcrest.Matchers.equalTo;
  import static org.hamcrest.Matchers.is;
  
  /**
   * Base test class for the {@link DirectExternalCache}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
   */
  @SuppressWarnings("OptionalGetWithoutIsPresent")
  public abstract class AbstractUnreliableDirectExternalCacheIT extends AbstractDirectExternalCacheIT {
      private static final String CACHE_NAME = "olympics.offline";
      private DirectExternalCache<String> offlineCache;
  
      protected abstract DirectExternalCache<String> createOfflineCache(String name, ExternalCacheSettings settings);
  
      @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 getIdentifiedOperation() {
          final IdentifiedValue<String> result = fold(offlineCache.getIdentified("key", () -> "value"),
                  t -> t,
                  err -> null);
  
          assertThat(result, is(equalTo(null)));
      }
  
      @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);
     }
 }