httpkit 0.6.0.pre.3 → 0.6.0.pre.5

data/spec/shared/integration/server_client_pair.rb

@@ -2,7 +2,7 @@
 
 shared_context :server_client_pair do
   let(:server_config) { { handlers: [SpecHandler.new] } }
-  let(:client_config) { {} }
+  let(:client_config) { { handlers: [] } }
   let(:interceptor)   { double('interceptor') }
 
   let(:server_and_client) do

data/spec/spec_helper.rb

@@ -23,6 +23,7 @@ require 'weakref'
 require 'awesome_print'
 
 require 'devtools/spec_helper'
+require 'rspec/its'
 
 RSpec.configure do |config|
   config.include(SpecHelper)
@@ -30,7 +31,7 @@ RSpec.configure do |config|
   config.around do |example|
     if example.metadata[:reactor]
       EM.run do
-        EM.add_timer(0.5) { raise 'Example timed out' }
+        EM.add_timer(0.25) { raise 'Example timed out' }
 
         Fiber.new do
           example.call
@@ -39,7 +40,7 @@ RSpec.configure do |config|
         end.resume
       end
     else
-      Timeout.timeout(0.5) { example.call }
+      Timeout.timeout(0.25) { example.call }
     end
   end
 end

data/spec/support/handler.rb

@@ -39,7 +39,7 @@ class SpecHandler
     SpecHelper.defer do
       %w[foo bar baz].each do |chunk|
         SpecHelper.tick(2)
-        response.body.closed.progress(chunk)
+        response.body.write(chunk)
       end
       response.close
     end

data/spec/support/helper.rb

@@ -24,16 +24,18 @@ module SpecHelper
   end
   module_function :defer
 
-  def open_request(http_method = :get, uri = '/', headers = {})
-    HTTPkit::Request.new(http_method, uri, headers, HTTPkit::Body.new)
+  def open_request(http_method = :get, uri = '/', headers = {}, body = nil,
+                   http_version = 1.1)
+    HTTPkit::Request.new(http_method, uri, headers, body,
+                         http_version)
   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)
+  def open_response(status = 200, headers = {}, body = nil, http_version = 1.1)
+    HTTPkit::Response.new(status, headers, body, http_version)
   end
 
   def closed_response(*args)

data/spec/unit/body_spec.rb

@@ -0,0 +1,6 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe HTTPkit::Body do
+end

data/spec/unit/client/keep_alive_handler_spec.rb

@@ -0,0 +1,6 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe HTTPkit::Client::KeepAliveHandler do
+end

data/spec/unit/client/mandatory_handler_spec.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe HTTPkit::Client::MandatoryHandler do
+  describe '#perform' do
+    let(:handler) { described_class.new }
+    let(:request) { HTTPkit::Request.new(:get, '/', headers) }
+    let(:headers) { {} }
+
+    subject! do
+      handler.setup({ address: 'example.net', port: 80 }, nil, nil)
+      handler.perform(request) { |req| @request = req }
+    end
+
+    it 'sets User-Agent and Host headers' do
+      expect(@request.headers['User-Agent'])
+        .to eq("httpkit/#{HTTPkit::VERSION}")
+      expect(@request.headers['Host']).to eq('example.net:80')
+    end
+
+    describe 'with User-Agent or Host header set to anything' do
+      let(:headers) { { 'User-Agent' => nil, 'Host' => nil } }
+
+      it 'does not override' do
+        expect(@request.headers['User-Agent']).to be(nil)
+        expect(@request.headers['Host']).to be(nil)
+      end
+    end
+  end
+end

data/spec/unit/client/timeouts_handler_spec.rb

@@ -0,0 +1,6 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe HTTPkit::Client::TimeoutsHandler do
+end

data/spec/unit/client_spec.rb

@@ -31,21 +31,53 @@ describe HTTPkit::Client do
     end
   end
 
+  describe '.request' do
+    let(:arg) { double }
+    let(:uri) { 'http://localhost:3000' }
+
+    let(:options)  { { address: 'localhost', port: 3000 } }
+    let(:client)   { double }
+    let(:response) { double }
+
+    before do
+      allow(described_class).to receive(:start).with(options) { client }
+      allow(client).to receive(:request).with(arg, uri, arg, arg) { response }
+    end
+
+    subject { described_class.request(arg, uri, arg, arg) }
+
+    it 'starts a client and performs the request' do
+      expect(subject).to be(response)
+    end
+  end
+
   describe '#initialize' do
