ldclient-rb 5.1.0 → 5.2.0

data/lib/ldclient-rb/version.rb

@@ -1,3 +1,3 @@
 module LaunchDarkly
-  VERSION = "5.1.0"
+  VERSION = "5.2.0"
 end

data/spec/evaluation_spec.rb

@@ -2,6 +2,9 @@ require "spec_helper"
 
 describe LaunchDarkly::Evaluation do
   subject { LaunchDarkly::Evaluation }
+
+  include LaunchDarkly::Evaluation
+
   let(:features) { LaunchDarkly::InMemoryFeatureStore.new }
 
   let(:user) {
@@ -14,7 +17,13 @@ describe LaunchDarkly::Evaluation do
 
   let(:logger) { LaunchDarkly::Config.default_logger }
 
-  include LaunchDarkly::Evaluation
+  def boolean_flag_with_rules(rules)
+    { key: 'feature', on: true, rules: rules, fallthrough: { variation: 0 }, variations: [ false, true ] }
+  end
+
+  def boolean_flag_with_clauses(clauses)
+    boolean_flag_with_rules([{ id: 'ruleid', clauses: clauses, variation: 1 }])
+  end
 
   describe "evaluate" do
     it "returns off variation if flag is off" do
@@ -26,7 +35,10 @@ describe LaunchDarkly::Evaluation do
         variations: ['a', 'b', 'c']
       }
       user = { key: 'x' }
-      expect(evaluate(flag, user, features, logger)).to eq({variation: 1, value: 'b', events: []})
+      detail = LaunchDarkly::EvaluationDetail.new('b', 1, { kind: 'OFF' })
+      result = evaluate(flag, user, features, logger)
+      expect(result.detail).to eq(detail)
+      expect(result.events).to eq([])
     end
 
     it "returns nil if flag is off and off variation is unspecified" do
@@ -37,7 +49,42 @@ describe LaunchDarkly::Evaluation do
         variations: ['a', 'b', 'c']
       }
       user = { key: 'x' }
-      expect(evaluate(flag, user, features, logger)).to eq({variation: nil, value: nil, events: []})
+      detail = LaunchDarkly::EvaluationDetail.new(nil, nil, { kind: 'OFF' })
+      result = evaluate(flag, user, features, logger)
+      expect(result.detail).to eq(detail)
+      expect(result.events).to eq([])
+    end
+
+    it "returns an error if off variation is too high" do
+      flag = {
+        key: 'feature',
+        on: false,
+        offVariation: 999,
+        fallthrough: { variation: 0 },
+        variations: ['a', 'b', 'c']
+      }
+      user = { key: 'x' }
+      detail = LaunchDarkly::EvaluationDetail.new(nil, nil,
+        { kind: 'ERROR', errorKind: 'MALFORMED_FLAG' })
+      result = evaluate(flag, user, features, logger)
+      expect(result.detail).to eq(detail)
+      expect(result.events).to eq([])
+    end
+
+    it "returns an error if off variation is negative" do
+      flag = {
+        key: 'feature',
+        on: false,
+        offVariation: -1,
+        fallthrough: { variation: 0 },
+        variations: ['a', 'b', 'c']
+      }
+      user = { key: 'x' }
+      detail = LaunchDarkly::EvaluationDetail.new(nil, nil,
+        { kind: 'ERROR', errorKind: 'MALFORMED_FLAG' })
+      result = evaluate(flag, user, features, logger)
+      expect(result.detail).to eq(detail)
+      expect(result.events).to eq([])
     end
 
     it "returns off variation if prerequisite is not found" do
@@ -50,7 +97,11 @@ describe LaunchDarkly::Evaluation do
         variations: ['a', 'b', 'c']
       }
       user = { key: 'x' }
-      expect(evaluate(flag, user, features, logger)).to eq({variation: 1, value: 'b', events: []})
+      detail = LaunchDarkly::EvaluationDetail.new('b', 1,
+        { kind: 'PREREQUISITE_FAILED', prerequisiteKey: 'badfeature' })
+      result = evaluate(flag, user, features, logger)
+      expect(result.detail).to eq(detail)
+      expect(result.events).to eq([])
     end
 
     it "returns off variation and event if prerequisite of a prerequisite is not found" do
