launchdarkly-server-sdk 6.2.3 → 6.3.1

data/spec/diagnostic_events_spec.rb

@@ -1,165 +0,0 @@
-require "ldclient-rb/impl/diagnostic_events"
-
-require "spec_helper"
-
-module LaunchDarkly
-  module Impl
-    describe DiagnosticAccumulator do
-      subject { DiagnosticAccumulator }
-
-      let(:sdk_key) { "sdk_key" }
-      let(:default_id) { subject.create_diagnostic_id("my-key") }
-      let(:default_acc) { subject.new(default_id) }
-
-      it "creates unique ID with SDK key suffix" do
-        id1 = subject.create_diagnostic_id("1234567890")
-        expect(id1[:sdkKeySuffix]).to eq "567890"
-        expect(id1[:diagnosticId]).not_to be_nil
-
-        id2 = subject.create_diagnostic_id("1234567890")
-        expect(id2[:diagnosticId]).not_to eq id1[:diagnosticId]
-      end
-
-      describe "init event" do
-        def expected_default_config
-          {
-            allAttributesPrivate: false,
-            connectTimeoutMillis: Config.default_connect_timeout * 1000,
-            customBaseURI: false,
-            customEventsURI: false,
-            customStreamURI: false,
-            diagnosticRecordingIntervalMillis: Config.default_diagnostic_recording_interval * 1000,
-            eventsCapacity: Config.default_capacity,
-            eventsFlushIntervalMillis: Config.default_flush_interval * 1000,
-            inlineUsersInEvents: false,
-            pollingIntervalMillis: Config.default_poll_interval * 1000,
-            socketTimeoutMillis: Config.default_read_timeout * 1000,
-            streamingDisabled: false,
-            userKeysCapacity: Config.default_user_keys_capacity,
-            userKeysFlushIntervalMillis: Config.default_user_keys_flush_interval * 1000,
-            usingProxy: false,
-            usingRelayDaemon: false
-          }
-        end
-
-        it "has basic fields" do
-          event = default_acc.create_init_event(Config.new)
-          expect(event[:kind]).to eq 'diagnostic-init'
-          expect(event[:creationDate]).not_to be_nil
-          expect(event[:id]).to eq default_id
-        end
-
-        it "can have default config data" do
-          event = default_acc.create_init_event(Config.new)
-          expect(event[:configuration]).to eq expected_default_config
-        end
-
-        it "can have custom config data" do
-          changes_and_expected = [
-            [ { all_attributes_private: true }, { allAttributesPrivate: true } ],
-            [ { connect_timeout: 46 }, { connectTimeoutMillis: 46000 } ],
-            [ { base_uri: 'http://custom' }, { customBaseURI: true } ],
-            [ { events_uri: 'http://custom' }, { customEventsURI: true } ],
-            [ { stream_uri: 'http://custom' }, { customStreamURI: true } ],
-            [ { diagnostic_recording_interval: 9999 }, { diagnosticRecordingIntervalMillis: 9999000 } ],
-            [ { capacity: 4000 }, { eventsCapacity: 4000 } ],
-            [ { flush_interval: 46 }, { eventsFlushIntervalMillis: 46000 } ],
-            [ { inline_users_in_events: true }, { inlineUsersInEvents: true } ],
-            [ { poll_interval: 999 }, { pollingIntervalMillis: 999000 } ],
-            [ { read_timeout: 46 }, { socketTimeoutMillis: 46000 } ],
-            [ { stream: false }, { streamingDisabled: true } ],
-            [ { user_keys_capacity: 999 }, { userKeysCapacity: 999 } ],
-            [ { user_keys_flush_interval: 999 }, { userKeysFlushIntervalMillis: 999000 } ],
-            [ { use_ldd: true }, { usingRelayDaemon: true } ]
-          ]
-          changes_and_expected.each do |config_values, expected_values|
-            config = Config.new(config_values)
-            event = default_acc.create_init_event(config)
-            expect(event[:configuration]).to eq expected_default_config.merge(expected_values)
-          end
-        end
-
-        ['http_proxy', 'https_proxy', 'HTTP_PROXY', 'HTTPS_PROXY'].each do |name|
-          it "detects proxy #{name}" do
-            begin
-              ENV[name] = 'http://my-proxy'
-              event = default_acc.create_init_event(Config.new)
-              expect(event[:configuration][:usingProxy]).to be true
-            ensure
-              ENV[name] = nil
-            end
-          end
-        end
-
-        it "has expected SDK data" do
-          event = default_acc.create_init_event(Config.new)
-          expect(event[:sdk]).to eq ({
-            name: 'ruby-server-sdk',
-            version: LaunchDarkly::VERSION
-          })
-        end
-
-        it "has expected SDK data with wrapper" do
-          event = default_acc.create_init_event(Config.new(wrapper_name: 'my-wrapper', wrapper_version: '2.0'))
-          expect(event[:sdk]).to eq ({
-            name: 'ruby-server-sdk',
-            version: LaunchDarkly::VERSION,
-            wrapperName: 'my-wrapper',
-            wrapperVersion: '2.0'
-          })
-        end
-
-        it "has expected platform data" do
-          event = default_acc.create_init_event(Config.new)
-          expect(event[:platform]).to include ({
-            name: 'ruby'
-          })
-        end
-      end
-
-      describe "periodic event" do
-        it "has correct default values" do
-          acc = subject.new(default_id)
-          event = acc.create_periodic_event_and_reset(2, 3, 4)
-          expect(event).to include({
-            kind: 'diagnostic',
-            id: default_id,
-            droppedEvents: 2,
-            deduplicatedUsers: 3,
-            eventsInLastBatch: 4,
-            streamInits: []
-          })
-          expect(event[:creationDate]).not_to be_nil
-          expect(event[:dataSinceDate]).not_to be_nil
-        end
-
-        it "can add stream init" do
-          acc = subject.new(default_id)
-          acc.record_stream_init(1000, false, 2000)
-          event = acc.create_periodic_event_and_reset(0, 0, 0)
-          expect(event[:streamInits]).to eq [{ timestamp: 1000, failed: false, durationMillis: 2000 }]
-        end
-
-        it "resets fields after creating event" do
-          acc = subject.new(default_id)
-          acc.record_stream_init(1000, false, 2000)
-          event1 = acc.create_periodic_event_and_reset(2, 3, 4)
-          event2 = acc.create_periodic_event_and_reset(5, 6, 7)
-          expect(event1).to include ({
-            droppedEvents: 2,
-            deduplicatedUsers: 3,
-            eventsInLastBatch: 4,
-            streamInits: [{ timestamp: 1000, failed: false, durationMillis: 2000 }]
-          })
-          expect(event2).to include ({
-            dataSinceDate: event1[:creationDate],
-            droppedEvents: 5,
-            deduplicatedUsers: 6,
-            eventsInLastBatch: 7,
-            streamInits: []
-          })
-        end
-      end
-    end
-  end
-end

