fix: respect graceful mode during client initialization (#68)

* bump for patch release
* respect graceful mode on initialization
* test
* update version string in tests

Author: typotter

README.md

@@ -10,7 +10,7 @@ or [JVM](https://github.com/Eppo-exp/java-server-sdk) SDKs.
 
 ```groovy
 dependencies {
-  implementation 'cloud.eppo:sdk-common-jvm:3.5.0'
+  implementation 'cloud.eppo:sdk-common-jvm:3.5.3'
 }
 ```
 

build.gradle

@@ -6,7 +6,7 @@ plugins {
 }
 
 group = 'cloud.eppo'
-version = '3.5.2-SNAPSHOT'
+version = '3.5.3'
 ext.isReleaseVersion = !version.endsWith("SNAPSHOT")
 
 java {

src/main/java/cloud/eppo/BaseEppoClient.java

@@ -110,11 +110,32 @@ private EppoHttpClient buildHttpClient(
   }
 
   protected void loadConfiguration() {
-    requestor.fetchAndSaveFromRemote();
+    try {
+      requestor.fetchAndSaveFromRemote();
+    } catch (Exception ex) {
+      log.error("Encountered Exception while loading configuration", ex);
+      if (!isGracefulMode) {
+        throw ex;
+      }
+    }
   }
 
   protected CompletableFuture<Void> loadConfigurationAsync() {
-    return requestor.fetchAndSaveFromRemoteAsync();
+    CompletableFuture<Void> future = new CompletableFuture<>();
+
+    requestor
+        .fetchAndSaveFromRemoteAsync()
+        .exceptionally(
+            ex -> {
+              log.error("Encountered Exception while loading configuration", ex);
+              if (!isGracefulMode) {
+                future.completeExceptionally(ex);
+              }
+              return null;
+            })
+        .thenAccept(future::complete);
+
+    return future;
   }
 
   protected EppoValue getTypedAssignment(

src/test/java/cloud/eppo/BaseEppoClientTest.java

@@ -2,18 +2,17 @@
 
 import static cloud.eppo.helpers.AssignmentTestCase.parseTestCaseFile;
 import static cloud.eppo.helpers.AssignmentTestCase.runTestCase;
+import static cloud.eppo.helpers.TestUtils.mockHttpError;
 import static cloud.eppo.helpers.TestUtils.mockHttpResponse;
 import static cloud.eppo.helpers.TestUtils.setBaseClientHttpClientOverrideField;
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.mockito.Mockito.*;
 
-import cloud.eppo.api.Attributes;
-import cloud.eppo.api.Configuration;
-import cloud.eppo.api.EppoValue;
-import cloud.eppo.api.IAssignmentCache;
+import cloud.eppo.api.*;
 import cloud.eppo.cache.LRUInMemoryAssignmentCache;
 import cloud.eppo.helpers.AssignmentTestCase;
 import cloud.eppo.logging.Assignment;
@@ -25,6 +24,7 @@
 import java.io.IOException;
 import java.util.*;
 import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionException;
 import java.util.stream.Stream;
 import org.apache.commons.io.FileUtils;
 import org.junit.jupiter.api.BeforeEach;
@@ -66,7 +66,7 @@ private void initClientWithData(
         new BaseEppoClient(
             DUMMY_FLAG_API_KEY,
             isConfigObfuscated ? "android" : "java",
-            "3.0.0",
+            "100.1.0",
             TEST_HOST,
             mockAssignmentLogger,
             null,
@@ -86,7 +86,7 @@ private void initClient(boolean isGracefulMode, boolean isConfigObfuscated) {
         new BaseEppoClient(
             DUMMY_FLAG_API_KEY,
             isConfigObfuscated ? "android" : "java",
-            "3.0.0",
+            "100.1.0",
             TEST_HOST,
             mockAssignmentLogger,
             null,
@@ -102,14 +102,37 @@ private void initClient(boolean isGracefulMode, boolean isConfigObfuscated) {
     log.info("Test client initialized");
   }
 
+  private CompletableFuture<Void> initClientAsync(
+      boolean isGracefulMode, boolean isConfigObfuscated) {
+    mockAssignmentLogger = mock(AssignmentLogger.class);
+
+    eppoClient =
+        new BaseEppoClient(
+            DUMMY_FLAG_API_KEY,
+            isConfigObfuscated ? "android" : "java",
+            "100.1.0",
+            TEST_HOST,
+            mockAssignmentLogger,
+            null,
+            null,
+            isGracefulMode,
+            isConfigObfuscated,
+            true,
+            null,
+            null,
+            null);
+
+    return eppoClient.loadConfigurationAsync();
+  }
+
   private void initClientWithAssignmentCache(IAssignmentCache cache) {
     mockAssignmentLogger = mock(AssignmentLogger.class);
 
     eppoClient =
         new BaseEppoClient(
             DUMMY_FLAG_API_KEY,
             "java",
-            "3.0.0",
+            "100.1.0",
             TEST_HOST,
             mockAssignmentLogger,
             null,
@@ -272,6 +295,78 @@ private CompletableFuture<Configuration> immediateConfigFuture(
         Configuration.builder(config.getBytes(), isObfuscated).build());
   }
 
+  @Test
+  public void testGracefulInitializationFailure() {
+    // Set up bad HTTP response
+    mockHttpError();
+
+    // Initialize and no exception should be thrown.
+    assertDoesNotThrow(() -> initClient(true, false));
+  }
+
+  @Test
+  public void testClientMakesDefaultAssignmentsAfterFailingToInitialize() {
+    // Set up bad HTTP response
+    mockHttpError();
+
+    // Initialize and no exception should be thrown.
+    assertDoesNotThrow(() -> initClient(true, false));
+
+    assertEquals("default", eppoClient.getStringAssignment("experiment1", "subject1", "default"));
+  }
+
+  @Test
+  public void testClientMakesDefaultAssignmentsAfterFailingToInitializeNonGracefulMode() {
+    // Set up bad HTTP response
+    mockHttpError();
+
+    // Initialize and no exception should be thrown.
+    try {
+      initClient(false, false);
+    } catch (RuntimeException e) {
+      // Expected
+      assertEquals("Intentional Error", e.getMessage());
+    } finally {
+      assertEquals("default", eppoClient.getStringAssignment("experiment1", "subject1", "default"));
+    }
+  }
+
+  @Test
+  public void testNonGracefulInitializationFailure() {
+    // Set up bad HTTP response
+    mockHttpError();
+
+    // Initialize and assert exception thrown
+    assertThrows(Exception.class, () -> initClient(false, false));
+  }
+
+  @Test
+  public void testGracefulAsyncInitializationFailure() {
+    // Set up bad HTTP response
+    mockHttpError();
+
+    // Initialize
+    CompletableFuture<Void> init = initClientAsync(true, false);
+
+    // Wait for initialization; future should not complete exceptionally (equivalent of exception
+    // being thrown).
+    init.join();
+    assertFalse(init.isCompletedExceptionally());
+  }
+
+  @Test
+  public void testNonGracefulAsyncInitializationFailure() {
+    // Set up bad HTTP response
+    mockHttpError();
+
+    // Initialize
+    CompletableFuture<Void> init = initClientAsync(false, false);
+
+    // Exceptions thrown in CompletableFutures are wrapped in a CompletionException.
+    assertThrows(CompletionException.class, init::join);
+    assertTrue(init.isCompletedExceptionally());
+  }
+
   @Test
   public void testWithInitialConfiguration() {
     try {
@@ -341,7 +436,7 @@ public void testAssignmentEventCorrectlyCreated() {
     Map<String, String> expectedMeta = new HashMap<>();
     expectedMeta.put("obfuscated", "false");
     expectedMeta.put("sdkLanguage", "java");
-    expectedMeta.put("sdkLibVersion", "3.0.0");
+    expectedMeta.put("sdkLibVersion", "100.1.0");
 
     assertEquals(expectedMeta, capturedAssignment.getMetaData());
   }

src/test/java/cloud/eppo/helpers/TestUtils.java

@@ -27,6 +27,21 @@ public static void mockHttpResponse(String host, String responseBody) {
     setBaseClientHttpClientOverrideField(mockHttpClient);
   }
 
+  public static void mockHttpError() {
+    // Create a mock instance of EppoHttpClient
+    EppoHttpClient mockHttpClient = mock(EppoHttpClient.class);
+
+    // Mock sync get
+    when(mockHttpClient.get(anyString())).thenThrow(new RuntimeException("Intentional Error"));
+
+    // Mock async get
+    CompletableFuture<byte[]> mockAsyncResponse = new CompletableFuture<>();
+    when(mockHttpClient.getAsync(anyString())).thenReturn(mockAsyncResponse);
+    mockAsyncResponse.completeExceptionally(new RuntimeException("Intentional Error"));
+
+    setBaseClientHttpClientOverrideField(mockHttpClient);
+  }
+
   public static void setBaseClientHttpClientOverrideField(EppoHttpClient httpClient) {
     setBaseClientOverrideField("httpClientOverride", httpClient);
   }