launchdarkly-server-sdk 5.8.0 → 6.1.1

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

data/spec/ldclient_spec.rb

@@ -25,6 +25,12 @@ describe LaunchDarkly::LDClient do
       }
     }
   end
+  let(:user_anonymous) do
+    {
+      key: "anonymous@test.com",
+      anonymous: true
+    }
+  end
   let(:numeric_key_user) do
     {
       key: 33,
@@ -139,20 +145,30 @@ describe LaunchDarkly::LDClient do
       client.variation("key", user, "default")
     end
 
-    it "queues a feature event for an existing feature when user is nil" do
+    it "does not send an event if user is nil" do
+      config.feature_store.init({ LaunchDarkly::FEATURES => {} })
+      config.feature_store.upsert(LaunchDarkly::FEATURES, feature_with_value)
+      expect(event_processor).not_to receive(:add_event)
+      expect(logger).to receive(:error)
+      client.variation("key", nil, "default")
+    end
+
+    it "queues a feature event for an existing feature when user is anonymous" do
       config.feature_store.init({ LaunchDarkly::FEATURES => {} })
       config.feature_store.upsert(LaunchDarkly::FEATURES, feature_with_value)
       expect(event_processor).to receive(:add_event).with(hash_including(
         kind: "feature",
         key: "key",
         version: 100,
-        user: nil,
-        value: "default",
+        contextKind: "anonymousUser",
+        user: user_anonymous,
+        variation: 0,
+        value: "value",
         default: "default",
         trackEvents: true,
         debugEventsUntilDate: 1000
       ))
-      client.variation("key", nil, "default")
+      client.variation("key", user_anonymous, "default")
     end
 
     it "queues a feature event for an existing feature when user key is nil" do
@@ -197,7 +213,7 @@ describe LaunchDarkly::LDClient do
         value: 'value',
         default: 'default',
         trackEvents: true,
-        reason: { kind: 'RULE_MATCH', ruleIndex: 0, ruleId: 'id' }
+        reason: LaunchDarkly::EvaluationReason::rule_match(0, 'id')
       ))
       client.variation('flag', user, 'default')
     end
@@ -222,7 +238,7 @@ describe LaunchDarkly::LDClient do
         value: 'value',
         default: 'default',
         trackEvents: true,
-        reason: { kind: 'FALLTHROUGH' }
+        reason: LaunchDarkly::EvaluationReason::fallthrough
       ))
       client.variation('flag', user, 'default')
     end
@@ -234,20 +250,22 @@ describe LaunchDarkly::LDClient do
 
     it "returns the default value if the client is offline" do
       result = offline_client.variation_detail("doesntmatter", user, "default")
-      expected = LaunchDarkly::EvaluationDetail.new("default", nil, { kind: 'ERROR', errorKind: 'CLIENT_NOT_READY' })
+      expected = LaunchDarkly::EvaluationDetail.new("default", nil,
+        LaunchDarkly::EvaluationReason::error(LaunchDarkly::EvaluationReason::ERROR_CLIENT_NOT_READY))
       expect(result).to eq expected
     end
 
     it "returns the default value for an unknown feature" do
       result = client.variation_detail("badkey", user, "default")
-      expected = LaunchDarkly::EvaluationDetail.new("default", nil, { kind: 'ERROR', errorKind: 'FLAG_NOT_FOUND'})
+      expected = LaunchDarkly::EvaluationDetail.new("default", nil,
+      LaunchDarkly::EvaluationReason::error(LaunchDarkly::EvaluationReason::ERROR_FLAG_NOT_FOUND))
       expect(result).to eq expected
     end
 
     it "queues a feature request event for an unknown feature" do
       expect(event_processor).to receive(:add_event).with(hash_including(
         kind: "feature", key: "badkey", user: user, value: "default", default: "default",
-        reason: { kind: 'ERROR', errorKind: 'FLAG_NOT_FOUND' }
+        reason: LaunchDarkly::EvaluationReason::error(LaunchDarkly::EvaluationReason::ERROR_FLAG_NOT_FOUND)
       ))
       client.variation_detail("badkey", user, "default")
     end
@@ -256,7 +274,7 @@ describe LaunchDarkly::LDClient do
       config.feature_store.init({ LaunchDarkly::FEATURES => {} })
       config.feature_store.upsert(LaunchDarkly::FEATURES, feature_with_value)
       result = client.variation_detail("key", user, "default")
-      expected = LaunchDarkly::EvaluationDetail.new("value", 0, { kind: 'OFF' })
+      expected = LaunchDarkly::EvaluationDetail.new("value", 0, LaunchDarkly::EvaluationReason::off)
       expect(result).to eq expected
     end
 
@@ -265,7 +283,7 @@ describe LaunchDarkly::LDClient do
       config.feature_store.init({ LaunchDarkly::FEATURES => {} })
       config.feature_store.upsert(LaunchDarkly::FEATURES, empty_feature)
       result = client.variation_detail("key", user, "default")
