ldclient-rb 4.0.0 → 5.0.0

data/spec/events_spec.rb

@@ -351,12 +351,12 @@ describe LaunchDarkly::EventProcessor do
     expect(hc.get_request.headers["Authorization"]).to eq "sdk_key"
   end
 
-  it "stops posting events after getting a 401 error" do
+  def verify_unrecoverable_http_error(status)
     @ep = subject.new("sdk_key", default_config, hc)
     e = { kind: "identify", user: user }
     @ep.add_event(e)
 
-    hc.set_response_status(401)
+    hc.set_response_status(status)
     @ep.flush
     @ep.wait_until_inactive
     expect(hc.get_request).not_to be_nil
@@ -368,7 +368,7 @@ describe LaunchDarkly::EventProcessor do
     expect(hc.get_request).to be_nil
   end
 
-  it "retries flush once after 5xx error" do
+  def verify_recoverable_http_error(status)
     @ep = subject.new("sdk_key", default_config, hc)
     e = { kind: "identify", user: user }
     @ep.add_event(e)
@@ -380,6 +380,33 @@ describe LaunchDarkly::EventProcessor do
     expect(hc.get_request).not_to be_nil
     expect(hc.get_request).not_to be_nil
     expect(hc.get_request).to be_nil  # no 3rd request
+
+    # now verify that a subsequent flush still generates a request
+    hc.reset
+    @ep.add_event(e)
+    @ep.flush
+    @ep.wait_until_inactive
+    expect(hc.get_request).not_to be_nil
+  end
+
+  it "stops posting events after getting a 401 error" do
+    verify_unrecoverable_http_error(401)
+  end
+
+  it "stops posting events after getting a 403 error" do
+    verify_unrecoverable_http_error(403)
+  end
+
+  it "retries after 408 error" do
+    verify_recoverable_http_error(408)
+  end
+
+  it "retries after 429 error" do
+    verify_recoverable_http_error(429)
+  end
+
+  it "retries after 503 error" do
+    verify_recoverable_http_error(503)
   end
 
   it "retries flush once after connection error" do

data/spec/ldclient_spec.rb

@@ -7,7 +7,7 @@ describe LaunchDarkly::LDClient do
   let(:offline_client) do
     subject.new("secret", offline_config)
   end
-  let(:update_processor) { NullUpdateProcessor.new }
+  let(:update_processor) { LaunchDarkly::NullUpdateProcessor.new }
   let(:config) { LaunchDarkly::Config.new({send_events: false, update_processor: update_processor}) }
   let(:client) do
     subject.new("secret", config)
@@ -160,13 +160,4 @@ describe LaunchDarkly::LDClient do
       expect(ep).not_to be_a(LaunchDarkly::NullEventProcessor)
     end
   end
-
-  class NullUpdateProcessor
-    def start
-    end
-
-    def initialized?
-      true
-    end
-  end
 end

data/spec/polling_spec.rb

@@ -0,0 +1,89 @@
+require "spec_helper"
+require 'ostruct'
+
+describe LaunchDarkly::PollingProcessor do
+  subject { LaunchDarkly::PollingProcessor }
+  let(:store) { LaunchDarkly::InMemoryFeatureStore.new }
+  let(:config) { LaunchDarkly::Config.new(feature_store: store) }
+  let(:requestor) { double() }
+  let(:processor) { subject.new(config, requestor) }
+
+  describe 'successful request' do
+    flag = { key: 'flagkey', version: 1 }
+    segment = { key: 'segkey', version: 1 }
+    all_data = {
+      flags: {
+        flagkey: flag
+      },
+      segments: {
+        segkey: segment
+      }
+    }
+
+    it 'puts feature data in store' do
+      allow(requestor).to receive(:request_all_data).and_return(all_data)
+      ready = processor.start
+      ready.wait
+      expect(store.get(LaunchDarkly::FEATURES, "flagkey")).to eq(flag)
+      expect(store.get(LaunchDarkly::SEGMENTS, "segkey")).to eq(segment)
+    end
+
+    it 'sets initialized to true' do
+      allow(requestor).to receive(:request_all_data).and_return(all_data)
+      ready = processor.start
+      ready.wait
+      expect(processor.initialized?).to be true
+      expect(store.initialized?).to be true
+    end
+  end
+
+  describe 'connection error' do
+    it 'does not cause immediate failure, does not set initialized' do
+      allow(requestor).to receive(:request_all_data).and_raise(StandardError.new("test error"))
+      ready = processor.start
+      finished = ready.wait(0.2)
+      expect(finished).to be false
+      expect(processor.initialized?).to be false
+      expect(store.initialized?).to be false
+    end
+  end
+
+  describe 'HTTP errors' do
+    def verify_unrecoverable_http_error(status)
+      allow(requestor).to receive(:request_all_data).and_raise(LaunchDarkly::UnexpectedResponseError.new(status))
+      ready = processor.start
+      finished = ready.wait(0.2)
+      expect(finished).to be true
+      expect(processor.initialized?).to be false
+    end
+
+    def verify_recoverable_http_error(status)
+      allow(requestor).to receive(:request_all_data).and_raise(LaunchDarkly::UnexpectedResponseError.new(status))
+      ready = processor.start
+      finished = ready.wait(0.2)
+      expect(finished).to be false
+      expect(processor.initialized?).to be false
+    end
+
+    it 'stops immediately for error 401' do
+      verify_unrecoverable_http_error(401)
+    end
+
+    it 'stops immediately for error 403' do
+      verify_unrecoverable_http_error(403)
+    end
+
+    it 'does not stop immediately for error 408' do
+      verify_recoverable_http_error(408)
+    end
+
+    it 'does not stop immediately for error 429' do
+      verify_recoverable_http_error(429)
+    end
+
+    it 'does not stop immediately for error 503' do
+      verify_recoverable_http_error(503)
+    end
+  end
+end
+

