launchdarkly-server-sdk 6.1.1 → 6.4.0

data/spec/impl/evaluator_segment_spec.rb

@@ -1,125 +0,0 @@
-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

@@ -1,305 +0,0 @@
-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

data/spec/impl/evaluator_spec_base.rb

@@ -1,75 +0,0 @@
-require "spec_helper"
-
-module LaunchDarkly
-  module Impl
-    module EvaluatorSpecBase
-      def factory
-        EventFactory.new(false)
-      end
-
-      def user
-        {
-          key: "userkey",
-          email: "test@example.com",
-          name: "Bob"
-        }
-      end
-
-      def logger
-        ::Logger.new($stdout, level: ::Logger::FATAL)
-      end
-
-      def get_nothing
-        lambda { |key| raise "should not have requested #{key}" }
-      end
-
-      def get_things(map)
-        lambda { |key|
-          raise "should not have requested #{key}" if !map.has_key?(key)
-          map[key]
-        }
-      end
-
-      def basic_evaluator
-        subject.new(get_nothing, get_nothing, logger)
-      end
-
-      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
-
-      def make_user_matching_clause(user, attr)
-        {
-          attribute: attr.to_s,
-          op: :in,
-          values: [ user[attr.to_sym] ],
-          negate: false
-        }
-      end
-
-      def make_segment(key)
-        {
-          key: key,
-          included: [],
-          excluded: [],
-          salt: 'abcdef',
-          version: 1
-        }
-      end
-
-      def make_segment_match_clause(segment)
-        {
-          op: :segmentMatch,
-          values: [ segment[:key] ],
-          negate: false
-        }
-      end
-    end
-
-    RSpec.configure { |c| c.include EvaluatorSpecBase, :evaluator_spec_base => true }
-  end
-end

data/spec/impl/model/serialization_spec.rb

@@ -1,41 +0,0 @@
-require "spec_helper"
-
-module LaunchDarkly
-  module Impl
-    module Model
-      describe "model serialization" do
-        it "serializes flag" do
-          flag = { key: "flagkey", version: 1 }
-          json = Model.serialize(FEATURES, flag)
-          expect(JSON.parse(json, symbolize_names: true)).to eq flag
-        end
-
-        it "serializes segment" do
-          segment = { key: "segkey", version: 1 }
-          json = Model.serialize(SEGMENTS, segment)
-          expect(JSON.parse(json, symbolize_names: true)).to eq segment
-        end
-
-        it "serializes arbitrary data kind" do
-          thing = { key: "thingkey", name: "me" }
-          json = Model.serialize({ name: "things" }, thing)
-          expect(JSON.parse(json, symbolize_names: true)).to eq thing
-        end
-
-        it "deserializes flag with no rules or prerequisites" do
-          flag_in = { key: "flagkey", version: 1 }
-          json = Model.serialize(FEATURES, flag_in)
-          flag_out = Model.deserialize(FEATURES, json)
-          expect(flag_out).to eq flag_in
-        end
-
-        it "deserializes segment" do
-          segment_in = { key: "segkey", version: 1 }
-          json = Model.serialize(SEGMENTS, segment_in)
-          segment_out = Model.deserialize(SEGMENTS, json)
-          expect(segment_out).to eq segment_in
-        end
-      end
-    end
-  end
-end

data/spec/in_memory_feature_store_spec.rb

@@ -1,12 +0,0 @@
-require "feature_store_spec_base"
-require "spec_helper"
-
-def create_in_memory_store(opts = {})
-  LaunchDarkly::InMemoryFeatureStore.new
-end
-
-describe LaunchDarkly::InMemoryFeatureStore do
-  subject { LaunchDarkly::InMemoryFeatureStore }
-  
-  include_examples "feature_store", method(:create_in_memory_store)
-end

data/spec/integrations/consul_feature_store_spec.rb

@@ -1,40 +0,0 @@
-require "feature_store_spec_base"
-require "diplomat"
-require "spec_helper"
-
-
-$my_prefix = 'testprefix'
-
-$consul_base_opts = {
-  prefix: $my_prefix,
-  logger: $null_log
-}
-
-def create_consul_store(opts = {})
-  LaunchDarkly::Integrations::Consul::new_feature_store(
-    $consul_base_opts.merge(opts).merge({ expiration: 60 }))
-end
-
-def create_consul_store_uncached(opts = {})
-  LaunchDarkly::Integrations::Consul::new_feature_store(
-    $consul_base_opts.merge(opts).merge({ expiration: 0 }))
-end
-
-def clear_all_data
-  Diplomat::Kv.delete($my_prefix + '/', recurse: true)
-end
-
-
-describe "Consul feature store" do
-  break if ENV['LD_SKIP_DATABASE_TESTS'] == '1'
-  
-  # These tests will all fail if there isn't a local Consul instance running.
-  
-  context "with local cache" do
-    include_examples "feature_store", method(:create_consul_store), method(:clear_all_data)
-  end
-
-  context "without local cache" do
-    include_examples "feature_store", method(:create_consul_store_uncached), method(:clear_all_data)
-  end
-end