feat: getConfig and getFlagType (Eppo-exp#89)

* getConfig and getFlagType

* doc comments and tests

* chore: update doc comments

Author: typotter

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

@@ -203,7 +203,7 @@ protected EppoValue getTypedAssignment(
     throwIfEmptyOrNull(flagKey, "flagKey must not be empty");
     throwIfEmptyOrNull(subjectKey, "subjectKey must not be empty");
 
-    Configuration config = configurationStore.getConfiguration();
+    Configuration config = getConfiguration();
 
     FlagConfig flag = config.getFlag(flagKey);
     if (flag == null) {
@@ -496,7 +496,7 @@ public BanditResult getBanditAction(
       Actions actions,
       String defaultValue) {
     BanditResult result = new BanditResult(defaultValue, null);
-    final Configuration config = configurationStore.getConfiguration();
+    final Configuration config = getConfiguration();
     try {
       String assignedVariation =
           getStringAssignment(
@@ -579,4 +579,20 @@ private <T> T throwIfNotGraceful(Exception e, T defaultValue) {
   public void setIsGracefulFailureMode(boolean isGracefulFailureMode) {
     this.isGracefulMode = isGracefulFailureMode;
   }
+
+  /**
+   * Returns the configuration object used by the EppoClient for assignment and bandit evaluation.
+   *
+   * <p>The configuration object is for debugging (inspect the loaded config) and other advanced use
+   * cases where flag metadata or a list of flag keys, for example, is required.
+   *
+   * <p>It is not recommended to use the list of keys to preload assignments as assignment
+   * computation also logs its use which will affect your metrics.
+   *
+   * @see <a href="https://docs.geteppo.com/sdks/best-practices/where-to-assign/">Where To
+   *     Assign</a> for more details.
+   */
+  public Configuration getConfiguration() {
+    return configurationStore.getConfiguration();
+  }
 }

src/main/java/cloud/eppo/api/Configuration.java

@@ -66,7 +66,8 @@ public class Configuration {
 
   private final byte[] banditParamsJson;
 
-  private Configuration(
+  /** Default visibility for tests. */
+  Configuration(
       Map<String, FlagConfig> flags,
       Map<String, BanditReference> banditReferences,
       Map<String, BanditParameters> bandits,
@@ -121,6 +122,19 @@ public FlagConfig getFlag(String flagKey) {
     return flags.get(flagKeyForLookup);
   }
 
+  /**
+   * Returns the Variation Type for the specified flag if it exists, otherwise returns null.
+   *
+   * @return The flag's variation type or null.
+   */
+  public @Nullable VariationType getFlagType(String flagKey) {
+    FlagConfig flag = getFlag(flagKey);
+    if (flag == null) {
+      return null;
+    }
+    return flag.getVariationType();
+  }
+
   public String banditKeyForVariation(String flagKey, String variationValue) {
     // Note: In practice this double loop should be quite quick as the number of bandits and bandit
     // variations will be small. Should this ever change, we can optimize things.

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

@@ -13,6 +13,7 @@
 import cloud.eppo.helpers.AssignmentTestCase;
 import cloud.eppo.logging.Assignment;
 import cloud.eppo.logging.AssignmentLogger;
+import cloud.eppo.ufc.dto.FlagConfig;
 import cloud.eppo.ufc.dto.VariationType;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
@@ -655,6 +656,103 @@ public void testPolling() {
     eppoClient.stopPolling();
   }
 
+  @Test
+  public void testGetConfiguration() {
+    // Initialize client with default settings
+    initClient();
+
+    // Get configuration
+    Configuration config = eppoClient.getConfiguration();
+
+    // Verify configuration is not null
+    assertNotNull(config);
+
+    // Verify some known flags from the test configuration
+    assertNotNull(config.getFlag("numeric_flag"));
+    assertEquals(VariationType.NUMERIC, config.getFlagType("numeric_flag"));
+
+    // Verify a non-existent flag returns null
+    assertNull(config.getFlag("non_existent_flag"));
+  }
+
+  @Test
+  public void testGetConfigurationWithInitialConfig() {
+    try {
+      // Load initial configuration from file
+      String flagConfig = FileUtils.readFileToString(initialFlagConfigFile, "UTF8");
+
+      // Initialize client with initial configuration
+      initClientWithData(immediateConfigFuture(flagConfig, false), false, true);
+
+      // Get configuration
+      Configuration config = eppoClient.getConfiguration();
+
+      // Verify configuration is not null
+      assertNotNull(config);
+
+      // Verify known flag from initial configuration
+      FlagConfig numericFlag = config.getFlag("numeric_flag");
+      assertNotNull(numericFlag);
+      assertEquals(VariationType.NUMERIC, numericFlag.getVariationType());
+
+      // verify `no_allocations_flag` DNE
+      assertNull(config.getFlag("no_allocations_flag"));
+
+      // Load new configuration
+      eppoClient.loadConfiguration();
+
+      // Get updated configuration
+      Configuration updatedConfig = eppoClient.getConfiguration();
+
+      // Verify numeric_flag is still there.
+      assertNotNull(updatedConfig.getFlag("numeric_flag"));
+      // verify `no_allocations_flag` exists now
+      assertNotNull(updatedConfig.getFlag("no_allocations_flag"));
+
+    } catch (IOException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  @Test
+  public void testGetConfigurationBeforeInitialization() {
+    // Create client without loading configuration
+    mockAssignmentLogger = mock(AssignmentLogger.class);
+
+    eppoClient =
+        new BaseEppoClient(
+            DUMMY_FLAG_API_KEY,
+            "java",
+            "100.1.0",
+            null,
+            TEST_BASE_URL,
+            mockAssignmentLogger,
+            null,
+            null,
+            false,
+            false,
+            true,
+            null,
+            null,
+            null);
+
+    // Get configuration before loading
+    Configuration config = eppoClient.getConfiguration();
+
+    // Verify we get an empty configuration
+    assertNotNull(config);
+    assertTrue(config.isEmpty());
+
+    eppoClient.loadConfiguration();
+
+    // Get configuration again after loading
+    Configuration nextConfig = eppoClient.getConfiguration();
+
+    // Verify we get an empty configuration
+    assertNotNull(nextConfig);
+    assertFalse(nextConfig.isEmpty());
+  }
+
   @SuppressWarnings("SameParameterValue")
   private void sleepUninterruptedly(long sleepMs) {
     try {

src/test/java/cloud/eppo/api/ConfigurationBuilderTest.java

@@ -1,11 +1,16 @@
 package cloud.eppo.api;
 
+import static cloud.eppo.Utils.getMD5Hex;
 import static org.junit.jupiter.api.Assertions.*;
 
+import cloud.eppo.ufc.dto.FlagConfig;
 import cloud.eppo.ufc.dto.FlagConfigResponse;
+import cloud.eppo.ufc.dto.VariationType;
 import cloud.eppo.ufc.dto.adapters.EppoModule;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import java.io.IOException;
+import java.util.Collections;
+import java.util.Map;
 import org.junit.jupiter.api.Test;
 
 public class ConfigurationBuilderTest {
@@ -52,4 +57,66 @@ public void testBuildConfigAddsForServer_false() throws IOException {
 
     assertEquals(rehydratedConfig.getFormat(), FlagConfigResponse.Format.CLIENT);
   }
+
+  @Test
+  public void getFlagType_shouldReturnCorrectType() {
+    // Create a flag config with a STRING variation type
+    FlagConfig flagConfig =
+        new FlagConfig(
+            "test-flag",
+            true,
+            1,
+            VariationType.STRING,
+            Collections.emptyMap(),
+            Collections.emptyList());
+
+    // Create configuration with this flag
+    Map<String, FlagConfig> flags = Collections.singletonMap("test-flag", flagConfig);
+    Configuration config =
+        new Configuration(flags, Collections.emptyMap(), Collections.emptyMap(), false, null, null);
+
+    // Test successful case
+    assertEquals(VariationType.STRING, config.getFlagType("test-flag"));
+
+    // Test non-existent flag
+    assertNull(config.getFlagType("non-existent-flag"));
+  }
+
+  @Test
+  public void getFlagType_withObfuscatedConfig_shouldReturnCorrectType() {
+    // Create a flag config with a NUMERIC variation type
+    FlagConfig flagConfig =
+        new FlagConfig(
+            "test-flag",
+            true,
+            1,
+            VariationType.NUMERIC,
+            Collections.emptyMap(),
+            Collections.emptyList());
+
+    // Create configuration with this flag using MD5 hash of the flag key
+    String hashedKey = getMD5Hex("test-flag");
+    Map<String, FlagConfig> flags = Collections.singletonMap(hashedKey, flagConfig);
+    Configuration config =
+        new Configuration(
+            flags,
+            Collections.emptyMap(),
+            Collections.emptyMap(),
+            true, // obfuscated
+            null,
+            null);
+
+    // Test successful case with obfuscated config
+    assertEquals(VariationType.NUMERIC, config.getFlagType("test-flag"));
+
+    // Test non-existent flag
+    assertNull(config.getFlagType("non-existent-flag"));
+    assertNull(config.getFlagType(hashedKey));
+  }
+
+  @Test
+  public void getFlagType_withEmptyConfig_shouldReturnNull() {
+    Configuration config = Configuration.emptyConfig();
+    assertNull(config.getFlagType("any-flag"));
+  }
 }