data/spec/evaluation_detail_spec.rb

@@ -1,135 +0,0 @@
-require "spec_helper"
-
-module LaunchDarkly
-  describe "EvaluationDetail" do
-    subject { EvaluationDetail }
-
-    it "sets properties" do
-      expect(EvaluationDetail.new("x", 0, EvaluationReason::off).value).to eq "x"
-      expect(EvaluationDetail.new("x", 0, EvaluationReason::off).variation_index).to eq 0
-      expect(EvaluationDetail.new("x", 0, EvaluationReason::off).reason).to eq EvaluationReason::off
-    end
-
-    it "checks parameter types" do
-      expect { EvaluationDetail.new(nil, nil, EvaluationReason::off) }.not_to raise_error
-      expect { EvaluationDetail.new(nil, 0, EvaluationReason::off) }.not_to raise_error
-      expect { EvaluationDetail.new(nil, "x", EvaluationReason::off) }.to raise_error(ArgumentError)
-      expect { EvaluationDetail.new(nil, 0, { kind: "OFF" }) }.to raise_error(ArgumentError)
-      expect { EvaluationDetail.new(nil, 0, nil) }.to raise_error(ArgumentError)
-    end
-
-    it "equality test" do
-      expect(EvaluationDetail.new("x", 0, EvaluationReason::off)).to eq EvaluationDetail.new("x", 0, EvaluationReason::off)
-      expect(EvaluationDetail.new("x", 0, EvaluationReason::off)).not_to eq EvaluationDetail.new("y", 0, EvaluationReason::off)
-      expect(EvaluationDetail.new("x", 0, EvaluationReason::off)).not_to eq EvaluationDetail.new("x", 1, EvaluationReason::off)
-      expect(EvaluationDetail.new("x", 0, EvaluationReason::off)).not_to eq EvaluationDetail.new("x", 0, EvaluationReason::fallthrough)
-    end
-  end
-
-  describe "EvaluationReason" do
-    subject { EvaluationReason }
-
-    values = [
-      [ EvaluationReason::off, EvaluationReason::OFF, { "kind" => "OFF" }, "OFF", nil ],
-      [ EvaluationReason::fallthrough, EvaluationReason::FALLTHROUGH,
-        { "kind" => "FALLTHROUGH" }, "FALLTHROUGH", nil ],
-      [ EvaluationReason::target_match, EvaluationReason::TARGET_MATCH,
-        { "kind" => "TARGET_MATCH" }, "TARGET_MATCH", nil ],
-      [ EvaluationReason::rule_match(1, "x"), EvaluationReason::RULE_MATCH,
-        { "kind" => "RULE_MATCH", "ruleIndex" => 1, "ruleId" => "x" }, "RULE_MATCH(1,x)",
-        [ EvaluationReason::rule_match(2, "x"), EvaluationReason::rule_match(1, "y") ] ],
-      [ EvaluationReason::prerequisite_failed("x"), EvaluationReason::PREREQUISITE_FAILED,
-        { "kind" => "PREREQUISITE_FAILED", "prerequisiteKey" => "x" }, "PREREQUISITE_FAILED(x)" ],
-      [ EvaluationReason::error(EvaluationReason::ERROR_FLAG_NOT_FOUND), EvaluationReason::ERROR,
-        { "kind" => "ERROR", "errorKind" => "FLAG_NOT_FOUND" }, "ERROR(FLAG_NOT_FOUND)" ]
-    ]
-    values.each_index do |i|
-      params = values[i]
-      reason = params[0]
-      kind = params[1]
-      json_rep = params[2]
-      brief_str = params[3]
-      unequal_values = params[4]
-
-      describe "reason #{reason.kind}" do
-        it "has correct kind" do
-          expect(reason.kind).to eq kind
-        end
-
-        it "equality to self" do
-          expect(reason).to eq reason
-        end
-
-        it "inequality to others" do
-          values.each_index do |j|
-            if i != j
-              expect(reason).not_to eq values[j][0]
-            end
-          end
-          if !unequal_values.nil?
-            unequal_values.each do |v|
-              expect(reason).not_to eq v
-            end
-          end
-        end
-
-        it "JSON representation" do
-          expect(JSON.parse(reason.as_json.to_json)).to eq json_rep
-          expect(JSON.parse(reason.to_json)).to eq json_rep
-        end
-
-        it "brief representation" do
-          expect(reason.inspect).to eq brief_str
-          expect(reason.to_s).to eq brief_str
-        end
-      end
-    end
-
-    it "reuses singleton reasons" do
-      expect(EvaluationReason::off).to be EvaluationReason::off
-      expect(EvaluationReason::fallthrough).to be EvaluationReason::fallthrough
-      expect(EvaluationReason::target_match).to be EvaluationReason::target_match
-      expect(EvaluationReason::rule_match(1, 'x')).not_to be EvaluationReason::rule_match(1, 'x')
-      expect(EvaluationReason::prerequisite_failed('x')).not_to be EvaluationReason::prerequisite_failed('x')
-      errors = [ EvaluationReason::ERROR_CLIENT_NOT_READY, EvaluationReason::ERROR_FLAG_NOT_FOUND,
-        EvaluationReason::ERROR_MALFORMED_FLAG, EvaluationReason::ERROR_USER_NOT_SPECIFIED, EvaluationReason::ERROR_EXCEPTION ]
-      errors.each do |e|
-        expect(EvaluationReason::error(e)).to be EvaluationReason::error(e)
-      end
-    end
-
-    it "supports [] with JSON property names" do
-      expect(EvaluationReason::off[:kind]).to eq "OFF"
-      expect(EvaluationReason::off[:ruleIndex]).to be nil
-      expect(EvaluationReason::off[:ruleId]).to be nil
-      expect(EvaluationReason::off[:prerequisiteKey]).to be nil
-      expect(EvaluationReason::off[:errorKind]).to be nil
-      expect(EvaluationReason::rule_match(1, "x")[:ruleIndex]).to eq 1
-      expect(EvaluationReason::rule_match(1, "x")[:ruleId]).to eq "x"
-      expect(EvaluationReason::prerequisite_failed("x")[:prerequisiteKey]).to eq "x"
-      expect(EvaluationReason::error(EvaluationReason::ERROR_FLAG_NOT_FOUND)[:errorKind]).to eq "FLAG_NOT_FOUND"
-    end
-
-    it "freezes string properties" do
-      rm = EvaluationReason::rule_match(1, "x")
-      expect { rm.rule_id.upcase! }.to raise_error(RuntimeError)
-      pf = EvaluationReason::prerequisite_failed("x")
-      expect { pf.prerequisite_key.upcase! }.to raise_error(RuntimeError)
-    end
-
-    it "checks parameter types" do
-      expect { EvaluationReason::rule_match(nil, "x") }.to raise_error(ArgumentError)
-      expect { EvaluationReason::rule_match(true, "x") }.to raise_error(ArgumentError)
-      expect { EvaluationReason::rule_match(1, nil) }.not_to raise_error # we allow nil rule_id for backward compatibility
-      expect { EvaluationReason::rule_match(1, 9) }.to raise_error(ArgumentError)
-      expect { EvaluationReason::prerequisite_failed(nil) }.to raise_error(ArgumentError)
-      expect { EvaluationReason::prerequisite_failed(9) }.to raise_error(ArgumentError)
-      expect { EvaluationReason::error(nil) }.to raise_error(ArgumentError)
-      expect { EvaluationReason::error(9) }.to raise_error(ArgumentError)
-    end
-
-    it "does not allow direct access to constructor" do
-      expect { EvaluationReason.new(:off, nil, nil, nil, nil) }.to raise_error(NoMethodError)
-    end
-  end
-end