+    let(:on_message) { client.method(:receive) }
+    let(:teadown) { client.method(:teardown) }
+
     subject! { client }
 
     its(:config) { should be(config) }
 
-    specify do
-      expect(connection).to        have_received(:on_message=)
-        .with(subject.method(:receive))
-      expect(connection.closed).to have_received(:then)
-        .with(subject.method(:teardown), subject.method(:teardown))
+    it 'wires up #receive and #teardown' do
+      expect(connection).to have_received(:on_message=).with(on_message)
+      expect(connection.closed).to have_received(:then).with(teadown, teadown)
     end
 
-    specify do
-      expect(handler).to have_received(:setup)
-        .with(config, subject, connection)
+    it 'sets up handlers' do
+      expect(handler).to have_received(:setup).with(config, client, connection)
+      expect(config[:handlers].first).to be(handler)
+    end
+
+    describe 'without handlers' do
+      let(:config) { {} }
+
+      it 'adds the mandatory and body handlers' do
+        expect(config[:handlers][0])
+          .to be_a(HTTPkit::Client::MandatoryHandler)
+        expect(config[:handlers][1])
+          .to be_a(HTTPkit::Client::BodyHandler)
+      end
     end
   end
 
@@ -58,21 +90,21 @@ describe HTTPkit::Client do
 
     before do
       allow(HTTPkit::Request).to receive(:new)     { request }
-      allow(client).to            receive(:perform) { served }
+      allow(client).to receive(:perform) { served }
     end
 
     subject! { client.request(:head, '/wat') }
 
     specify do
       expect(HTTPkit::Request).to have_received(:new).with(:head, '/wat')
-      expect(client).to            have_received(:perform).with(request)
+      expect(client).to have_received(:perform).with(request)
 
       expect(subject).to be(response)
     end
   end
 
   describe '#perform' do
-    let(:request)       { double('request', add_extra_headers: nil) }
+    let(:request)       { HTTPkit::Request.new(:get, '/') }
     let(:closed_reason) { nil }
 
     before do
@@ -80,29 +112,26 @@ describe HTTPkit::Client do
       allow(connection.closed).to receive(:reason)   { closed_reason }
 
       @fibers = []
-      allow(handler).to    receive(:perform) { @fibers << Fiber.current }
+      allow(handler).to receive(:perform) { @fibers << Fiber.current }
       allow(connection).to receive(:serialize) { @fibers << Fiber.current }
     end
 
     subject! { client.perform(request) }
 
     it 'sends the request on the wire' do
-      expect(handler).to    have_received(:perform).with(request)
-      expect(connection).to have_received(:serialize).with(request)
-
-      expect(@fibers).not_to   include(Fiber.current)
-      expect(@fibers.uniq).to  be_one
+      expect(handler).to have_received(:perform).with(kind_of(request.class))
+      expect(connection)
+        .to have_received(:serialize).with(kind_of(request.class))
 
-      expect(request).to have_received(:add_extra_headers)
-        .with('User-Agent' => "httpkit/#{HTTPkit::VERSION}",
-              'Host'       => "#{config[:address]}:#{config[:port]}")
+      expect(@fibers).not_to include(Fiber.current)
+      expect(@fibers.uniq).to be_one
     end
 
     describe 'with closed connection' do
       let(:closed_reason) { double }
 
       it 'rejects the request' do
-        expect(subject).to        be_rejected
+        expect(subject).to be_rejected
         expect(subject.reason).to be(closed_reason)
         expect(connection).to_not have_received(:serialize)
       end
@@ -125,14 +154,22 @@ describe HTTPkit::Client do
       end
 
       it 'correlates response with request, and notifies handlers' do
-        expect(served).to       be_fulfilled
+        expect(served).to be_fulfilled
         expect(served.value).to be(response)
-        expect(other_served).to       be_fulfilled
+        expect(other_served).to be_fulfilled
         expect(other_served.value).to be(other_response)
 
-        expect(handler).to have_received(:receive).with(request, response)
         expect(handler)
-          .to have_received(:receive).with(other_request, other_response)
+          .to have_received(:receive).with(kind_of(request.class),
+                                           kind_of(response.class)).twice
+      end
+    end
+
+    describe 'without outstanding request' do
+      subject! { client.receive(response) }
+
+      it 'does not do anything' do
+        expect(handler).not_to have_received(:receive)
       end
     end
 
