launchdarkly-server-sdk 6.1.1 → 6.4.0

data/lib/ldclient-rb/impl/event_factory.rb

@@ -1,120 +0,0 @@
-
-module LaunchDarkly
-  module Impl
-    # Event constructors are centralized here to avoid mistakes and repetitive logic.
-    # The LDClient owns two instances of EventFactory: one that always embeds evaluation reasons
-    # in the events (for when variation_detail is called) and one that doesn't.
-    #
-    # Note that these methods do not set the "creationDate" property, because in the Ruby client,
-    # that is done by EventProcessor.add_event().
-    class EventFactory
-      def initialize(with_reasons)
-        @with_reasons = with_reasons
-      end
-
-      def new_eval_event(flag, user, detail, default_value, prereq_of_flag = nil)
-        add_experiment_data = is_experiment(flag, detail.reason)
-        e = {
-          kind: 'feature',
-          key: flag[:key],
-          user: user,
-          variation: detail.variation_index,
-          value: detail.value,
-          default: default_value,
-          version: flag[:version]
-        }
-        # the following properties are handled separately so we don't waste bandwidth on unused keys
-        e[:trackEvents] = true if add_experiment_data || flag[:trackEvents]
-        e[:debugEventsUntilDate] = flag[:debugEventsUntilDate] if flag[:debugEventsUntilDate]
-        e[:prereqOf] = prereq_of_flag[:key] if !prereq_of_flag.nil?
-        e[:reason] = detail.reason if add_experiment_data || @with_reasons
-        e[:contextKind] = context_to_context_kind(user) if !user.nil? && user[:anonymous]
-        e
-      end
-
-      def new_default_event(flag, user, default_value, reason)
-        e = {
-          kind: 'feature',
-          key: flag[:key],
-          user: user,
-          value: default_value,
-          default: default_value,
-          version: flag[:version]
-        }
-        e[:trackEvents] = true if flag[:trackEvents]
-        e[:debugEventsUntilDate] = flag[:debugEventsUntilDate] if flag[:debugEventsUntilDate]
-        e[:reason] = reason if @with_reasons
-        e[:contextKind] = context_to_context_kind(user) if !user.nil? && user[:anonymous]
-        e
-      end
-
-      def new_unknown_flag_event(key, user, default_value, reason)
-        e = {
-          kind: 'feature',
-          key: key,
-          user: user,
-          value: default_value,
-          default: default_value
-        }
-        e[:reason] = reason if @with_reasons
-        e[:contextKind] = context_to_context_kind(user) if !user.nil? && user[:anonymous]
-        e
-      end
-
-      def new_identify_event(user)
-        {
-          kind: 'identify',
-          key: user[:key],
-          user: user
-        }
-      end
-
-      def new_alias_event(current_context, previous_context)
-        {
-          kind: 'alias',
-          key: current_context[:key],
-          contextKind: context_to_context_kind(current_context),
-          previousKey: previous_context[:key],
-          previousContextKind: context_to_context_kind(previous_context)
-        }
-      end
-
-      def new_custom_event(event_name, user, data, metric_value)
-        e = {
-          kind: 'custom',
-          key: event_name,
-          user: user
-        }
-        e[:data] = data if !data.nil?
-        e[:metricValue] = metric_value if !metric_value.nil?
-        e[:contextKind] = context_to_context_kind(user) if !user.nil? && user[:anonymous]
-        e
-      end
-
-      private
-
-      def context_to_context_kind(user)
-          if !user.nil? && user[:anonymous]
-            return "anonymousUser"
-          else
-            return "user"
-          end
-      end
-
-      def is_experiment(flag, reason)
-        return false if !reason
-        case reason[:kind]
-        when 'RULE_MATCH'
-          index = reason[:ruleIndex]
-          if !index.nil?
-            rules = flag[:rules] || []
-            return index >= 0 && index < rules.length && rules[index][:trackEvents]
-          end
-        when 'FALLTHROUGH'
-          return !!flag[:trackEventsFallthrough]
-        end
-        false
-      end
-    end
-  end
-end

data/spec/config_spec.rb

@@ -1,63 +0,0 @@
-require "spec_helper"
-
-describe LaunchDarkly::Config do
-  subject { LaunchDarkly::Config }
-  describe ".initialize" do
-    it "can be initialized with default settings" do
-      expect(subject).to receive(:default_capacity).and_return 1234
-      expect(subject.new.capacity).to eq 1234
-    end
-    it "accepts custom arguments" do
-      expect(subject).to_not receive(:default_capacity)
-      expect(subject.new(capacity: 50).capacity).to eq 50
-    end
-    it "will chomp base_url and stream_uri" do
-      uri = "https://test.launchdarkly.com"
-      config = subject.new(base_uri: uri + "/")
-      expect(config.base_uri).to eq uri
-    end
-  end
-  describe "@base_uri" do
-    it "can be read" do
-      expect(subject.new.base_uri).to eq subject.default_base_uri
-    end
-  end
-  describe "@events_uri" do
-    it "can be read" do
-      expect(subject.new.events_uri).to eq subject.default_events_uri
-    end
-  end
-  describe "@stream_uri" do
-    it "can be read" do
-      expect(subject.new.stream_uri).to eq subject.default_stream_uri
-    end
-  end
-  describe ".default_cache_store" do
-    it "uses Rails cache if it is available" do
-      rails = instance_double("Rails", cache: :cache)
-      stub_const("Rails", rails)
-      expect(subject.default_cache_store).to eq :cache
-    end
-    it "uses memory store if Rails is not available" do
-      expect(subject.default_cache_store).to be_an_instance_of LaunchDarkly::ThreadSafeMemoryStore
-    end
-  end
-  describe ".default_logger" do
-    it "uses Rails logger if it is available" do
-      rails = instance_double("Rails", logger: :logger)
-      stub_const("Rails", rails)
-      expect(subject.default_logger).to eq :logger
-    end
-    it "Uses logger if Rails is not available" do
-      expect(subject.default_logger).to be_an_instance_of Logger
-    end
-  end
-  describe ".poll_interval" do
-    it "can be set to greater than the default" do
-      expect(subject.new(poll_interval: 31).poll_interval).to eq 31
-    end
-    it "cannot be set to less than the default" do
-      expect(subject.new(poll_interval: 29).poll_interval).to eq 30
-    end
-  end
-end

data/spec/diagnostic_events_spec.rb

@@ -1,163 +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
-
-        it "detects proxy" do
-          begin
-            ENV["http_proxy"] = 'http://my-proxy'
-            event = default_acc.create_init_event(Config.new)
-            expect(event[:configuration][:usingProxy]).to be true
-          ensure
-            ENV["http_proxy"] = nil
-          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