@@ -73,11 +124,47 @@ describe LaunchDarkly::Evaluation do
       }
       features.upsert(LaunchDarkly::FEATURES, flag1)
       user = { key: 'x' }
+      detail = LaunchDarkly::EvaluationDetail.new('b', 1,
+        { kind: 'PREREQUISITE_FAILED', prerequisiteKey: 'feature1' })
       events_should_be = [{
         kind: 'feature', key: 'feature1', variation: nil, value: nil, version: 2, prereqOf: 'feature0',
         trackEvents: nil, debugEventsUntilDate: nil
       }]
-      expect(evaluate(flag, user, features, logger)).to eq({variation: 1, value: 'b', events: events_should_be})
+      result = evaluate(flag, user, features, logger)
+      expect(result.detail).to eq(detail)
+      expect(result.events).to eq(events_should_be)
+    end
+
+    it "returns off variation and event if prerequisite is off" do
+      flag = {
+        key: 'feature0',
+        on: true,
+        prerequisites: [{key: 'feature1', variation: 1}],
+        fallthrough: { variation: 0 },
+        offVariation: 1,
+        variations: ['a', 'b', 'c'],
+        version: 1
+      }
+      flag1 = {
+        key: 'feature1',
+        on: false,
+        # note that even though it returns the desired variation, it is still off and therefore not a match
+        offVariation: 1,
+        fallthrough: { variation: 0 },
+        variations: ['d', 'e'],
+        version: 2
+      }
+      features.upsert(LaunchDarkly::FEATURES, flag1)
+      user = { key: 'x' }
+      detail = LaunchDarkly::EvaluationDetail.new('b', 1,
+        { kind: 'PREREQUISITE_FAILED', prerequisiteKey: 'feature1' })
+      events_should_be = [{
+        kind: 'feature', key: 'feature1', variation: 1, value: 'e', version: 2, prereqOf: 'feature0',
+        trackEvents: nil, debugEventsUntilDate: nil
+      }]
+      result = evaluate(flag, user, features, logger)
+      expect(result.detail).to eq(detail)
+      expect(result.events).to eq(events_should_be)
     end
 
     it "returns off variation and event if prerequisite is not met" do
@@ -99,11 +186,15 @@ describe LaunchDarkly::Evaluation do
       }
       features.upsert(LaunchDarkly::FEATURES, flag1)
       user = { key: 'x' }
+      detail = LaunchDarkly::EvaluationDetail.new('b', 1,
+        { kind: 'PREREQUISITE_FAILED', prerequisiteKey: 'feature1' })
       events_should_be = [{
         kind: 'feature', key: 'feature1', variation: 0, value: 'd', version: 2, prereqOf: 'feature0',
         trackEvents: nil, debugEventsUntilDate: nil
       }]
-      expect(evaluate(flag, user, features, logger)).to eq({variation: 1, value: 'b', events: events_should_be})
+      result = evaluate(flag, user, features, logger)
+      expect(result.detail).to eq(detail)
+      expect(result.events).to eq(events_should_be)
     end
 
     it "returns fallthrough variation and event if prerequisite is met and there are no rules" do
@@ -125,76 +216,195 @@ describe LaunchDarkly::Evaluation do
       }
       features.upsert(LaunchDarkly::FEATURES, flag1)
       user = { key: 'x' }
+      detail = LaunchDarkly::EvaluationDetail.new('a', 0, { kind: 'FALLTHROUGH' })
       events_should_be = [{
         kind: 'feature', key: 'feature1', variation: 1, value: 'e', version: 2, prereqOf: 'feature0',
         trackEvents: nil, debugEventsUntilDate: nil
       }]