data/spec/sse_client/sse_client_spec.rb

@@ -0,0 +1,139 @@
+require "spec_helper"
+require "socketry"
+require "sse_client/sse_shared"
+
+#
+# End-to-end tests of SSEClient against a real server
+#
+describe SSE::SSEClient do
+  subject { SSE::SSEClient }
+
+  def with_client(client)
+    begin
+      yield client
+    ensure
+      client.close
+    end
+  end
+
+  it "sends expected headers" do
+    with_server do |server|
+      requests = Queue.new
+      server.setup_response("/") do |req,res|
+        requests << req
+        res.content_type = "text/event-stream"
+        res.status = 200
+      end
+      
+      headers = {
+        "Authorization" => "secret"
+      }
+
+      with_client(subject.new(server.base_uri, headers: headers)) do |client|
+        received_req = requests.pop
+        expect(received_req.header).to eq({
+          "accept" => ["text/event-stream"],
+          "cache-control" => ["no-cache"],
+          "host" => ["127.0.0.1"],
+          "authorization" => ["secret"]
+        })
+      end
+    end
+  end
+
+  it "receives messages" do
+    events_body = <<-EOT
+event: go
+data: foo
+id: 1
+
+event: stop
+data: bar
+
+EOT
+    with_server do |server|
+      server.setup_response("/") do |req,res|
+        res.content_type = "text/event-stream"
+        res.status = 200
+        res.body = events_body
+      end
+
+      event_sink = Queue.new
+      client = subject.new(server.base_uri) do |c|
+        c.on_event { |event| event_sink << event }
+      end
+
+      with_client(client) do |client|
+        expect(event_sink.pop).to eq(SSE::SSEEvent.new(:go, "foo", "1"))
+        expect(event_sink.pop).to eq(SSE::SSEEvent.new(:stop, "bar", nil))
+      end
+    end
+  end
+
+  it "reconnects after error response" do
+    events_body = <<-EOT
+event: go
+data: foo
+
+EOT
+    with_server do |server|
+      attempt = 0
+      server.setup_response("/") do |req,res|
+        attempt += 1
+        if attempt == 1
+          res.status = 500
+          res.body = "sorry"
+          res.keep_alive = false
+        else
+          res.content_type = "text/event-stream"
+          res.status = 200
+          res.body = events_body
+        end
+      end
+
+      event_sink = Queue.new
+      error_sink = Queue.new
+      client = subject.new(server.base_uri, reconnect_time: 0.25) do |c|
+        c.on_event { |event| event_sink << event }
+        c.on_error { |error| error_sink << error }
+      end
+
+      with_client(client) do |client|
+        expect(event_sink.pop).to eq(SSE::SSEEvent.new(:go, "foo", nil))
+        expect(error_sink.pop).to eq({ status_code: 500, body: "sorry" })
+        expect(attempt).to be >= 2
+      end
+    end
+  end
+
+  it "reconnects after read timeout" do
+    events_body = <<-EOT
+event: go
+data: foo
+
+EOT
+    with_server do |server|
+      attempt = 0
+      server.setup_response("/") do |req,res|
+        attempt += 1
+        if attempt == 1
+          sleep(2)
+        end
+        res.content_type = "text/event-stream"
+        res.status = 200
+        res.body = events_body
+      end
+
+      event_sink = Queue.new
+      client = subject.new(server.base_uri,
+          reconnect_time: 0.25, read_timeout: 0.25) do |c|
+        c.on_event { |event| event_sink << event }
+      end
+
+      with_client(client) do |client|
+        expect(event_sink.pop).to eq(SSE::SSEEvent.new(:go, "foo", nil))
+        expect(attempt).to be >= 2
+      end
+    end
+  end
+end