-      expected = LaunchDarkly::EvaluationDetail.new("default", nil, { kind: 'OFF' })
+      expected = LaunchDarkly::EvaluationDetail.new("default", nil, LaunchDarkly::EvaluationReason::off)
       expect(result).to eq expected
       expect(result.default_value?).to be true
     end
@@ -283,10 +301,18 @@ describe LaunchDarkly::LDClient do
         default: "default",
         trackEvents: true,
         debugEventsUntilDate: 1000,
-        reason: { kind: "OFF" }
+        reason: LaunchDarkly::EvaluationReason::off
       ))
       client.variation_detail("key", user, "default")
     end
+
+    it "does not send an event if user is nil" do
+      config.feature_store.init({ LaunchDarkly::FEATURES => {} })
+      config.feature_store.upsert(LaunchDarkly::FEATURES, feature_with_value)
+      expect(event_processor).not_to receive(:add_event)
+      expect(logger).to receive(:error)
+      client.variation_detail("key", nil, "default")
+    end
   end
 
   describe '#all_flags' do
@@ -453,6 +479,12 @@ describe LaunchDarkly::LDClient do
       client.track("custom_event_name", user, nil, 1.5)
     end
 
+    it "includes contextKind with anonymous user" do
+      expect(event_processor).to receive(:add_event).with(hash_including(
+        kind: "custom", key: "custom_event_name", user: user_anonymous, metricValue: 2.2, contextKind: "anonymousUser"))
+      client.track("custom_event_name", user_anonymous, nil, 2.2)
+    end
+
     it "sanitizes the user in the event" do
       expect(event_processor).to receive(:add_event).with(hash_including(user: sanitized_numeric_key_user))
       client.track("custom_event_name", numeric_key_user, nil)
@@ -471,6 +503,26 @@ describe LaunchDarkly::LDClient do
     end
   end
 
+  describe '#alias' do
+    it "queues up an alias event" do
+      expect(event_processor).to receive(:add_event).with(hash_including(
+        kind: "alias", key: user[:key], contextKind: "user", previousKey: user_anonymous[:key], previousContextKind: "anonymousUser"))
+      client.alias(user, user_anonymous)
+    end
+
+    it "does not send an event, and logs a warning, if user is nil" do
+      expect(event_processor).not_to receive(:add_event)
+      expect(logger).to receive(:warn)
+      client.alias(nil, nil)
+    end
+
+    it "does not send an event, and logs a warning, if user key is nil" do
+      expect(event_processor).not_to receive(:add_event)
+      expect(logger).to receive(:warn)
+      client.alias(user_without_key, user_without_key)
+    end
+  end
+
   describe '#identify' do 
     it "queues up an identify event" do
       expect(event_processor).to receive(:add_event).with(hash_including(kind: "identify", key: user[:key], user: user))

data/spec/polling_spec.rb

