update: implement asynchronous decision-making methods in Optimizely and OptimizelyUserContext with corresponding tests

Author: FarhanAnjum-opti

core-api/src/main/java/com/optimizely/ab/Optimizely.java

@@ -64,12 +64,7 @@
 import com.optimizely.ab.optimizelyconfig.OptimizelyConfig;
 import com.optimizely.ab.optimizelyconfig.OptimizelyConfigManager;
 import com.optimizely.ab.optimizelyconfig.OptimizelyConfigService;
-import com.optimizely.ab.optimizelydecision.DecisionMessage;
-import com.optimizely.ab.optimizelydecision.DecisionReasons;
-import com.optimizely.ab.optimizelydecision.DecisionResponse;
-import com.optimizely.ab.optimizelydecision.DefaultDecisionReasons;
-import com.optimizely.ab.optimizelydecision.OptimizelyDecideOption;
-import com.optimizely.ab.optimizelydecision.OptimizelyDecision;
+import com.optimizely.ab.optimizelydecision.*;
 import com.optimizely.ab.optimizelyjson.OptimizelyJSON;
 
 import org.slf4j.Logger;
@@ -1525,8 +1520,8 @@ Map<String, OptimizelyDecision> decideAll(@Nonnull OptimizelyUserContext user,
      * @return A decision result using traditional A/B testing logic only.
      */
     OptimizelyDecision decideSync(@Nonnull OptimizelyUserContext user,
-                                        @Nonnull String key,
-                                        @Nonnull List<OptimizelyDecideOption> options) {
+                                  @Nonnull String key,
+                                  @Nonnull List<OptimizelyDecideOption> options) {
         ProjectConfig projectConfig = getProjectConfig();
         if (projectConfig == null) {
             return OptimizelyDecision.newErrorDecision(key, user, DecisionMessage.SDK_NOT_READY.reason());
@@ -1541,28 +1536,28 @@ OptimizelyDecision decideSync(@Nonnull OptimizelyUserContext user,
     /**
      * Returns decision results for multiple flag keys, skipping CMAB logic and using only traditional A/B testing.
      * This will be called by mobile apps which will make synchronous decisions only (for backward compatibility with android-sdk)
-     * 
+     *
      * @param user    An OptimizelyUserContext associated with this OptimizelyClient.
      * @param keys    A list of flag keys for which decisions will be made.
      * @param options A list of options for decision-making.
      * @return All decision results mapped by flag keys, using traditional A/B testing logic only.
      */
     Map<String, OptimizelyDecision> decideForKeysSync(@Nonnull OptimizelyUserContext user,
-                                                            @Nonnull List<String> keys,
-                                                            @Nonnull List<OptimizelyDecideOption> options) {
+                                                      @Nonnull List<String> keys,
+                                                      @Nonnull List<OptimizelyDecideOption> options) {
         return decideForKeysSync(user, keys, options, false);
     }
 
     /**
      * Returns decision results for all active flag keys, skipping CMAB logic and using only traditional A/B testing.
      * This will be called by mobile apps which will make synchronous decisions only (for backward compatibility with android-sdk)
-     * 
+     *
      * @param user    An OptimizelyUserContext associated with this OptimizelyClient.
      * @param options A list of options for decision-making.
      * @return All decision results mapped by flag keys, using traditional A/B testing logic only.
      */
     Map<String, OptimizelyDecision> decideAllSync(@Nonnull OptimizelyUserContext user,
-                                                        @Nonnull List<OptimizelyDecideOption> options) {
+                                                  @Nonnull List<OptimizelyDecideOption> options) {
         Map<String, OptimizelyDecision> decisionMap = new HashMap<>();
 
         ProjectConfig projectConfig = getProjectConfig();
@@ -1579,12 +1574,59 @@ Map<String, OptimizelyDecision> decideAllSync(@Nonnull OptimizelyUserContext use
     }
 
     private Map<String, OptimizelyDecision> decideForKeysSync(@Nonnull OptimizelyUserContext user,
-                                                                    @Nonnull List<String> keys,
-                                                                    @Nonnull List<OptimizelyDecideOption> options,
-                                                                    boolean ignoreDefaultOptions) {
+                                                              @Nonnull List<String> keys,
+                                                              @Nonnull List<OptimizelyDecideOption> options,
+                                                              boolean ignoreDefaultOptions) {
         return decideForKeys(user, keys, options, ignoreDefaultOptions, DecisionPath.WITHOUT_CMAB);
     }
 
+    //============ decide async ============//
+
+    /**
+     * Returns a decision result asynchronously for a given flag key and a user context.
+     *
+     * @param userContext The user context to make decisions for
+     * @param key A flag key for which a decision will be made
+     * @param callback A callback to invoke when the decision is available
+     * @param options A list of options for decision-making
+     */
+    public void decideAsync(@Nonnull OptimizelyUserContext userContext,
+                            @Nonnull String key,
+                            @Nonnull OptimizelyDecisionCallback callback,
+                            @Nonnull List<OptimizelyDecideOption> options) {
+        AsyncDecisionFetcher fetcher = new AsyncDecisionFetcher(userContext, key, options, callback);
+        fetcher.start();
+    }
+
+    /**
+     * Returns decision results asynchronously for multiple flag keys.
+     *
+     * @param userContext The user context to make decisions for
+     * @param keys        A list of flag keys for which decisions will be made
+     * @param callback    A callback to invoke when decisions are available
+     * @param options     A list of options for decision-making
+     */
+    public void decideForKeysAsync(@Nonnull OptimizelyUserContext userContext,
+                                   @Nonnull List<String> keys,
+                                   @Nonnull OptimizelyDecisionsCallback callback,
+                                   @Nonnull List<OptimizelyDecideOption> options) {
+        AsyncDecisionFetcher fetcher = new AsyncDecisionFetcher(userContext, keys, options, callback);
+        fetcher.start();
+    }
+
+    /**
+     * Returns decision results asynchronously for all active flag keys.
+     *
+     * @param userContext The user context to make decisions for
+     * @param callback A callback to invoke when decisions are available
+     * @param options A list of options for decision-making
+     */
+    public void decideAllAsync(@Nonnull OptimizelyUserContext userContext,
+                               @Nonnull OptimizelyDecisionsCallback callback,
+                               @Nonnull List<OptimizelyDecideOption> options) {
+        AsyncDecisionFetcher fetcher = new AsyncDecisionFetcher(userContext, options, callback);
+        fetcher.start();
+    }
 
     private List<OptimizelyDecideOption> getAllOptions(List<OptimizelyDecideOption> options) {
         List<OptimizelyDecideOption> copiedOptions = new ArrayList(defaultDecideOptions);

core-api/src/main/java/com/optimizely/ab/OptimizelyUserContext.java

@@ -31,11 +31,8 @@
 
 import com.optimizely.ab.odp.ODPSegmentCallback;
 import com.optimizely.ab.odp.ODPSegmentOption;
-import com.optimizely.ab.optimizelydecision.AsyncDecisionFetcher;
 import com.optimizely.ab.optimizelydecision.OptimizelyDecideOption;
 import com.optimizely.ab.optimizelydecision.OptimizelyDecision;
-import com.optimizely.ab.optimizelydecision.OptimizelyDecisionCallback;
-import com.optimizely.ab.optimizelydecision.OptimizelyDecisionsCallback;
 
 public class OptimizelyUserContext {
     // OptimizelyForcedDecisionsKey mapped to variationKeys
@@ -205,48 +202,6 @@ public Map<String, OptimizelyDecision> decideAll() {
         return decideAll(Collections.emptyList());
     }
 
-
-    /**
-     * Returns a decision result asynchronously for a given flag key and a user context.
-     * support for android async decisions
-     * @param key A flag key for which a decision will be made.
-     * @param callback A callback to invoke when the decision is available.
-     * @param options A list of options for decision-making.
-     */
-    public void decideAsync(@Nonnull String key,
-                            @Nonnull OptimizelyDecisionCallback callback,
-                            @Nonnull List<OptimizelyDecideOption> options) {
-        AsyncDecisionFetcher fetcher = new AsyncDecisionFetcher(this, key, options, callback);
-        fetcher.start();
-    }
-
-
-    /**
-     * Returns decision results asynchronously for multiple flag keys.
-     * support for android async decisions
-     * @param keys A list of flag keys for which decisions will be made.
-     * @param callback A callback to invoke when decisions are available.
-     * @param options A list of options for decision-making.
-     */
-    public void decideForKeysAsync(@Nonnull List<String> keys,
-                                   @Nonnull OptimizelyDecisionsCallback callback,
-                                   @Nonnull List<OptimizelyDecideOption> options) {
-        AsyncDecisionFetcher fetcher = new AsyncDecisionFetcher(this, keys, options, callback);
-        fetcher.start();
-    }
-
-    /**
-     * Returns decision results asynchronously for all active flag keys.
-     * support for android async decisions
-     * @param callback A callback to invoke when decisions are available.
-     * @param options A list of options for decision-making.
-     */
-    public void decideAllAsync(@Nonnull OptimizelyDecisionsCallback callback,
-                               @Nonnull List<OptimizelyDecideOption> options) {
-        AsyncDecisionFetcher fetcher = new AsyncDecisionFetcher(this, options, callback);
-        fetcher.start();
-    }
-
     /**
      * Track an event.
      *

core-api/src/test/java/com/optimizely/ab/OptimizelyTest.java

@@ -23,6 +23,9 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Function;
 
 import static org.hamcrest.CoreMatchers.is;
@@ -5135,4 +5138,101 @@ public void testDecideReturnsErrorDecisionWhenDecisionServiceFails() throws Exce
         assertTrue(decision.getReasons().contains("Failed to fetch CMAB data for experiment exp-cmab."));
     }
 
+    @Test
+    public void decideAsyncReturnsDecision() throws Exception {
+        assumeTrue(datafileVersion >= Integer.parseInt(ProjectConfig.Version.V4.toString()));
+        ProjectConfigManager mockProjectConfigManager = mock(ProjectConfigManager.class);
+        Mockito.when(mockProjectConfigManager.getConfig()).thenReturn(validProjectConfig);
+        Optimizely optimizely = Optimizely.builder()
+            .withConfigManager(mockProjectConfigManager)
+            .build();
+        OptimizelyUserContext userContext = optimizely.createUserContext(testUserId);
+
+        final CountDownLatch latch = new CountDownLatch(1);
+        final AtomicReference<OptimizelyDecision> decisionRef = new AtomicReference<>();
+        final AtomicReference<Throwable> errorRef = new AtomicReference<>();
+
+        optimizely.decideAsync(userContext,
+            FEATURE_MULTI_VARIATE_FEATURE_KEY, (OptimizelyDecision decision) -> {
+                try {
+                    decisionRef.set(decision);
+                } catch (Throwable t) {
+                    errorRef.set(t);
+                } finally {
+                    latch.countDown();
+                }
+        },
+            Collections.emptyList()
+        );
+
+        boolean completed = latch.await(5, TimeUnit.SECONDS);
+        
+        if (errorRef.get() != null) {
+            throw new AssertionError("Error in callback", errorRef.get());
+        }
+        
+        assertTrue("Callback should be called within timeout", completed);
+        
+        OptimizelyDecision decision = decisionRef.get();
+        assertNotNull("Decision should not be null", decision);
+        assertEquals("Flag key should match", FEATURE_MULTI_VARIATE_FEATURE_KEY, decision.getFlagKey());
+    }
+
+    @Test
+    public void decideForKeysAsyncReturnsDecisions() throws Exception {
+        assumeTrue(datafileVersion >= Integer.parseInt(ProjectConfig.Version.V4.toString()));
+        ProjectConfigManager mockProjectConfigManager = mock(ProjectConfigManager.class);
+        Mockito.when(mockProjectConfigManager.getConfig()).thenReturn(validProjectConfig);
+        Optimizely optimizely = Optimizely.builder()
+            .withConfigManager(mockProjectConfigManager)
+            .build();
+        OptimizelyUserContext userContext = optimizely.createUserContext(testUserId);
+
+        List<String> flagKeys = Arrays.asList(
+            FEATURE_MULTI_VARIATE_FEATURE_KEY,
+            FEATURE_SINGLE_VARIABLE_STRING_KEY
+        );
+
+        final CountDownLatch latch = new CountDownLatch(1);
+        final AtomicReference<Map<String, OptimizelyDecision>> decisionsRef = new AtomicReference<>();
+
+        optimizely.decideForKeysAsync(userContext,
+            flagKeys, (Map<String, OptimizelyDecision> decisions) -> {
+                decisionsRef.set(decisions);
+                latch.countDown();
+        },
+            Collections.emptyList()
+        );
+
+        assertTrue("Callback should be called within timeout", latch.await(5, TimeUnit.SECONDS));
+        assertNotNull("Decisions should not be null", decisionsRef.get());
+        assertEquals("Should return decisions for 2 keys", 2, decisionsRef.get().size());
+        assertTrue("Should contain first flag key", decisionsRef.get().containsKey(FEATURE_MULTI_VARIATE_FEATURE_KEY));
+        assertTrue("Should contain second flag key", decisionsRef.get().containsKey(FEATURE_SINGLE_VARIABLE_STRING_KEY));
+    }
+
+    @Test
+    public void decideAllAsyncReturnsAllDecisions() throws Exception {
+        assumeTrue(datafileVersion >= Integer.parseInt(ProjectConfig.Version.V4.toString()));
+        ProjectConfigManager mockProjectConfigManager = mock(ProjectConfigManager.class);
+        Mockito.when(mockProjectConfigManager.getConfig()).thenReturn(validProjectConfig);
+        Optimizely optimizely = Optimizely.builder()
+            .withConfigManager(mockProjectConfigManager)
+            .build();
+        OptimizelyUserContext userContext = optimizely.createUserContext(testUserId);
+
+        final CountDownLatch latch = new CountDownLatch(1);
+        final AtomicReference<Map<String, OptimizelyDecision>> decisionsRef = new AtomicReference<>();
+
+        optimizely.decideAllAsync(userContext, (Map<String, OptimizelyDecision> decisions) -> {
+            decisionsRef.set(decisions);
+            latch.countDown();
+        },
+            Collections.emptyList()
+        );
+
+        assertTrue("Callback should be called within timeout", latch.await(5, TimeUnit.SECONDS));
+        assertNotNull("Decisions should not be null", decisionsRef.get());
+        assertFalse("Decisions should not be empty", decisionsRef.get().isEmpty());
+    }
 }