-      expect(evaluate(flag, user, features, logger)).to eq({variation: 0, value: 'a', events: events_should_be})
+      result = evaluate(flag, user, features, logger)
+      expect(result.detail).to eq(detail)
+      expect(result.events).to eq(events_should_be)
     end
 
-    it "matches user from targets" do
+    it "returns an error if fallthrough variation is too high" do
       flag = {
-        key: 'feature0',
+        key: 'feature',
         on: true,
-        targets: [
-          { values: [ 'whoever', 'userkey' ], variation: 2 }
-        ],
-        fallthrough: { variation: 0 },
+        fallthrough: { variation: 999 },
         offVariation: 1,
         variations: ['a', 'b', 'c']
       }
       user = { key: 'userkey' }
-      expect(evaluate(flag, user, features, logger)).to eq({variation: 2, value: 'c', events: []})
+      detail = LaunchDarkly::EvaluationDetail.new(nil, nil, { kind: 'ERROR', errorKind: 'MALFORMED_FLAG' })
+      result = evaluate(flag, user, features, logger)
+      expect(result.detail).to eq(detail)
+      expect(result.events).to eq([])
     end
 
-    it "matches user from rules" do
+    it "returns an error if fallthrough variation is negative" do
       flag = {
-        key: 'feature0',
+        key: 'feature',
         on: true,
-        rules: [
-          {
-            clauses: [
-              {
-                attribute: 'key',
-                op: 'in',
-                values: [ 'userkey' ]
-              }
-            ],
-            variation: 2
-          }
+        fallthrough: { variation: -1 },
+        offVariation: 1,
+        variations: ['a', 'b', 'c']
+      }
+      user = { key: 'userkey' }
+      detail = LaunchDarkly::EvaluationDetail.new(nil, nil, { kind: 'ERROR', errorKind: 'MALFORMED_FLAG' })
+      result = evaluate(flag, user, features, logger)
+      expect(result.detail).to eq(detail)
+      expect(result.events).to eq([])
+    end
+
+    it "returns an error if fallthrough has no variation or rollout" do
+      flag = {
+        key: 'feature',
+        on: true,
+        fallthrough: { },
+        offVariation: 1,
+        variations: ['a', 'b', 'c']
+      }
+      user = { key: 'userkey' }
+      detail = LaunchDarkly::EvaluationDetail.new(nil, nil, { kind: 'ERROR', errorKind: 'MALFORMED_FLAG' })
+      result = evaluate(flag, user, features, logger)
+      expect(result.detail).to eq(detail)
+      expect(result.events).to eq([])
+    end
+
+    it "returns an error if fallthrough has a rollout with no variations" do
+      flag = {
+        key: 'feature',
+        on: true,
+        fallthrough: { rollout: { variations: [] } },
+        offVariation: 1,
+        variations: ['a', 'b', 'c']
+      }
+      user = { key: 'userkey' }
+      detail = LaunchDarkly::EvaluationDetail.new(nil, nil, { kind: 'ERROR', errorKind: 'MALFORMED_FLAG' })
+      result = evaluate(flag, user, features, logger)
+      expect(result.detail).to eq(detail)
+      expect(result.events).to eq([])
+    end
+
+    it "matches user from targets" do
+      flag = {
+        key: 'feature',
+        on: true,
+        targets: [
+          { values: [ 'whoever', 'userkey' ], variation: 2 }
         ],
         fallthrough: { variation: 0 },
         offVariation: 1,
         variations: ['a', 'b', 'c']
       }
       user = { key: 'userkey' }
-      expect(evaluate(flag, user, features, logger)).to eq({variation: 2, value: 'c', events: []})
+      detail = LaunchDarkly::EvaluationDetail.new('c', 2, { kind: 'TARGET_MATCH' })
+      result = evaluate(flag, user, features, logger)
+      expect(result.detail).to eq(detail)
+      expect(result.events).to eq([])
+    end
+
+    it "matches user from rules" do
+      rule = { id: 'ruleid', clauses: [{ attribute: 'key', op: 'in', values: ['userkey'] }], variation: 1 }
+      flag = boolean_flag_with_rules([rule])
+      user = { key: 'userkey' }
+      detail = LaunchDarkly::EvaluationDetail.new(true, 1,
+        { kind: 'RULE_MATCH', ruleIndex: 0, ruleId: 'ruleid' })
+      result = evaluate(flag, user, features, logger)
+      expect(result.detail).to eq(detail)
+      expect(result.events).to eq([])
+    end
+
+    it "returns an error if rule variation is too high" do
+      rule = { id: 'ruleid', clauses: [{ attribute: 'key', op: 'in', values: ['userkey'] }], variation: 999 }
+      flag = boolean_flag_with_rules([rule])
+      user = { key: 'userkey' }
+      detail = LaunchDarkly::EvaluationDetail.new(nil, nil,
+        { kind: 'ERROR', errorKind: 'MALFORMED_FLAG' })
+      result = evaluate(flag, user, features, logger)
+      expect(result.detail).to eq(detail)
+      expect(result.events).to eq([])
+    end
+
+    it "returns an error if rule variation is negative" do
+      rule = { id: 'ruleid', clauses: [{ attribute: 'key', op: 'in', values: ['userkey'] }], variation: -1 }
+      flag = boolean_flag_with_rules([rule])
+      user = { key: 'userkey' }
+      detail = LaunchDarkly::EvaluationDetail.new(nil, nil,
+        { kind: 'ERROR', errorKind: 'MALFORMED_FLAG' })
+      result = evaluate(flag, user, features, logger)
+      expect(result.detail).to eq(detail)
+      expect(result.events).to eq([])
+    end
+
+    it "returns an error if rule has neither variation nor rollout" do
+      rule = { id: 'ruleid', clauses: [{ attribute: 'key', op: 'in', values: ['userkey'] }] }
+      flag = boolean_flag_with_rules([rule])
+      user = { key: 'userkey' }
+      detail = LaunchDarkly::EvaluationDetail.new(nil, nil,
+        { kind: 'ERROR', errorKind: 'MALFORMED_FLAG' })
+      result = evaluate(flag, user, features, logger)
+      expect(result.detail).to eq(detail)
+      expect(result.events).to eq([])
+    end
+
+    it "returns an error if rule has a rollout with no variations" do
+      rule = { id: 'ruleid', clauses: [{ attribute: 'key', op: 'in', values: ['userkey'] }],
+        rollout: { variations: [] } }
+      flag = boolean_flag_with_rules([rule])
+      user = { key: 'userkey' }
+      detail = LaunchDarkly::EvaluationDetail.new(nil, nil,
+        { kind: 'ERROR', errorKind: 'MALFORMED_FLAG' })
+      result = evaluate(flag, user, features, logger)
+      expect(result.detail).to eq(detail)
+      expect(result.events).to eq([])
     end
   end
 
-  describe "clause_match_user" do
+  describe "clause" do
     it "can match built-in attribute" do
       user = { key: 'x', name: 'Bob' }
       clause = { attribute: 'name', op: 'in', values: ['Bob'] }
-      expect(clause_match_user(clause, user, features)).to be true
+      flag = boolean_flag_with_clauses([clause])
+      expect(evaluate(flag, user, features, logger).detail.value).to be true
     end
 
     it "can match custom attribute" do
       user = { key: 'x', name: 'Bob', custom: { legs: 4 } }
       clause = { attribute: 'legs', op: 'in', values: [4] }
-      expect(clause_match_user(clause, user, features)).to be true
+      flag = boolean_flag_with_clauses([clause])
+      expect(evaluate(flag, user, features, logger).detail.value).to be true
     end
 
     it "returns false for missing attribute" do
       user = { key: 'x', name: 'Bob' }
       clause = { attribute: 'legs', op: 'in', values: [4] }
-      expect(clause_match_user(clause, user, features)).to be false
+      flag = boolean_flag_with_clauses([clause])
+      expect(evaluate(flag, user, features, logger).detail.value).to be false
+    end
+
+    it "returns false for unknown operator" do
+      user = { key: 'x', name: 'Bob' }
+      clause = { attribute: 'name', op: 'unknown', values: [4] }
+      flag = boolean_flag_with_clauses([clause])
+      expect(evaluate(flag, user, features, logger).detail.value).to be false
+    end
+
+    it "does not stop evaluating rules after clause with unknown operator" do
+      user = { key: 'x', name: 'Bob' }
+      clause0 = { attribute: 'name', op: 'unknown', values: [4] }
+      rule0 = { clauses: [ clause0 ], variation: 1 }
+      clause1 = { attribute: 'name', op: 'in', values: ['Bob'] }
+      rule1 = { clauses: [ clause1 ], variation: 1 }
+      flag = boolean_flag_with_rules([rule0, rule1])
+      expect(evaluate(flag, user, features, logger).detail.value).to be true
     end
 
     it "can be negated" do
       user = { key: 'x', name: 'Bob' }
       clause = { attribute: 'name', op: 'in', values: ['Bob'], negate: true }
-      expect(clause_match_user(clause, user, features)).to be false
+      flag = boolean_flag_with_clauses([clause])
+      expect(evaluate(flag, user, features, logger).detail.value).to be false
     end
 
     it "retrieves segment from segment store for segmentMatch operator" do
@@ -208,23 +418,24 @@ describe LaunchDarkly::Evaluation do
 
       user = { key: 'userkey' }
       clause = { attribute: '', op: 'segmentMatch', values: ['segkey'] }
-
-      expect(clause_match_user(clause, user, features)).to be true
+      flag = boolean_flag_with_clauses([clause])
+      expect(evaluate(flag, user, features, logger).detail.value).to be true
     end
 
     it "falls through with no errors if referenced segment is not found" do
       user = { key: 'userkey' }
       clause = { attribute: '', op: 'segmentMatch', values: ['segkey'] }
-
-      expect(clause_match_user(clause, user, features)).to be false
+      flag = boolean_flag_with_clauses([clause])
+      expect(evaluate(flag, user, features, logger).detail.value).to be false
     end
 
     it "can be negated" do
       user = { key: 'x', name: 'Bob' }
       clause = { attribute: 'name', op: 'in', values: ['Bob'] }
+      flag = boolean_flag_with_clauses([clause])
       expect {
          clause[:negate] = true
-      }.to change {clause_match_user(clause, user, features)}.from(true).to(false)
+      }.to change {evaluate(flag, user, features, logger).detail.value}.from(true).to(false)
     end
   end
 