@@ -153,7 +190,7 @@ describe HTTPkit::Client do
       end
 
       it 'wires up #finish' do
-        client.should have_received(:finish).with(request)
+        client.should have_received(:finish).with(kind_of(request.class))
       end
     end
 
@@ -182,8 +219,8 @@ describe HTTPkit::Client do
   end
 
   describe '#finish' do
-    let(:request)        { open_request }
-    let(:other_request)  { open_request }
+    let(:request)        { open_request(:get) }
+    let(:other_request)  { open_request(:head) }
     let(:response)       { open_response }
 
     before do
@@ -197,16 +234,21 @@ describe HTTPkit::Client do
     end
 
     it 'removes the request' do
-      expect(handler).to have_received(:receive).with(other_request, response)
+      expect(handler).to have_received(:receive) { |req, res|
+        expect(req.http_method).to be(:head)
+        expect(res).to be(res)
+      }
     end
 
     it 'notifies the handlers' do
-      expect(handler).to have_received(:finish).with(request)
+      expect(handler).to have_received(:finish) { |req|
+        expect(req.http_method).to be(:get)
+      }
     end
   end
 
   describe '#teardown' do
-    let(:requests)  { [closed_request, closed_request] }
+    let(:requests)  { [closed_request, closed_request, closed_request] }
     let(:responses) { [open_response] }
     let(:reason)    { double('reason') }
 
@@ -216,15 +258,22 @@ describe HTTPkit::Client do
 
     before do
       client.receive(responses[0])
+      served[1].reject
     end
 
     subject! { client.teardown(reason) }
 
     it 'rejects outstanding requests and responses' do
-      expect(responses[0].body.closed).to        be_rejected
+      expect(responses[0].body.closed).to be_rejected
       expect(responses[0].body.closed.reason).to be(reason)
-      expect(served[1]).to                    be_rejected
-      expect(served[1].reason).to             be(reason)
+      expect(served[2]).to be_rejected
+      expect(served[2].reason).to be(reason)
     end
   end
+
+  describe '#find_request'
+
+  describe '#perform!'
+
+  describe '#setup_connection'
 end

data/spec/unit/connection/eventmachine_spec.rb

@@ -10,9 +10,9 @@ describe HTTPkit::Connection::EventMachine do
   let(:message)    { open_request }
 
   before do
-    allow(connection).to             receive(:close_connection_after_writing)
-    allow(HTTP::Parser).to           receive(:new)   { parser }
-    allow(HTTPkit::Serializer).to       receive(:new)   { serializer }
+    allow(connection).to receive(:close_connection_after_writing)
+    allow(HTTP::Parser).to receive(:new)   { parser }
+    allow(HTTPkit::Serializer).to receive(:new)   { serializer }
     allow(HTTPkit::Support::Message).to receive(:build) { message }
 
     connection.instance_variable_set(:@signature, 123)
@@ -34,7 +34,7 @@ describe HTTPkit::Connection::EventMachine do
     subject! { described_class.start_client(config, client_class) }
 
     it 'starts a Client connection' do
-      expect(EM).to           have_received(:connect)
+      expect(EM).to have_received(:connect)
         .with(config[:address], config[:port], described_class)
       expect(client_class).to have_received(:new)
         .with(config, connection)
@@ -54,7 +54,7 @@ describe HTTPkit::Connection::EventMachine do
     subject! { described_class.start_server(config, server_class) }
 
     it 'starts a Client connection' do
-      expect(EM).to           have_received(:start_server)
+      expect(EM).to have_received(:start_server)
         .with(config[:address], config[:port], described_class, kind_of(Proc))
       expect(server_class).to have_received(:new)
         .with(config, connection)
@@ -90,8 +90,7 @@ describe HTTPkit::Connection::EventMachine do
 
     it 'feeds a serializer' do
       expect(HTTPkit::Serializer).to have_received(:new).with(message, writer)
-      expect(serializer).to           have_received(:setup_body)
-      expect(serializer).to           have_received(:serialize)
+      expect(serializer).to have_received(:serialize)
     end
   end
 
@@ -109,7 +108,7 @@ describe HTTPkit::Connection::EventMachine do
       subject! { connection.close(reason) }
 
       it 'rejects the promise' do
-        expect(connection.closed).to        be_rejected
+        expect(connection.closed).to be_rejected
         expect(connection.closed.reason).to be(reason)
         expect(connection).to have_received(:close_connection_after_writing)
       end