data/spec/sse_client/sse_events_spec.rb

@@ -0,0 +1,100 @@
+require "spec_helper"
+
+describe SSE::EventParser do
+  subject { SSE::EventParser }
+
+  it "parses an event with all fields" do
+    lines = [
+      "event: abc\r\n",
+      "data: def\r\n",
+      "id: 1\r\n",
+      "\r\n"
+    ]
+    ep = subject.new(lines)
+    
+    expected_event = SSE::SSEEvent.new(:abc, "def", "1")
+    output = ep.items.to_a
+    expect(output).to eq([ expected_event ])
+  end
+
+  it "parses an event with only data" do
+    lines = [
+      "data: def\r\n",
+      "\r\n"
+    ]
+    ep = subject.new(lines)
+    
+    expected_event = SSE::SSEEvent.new(:message, "def", nil)
+    output = ep.items.to_a
+    expect(output).to eq([ expected_event ])
+  end
+
+  it "parses an event with multi-line data" do
+    lines = [
+      "data: def\r\n",
+      "data: ghi\r\n",
+      "\r\n"
+    ]
+    ep = subject.new(lines)
+    
+    expected_event = SSE::SSEEvent.new(:message, "def\nghi", nil)
+    output = ep.items.to_a
+    expect(output).to eq([ expected_event ])
+  end
+
+  it "ignores comments" do
+    lines = [
+      ":",
+      "data: def\r\n",
+      ":",
+      "\r\n"
+    ]
+    ep = subject.new(lines)
+    
+    expected_event = SSE::SSEEvent.new(:message, "def", nil)
+    output = ep.items.to_a
+    expect(output).to eq([ expected_event ])
+  end
+
+  it "parses reconnect interval" do
+    lines = [
+      "retry: 2500\r\n",
+      "\r\n"
+    ]
+    ep = subject.new(lines)
+
+    expected_item = SSE::SSESetRetryInterval.new(2500)
+    output = ep.items.to_a
+    expect(output).to eq([ expected_item ])
+  end
+
+  it "parses multiple events" do
+    lines = [
+      "event: abc\r\n",
+      "data: def\r\n",
+      "id: 1\r\n",
+      "\r\n",
+      "data: ghi\r\n",
+      "\r\n"
+    ]
+    ep = subject.new(lines)
+    
+    expected_event_1 = SSE::SSEEvent.new(:abc, "def", "1")
+    expected_event_2 = SSE::SSEEvent.new(:message, "ghi", nil)
+    output = ep.items.to_a
+    expect(output).to eq([ expected_event_1, expected_event_2 ])
+  end
+
+  it "ignores events with no data" do
+    lines = [
+      "event: nothing\r\n",
+      "\r\n",
+      "event: nada\r\n",
+      "\r\n"
+    ]
+    ep = subject.new(lines)
+    
+    output = ep.items.to_a
+    expect(output).to eq([])
+  end
+end

data/spec/sse_client/sse_shared.rb

@@ -0,0 +1,82 @@
+require "spec_helper"
+require "webrick"
+require "webrick/httpproxy"
+require "webrick/https"
+
+class StubHTTPServer
+  def initialize
+    @port = 50000
+    begin
+      @server = create_server(@port)
+    rescue Errno::EADDRINUSE
+      @port += 1
+      retry
+    end
+  end
+
+  def create_server(port)
+    WEBrick::HTTPServer.new(
+      BindAddress: '127.0.0.1',
+      Port: port,
+      AccessLog: [],
+      Logger: NullLogger.new
+    )
+  end
+
+  def start
+    Thread.new { @server.start }
+  end
+
+  def stop
+    @server.shutdown
+  end
+
+  def base_uri
+    URI("http://127.0.0.1:#{@port}")
+  end
+
+  def setup_response(uri_path, &action)
+    @server.mount_proc(uri_path, action)
+  end
+end
+
+class StubProxyServer < StubHTTPServer
+  attr_reader :request_count
+  attr_accessor :connect_status
+
+  def initialize
+    super
+    @request_count = 0
+  end
+
+  def create_server(port)
+    WEBrick::HTTPProxyServer.new(
+      BindAddress: '127.0.0.1',
+      Port: port,
+      AccessLog: [],
+      Logger: NullLogger.new,
+      ProxyContentHandler: proc do |req,res|
+        if !@connect_status.nil?
+          res.status = @connect_status
+        end
+        @request_count += 1
+      end
+    )
+  end
+end
+
+class NullLogger
+  def method_missing(*)
+    self
+  end
+end
+
+def with_server(server = nil)
+  server = StubHTTPServer.new if server.nil?
+  begin
+    server.start
+    yield server
+  ensure
+    server.stop
+  end
+end