httpkit 0.6.0.pre.3

data/lib/httpkit.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+require 'eventmachine'
+require 'fiber'
+require 'promise'
+require 'http/parser'
+require 'time'
+
+require 'httpkit/version'
+
+require 'httpkit/support/handler_manager'
+require 'httpkit/support/message'
+
+require 'httpkit/promise'
+require 'httpkit/body'
+require 'httpkit/request'
+require 'httpkit/response'
+
+require 'httpkit/connection/eventmachine'
+require 'httpkit/connection/status'
+require 'httpkit/serializer/encoding'
+require 'httpkit/serializer'
+
+require 'httpkit/client'
+require 'httpkit/client/keep_alive'
+require 'httpkit/client/timeouts'
+require 'httpkit/server'
+require 'httpkit/server/keep_alive'
+require 'httpkit/server/timeouts'
+
+module HTTPkit
+  def self.run
+    start do
+      yield
+      stop
+    end
+  end
+
+  def self.start
+    EM.run do
+      Fiber.new { yield }.resume
+    end
+  end
+
+  def self.stop
+    EM.stop
+    EM.next_tick {}
+  end
+end

data/spec/integration/error_handling_spec.rb

@@ -0,0 +1,76 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe 'Client error handling', reactor: true do
+  include_context :server_client_pair
+
+  let(:served) { client.perform(open_request) }
+
+  subject! { client.close(reason) }
+
+  describe 'on connection error' do
+    let(:reason) { Errno::ENETUNREACH }
+
+    it 'rejects promises' do
+      expect(client).to be_closed
+      expect(client).to be_error
+      expect(client).to be_network_fault
+
+      expect(served).to be_rejected
+      expect(served.reason).to be(reason)
+    end
+  end
+
+  describe 'on timeout' do
+    let(:reason) { Errno::ETIMEDOUT }
+
+    it 'rejects promises' do
+      expect(client).to be_closed
+      expect(client).to be_error
+      expect(client).to be_timeout
+
+      expect(served).to be_rejected
+      expect(served.reason).to be(reason)
+    end
+  end
+end
+
+describe 'Server error handling', reactor: true do
+  include_context :server_client_pair
+
+  describe 'on application error' do
+    let(:server_config) { { handlers: [handler] } }
+    let(:handler) { double('handler') }
+    let(:reason) { RuntimeError.new }
+
+    before do
+      allow(handler).to receive(:serve) { raise reason }
+    end
+
+    subject! do
+      client.perform(open_request)
+      tick(2)
+    end
+
+    it 'rejects promises' do
+      expect(server).to be_closed
+      expect(server).to be_error
+    end
+  end
+
+  describe 'on timeout' do
+    subject! do
+      client.perform(open_request)
+      tick(1)
+      server.close(Errno::ETIMEDOUT)
+      tick(1)
+    end
+
+    it 'rejects promises' do
+      expect(server).to be_closed
+      expect(server).to be_error
+      expect(server).to be_timeout
+    end
+  end
+end

data/spec/integration/keep_alive_spec.rb

@@ -0,0 +1,101 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe reactor: true do
+  include_context :server_client_pair
+
+  let(:server_config) do
+    { handlers: [HTTPkit::Server::KeepAlive.new, SpecHandler.new] }
+  end
+  let(:client_config) do
+    { handlers: [HTTPkit::Client::KeepAlive.new] }
+  end
+
+  let!(:served) do
+    requests.map { |request| client.perform(request) }
+  end
+  let(:responses) { served.map(&:sync) }
+
+  describe HTTPkit::Server, 'with KeepAlive' do
+    let(:requests) do
+      [closed_request(:get, '/sleep'), closed_request]
+    end
+
+    # XXX: tends to fail
+    it 'sends responses in the correct order' do
+      expect(responses[0].body.to_s).to eq('/sleep')
+      expect(responses[1].body.to_s).to eq('/')
+    end
+
+    describe 'and HTTP/1.1 request' do
+      let(:requests) { [closed_request] }
+
+      it 'assumes Connection: keep-alive' do
+        expect(client).not_to be_closed
+        expect(server).not_to be_closed
+
+        expect(responses[0].headers).to include('Connection' => 'keep-alive')
+      end
+    end
+
+    describe 'and HTTP/1.0 request' do
+      let(:requests) do
+        [closed_request.tap { |r| r.http_version = 1.0 }]
+      end
+
+      it 'assumes Connection: close' do
+        responses
+        tick(2)
+        expect(client).to be_closed
+        expect(server).to be_closed
+
+        expect(responses[0].headers).to include('Connection' => 'close')
+      end
+    end
+
+    describe 'and Connection: keep-alive' do
+      let(:requests) do
+        [closed_request(:get, '/', 'Connection' => 'keep-alive')
+          .tap { |r| r.http_version = 1.0 }]
+      end
+
+      it 'keeps the connection open' do
+        expect(client).not_to be_closed
+        expect(server).not_to be_closed
+
+        expect(responses[0].headers).to include('Connection' => 'keep-alive')
+      end
+    end
+
+    describe 'and Connection: close' do
+      let(:requests) do
+        [closed_request(:get, '/', 'Connection' => 'close')]
+      end
+
+      it 'closes the connection after sending the response' do
+        responses
+        tick(2)
+        expect(client).to be_closed
+        expect(server).to be_closed
+
+        expect(responses[0].headers).to include('Connection' => 'close')
+      end
+    end
+  end
+
+  describe HTTPkit::Client, 'with KeepAlive' do
+    let(:requests) do
+      [open_request(:get, '/?1'), closed_request(:get, '/?2')]
+    end
+
+    before do
+      requests[0].close
+    end
+
+    it 'sends one request at a time' do
+      expect(responses[0].body.to_s).to eq('/?1')
+      expect(responses[1].body.to_s).to eq('/?2')
+    end
+  end
+end