@@ -130,7 +129,7 @@ describe HTTPkit::Connection::EventMachine do
       let(:error) { RuntimeError.new }
 
       before do
-        allow(parser).to     receive(:<<) { raise error }
+        allow(parser).to receive(:<<) { raise error }
         allow(connection).to receive(:close)
       end
 
@@ -145,7 +144,7 @@ describe HTTPkit::Connection::EventMachine do
     subject! { connection.unbind }
 
     it 'fulfills the promise' do
-      expect(connection.closed).to       be_fulfilled
+      expect(connection.closed).to be_fulfilled
       expect(connection.closed.value).to be(nil)
     end
 
@@ -155,7 +154,7 @@ describe HTTPkit::Connection::EventMachine do
       subject! { connection.unbind(reason) }
 
       it 'rejects the promise' do
-        expect(connection.closed).to        be_rejected
+        expect(connection.closed).to be_rejected
         expect(connection.closed.reason).to be(reason)
       end
     end
@@ -170,7 +169,7 @@ describe HTTPkit::Connection::EventMachine do
 
     it 'builds the message and passes it on' do
       expect(HTTPkit::Support::Message).to have_received(:build).with(parser)
-      expect(parse).to                  have_received(:call).with(message)
+      expect(parse).to have_received(:call).with(message)
     end
   end
 
@@ -192,7 +191,7 @@ describe HTTPkit::Connection::EventMachine do
 
     it 'passes chunk to message body' do
       expect(message.body.to_s).to eq(chunks.join)
-      expect(progress).to          eq(chunks)
+      expect(progress).to eq(chunks)
     end
   end
 

data/spec/unit/httpkit_spec.rb

@@ -2,40 +2,81 @@
 
 require 'spec_helper'
 
-describe HTTPkit, '#run', reactor: false do
-  subject! do
-    HTTPkit.run do
-      @reactor = EM.reactor_running?
-      @fiber   = Fiber.current
+describe HTTPkit do
+  describe '.run' do
+    subject! do
+      HTTPkit.run do
+        @reactor = EM.reactor_running?
+        @fiber   = Fiber.current
+      end
     end
-  end
 
-  it 'starts an EventMachine reactor' do
-    expect(@reactor).to be(true)
-  end
+    it 'starts an EventMachine reactor' do
+      expect(@reactor).to be(true)
+    end
 
-  it 'yields in a new Fiber' do
-    expect(@fiber).not_to be(Fiber.current)
-  end
+    it 'yields in a new Fiber' do
+      expect(@fiber).not_to be(Fiber.current)
+    end
 
-  it 'stops the EventMachine reactor' do
-    expect(EM.reactor_running?).to be(false)
+    it 'stops the EventMachine reactor' do
+      expect(EM.reactor_running?).to be(false)
+    end
   end
-end
 
-describe HTTPkit, '#stop', reactor: false do
-  subject! do
-    EM.run do
-      EM.add_timer(1.0) { @timer = true }
-      HTTPkit.stop
+  describe '.start' do
+    subject! do
+      HTTPkit.start do
+        @reactor = EM.reactor_running?
+        @fiber   = Fiber.current
+        EM.stop
+        EM.next_tick {}
+      end
+    end
+
+    it 'starts an EventMachine reactor' do
+      expect(@reactor).to be(true)
+    end
+
+    it 'yields in a new Fiber' do
+      expect(@fiber).not_to be(Fiber.current)
     end
   end
 
-  it 'stops the EventMachine reactor' do
-    expect(EM.reactor_running?).to be(false)
+  describe '.stop' do
+    subject! do
+      EM.run do
+        EM.add_timer(1.0) { @timer = true }
+        HTTPkit.stop
+      end
+    end
+
+    it 'stops the EventMachine reactor' do
+      expect(EM.reactor_running?).to be(false)
+    end
+
+    it 'stops EventMachine timers' do
+      expect(@timer).not_to be(true)
+    end
   end
 
-  it 'stops EventMachine timers' do
-    expect(@timer).not_to be(true)
+  describe '.sleep', reactor: true do
+    subject { HTTPkit.sleep(0.005) }
+
+    let(:fiber) do
+      @slept = false
+      Fiber.new do
+        subject
+        @slept = true
+      end
+    end
+
+    it 'sleeps for the given number of seconds' do
+      fiber.resume
+      expect(@slept).to be(false)
+      sleep(0.005)
+      tick(3)
+      expect(@slept).to be(true)
+    end
   end
 end