launchdarkly-server-sdk 5.8.0 → 6.1.1

data/spec/impl/evaluator_clause_spec.rb

@@ -0,0 +1,55 @@
+require "spec_helper"
+require "impl/evaluator_spec_base"
+
+module LaunchDarkly
+  module Impl
+    describe "Evaluator (clauses)", :evaluator_spec_base => true do
+      subject { Evaluator }
+
+      it "can match built-in attribute" do
+        user = { key: 'x', name: 'Bob' }
+        clause = { attribute: 'name', op: 'in', values: ['Bob'] }
+        flag = boolean_flag_with_clauses([clause])
+        expect(basic_evaluator.evaluate(flag, user, factory).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] }
+        flag = boolean_flag_with_clauses([clause])
+        expect(basic_evaluator.evaluate(flag, user, factory).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] }
+        flag = boolean_flag_with_clauses([clause])
+        expect(basic_evaluator.evaluate(flag, user, factory).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(basic_evaluator.evaluate(flag, user, factory).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(basic_evaluator.evaluate(flag, user, factory).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 }
+        flag = boolean_flag_with_clauses([clause])
+        expect(basic_evaluator.evaluate(flag, user, factory).detail.value).to be false
+      end
+    end
+  end
+end

data/spec/impl/evaluator_operators_spec.rb

@@ -0,0 +1,141 @@
+require "spec_helper"
+
+describe LaunchDarkly::Impl::EvaluatorOperators do
+  subject { LaunchDarkly::Impl::EvaluatorOperators }
+
+  describe "operators" do
+    dateStr1 = "2017-12-06T00:00:00.000-07:00"
+    dateStr2 = "2017-12-06T00:01:01.000-07:00"
+    dateMs1 = 10000000
+    dateMs2 = 10000001
+    invalidDate = "hey what's this?"
+
+    operatorTests = [
+      # numeric comparisons
+      [ :in,                 99,      99,      true ],
+      [ :in,                 99.0001, 99.0001, true ],
+      [ :in,                 99,      99.0001, false ],
+      [ :in,                 99.0001, 99,      false ],
+      [ :lessThan,           99,      99.0001, true ],
+      [ :lessThan,           99.0001, 99,      false ],
+      [ :lessThan,           99,      99,      false ],
+      [ :lessThanOrEqual,    99,      99.0001, true ],
+      [ :lessThanOrEqual,    99.0001, 99,      false ],
+      [ :lessThanOrEqual,    99,      99,      true ],
+      [ :greaterThan,        99.0001, 99,      true ],
+      [ :greaterThan,        99,      99.0001, false ],
+      [ :greaterThan,        99,      99,      false ],
+      [ :greaterThanOrEqual, 99.0001, 99,      true ],
+      [ :greaterThanOrEqual, 99,      99.0001, false ],
+      [ :greaterThanOrEqual, 99,      99,      true ],
+
+      # string comparisons
+      [ :in,         "x",   "x",   true ],
+      [ :in,         "x",   "xyz", false ],
+      [ :startsWith, "xyz", "x",   true ],
+      [ :startsWith, "x",   "xyz", false ],
+      [ :endsWith,   "xyz", "z",   true ],
+      [ :endsWith,   "z",   "xyz", false ],
+      [ :contains,   "xyz", "y",   true ],
+      [ :contains,   "y",   "xyz", false ],
+
+      # mixed strings and numbers
+      [ :in,                 "99", 99, false ],
+      [ :in,                  99, "99", false ],
+      [ :contains,           "99", 99, false ],
+      [ :startsWith,         "99", 99, false ],
+      [ :endsWith,           "99", 99, false ],
+      [ :lessThanOrEqual,    "99", 99, false ],
+      [ :lessThanOrEqual,    99, "99", false ],
+      [ :greaterThanOrEqual, "99", 99, false ],
+      [ :greaterThanOrEqual, 99, "99", false ],
+      
+      # regex
+      [ :matches, "hello world", "hello.*rld",     true ],
+      [ :matches, "hello world", "hello.*orl",     true ],
+      [ :matches, "hello world", "l+",             true ],
+      [ :matches, "hello world", "(world|planet)", true ],
+      [ :matches, "hello world", "aloha",          false ],
+      [ :matches, "hello world", "***not a regex", false ],
+
+      # dates
+      [ :before, dateStr1, dateStr2,    true ],
+      [ :before, dateMs1,  dateMs2,     true ],
+      [ :before, dateStr2, dateStr1,    false ],
+      [ :before, dateMs2,  dateMs1,     false ],
+      [ :before, dateStr1, dateStr1,    false ],
+      [ :before, dateMs1,  dateMs1,     false ],
+      [ :before, dateStr1, invalidDate, false ],
+      [ :after,  dateStr1, dateStr2,    false ],
+      [ :after,  dateMs1,  dateMs2,     false ],
+      [ :after,  dateStr2, dateStr1,    true ],
+      [ :after,  dateMs2,  dateMs1,     true ],
+      [ :after,  dateStr1, dateStr1,    false ],
+      [ :after,  dateMs1,  dateMs1,     false ],
+      [ :after,  dateStr1, invalidDate, false ],
+
+      # semver
+      [ :semVerEqual,       "2.0.1", "2.0.1", true ],
+      [ :semVerEqual,       "2.0",   "2.0.0", true ],
+      [ :semVerEqual,       "2-rc1", "2.0.0-rc1", true ],
+      [ :semVerEqual,       "2+build2", "2.0.0+build2", true ],
+      [ :semVerLessThan,    "2.0.0", "2.0.1", true ],
+      [ :semVerLessThan,    "2.0",   "2.0.1", true ],
+      [ :semVerLessThan,    "2.0.1", "2.0.0", false ],
+      [ :semVerLessThan,    "2.0.1", "2.0",   false ],
+      [ :semVerLessThan,    "2.0.0-rc", "2.0.0-rc.beta", true ],
+      [ :semVerGreaterThan, "2.0.1", "2.0.0", true ],
+      [ :semVerGreaterThan, "2.0.1", "2.0",   true ],
+      [ :semVerGreaterThan, "2.0.0", "2.0.1", false ],
+      [ :semVerGreaterThan, "2.0",   "2.0.1", false ],
+      [ :semVerGreaterThan, "2.0.0-rc.1", "2.0.0-rc.0", true ],
+      [ :semVerLessThan,    "2.0.1", "xbad%ver", false ],
+      [ :semVerGreaterThan, "2.0.1", "xbad%ver", false ]
+    ]
+
+    operatorTests.each do |params|
+      op = params[0]
+      value1 = params[1]
+      value2 = params[2]
+      shouldBe = params[3]
+      it "should return #{shouldBe} for #{value1} #{op} #{value2}" do
+        expect(subject::apply(op, value1, value2)).to be shouldBe
+      end
+    end
+  end
+
+  describe "user_value" do
+    [:key, :ip, :country, :email, :firstName, :lastName, :avatar, :name, :anonymous, :some_custom_attr].each do |attr|
+      it "returns nil if property #{attr} is not defined" do
+        expect(subject::user_value({}, attr)).to be nil
+      end
+    end
+
+    [:key, :ip, :country, :email, :firstName, :lastName, :avatar, :name].each do |attr|
+      it "gets string value of string property #{attr}" do
+        expect(subject::user_value({ attr => 'x' }, attr)).to eq 'x'
+      end
+
+      it "coerces non-string value of property #{attr} to string" do
+        expect(subject::user_value({ attr => 3 }, attr)).to eq '3'
+      end
+    end
+
+    it "gets boolean value of property anonymous" do
+      expect(subject::user_value({ anonymous: true }, :anonymous)).to be true
+      expect(subject::user_value({ anonymous: false }, :anonymous)).to be false
+    end
+
+    it "does not coerces non-boolean value of property anonymous" do
+      expect(subject::user_value({ anonymous: 3 }, :anonymous)).to eq 3
+    end
+
+    it "gets string value of custom property" do
+      expect(subject::user_value({ custom: { some_custom_attr: 'x' } }, :some_custom_attr)).to eq 'x'
+    end
+
+    it "gets non-string value of custom property" do
+      expect(subject::user_value({ custom: { some_custom_attr: 3 } }, :some_custom_attr)).to eq 3
+    end
+  end
+end

data/spec/impl/evaluator_rule_spec.rb

@@ -0,0 +1,96 @@
+require "spec_helper"
+require "impl/evaluator_spec_base"
+
+module LaunchDarkly
+  module Impl
+    describe "Evaluator (rules)", :evaluator_spec_base => true do
+      subject { Evaluator }
+
+      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 = EvaluationDetail.new(true, 1, EvaluationReason::rule_match(0, 'ruleid'))
+        result = basic_evaluator.evaluate(flag, user, factory)
+        expect(result.detail).to eq(detail)
+        expect(result.events).to eq(nil)
+      end
+
+      it "reuses rule match reason instances if possible" do
+        rule = { id: 'ruleid', clauses: [{ attribute: 'key', op: 'in', values: ['userkey'] }], variation: 1 }
+        flag = boolean_flag_with_rules([rule])
+        Model.postprocess_item_after_deserializing!(FEATURES, flag)  # now there's a cached rule match reason
+        user = { key: 'userkey' }
+        detail = EvaluationDetail.new(true, 1, EvaluationReason::rule_match(0, 'ruleid'))
+        result1 = basic_evaluator.evaluate(flag, user, factory)
+        result2 = basic_evaluator.evaluate(flag, user, factory)
+        expect(result1.detail.reason.rule_id).to eq 'ruleid'
+        expect(result1.detail.reason).to be result2.detail.reason
+      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 = EvaluationDetail.new(nil, nil,
+          EvaluationReason::error(EvaluationReason::ERROR_MALFORMED_FLAG))
+        result = basic_evaluator.evaluate(flag, user, factory)
+        expect(result.detail).to eq(detail)
+        expect(result.events).to eq(nil)
+      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 = EvaluationDetail.new(nil, nil,
+          EvaluationReason::error(EvaluationReason::ERROR_MALFORMED_FLAG))
+        result = basic_evaluator.evaluate(flag, user, factory)
+        expect(result.detail).to eq(detail)
+        expect(result.events).to eq(nil)
+      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 = EvaluationDetail.new(nil, nil,
+          EvaluationReason::error(EvaluationReason::ERROR_MALFORMED_FLAG))
+        result = basic_evaluator.evaluate(flag, user, factory)
+        expect(result.detail).to eq(detail)
+        expect(result.events).to eq(nil)
+      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 = EvaluationDetail.new(nil, nil,
+          EvaluationReason::error(EvaluationReason::ERROR_MALFORMED_FLAG))
+        result = basic_evaluator.evaluate(flag, user, factory)
+        expect(result.detail).to eq(detail)
+        expect(result.events).to eq(nil)
+      end
+
+      it "coerces user key to a string for evaluation" do
+        clause = { attribute: 'key', op: 'in', values: ['999'] }
+        flag = boolean_flag_with_clauses([clause])
+        user = { key: 999 }
+        result = basic_evaluator.evaluate(flag, user, factory)
+        expect(result.detail.value).to eq(true)
+      end
+
+      it "coerces secondary key to a string for evaluation" do
+        # We can't really verify that the rollout calculation works correctly, but we can at least
+        # make sure it doesn't error out if there's a non-string secondary value (ch35189)
+        rule = { id: 'ruleid', clauses: [{ attribute: 'key', op: 'in', values: ['userkey'] }],
+          rollout: { salt: '', variations: [ { weight: 100000, variation: 1 } ] } }
+        flag = boolean_flag_with_rules([rule])
+        user = { key: "userkey", secondary: 999 }
+        result = basic_evaluator.evaluate(flag, user, factory)
+        expect(result.detail.reason).to eq(EvaluationReason::rule_match(0, 'ruleid'))
+      end
+    end
+  end
+end

data/spec/impl/evaluator_segment_spec.rb

@@ -0,0 +1,125 @@
+require "spec_helper"
+require "impl/evaluator_spec_base"
+
+module LaunchDarkly
+  module Impl
+    describe "Evaluator (segments)", :evaluator_spec_base => true do
+      subject { Evaluator }
+
+      def test_segment_match(segment)
+        clause = make_segment_match_clause(segment)
+        flag = boolean_flag_with_clauses([clause])
+        e = Evaluator.new(get_nothing, get_things({ segment[:key] => segment }), logger)
+        e.evaluate(flag, user, factory).detail.value
+      end
+
+      it "retrieves segment from segment store for segmentMatch operator" do
+        segment = {
+          key: 'segkey',
+          included: [ 'userkey' ],
+          version: 1,
+          deleted: false
+        }
+        get_segment = get_things({ 'segkey' => segment })
+        e = subject.new(get_nothing, get_segment, logger)
+        user = { key: 'userkey' }
+        clause = { attribute: '', op: 'segmentMatch', values: ['segkey'] }
+        flag = boolean_flag_with_clauses([clause])
+        expect(e.evaluate(flag, user, factory).detail.value).to be true
+      end
+
+      it "falls through with no errors if referenced segment is not found" do
+        e = subject.new(get_nothing, get_things({ 'segkey' => nil }), logger)
+        user = { key: 'userkey' }
+        clause = { attribute: '', op: 'segmentMatch', values: ['segkey'] }
+        flag = boolean_flag_with_clauses([clause])
+        expect(e.evaluate(flag, user, factory).detail.value).to be false
+      end
+
+      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] ]
+        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] ]
+        expect(test_segment_match(segment)).to be true
+      end
+
+      it 'matches user by rule when weight is absent' do
+        segClause = make_user_matching_clause(user, :email)
+        segRule = {
+          clauses: [ segClause ]
+        }
+        segment = make_segment('segkey')
+        segment[:rules] = [ segRule ]
+        expect(test_segment_match(segment)).to be true
+      end
+
+      it 'matches user by rule when weight is nil' do
+        segClause = make_user_matching_clause(user, :email)
+        segRule = {
+          clauses: [ segClause ],
+          weight: nil
+        }
+        segment = make_segment('segkey')
+        segment[:rules] = [ segRule ]
+        expect(test_segment_match(segment)).to be true
+      end
+
+      it 'matches user with full rollout' do
+        segClause = make_user_matching_clause(user, :email)
+        segRule = {
+          clauses: [ segClause ],
+          weight: 100000
+        }
+        segment = make_segment('segkey')
+        segment[:rules] = [ segRule ]
+        expect(test_segment_match(segment)).to be true
+      end
+
+      it "doesn't match user with zero rollout" do
+        segClause = make_user_matching_clause(user, :email)
+        segRule = {
+          clauses: [ segClause ],
+          weight: 0
+        }
+        segment = make_segment('segkey')
+        segment[:rules] = [ segRule ]
+        expect(test_segment_match(segment)).to be false
+      end
+
+      it "matches user with multiple clauses" do
+        segClause1 = make_user_matching_clause(user, :email)
+        segClause2 = make_user_matching_clause(user, :name)
+        segRule = {
+          clauses: [ segClause1, segClause2 ]
+        }
+        segment = make_segment('segkey')
+        segment[:rules] = [ segRule ]
+        expect(test_segment_match(segment)).to be true
+      end
+
+      it "doesn't match user with multiple clauses if a clause doesn't match" do
+        segClause1 = make_user_matching_clause(user, :email)
+        segClause2 = make_user_matching_clause(user, :name)
+        segClause2[:values] = [ 'wrong' ]
+        segRule = {
+          clauses: [ segClause1, segClause2 ]
+        }
+        segment = make_segment('segkey')
+        segment[:rules] = [ segRule ]
+        expect(test_segment_match(segment)).to be false
+      end
+    end
+  end
+end