data/spec/event_sender_spec.rb

@@ -1,197 +0,0 @@
-require "ldclient-rb/impl/event_sender"
-
-require "http_util"
-require "spec_helper"
-
-require "time"
-
-module LaunchDarkly
-  module Impl
-    describe EventSender do
-      subject { EventSender }
-
-      let(:sdk_key) { "sdk_key" }
-      let(:fake_data) { '{"things":[]}' }
-
-      def make_sender(server)
-        subject.new(sdk_key, Config.new(events_uri: server.base_uri.to_s, logger: $null_log), nil, 0.1)
-      end
-
-      def with_sender_and_server
-        with_server do |server|
-          yield make_sender(server), server
-        end
-      end
-
-      it "sends analytics event data" do
-        with_sender_and_server do |es, server|
-          server.setup_ok_response("/bulk", "")
-
-          result = es.send_event_data(fake_data, "", false)
-
-          expect(result.success).to be true
-          expect(result.must_shutdown).to be false
-          expect(result.time_from_server).not_to be_nil
-
-          req = server.await_request
-          expect(req.body).to eq fake_data
-          expect(req.header).to include({
-            "authorization" => [ sdk_key ],
-            "content-type" => [ "application/json" ],
-            "user-agent" => [ "RubyClient/" + LaunchDarkly::VERSION ],
-            "x-launchdarkly-event-schema" => [ "3" ],
-            "connection" => [ "Keep-Alive" ]
-          })
-          expect(req.header['x-launchdarkly-payload-id']).not_to eq []
-        end
-      end
-
-      it "can use a socket factory" do
-        with_server do |server|
-          server.setup_ok_response("/bulk", "")
-
-          config = Config.new(events_uri: "http://events.com/bulk", socket_factory: SocketFactoryFromHash.new({"events.com" => server.port}), logger: $null_log)
-          es = subject.new(sdk_key, config, nil, 0.1)
-
-          result = es.send_event_data(fake_data, "", false)
-
-          expect(result.success).to be true
-          req = server.await_request
-          expect(req.body).to eq fake_data
-          expect(req.host).to eq "events.com"
-        end
-      end
-
-      it "generates a new payload ID for each payload" do
-        with_sender_and_server do |es, server|
-          server.setup_ok_response("/bulk", "")
-
-          result1 = es.send_event_data(fake_data, "", false)
-          result2 = es.send_event_data(fake_data, "", false)
-          expect(result1.success).to be true
-          expect(result2.success).to be true
-
-          req1, body1 = server.await_request_with_body
-          req2, body2 = server.await_request_with_body
-          expect(body1).to eq fake_data
-          expect(body2).to eq fake_data
-          expect(req1.header['x-launchdarkly-payload-id']).not_to eq req2.header['x-launchdarkly-payload-id']
-        end
-      end
-
-      it "sends diagnostic event data" do
-        with_sender_and_server do |es, server|
-          server.setup_ok_response("/diagnostic", "")
-
-          result = es.send_event_data(fake_data, "", true)
-
-          expect(result.success).to be true
-          expect(result.must_shutdown).to be false
-          expect(result.time_from_server).not_to be_nil
-
-          req, body = server.await_request_with_body
-          expect(body).to eq fake_data
-          expect(req.header).to include({
-            "authorization" => [ sdk_key ],
-            "content-type" => [ "application/json" ],
-            "user-agent" => [ "RubyClient/" + LaunchDarkly::VERSION ],
-            "connection" => [ "Keep-Alive" ]
-          })
-          expect(req.header['x-launchdarkly-event-schema']).to eq []
-          expect(req.header['x-launchdarkly-payload-id']).to eq []
-        end
-      end
-
-      it "can use a proxy server" do
-        with_server do |server|
-          server.setup_ok_response("/bulk", "")
-    
-          with_server(StubProxyServer.new) do |proxy|
-            begin
-              ENV["http_proxy"] = proxy.base_uri.to_s
-
-              es = make_sender(server)
-
-              result = es.send_event_data(fake_data, "", false)
-              
-              expect(result.success).to be true
-
-              req, body = server.await_request_with_body
-              expect(body).to eq fake_data
-            ensure
-              ENV["http_proxy"] = nil
-            end
-          end
-        end
-      end
-    
-      [400, 408, 429, 500].each do |status|
-        it "handles recoverable error #{status}" do
-          with_sender_and_server do |es, server|
-            req_count = 0
-            server.setup_response("/bulk") do |req, res|
-              req_count = req_count + 1
-              res.status = req_count == 2 ? 200 : status
-            end
-
-            result = es.send_event_data(fake_data, "", false)
-
-            expect(result.success).to be true
-            expect(result.must_shutdown).to be false
-            expect(result.time_from_server).not_to be_nil
-
-            expect(server.requests.count).to eq 2
-            req1, body1 = server.await_request_with_body
-            req2, body2 = server.await_request_with_body
-            expect(body1).to eq fake_data
-            expect(body2).to eq fake_data
-            expect(req1.header['x-launchdarkly-payload-id']).to eq req2.header['x-launchdarkly-payload-id']
-          end
-        end
-      end
-
-      [400, 408, 429, 500].each do |status|
-        it "only retries error #{status} once" do
-          with_sender_and_server do |es, server|
-            req_count = 0
-            server.setup_response("/bulk") do |req, res|
-              req_count = req_count + 1
-              res.status = req_count == 3 ? 200 : status
-            end
-
-            result = es.send_event_data(fake_data, "", false)
-
-            expect(result.success).to be false
-            expect(result.must_shutdown).to be false
-            expect(result.time_from_server).to be_nil
-
-            expect(server.requests.count).to eq 2
-            req1, body1 = server.await_request_with_body
-            req2, body2 = server.await_request_with_body
-            expect(body1).to eq fake_data
-            expect(body2).to eq fake_data
-            expect(req1.header['x-launchdarkly-payload-id']).to eq req2.header['x-launchdarkly-payload-id']
-          end
-        end
-      end
-
-      [401, 403].each do |status|
-        it "gives up after unrecoverable error #{status}" do
-          with_sender_and_server do |es, server|
-            server.setup_response("/bulk") do |req, res|
-              res.status = status
-            end
-
-            result = es.send_event_data(fake_data, "", false)
-
-            expect(result.success).to be false
-            expect(result.must_shutdown).to be true
-            expect(result.time_from_server).to be_nil
-
-            expect(server.requests.count).to eq 1
-          end
-        end
-      end
-    end
-  end
-end