@@ -19,10 +19,10 @@ describe LaunchDarkly::PollingProcessor do
     flag = { key: 'flagkey', version: 1 }
     segment = { key: 'segkey', version: 1 }
     all_data = {
-      flags: {
+      LaunchDarkly::FEATURES => {
         flagkey: flag
       },
-      segments: {
+      LaunchDarkly::SEGMENTS => {
         segkey: segment
       }
     }

data/spec/redis_feature_store_spec.rb

@@ -1,5 +1,5 @@
-require "connection_pool"
 require "feature_store_spec_base"
+require "connection_pool"
 require "json"
 require "redis"
 require "spec_helper"
@@ -28,7 +28,7 @@ end
 
 describe LaunchDarkly::RedisFeatureStore do
   subject { LaunchDarkly::RedisFeatureStore }
-
+  
   break if ENV['LD_SKIP_DATABASE_TESTS'] == '1'
 
   # These tests will all fail if there isn't a Redis instance running on the default port.

data/spec/requestor_spec.rb

@@ -35,7 +35,7 @@ describe LaunchDarkly::Requestor do
         with_requestor(server.base_uri.to_s) do |requestor|
           server.setup_ok_response("/", expected_data.to_json)
           data = requestor.request_all_data()
-          expect(data).to eq expected_data
+          expect(data).to eq LaunchDarkly::Impl::Model.make_all_store_data(expected_data)
         end
       end
     end
@@ -91,7 +91,7 @@ describe LaunchDarkly::Requestor do
           data = requestor.request_all_data()
           expect(server.requests.count).to eq 2
           expect(server.requests[1].header).to include({ "if-none-match" => [ etag ] })
-          expect(data).to eq expected_data
+          expect(data).to eq LaunchDarkly::Impl::Model.make_all_store_data(expected_data)
         end
       end
     end
@@ -109,14 +109,14 @@ describe LaunchDarkly::Requestor do
             res["ETag"] = etag1
           end
           data = requestor.request_all_data()
-          expect(data).to eq expected_data1
+          expect(data).to eq LaunchDarkly::Impl::Model.make_all_store_data(expected_data1)
           expect(server.requests.count).to eq 1
 
           server.setup_response("/") do |req, res|
             res.status = 304
           end
           data = requestor.request_all_data()
-          expect(data).to eq expected_data1
+          expect(data).to eq LaunchDarkly::Impl::Model.make_all_store_data(expected_data1)
           expect(server.requests.count).to eq 2
           expect(server.requests[1].header).to include({ "if-none-match" => [ etag1 ] })
 
@@ -126,7 +126,7 @@ describe LaunchDarkly::Requestor do
             res["ETag"] = etag2
           end
           data = requestor.request_all_data()
-          expect(data).to eq expected_data2
+          expect(data).to eq LaunchDarkly::Impl::Model.make_all_store_data(expected_data2)
           expect(server.requests.count).to eq 3
           expect(server.requests[2].header).to include({ "if-none-match" => [ etag1 ] })
 
@@ -134,7 +134,7 @@ describe LaunchDarkly::Requestor do
             res.status = 304
           end
           data = requestor.request_all_data()
-          expect(data).to eq expected_data2
+          expect(data).to eq LaunchDarkly::Impl::Model.make_all_store_data(expected_data2)
           expect(server.requests.count).to eq 4
           expect(server.requests[3].header).to include({ "if-none-match" => [ etag2 ] })
         end
@@ -147,7 +147,7 @@ describe LaunchDarkly::Requestor do
         server.setup_ok_response("/sdk/latest-all", content, "application/json")
         with_requestor(server.base_uri.to_s) do |requestor|
           data = requestor.request_all_data
-          expect(data).to eq(JSON.parse(content, symbolize_names: true))
+          expect(data).to eq(LaunchDarkly::Impl::Model.make_all_store_data(JSON.parse(content, symbolize_names: true)))
         end
       end
     end
@@ -159,7 +159,7 @@ describe LaunchDarkly::Requestor do
           "text/plain; charset=ISO-8859-2")
         with_requestor(server.base_uri.to_s) do |requestor|
           data = requestor.request_all_data
-          expect(data).to eq(JSON.parse(content, symbolize_names: true))
+          expect(data).to eq(LaunchDarkly::Impl::Model.make_all_store_data(JSON.parse(content, symbolize_names: true)))
         end
       end
     end
@@ -176,15 +176,15 @@ describe LaunchDarkly::Requestor do
     end
 
     it "can use a proxy server" do
-      content = '{"flags": {"flagkey": {"key": "flagkey"}}}'
+      expected_data = { flags: { flagkey: { key: "flagkey" } } }
       with_server do |server|
-        server.setup_ok_response("/sdk/latest-all", content, "application/json", { "etag" => "x" })
+        server.setup_ok_response("/sdk/latest-all", expected_data.to_json, "application/json", { "etag" => "x" })
         with_server(StubProxyServer.new) do |proxy|
           begin
             ENV["http_proxy"] = proxy.base_uri.to_s
             with_requestor(server.base_uri.to_s) do |requestor|
               data = requestor.request_all_data
-              expect(data).to eq(JSON.parse(content, symbolize_names: true))
+              expect(data).to eq(LaunchDarkly::Impl::Model.make_all_store_data(expected_data))
             end
           ensure
             ENV["http_proxy"] = nil
@@ -193,38 +193,4 @@ describe LaunchDarkly::Requestor do
       end
     end
   end
-
-  describe "request_flag" do
-    it "uses expected URI and headers" do
-      with_server do |server|
-        with_requestor(server.base_uri.to_s) do |requestor|
-          server.setup_ok_response("/", "{}")
-          requestor.request_flag("key")
-          expect(server.requests.count).to eq 1
-          expect(server.requests[0].unparsed_uri).to eq "/sdk/latest-flags/key"
-          expect(server.requests[0].header).to include({
-            "authorization" => [ $sdk_key ],
-            "user-agent" => [ "RubyClient/" + LaunchDarkly::VERSION ]
-          })
-        end
-      end
-    end
-  end
-
-  describe "request_segment" do
-    it "uses expected URI and headers" do
-      with_server do |server|
-        with_requestor(server.base_uri.to_s) do |requestor|
-          server.setup_ok_response("/", "{}")
-          requestor.request_segment("key")
-          expect(server.requests.count).to eq 1
-          expect(server.requests[0].unparsed_uri).to eq "/sdk/latest-segments/key"
-          expect(server.requests[0].header).to include({
-            "authorization" => [ $sdk_key ],
-            "user-agent" => [ "RubyClient/" + LaunchDarkly::VERSION ]
-          })
-        end
-      end
-    end
-  end
 end