ldclient-rb 5.4.3 → 5.5.0

data/spec/sse_client/sse_client_spec.rb

@@ -1,177 +0,0 @@
-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
-
-  it "reconnects if stream returns EOF" do
-    events_body_1 = <<-EOT
-event: go
-data: foo
-
-EOT
-    events_body_2 = <<-EOT
-event: go
-data: bar
-
-EOT
-    with_server do |server|
-      attempt = 0
-      server.setup_response("/") do |req,res|
-        attempt += 1
-        if attempt == 1
-          res.body = events_body_1
-        else
-          res.body = events_body_2
-        end
-        res.content_type = "text/event-stream"
-        res.status = 200
-      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(event_sink.pop).to eq(SSE::SSEEvent.new(:go, "bar", nil))
-        expect(attempt).to be >= 2
-      end
-    end
-  end
-end

data/spec/sse_client/sse_events_spec.rb

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

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

data/spec/sse_client/streaming_http_spec.rb

@@ -1,263 +0,0 @@
-require "spec_helper"
-require "socketry"
-require "sse_client/sse_shared"
-
-#
-# End-to-end tests of HTTP requests against a real server
-#
-describe SSE::StreamingHTTPConnection do
-  subject { SSE::StreamingHTTPConnection }
-
-  def with_connection(cxn)
-    begin
-      yield cxn
-    ensure
-      cxn.close
-    end
-  end
-
-  it "makes HTTP connection and sends request" do
-    with_server do |server|
-      requests = Queue.new
-      server.setup_response("/foo") do |req,res|
-        requests << req
-        res.status = 200
-      end
-      headers = {
-        "Accept" => "text/plain"
-      }
-      with_connection(subject.new(server.base_uri.merge("/foo?bar"), nil, headers, 30, 30)) do
-        received_req = requests.pop
-        expect(received_req.unparsed_uri).to eq("/foo?bar")
-        expect(received_req.header).to eq({
-          "accept" => ["text/plain"],
-          "host" => [server.base_uri.host]
-        })
-      end
-    end
-  end
-
-  it "receives response status" do
-    with_server do |server|
-      server.setup_response("/foo") do |req,res|
-        res.status = 204
-      end
-      with_connection(subject.new(server.base_uri.merge("/foo"), nil, {}, 30, 30)) do |cxn|
-        expect(cxn.status).to eq(204)
-      end
-    end
-  end
-
-  it "receives response headers" do
-    with_server do |server|
-      server.setup_response("/foo") do |req,res|
-        res["Content-Type"] = "application/json"
-      end
-      with_connection(subject.new(server.base_uri.merge("/foo"), nil, {}, 30, 30)) do |cxn|
-        expect(cxn.headers["content-type"]).to eq("application/json")
-      end
-    end
-  end
-
-  it "can read response as lines" do
-    body = <<-EOT
-This is
-a response
-EOT
-    with_server do |server|
-      server.setup_response("/foo") do |req,res|
-        res.body = body
-      end
-      with_connection(subject.new(server.base_uri.merge("/foo"), nil, {}, 30, 30)) do |cxn|
-        lines = cxn.read_lines
-        expect(lines.next).to eq("This is\n")
-        expect(lines.next).to eq("a response\n")
-      end
-    end
-  end
-
-  it "can read entire response body" do
-    body = <<-EOT
-This is
-a response
-EOT
-    with_server do |server|
-      server.setup_response("/foo") do |req,res|
-        res.body = body
-      end
-      with_connection(subject.new(server.base_uri.merge("/foo"), nil, {}, 30, 30)) do |cxn|
-        read_body = cxn.read_all
-        expect(read_body).to eq("This is\na response\n")
-      end
-    end
-  end
-
-  it "enforces read timeout" do
-    with_server do |server|
-      server.setup_response("/") do |req,res|
-        sleep(2)
-        res.status = 200
-      end
-      expect { subject.new(server.base_uri, nil, {}, 30, 0.25) }.to raise_error(Socketry::TimeoutError)
-    end
-  end
-
-  it "connects to HTTP server through proxy" do
-    body = "hi"
-    with_server do |server|
-      server.setup_response("/") do |req,res|
-        res.body = body
-      end
-      with_server(StubProxyServer.new) do |proxy|
-        with_connection(subject.new(server.base_uri, proxy.base_uri, {}, 30, 30)) do |cxn|
-          read_body = cxn.read_all
-          expect(read_body).to eq("hi")
-          expect(proxy.request_count).to eq(1)
-        end
-      end
-    end
-  end
-
-  it "throws error if proxy responds with error status" do
-    with_server do |server|
-      server.setup_response("/") do |req,res|
-        res.body = body
-      end
-      with_server(StubProxyServer.new) do |proxy|
-        proxy.connect_status = 403
-        expect { subject.new(server.base_uri, proxy.base_uri, {}, 30, 30) }.to raise_error(SSE::ProxyError)
-      end
-    end
-  end
-
-  # The following 2 tests were originally written to connect to an embedded HTTPS server made with
-  # WEBrick. Unfortunately, some unknown problem prevents WEBrick's self-signed certificate feature
-  # from working in JRuby 9.1 (but not in any other Ruby version). Therefore these tests currently
-  # hit an external URL.
-
-  it "connects to HTTPS server" do
-    with_connection(subject.new(URI("https://app.launchdarkly.com"), nil, {}, 30, 30)) do |cxn|
-      expect(cxn.status).to eq 200
-    end
-  end
-  
-  it "connects to HTTPS server through proxy" do
-    with_server(StubProxyServer.new) do |proxy|
-      with_connection(subject.new(URI("https://app.launchdarkly.com"), proxy.base_uri, {}, 30, 30)) do |cxn|
-        expect(cxn.status).to eq 200
-        expect(proxy.request_count).to eq(1)
-      end
-    end
-  end
-end
-
-#
-# Tests of response parsing functionality without a real HTTP request
-#
-describe SSE::HTTPResponseReader do
-  subject { SSE::HTTPResponseReader }
-
-  let(:simple_response) { <<-EOT
-HTTP/1.1 200 OK
-Cache-Control: no-cache
-Content-Type: text/event-stream
-
-line1\r
-line2
-\r
-EOT
-  }
-
-  def make_chunks(str)
-    # arbitrarily split content into 5-character blocks
-    str.scan(/.{1,5}/m).to_enum
-  end
-
-  def mock_socket_without_timeout(chunks)
-    mock_socket(chunks) { :eof }
-  end
-
-  def mock_socket_with_timeout(chunks)
-    mock_socket(chunks) { raise Socketry::TimeoutError }
-  end
-
-  def mock_socket(chunks)
-    sock = double
-    allow(sock).to receive(:readpartial) do
-      begin
-        chunks.next
-      rescue StopIteration
-        yield
-      end
-    end
-    sock
-  end
-
-  it "parses status code" do
-    socket = mock_socket_without_timeout(make_chunks(simple_response))
-    reader = subject.new(socket, 0)
-    expect(reader.status).to eq(200)
-  end
-
-  it "parses headers" do
-    socket = mock_socket_without_timeout(make_chunks(simple_response))
-    reader = subject.new(socket, 0)
-    expect(reader.headers).to eq({
-      'cache-control' => 'no-cache',
-      'content-type' => 'text/event-stream'
-    })
-  end
-
-  it "can read entire response body" do
-    socket = mock_socket_without_timeout(make_chunks(simple_response))
-    reader = subject.new(socket, 0)
-    expect(reader.read_all).to eq("line1\r\nline2\n\r\n")
-  end
-
-  it "can read response body as lines" do
-    socket = mock_socket_without_timeout(make_chunks(simple_response))
-    reader = subject.new(socket, 0)
-    expect(reader.read_lines.to_a).to eq([
-      "line1\r\n",
-      "line2\n",
-      "\r\n"
-    ])
-  end
-
-  it "handles chunked encoding" do
-    chunked_response = <<-EOT
-HTTP/1.1 200 OK
-Content-Type: text/plain
-Transfer-Encoding: chunked
-
-6\r
-things\r
-A\r
- and stuff\r
-0\r
-\r
-EOT
-    socket = mock_socket_without_timeout(make_chunks(chunked_response))
-    reader = subject.new(socket, 0)
-    expect(reader.read_all).to eq("things and stuff")
-  end
-
-  it "raises error if response ends without complete headers" do
-    malformed_response = <<-EOT
-HTTP/1.1 200 OK
-Cache-Control: no-cache
-EOT
-    socket = mock_socket_without_timeout(make_chunks(malformed_response))
-    expect { subject.new(socket, 0) }.to raise_error(EOFError)
-  end
-
-  it "throws timeout if thrown by socket read" do
-    socket = mock_socket_with_timeout(make_chunks(simple_response))
-    reader = subject.new(socket, 0)
-    lines = reader.read_lines
-    lines.next
-    lines.next
-    lines.next
-    expect { lines.next }.to raise_error(Socketry::TimeoutError)
-  end
-end