data/spec/impl/evaluator_spec.rb

@@ -0,0 +1,305 @@
+require "spec_helper"
+require "impl/evaluator_spec_base"
+
+module LaunchDarkly
+  module Impl
+    describe "Evaluator (general)", :evaluator_spec_base => true do
+      subject { Evaluator }
+
+      describe "evaluate" do
+        it "returns off variation if flag is off" do
+          flag = {
+            key: 'feature',
+            on: false,
+            offVariation: 1,
+            fallthrough: { variation: 0 },
+            variations: ['a', 'b', 'c']
+          }
+          user = { key: 'x' }
+          detail = EvaluationDetail.new('b', 1, EvaluationReason::off)
+          result = basic_evaluator.evaluate(flag, user, factory)
+          expect(result.detail).to eq(detail)
+          expect(result.events).to eq(nil)
+        end
+
+        it "returns nil if flag is off and off variation is unspecified" do
+          flag = {
+            key: 'feature',
+            on: false,
+            fallthrough: { variation: 0 },
+            variations: ['a', 'b', 'c']
+          }
+          user = { key: 'x' }
+          detail = EvaluationDetail.new(nil, nil, EvaluationReason::off)
+          result = basic_evaluator.evaluate(flag, user, factory)
+          expect(result.detail).to eq(detail)
+          expect(result.events).to eq(nil)
+        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 = EvaluationDetail.new(nil, nil,
+            EvaluationReason::error(EvaluationReason::ERROR_MALFORMED_FLAG))
+          result = basic_evaluator.evaluate(flag, user, factory)
+          expect(result.detail).to eq(detail)
+          expect(result.events).to eq(nil)
+        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 = EvaluationDetail.new(nil, nil,
+            EvaluationReason::error(EvaluationReason::ERROR_MALFORMED_FLAG))
+          result = basic_evaluator.evaluate(flag, user, factory)
+          expect(result.detail).to eq(detail)
+          expect(result.events).to eq(nil)
+        end
+
+        it "returns off variation if prerequisite is not found" do
+          flag = {
+            key: 'feature0',
+            on: true,
+            prerequisites: [{key: 'badfeature', variation: 1}],
+            fallthrough: { variation: 0 },
+            offVariation: 1,
+            variations: ['a', 'b', 'c']
+          }
+          user = { key: 'x' }
+          detail = EvaluationDetail.new('b', 1, EvaluationReason::prerequisite_failed('badfeature'))
+          e = subject.new(get_things( 'badfeature' => nil ), get_nothing, logger)
+          result = e.evaluate(flag, user, factory)
+          expect(result.detail).to eq(detail)
+          expect(result.events).to eq(nil)
+        end
+
+        it "reuses prerequisite-failed reason instances if possible" do
+          flag = {
+            key: 'feature0',
+            on: true,
+            prerequisites: [{key: 'badfeature', variation: 1}],
+            fallthrough: { variation: 0 },
+            offVariation: 1,
+            variations: ['a', 'b', 'c']
+          }
+          Model.postprocess_item_after_deserializing!(FEATURES, flag)  # now there's a cached reason
+          user = { key: 'x' }
+          e = subject.new(get_things( 'badfeature' => nil ), get_nothing, logger)
+          result1 = e.evaluate(flag, user, factory)
+          expect(result1.detail.reason).to eq EvaluationReason::prerequisite_failed('badfeature')
+          result2 = e.evaluate(flag, user, factory)
+          expect(result2.detail.reason).to be result1.detail.reason
+        end
+
+        it "returns off variation and event if prerequisite of a prerequisite is not found" 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: true,
+            prerequisites: [{key: 'feature2', variation: 1}], # feature2 doesn't exist
+            fallthrough: { variation: 0 },
+            variations: ['d', 'e'],
+            version: 2
+          }
+          user = { key: 'x' }
+          detail = EvaluationDetail.new('b', 1, EvaluationReason::prerequisite_failed('feature1'))
+          events_should_be = [{
+            kind: 'feature', key: 'feature1', user: user, value: nil, default: nil, variation: nil, version: 2, prereqOf: 'feature0'
+          }]
+          get_flag = get_things('feature1' => flag1, 'feature2' => nil)
+          e = subject.new(get_flag, get_nothing, logger)
+          result = e.evaluate(flag, user, factory)
+          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
+          }
+          user = { key: 'x' }
+          detail = EvaluationDetail.new('b', 1, EvaluationReason::prerequisite_failed('feature1'))
+          events_should_be = [{
+            kind: 'feature', key: 'feature1', user: user, variation: 1, value: 'e', default: nil, version: 2, prereqOf: 'feature0'
+          }]
+          get_flag = get_things({ 'feature1' => flag1 })
+          e = subject.new(get_flag, get_nothing, logger)
+          result = e.evaluate(flag, user, factory)
+          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
+          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: true,
+            fallthrough: { variation: 0 },
+            variations: ['d', 'e'],
+            version: 2
+          }
+          user = { key: 'x' }
+          detail = EvaluationDetail.new('b', 1, EvaluationReason::prerequisite_failed('feature1'))
+          events_should_be = [{
+            kind: 'feature', key: 'feature1', user: user, variation: 0, value: 'd', default: nil, version: 2, prereqOf: 'feature0'
+          }]
+          get_flag = get_things({ 'feature1' => flag1 })
+          e = subject.new(get_flag, get_nothing, logger)
+          result = e.evaluate(flag, user, factory)
+          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
+          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: true,
+            fallthrough: { variation: 1 },
+            variations: ['d', 'e'],
+            version: 2
+          }
+          user = { key: 'x' }
+          detail = EvaluationDetail.new('a', 0, EvaluationReason::fallthrough)
+          events_should_be = [{
+            kind: 'feature', key: 'feature1', user: user, variation: 1, value: 'e', default: nil, version: 2, prereqOf: 'feature0'
+          }]
+          get_flag = get_things({ 'feature1' => flag1 })
+          e = subject.new(get_flag, get_nothing, logger)
+          result = e.evaluate(flag, user, factory)
+          expect(result.detail).to eq(detail)
+          expect(result.events).to eq(events_should_be)
+        end
+
+        it "returns an error if fallthrough variation is too high" do
+          flag = {
+            key: 'feature',
+            on: true,
+            fallthrough: { variation: 999 },
+            offVariation: 1,
+            variations: ['a', 'b', 'c']
+          }
+          user = { key: 'userkey' }
+          detail = EvaluationDetail.new(nil, nil, EvaluationReason::error(EvaluationReason::ERROR_MALFORMED_FLAG))
+          result = basic_evaluator.evaluate(flag, user, factory)
+          expect(result.detail).to eq(detail)
+          expect(result.events).to eq(nil)
+        end
+
+        it "returns an error if fallthrough variation is negative" do
+          flag = {
+            key: 'feature',
+            on: true,
+            fallthrough: { variation: -1 },
+            offVariation: 1,
+            variations: ['a', 'b', 'c']
+          }
+          user = { key: 'userkey' }
+          detail = EvaluationDetail.new(nil, nil, EvaluationReason::error(EvaluationReason::ERROR_MALFORMED_FLAG))
+          result = basic_evaluator.evaluate(flag, user, factory)
+          expect(result.detail).to eq(detail)
+          expect(result.events).to eq(nil)
+        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 = EvaluationDetail.new(nil, nil, EvaluationReason::error(EvaluationReason::ERROR_MALFORMED_FLAG))
+          result = basic_evaluator.evaluate(flag, user, factory)
+          expect(result.detail).to eq(detail)
+          expect(result.events).to eq(nil)
+        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 = EvaluationDetail.new(nil, nil, EvaluationReason::error(EvaluationReason::ERROR_MALFORMED_FLAG))
+          result = basic_evaluator.evaluate(flag, user, factory)
+          expect(result.detail).to eq(detail)
+          expect(result.events).to eq(nil)
+        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' }
+          detail = EvaluationDetail.new('c', 2, EvaluationReason::target_match)
+          result = basic_evaluator.evaluate(flag, user, factory)
+          expect(result.detail).to eq(detail)
+          expect(result.events).to eq(nil)
+        end
+      end
+    end
+  end
+end