data/spec/integration/smoke_spec.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe 'Smoke test', reactor: true do
+  include_context :server_client_pair
+
+  let(:response) { client.request(:get, '/') }
+  let(:request)  { intercepted_requests[0] }
+
+  it 'exchanges request and response' do
+    expect(response.status).to  be(200)
+    expect(response.headers).to include('Content-Length' => '1')
+    expect(response.body.to_s).to eq('/')
+
+    expect(request.http_method).to be(:get)
+    expect(request.uri).to         eq('/')
+    expect(request.headers).to     include('Content-Length' => '0')
+    expect(request.body.to_s).to   eq('')
+  end
+end

data/spec/integration/streaming_spec.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe 'Request body streaming', reactor: true do
+  include_context :server_client_pair
+
+  let(:chunks) { [] }
+
+  before do
+    client.perform(request)
+    tick(2)
+    Fiber.new do
+      intercepted_requests[0].body.each do |chunk|
+        chunks << chunk
+      end
+    end.resume
+  end
+
+  let(:request) { open_request }
+
+  subject! do
+    %w[foo bar baz].each do |chunk|
+      request.body.closed.progress(chunk)
+      tick
+    end
+    request.close
+    tick
+  end
+
+  it 'progressively sends the body' do
+    expect(intercepted_requests[0].headers)
+      .to include('Transfer-Encoding' => 'chunked')
+
+    expect(chunks).to eq(%w[foo bar baz])
+  end
+end
+
+describe 'Response body streaming', reactor: true do
+  include_context :server_client_pair
+
+  let(:chunks) { [] }
+
+  let(:response) { client.request(:get, '/streaming') }
+
+  subject! { response }
+
+  before do
+    response.body.each do |chunk|
+      chunks << chunk
+    end
+  end
+
+  it 'progressively receives the body' do
+    expect(chunks).to eq(%w[foo bar baz])
+  end
+end

data/spec/integration/timeouts_spec.rb

@@ -0,0 +1,82 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe HTTPkit::Client, 'in connecting state', reactor: true do
+  # connect to a non-existing host to provoke connection timeout
+  let(:address) { '1.2.3.4' }
+  let(:client_config) do
+    { address: address, port: random_port,
+      handlers: [HTTPkit::Client::Timeouts.new] }
+  end
+  let!(:client)  { HTTPkit::Client.start(client_config) }
+
+  after { client.close }
+
+  it 'times out after 2 seconds' do
+    # only test the config, and don't actually wait for 2 seconds
+    expect(client.config).to include(connect_timeout: 2.0)
+  end
+
+  describe 'with :connect_timeout option' do
+    let(:client_config) do
+      { address: address, port: random_port, connect_timeout: 0.01,
+        handlers: [HTTPkit::Client::Timeouts.new] }
+    end
+
+    it 'times out after $n seconds' do
+      async_sleep(0.015)
+      if client.network_fault?
+        pending 'Requires network connection'
+      else
+        expect(client).to be_timeout
+      end
+    end
+  end
+end
+
+describe HTTPkit::Client, 'in idle state', reactor: true do
+  include_context :server_client_pair
+
+  let(:client_config) { { handlers: [HTTPkit::Client::Timeouts.new] } }
+
+  it 'times out after 2 seconds' do
+    # only test the config, and don't actually wait for 2 seconds
+    expect(client.config).to include(connect_timeout: 2.0)
+  end
+
+  describe 'with :timeout option' do
+    let(:client_config) do
+      { timeout: 0.01, handlers: [HTTPkit::Client::Timeouts.new] }
+    end
+
+    it 'times out after $n seconds' do
+      async_sleep(0.015)
+      expect(client).to be_timeout
+      expect(server).to be_closed
+    end
+  end
+end
+
+describe HTTPkit::Server, 'in idle state', reactor: true do
+  include_context :server_client_pair
+
+  let(:server_config) { { handlers: [HTTPkit::Server::Timeouts.new] } }
+
+  it 'times out after 2 seconds' do
+    # only test the config, and don't actually wait for 2 seconds
+    expect(server.config).to include(timeout: 2.0)
+  end
+
+  describe 'with :timeout option' do
+    let(:server_config) do
+      { timeout: 0.01, handlers: [HTTPkit::Server::Timeouts.new] }
+    end
+
+    it 'times out after $n seconds' do
+      async_sleep(0.015)
+      expect(client).to be_closed
+      expect(server).to be_timeout
+    end
+  end
+end

