launchdarkly-server-sdk 5.7.4 → 6.1.0

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

data/spec/impl/evaluator_spec_base.rb

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

@@ -0,0 +1,41 @@
+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/launchdarkly-server-sdk_spec.rb

@@ -4,7 +4,7 @@ require "bundler"
 describe LaunchDarkly do
   it "can be automatically loaded by Bundler.require" do
     ldclient_loaded =
-      Bundler.with_clean_env do
+      Bundler.with_unbundled_env do
         Kernel.system("ruby", "./spec/launchdarkly-server-sdk_spec_autoloadtest.rb")
       end
 

data/spec/ldclient_end_to_end_spec.rb

@@ -80,6 +80,7 @@ module LaunchDarkly
 
             req, body = events_server.await_request_with_body
             expect(req.header['authorization']).to eq [ SDK_KEY ]
+            expect(req.header['connection']).to eq [ "Keep-Alive" ]
             data = JSON.parse(body)
             expect(data.length).to eq 1
             expect(data[0]["kind"]).to eq "identify"
@@ -111,6 +112,7 @@ module LaunchDarkly
             req = req0.path == "/diagnostic" ? req0 : req1
             body = req0.path == "/diagnostic" ? body0 : body1
             expect(req.header['authorization']).to eq [ SDK_KEY ]
+            expect(req.header['connection']).to eq [ "Keep-Alive" ]
             data = JSON.parse(body)
             expect(data["kind"]).to eq "diagnostic-init"
           end
@@ -118,6 +120,38 @@ module LaunchDarkly
       end
     end
 
+    it "can use socket factory" do
+      with_server do |poll_server|
+        with_server do |events_server|
+          events_server.setup_ok_response("/bulk", "")
+          poll_server.setup_ok_response("/sdk/latest-all", '{"flags":{},"segments":{}}', "application/json")
+          
+          config = Config.new(
+            stream: false,
+            base_uri: "http://polling.com",
+            events_uri: "http://events.com",
+            diagnostic_opt_out: true,
+            logger: NullLogger.new,
+            socket_factory: SocketFactoryFromHash.new({
+              "polling.com" => poll_server.port,
+              "events.com" => events_server.port  
+            })
+          )
+          with_client(config) do |client|
+            client.identify(USER)
+            client.flush
+
+            req, body = events_server.await_request_with_body
+            expect(req.header['authorization']).to eq [ SDK_KEY ]
+            expect(req.header['connection']).to eq [ "Keep-Alive" ]
+            data = JSON.parse(body)
+            expect(data.length).to eq 1
+            expect(data[0]["kind"]).to eq "identify"
+          end
+        end
+      end
+    end
+
     # TODO: TLS tests with self-signed cert
   end
 end