@@ -326,7 +537,8 @@ describe LaunchDarkly::Evaluation do
       it "should return #{shouldBe} for #{value1} #{op} #{value2}" do
         user = { key: 'x', custom: { foo: value1 } }
         clause = { attribute: 'foo', op: op, values: [value2] }
-        expect(clause_match_user(clause, user, features)).to be shouldBe
+        flag = boolean_flag_with_clauses([clause])
+        expect(evaluate(flag, user, features, logger).detail.value).to be shouldBe
       end
     end
   end
@@ -385,17 +597,6 @@ describe LaunchDarkly::Evaluation do
     end
   end
   
-  def make_flag(key)
-    {
-      key: key,
-      rules: [],
-      variations: [ false, true ],
-      on: true,
-      fallthrough: { variation: 0 },
-      version: 1
-    }
-  end
-
   def make_segment(key)
     {
       key: key,
@@ -424,35 +625,30 @@ describe LaunchDarkly::Evaluation do
   end
 
   describe 'segment matching' do
-    it 'explicitly includes user' do
-      segment = make_segment('segkey')
-      segment[:included] = [ user[:key] ]
+    def test_segment_match(segment)
       features.upsert(LaunchDarkly::SEGMENTS, segment)
       clause = make_segment_match_clause(segment)
+      flag = boolean_flag_with_clauses([clause])
+      evaluate(flag, user, features, logger).detail.value
+    end
 
-      result = clause_match_user(clause, user, features)
-      expect(result).to be true
+    it 'explicitly includes user' do
+      segment = make_segment('segkey')
+      segment[:included] = [ user[:key] ]
+      expect(test_segment_match(segment)).to be true
     end
 
     it 'explicitly excludes user' do
       segment = make_segment('segkey')
       segment[:excluded] = [ user[:key] ]
-      features.upsert(LaunchDarkly::SEGMENTS, segment)
-      clause = make_segment_match_clause(segment)
-
-      result = clause_match_user(clause, user, features)
-      expect(result).to be false
+      expect(test_segment_match(segment)).to be false
     end
 
     it 'both includes and excludes user; include takes priority' do
       segment = make_segment('segkey')
       segment[:included] = [ user[:key] ]
       segment[:excluded] = [ user[:key] ]
-      features.upsert(LaunchDarkly::SEGMENTS, segment)
-      clause = make_segment_match_clause(segment)
-
-      result = clause_match_user(clause, user, features)
-      expect(result).to be true
+      expect(test_segment_match(segment)).to be true
     end
 
     it 'matches user by rule when weight is absent' do
@@ -462,11 +658,7 @@ describe LaunchDarkly::Evaluation do
       }
       segment = make_segment('segkey')
       segment[:rules] = [ segRule ]