data/spec/shared/integration/server_client_pair.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+shared_context :server_client_pair do
+  let(:server_config) { { handlers: [SpecHandler.new] } }
+  let(:client_config) { {} }
+  let(:interceptor)   { double('interceptor') }
+
+  let(:server_and_client) do
+    server_client_pair(server_config, client_config, interceptor)
+  end
+
+  let(:intercepted_requests) { [] }
+  let(:intercepted_promises) { [] }
+
+  before do
+    allow(interceptor).to receive(:serve) { |request, served|
+      intercepted_requests << request
+      intercepted_promises << served
+    }
+  end
+
+  let!(:server) { server_and_client[0] }
+  let!(:client) { server_and_client[1] }
+
+  after do
+    server.close
+    client.close
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+if ENV['COVERAGE'] == 'true'
+  require 'simplecov'
+  require 'coveralls'
+
+  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+    SimpleCov::Formatter::HTMLFormatter,
+    Coveralls::SimpleCov::Formatter
+  ]
+
+  SimpleCov.start do
+    command_name 'spec:unit'
+
+    add_filter 'config'
+    add_filter 'spec'
+  end
+end
+
+require 'httpkit'
+require 'weakref'
+
+require 'awesome_print'
+
+require 'devtools/spec_helper'
+
+RSpec.configure do |config|
+  config.include(SpecHelper)
+
+  config.around do |example|
+    if example.metadata[:reactor]
+      EM.run do
+        EM.add_timer(0.5) { raise 'Example timed out' }
+
+        Fiber.new do
+          example.call
+          EM.stop
+          EM.next_tick {}
+        end.resume
+      end
+    else
+      Timeout.timeout(0.5) { example.call }
+    end
+  end
+end

data/spec/support/handler.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+class SpecHandler
+  def serve(request, served)
+    served.fulfill(response_for(request))
+  end
+
+  private
+
+  def response_for(request)
+    case request.uri
+    when '/sleep'     then sleep_response
+    when '/close'     then close_response
+    when '/streaming' then streaming_response
+    else                   echo_response(request)
+    end
+  end
+
+  def echo_response(request)
+    HTTPkit::Response.new(200, { 'Content-Type' => 'text/plain' },
+                          request.uri)
+  end
+
+  def sleep_response
+    SpecHelper.async_sleep(0.01)
+    HTTPkit::Response.new(200, { 'Content-Type' => 'text/plain' }, '/sleep')
+  end
+
+  def close_response
+    HTTPkit::Response.new(200,
+                          { 'Content-Type' => 'text/plain',
+                            'Connection' => 'close' },
+                          '/close')
+  end
+
+  def streaming_response
+    response = HTTPkit::Response.new(200, { 'Content-Type' => 'text/plain' },
+                                     HTTPkit::Body.new)
+    SpecHelper.defer do
+      %w[foo bar baz].each do |chunk|
+        SpecHelper.tick(2)
+        response.body.closed.progress(chunk)
+      end
+      response.close
+    end
+    response
+  end
+end

data/spec/support/helper.rb

@@ -0,0 +1,70 @@
+# encoding: utf-8
+
+module SpecHelper
+  def async_sleep(seconds)
+    fiber = Fiber.current
+    EM.add_timer(seconds) { fiber.resume }
+    Fiber.yield
+  end
+  module_function :async_sleep
+
+  def tick(ticks = 1)
+    fiber = Fiber.current
+    EM.next_tick { fiber.resume }
+    Fiber.yield
+
+    tick(ticks - 1) if ticks > 1
+  end
+  module_function :tick
+
+  def defer
+    EM.next_tick do
+      Fiber.new { yield }.resume
+    end
+  end
+  module_function :defer
+
+  def open_request(http_method = :get, uri = '/', headers = {})
+    HTTPkit::Request.new(http_method, uri, headers, HTTPkit::Body.new)
+  end
+
+  def closed_request(*args)
+    open_request(*args).tap(&:close)
+  end
+
+  def open_response(status = 200, headers = {})
+    HTTPkit::Response.new(status, headers, HTTPkit::Body.new)
+  end
+
+  def closed_response(*args)
+    open_response(*args).tap(&:close)
+  end
+
+  def localhost
+    '127.0.0.1'
+  end
+
+  def random_port
+    server = TCPServer.new(localhost, 0)
+    server.addr[1]
+  ensure
+    server.shutdown
+  end
+
+  def server_client_pair(server_config, client_config, interceptor)
+    server = nil
+    inspect_server(server_config, interceptor) { |_, s, _| server = s }
+
+    config = { address: localhost, port: random_port }
+    HTTPkit::Server.start(config.merge(server_config))
+    client = HTTPkit::Client.start(config.merge(client_config))
+
+    tick
+    [server, client]
+  end
+
+  def inspect_server(server_config, interceptor, &block)
+    allow(interceptor).to receive(:setup, &block)
+    server_config[:handlers].unshift(interceptor)
+  end
+end