Merge pull request #55 from launchdarkly/eb/flag-tests

add more flag evaluation unit tests

Author: eli-darkly

src/main/java/com/launchdarkly/client/FeatureFlagBuilder.java

@@ -3,6 +3,7 @@
 import com.google.gson.JsonElement;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 
 class FeatureFlagBuilder {
@@ -84,6 +85,10 @@ FeatureFlagBuilder variations(List<JsonElement> variations) {
     return this;
   }
 
+  FeatureFlagBuilder variations(JsonElement... variations) {
+    return variations(Arrays.asList(variations));
+  }
+  
   FeatureFlagBuilder deleted(boolean deleted) {
     this.deleted = deleted;
     return this;

src/test/java/com/launchdarkly/client/FeatureFlagTest.java

@@ -1,20 +1,24 @@
 package com.launchdarkly.client;
 
-import com.google.gson.JsonElement;
-import com.google.gson.JsonPrimitive;
-
-import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
 
 import java.util.Arrays;
 
+import static com.launchdarkly.client.TestUtil.booleanFlagWithClauses;
+import static com.launchdarkly.client.TestUtil.fallthroughVariation;
+import static com.launchdarkly.client.TestUtil.jbool;
+import static com.launchdarkly.client.TestUtil.jint;
+import static com.launchdarkly.client.TestUtil.js;
 import static com.launchdarkly.client.VersionedDataKind.FEATURES;
 import static com.launchdarkly.client.VersionedDataKind.SEGMENTS;
-import static java.util.Collections.singletonList;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
 
 public class FeatureFlagTest {
 
+  private static LDUser BASE_USER = new LDUser.Builder("x").build();
+  
   private FeatureStore featureStore;
 
   @Before
@@ -23,51 +27,222 @@ public void before() {
   }
 
   @Test
-  public void testPrereqDoesNotExist() throws EvaluationException {
-    String keyA = "keyA";
-    String keyB = "keyB";
-    FeatureFlag f1 = newFlagWithPrereq(keyA, keyB);
-
-    featureStore.upsert(FEATURES, f1);
-    LDUser user = new LDUser.Builder("userKey").build();
-    FeatureFlag.EvalResult actual = f1.evaluate(user, featureStore);
-
-    Assert.assertNull(actual.getValue());
-    Assert.assertNotNull(actual.getPrerequisiteEvents());
-    Assert.assertEquals(0, actual.getPrerequisiteEvents().size());
+  public void flagReturnsOffVariationIfFlagIsOff() throws Exception {
+    FeatureFlag f = new FeatureFlagBuilder("feature")
+        .on(false)
+        .offVariation(1)
+        .fallthrough(fallthroughVariation(0))
+        .variations(js("fall"), js("off"), js("on"))
+        .build();
+    FeatureFlag.EvalResult result = f.evaluate(BASE_USER, featureStore);
+    
+    assertEquals(js("off"), result.getValue());
+    assertEquals(0, result.getPrerequisiteEvents().size());
   }
 
   @Test
-  public void testPrereqCollectsEventsForPrereqs() throws EvaluationException {
-    String keyA = "keyA";
-    String keyB = "keyB";
-    String keyC = "keyC";
-    FeatureFlag flagA = newFlagWithPrereq(keyA, keyB);
-    FeatureFlag flagB = newFlagWithPrereq(keyB, keyC);
-    FeatureFlag flagC = newFlagOff(keyC);
-
-    featureStore.upsert(FEATURES, flagA);
-    featureStore.upsert(FEATURES, flagB);
-    featureStore.upsert(FEATURES, flagC);
-
-    LDUser user = new LDUser.Builder("userKey").build();
+  public void flagReturnsNullIfFlagIsOffAndOffVariationIsUnspecified() throws Exception {
+    FeatureFlag f = new FeatureFlagBuilder("feature")
+        .on(false)
+        .fallthrough(fallthroughVariation(0))
+        .variations(js("fall"), js("off"), js("on"))
+        .build();
+    FeatureFlag.EvalResult result = f.evaluate(BASE_USER, featureStore);
+    
+    assertNull(result.getValue());
+    assertEquals(0, result.getPrerequisiteEvents().size());
+  }
+  
+  @Test
+  public void flagReturnsOffVariationIfPrerequisiteIsNotFound() throws Exception {
+    FeatureFlag f0 = new FeatureFlagBuilder("feature0")
+        .on(true)
+        .prerequisites(Arrays.asList(new Prerequisite("feature1", 1)))
+        .fallthrough(fallthroughVariation(0))
+        .offVariation(1)
+        .variations(js("fall"), js("off"), js("on"))
+        .build();
+    FeatureFlag.EvalResult result = f0.evaluate(BASE_USER, featureStore);
+    
+    assertEquals(js("off"), result.getValue());
+    assertEquals(0, result.getPrerequisiteEvents().size());
+  }
+  
+  @Test
+  public void flagReturnsOffVariationAndEventIfPrerequisiteIsNotMet() throws Exception {
+    FeatureFlag f0 = new FeatureFlagBuilder("feature0")
+        .on(true)
+        .prerequisites(Arrays.asList(new Prerequisite("feature1", 1)))
+        .fallthrough(fallthroughVariation(0))
+        .offVariation(1)
+        .variations(js("fall"), js("off"), js("on"))
+        .version(1)
+        .build();
+    FeatureFlag f1 = new FeatureFlagBuilder("feature1")
+        .on(true)
+        .fallthrough(fallthroughVariation(0))
+        .variations(js("nogo"), js("go"))
+        .version(2)
+        .build();
+    featureStore.upsert(FEATURES, f1);        
+    FeatureFlag.EvalResult result = f0.evaluate(BASE_USER, featureStore);
+    
+    assertEquals(js("off"), result.getValue());
+    
+    assertEquals(1, result.getPrerequisiteEvents().size());
+    FeatureRequestEvent event = result.getPrerequisiteEvents().get(0);
+    assertEquals(f1.getKey(), event.key);
+    assertEquals("feature", event.kind);
+    assertEquals(js("nogo"), event.value);
+    assertEquals(f1.getVersion(), event.version.intValue());
+    assertEquals(f0.getKey(), event.prereqOf);
+  }
 
-    FeatureFlag.EvalResult flagAResult = flagA.evaluate(user, featureStore);
-    Assert.assertNotNull(flagAResult);
-    Assert.assertNull(flagAResult.getValue());
-    Assert.assertEquals(2, flagAResult.getPrerequisiteEvents().size());
+  @Test
+  public void flagReturnsFallthroughVariationAndEventIfPrerequisiteIsMetAndThereAreNoRules() throws Exception {
+    FeatureFlag f0 = new FeatureFlagBuilder("feature0")
+        .on(true)
+        .prerequisites(Arrays.asList(new Prerequisite("feature1", 1)))
+        .fallthrough(fallthroughVariation(0))
+        .offVariation(1)
+        .variations(js("fall"), js("off"), js("on"))
+        .version(1)
+        .build();
+    FeatureFlag f1 = new FeatureFlagBuilder("feature1")
+        .on(true)
+        .fallthrough(fallthroughVariation(1))
+        .variations(js("nogo"), js("go"))
+        .version(2)
+        .build();
+    featureStore.upsert(FEATURES, f1);        
+    FeatureFlag.EvalResult result = f0.evaluate(BASE_USER, featureStore);
+    
+    assertEquals(js("fall"), result.getValue());
+    assertEquals(1, result.getPrerequisiteEvents().size());
+    
+    FeatureRequestEvent event = result.getPrerequisiteEvents().get(0);
+    assertEquals(f1.getKey(), event.key);
+    assertEquals("feature", event.kind);
+    assertEquals(js("go"), event.value);
+    assertEquals(f1.getVersion(), event.version.intValue());
+    assertEquals(f0.getKey(), event.prereqOf);
+  }
 
-    FeatureFlag.EvalResult flagBResult = flagB.evaluate(user, featureStore);
-    Assert.assertNotNull(flagBResult);
-    Assert.assertNull(flagBResult.getValue());
-    Assert.assertEquals(1, flagBResult.getPrerequisiteEvents().size());
+  @Test
+  public void multipleLevelsOfPrerequisitesProduceMultipleEvents() throws Exception {
+    FeatureFlag f0 = new FeatureFlagBuilder("feature0")
+        .on(true)
+        .prerequisites(Arrays.asList(new Prerequisite("feature1", 1)))
+        .fallthrough(fallthroughVariation(0))
+        .offVariation(1)
+        .variations(js("fall"), js("off"), js("on"))
+        .version(1)
+        .build();
+    FeatureFlag f1 = new FeatureFlagBuilder("feature1")
+        .on(true)
+        .prerequisites(Arrays.asList(new Prerequisite("feature2", 1)))
+        .fallthrough(fallthroughVariation(1))
+        .variations(js("nogo"), js("go"))
+        .version(2)
+        .build();
+    FeatureFlag f2 = new FeatureFlagBuilder("feature2")
+        .on(true)
+        .fallthrough(fallthroughVariation(1))
+        .variations(js("nogo"), js("go"))
+        .version(3)
+        .build();
+    featureStore.upsert(FEATURES, f1);        
+    featureStore.upsert(FEATURES, f2);        
+    FeatureFlag.EvalResult result = f0.evaluate(BASE_USER, featureStore);
+    
+    assertEquals(js("fall"), result.getValue());    
+    assertEquals(2, result.getPrerequisiteEvents().size());
+    
+    FeatureRequestEvent event0 = result.getPrerequisiteEvents().get(0);
+    assertEquals(f2.getKey(), event0.key);
+    assertEquals("feature", event0.kind);
+    assertEquals(js("go"), event0.value);
+    assertEquals(f2.getVersion(), event0.version.intValue());
+    assertEquals(f1.getKey(), event0.prereqOf);
 
-    FeatureFlag.EvalResult flagCResult = flagC.evaluate(user, featureStore);
-    Assert.assertNotNull(flagCResult);
-    Assert.assertEquals(null, flagCResult.getValue());
-    Assert.assertEquals(0, flagCResult.getPrerequisiteEvents().size());
+    FeatureRequestEvent event1 = result.getPrerequisiteEvents().get(1);
+    assertEquals(f1.getKey(), event1.key);
+    assertEquals("feature", event1.kind);
+    assertEquals(js("go"), event1.value);
+    assertEquals(f1.getVersion(), event1.version.intValue());
+    assertEquals(f0.getKey(), event1.prereqOf);
   }
-
+  
+  @Test
+  public void flagMatchesUserFromTargets() throws Exception {
+    FeatureFlag f = new FeatureFlagBuilder("feature")
+        .on(true)
+        .targets(Arrays.asList(new Target(Arrays.asList("whoever", "userkey"), 2)))
+        .fallthrough(fallthroughVariation(0))
+        .offVariation(1)
+        .variations(js("fall"), js("off"), js("on"))
+        .build();
+    LDUser user = new LDUser.Builder("userkey").build();
+    FeatureFlag.EvalResult result = f.evaluate(user, featureStore);
+    
+    assertEquals(js("on"), result.getValue());
+    assertEquals(0, result.getPrerequisiteEvents().size());
+  }
+  
+  @Test
+  public void flagMatchesUserFromRules() throws Exception {
+    Clause clause = new Clause("key", Operator.in, Arrays.asList(js("userkey")), false);
+    Rule rule = new Rule(Arrays.asList(clause), 2, null);
+    FeatureFlag f = new FeatureFlagBuilder("feature")
+        .on(true)
+        .rules(Arrays.asList(rule))
+        .fallthrough(fallthroughVariation(0))
+        .offVariation(1)
+        .variations(js("fall"), js("off"), js("on"))
+        .build();
+    LDUser user = new LDUser.Builder("userkey").build();
+    FeatureFlag.EvalResult result = f.evaluate(user, featureStore);
+    
+    assertEquals(js("on"), result.getValue());
+    assertEquals(0, result.getPrerequisiteEvents().size());
+  }
+  
+  @Test
+  public void clauseCanMatchBuiltInAttribute() throws Exception {
+    Clause clause = new Clause("name", Operator.in, Arrays.asList(js("Bob")), false);
+    FeatureFlag f = booleanFlagWithClauses(clause);
+    LDUser user = new LDUser.Builder("key").name("Bob").build();
+    
+    assertEquals(jbool(true), f.evaluate(user, featureStore).getValue());
+  }
+  
+  @Test
+  public void clauseCanMatchCustomAttribute() throws Exception {
+    Clause clause = new Clause("legs", Operator.in, Arrays.asList(jint(4)), false);
+    FeatureFlag f = booleanFlagWithClauses(clause);
+    LDUser user = new LDUser.Builder("key").custom("legs", 4).build();
+    
+    assertEquals(jbool(true), f.evaluate(user, featureStore).getValue());
+  }
+  
+  @Test
+  public void clauseReturnsFalseForMissingAttribute() throws Exception {
+    Clause clause = new Clause("legs", Operator.in, Arrays.asList(jint(4)), false);
+    FeatureFlag f = booleanFlagWithClauses(clause);
+    LDUser user = new LDUser.Builder("key").name("Bob").build();
+    
+    assertEquals(jbool(false), f.evaluate(user, featureStore).getValue());
+  }
+  
+  @Test
+  public void clauseCanBeNegated() throws Exception {
+    Clause clause = new Clause("name", Operator.in, Arrays.asList(js("Bob")), true);
+    FeatureFlag f = booleanFlagWithClauses(clause);
+    LDUser user = new LDUser.Builder("key").name("Bob").build();
+    
+    assertEquals(jbool(false), f.evaluate(user, featureStore).getValue());
+  }
+  
   @Test
   public void testSegmentMatchClauseRetrievesSegmentFromStore() throws Exception {
     Segment segment = new Segment.Builder("segkey")
@@ -80,7 +255,7 @@ public void testSegmentMatchClauseRetrievesSegmentFromStore() throws Exception {
     LDUser user = new LDUser.Builder("foo").build();
 
     FeatureFlag.EvalResult result = flag.evaluate(user, featureStore);
-    Assert.assertEquals(new JsonPrimitive(true), result.getValue());
+    assertEquals(jbool(true), result.getValue());
   }
 
   @Test
@@ -89,34 +264,11 @@ public void testSegmentMatchClauseFallsThroughIfSegmentNotFound() throws Excepti
     LDUser user = new LDUser.Builder("foo").build();
 
     FeatureFlag.EvalResult result = flag.evaluate(user, featureStore);
-    Assert.assertEquals(new JsonPrimitive(false), result.getValue());
-  }
-  
-  private FeatureFlag newFlagWithPrereq(String featureKey, String prereqKey) {
-    return new FeatureFlagBuilder(featureKey)
-        .prerequisites(singletonList(new Prerequisite(prereqKey, 0)))
-        .variations(Arrays.<JsonElement>asList(new JsonPrimitive(0), new JsonPrimitive(1)))
-        .fallthrough(new VariationOrRollout(0, null))
-        .on(true)
-        .build();
+    assertEquals(jbool(false), result.getValue());
   }
-
-  private FeatureFlag newFlagOff(String featureKey) {
-    return new FeatureFlagBuilder(featureKey)
-        .variations(Arrays.<JsonElement>asList(new JsonPrimitive(0), new JsonPrimitive(1)))
-        .fallthrough(new VariationOrRollout(0, null))
-        .on(false)
-        .build();
-  }
-  
+ 
   private FeatureFlag segmentMatchBooleanFlag(String segmentKey) {
-    Clause clause = new Clause("", Operator.segmentMatch, Arrays.asList(new JsonPrimitive(segmentKey)), false);
-    Rule rule = new Rule(Arrays.asList(clause), 1, null);
-    return new FeatureFlagBuilder("key")
-        .variations(Arrays.<JsonElement>asList(new JsonPrimitive(false), new JsonPrimitive(true)))
-        .fallthrough(new VariationOrRollout(0, null))
-        .on(true)
-        .rules(Arrays.asList(rule))
-        .build();
+    Clause clause = new Clause("", Operator.segmentMatch, Arrays.asList(js(segmentKey)), false);
+    return booleanFlagWithClauses(clause);
   }
 }

src/test/java/com/launchdarkly/client/TestUtil.java

@@ -0,0 +1,35 @@
+package com.launchdarkly.client;
+
+import com.google.gson.JsonPrimitive;
+
+import java.util.Arrays;
+
+public class TestUtil {
+
+  public static JsonPrimitive js(String s) {
+    return new JsonPrimitive(s);
+  }
+
+  public static JsonPrimitive jint(int n) {
+    return new JsonPrimitive(n);
+  }
+  
+  public static JsonPrimitive jbool(boolean b) {
+    return new JsonPrimitive(b);
+  }
+  
+  public static VariationOrRollout fallthroughVariation(int variation) {
+    return new VariationOrRollout(variation, null);
+  }
+  
+  public static FeatureFlag booleanFlagWithClauses(Clause... clauses) {
+    Rule rule = new Rule(Arrays.asList(clauses), 1, null);
+    return new FeatureFlagBuilder("feature")
+        .on(true)
+        .rules(Arrays.asList(rule))
+        .fallthrough(fallthroughVariation(0))
+        .offVariation(0)
+        .variations(jbool(false), jbool(true))
+        .build();
+  }
+}