-      features.upsert(LaunchDarkly::SEGMENTS, segment)
-      clause = make_segment_match_clause(segment)
-
-      result = clause_match_user(clause, user, features)
-      expect(result).to be true
+      expect(test_segment_match(segment)).to be true
     end
 
     it 'matches user by rule when weight is nil' do
@@ -477,11 +669,7 @@ describe LaunchDarkly::Evaluation do
       }
       segment = make_segment('segkey')
       segment[:rules] = [ segRule ]
-      features.upsert(LaunchDarkly::SEGMENTS, segment)
-      clause = make_segment_match_clause(segment)
-
-      result = clause_match_user(clause, user, features)
-      expect(result).to be true
+      expect(test_segment_match(segment)).to be true
     end
 
     it 'matches user with full rollout' do
@@ -492,11 +680,7 @@ describe LaunchDarkly::Evaluation do
       }
       segment = make_segment('segkey')
       segment[:rules] = [ segRule ]
-      features.upsert(LaunchDarkly::SEGMENTS, segment)
-      clause = make_segment_match_clause(segment)
-
-      result = clause_match_user(clause, user, features)
-      expect(result).to be true
+      expect(test_segment_match(segment)).to be true
     end
 
     it "doesn't match user with zero rollout" do
@@ -507,11 +691,7 @@ describe LaunchDarkly::Evaluation do
       }
       segment = make_segment('segkey')
       segment[:rules] = [ segRule ]
-      features.upsert(LaunchDarkly::SEGMENTS, segment)
-      clause = make_segment_match_clause(segment)
-
-      result = clause_match_user(clause, user, features)
-      expect(result).to be false
+      expect(test_segment_match(segment)).to be false
     end
 
     it "matches user with multiple clauses" do
@@ -522,11 +702,7 @@ describe LaunchDarkly::Evaluation do
       }
       segment = make_segment('segkey')
       segment[:rules] = [ segRule ]
-      features.upsert(LaunchDarkly::SEGMENTS, segment)
-      clause = make_segment_match_clause(segment)
-
-      result = clause_match_user(clause, user, features)
-      expect(result).to be true
+      expect(test_segment_match(segment)).to be true
     end
 
     it "doesn't match user with multiple clauses if a clause doesn't match" do
@@ -538,11 +714,7 @@ describe LaunchDarkly::Evaluation do
       }
       segment = make_segment('segkey')
       segment[:rules] = [ segRule ]
-      features.upsert(LaunchDarkly::SEGMENTS, segment)
-      clause = make_segment_match_clause(segment)
-
-      result = clause_match_user(clause, user, features)
-      expect(result).to be false
+      expect(test_segment_match(segment)).to be false
     end
   end
 end