data/spec/event_summarizer_spec.rb

@@ -1,63 +0,0 @@
-require "spec_helper"
-
-describe LaunchDarkly::EventSummarizer do
-  subject { LaunchDarkly::EventSummarizer }
-
-  let(:user) { { key: "key" } }
-
-  it "does not add identify event to summary" do
-    es = subject.new
-    snapshot = es.snapshot
-    es.summarize_event({ kind: "identify", user: user })
-
-    expect(es.snapshot).to eq snapshot
-  end
-
-  it "does not add custom event to summary" do
-    es = subject.new
-    snapshot = es.snapshot
-    es.summarize_event({ kind: "custom", key: "whatever", user: user })
-
-    expect(es.snapshot).to eq snapshot
-  end
-
-  it "tracks start and end dates" do
-    es = subject.new
-    flag = { key: "key" }
-    event1 = { kind: "feature", creationDate: 2000, user: user }
-    event2 = { kind: "feature", creationDate: 1000, user: user }
-    event3 = { kind: "feature", creationDate: 1500, user: user }
-    es.summarize_event(event1)
-    es.summarize_event(event2)
-    es.summarize_event(event3)
-    data = es.snapshot
-
-    expect(data.start_date).to be 1000
-    expect(data.end_date).to be 2000
-  end
-
-  it "counts events" do
-    es = subject.new
-    flag1 = { key: "key1", version: 11 }
-    flag2 = { key: "key2", version: 22 }
-    event1 = { kind: "feature", key: "key1", version: 11, user: user, variation: 1, value: "value1", default: "default1" }
-    event2 = { kind: "feature", key: "key1", version: 11, user: user, variation: 2, value: "value2", default: "default1" }
-    event3 = { kind: "feature", key: "key2", version: 22, user: user, variation: 1, value: "value99", default: "default2" }
-    event4 = { kind: "feature", key: "key1", version: 11, user: user, variation: 1, value: "value1", default: "default1" }
-    event5 = { kind: "feature", key: "badkey", user: user, variation: nil, value: "default3", default: "default3" }
-    [event1, event2, event3, event4, event5].each { |e| es.summarize_event(e) }
-    data = es.snapshot
-
-    expectedCounters = {
-      { key: "key1", version: 11, variation: 1 } =>
-        { count: 2, value: "value1", default: "default1" },
-      { key: "key1", version: 11, variation: 2 } =>
-        { count: 1, value: "value2", default: "default1" },
-      { key: "key2", version: 22, variation: 1 } =>
-        { count: 1, value: "value99", default: "default2" },
-      { key: "badkey", version: nil, variation: nil } =>
-        { count: 1, value: "default3", default: "default3" }
-    }
-    expect(data.counters).to eq expectedCounters
-  end
-end