httpkit 0.6.0.pre.3

data/spec/unit/client_spec.rb

@@ -0,0 +1,230 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe HTTPkit::Client do
+  let(:client) { described_class.new(config, connection) }
+
+  let(:config) do
+    { address: localhost, port: random_port, handlers: [handler] }
+  end
+  let(:connection) do
+    double('connection', :'on_message=' => nil,
+                         closed: double('closed', then: nil,
+                                                  fulfill: nil,
+                                                  pending?: true,
+                                                  reason: nil),
+                         serialize: nil,
+                         close: nil)
+  end
+  let(:handler) do
+    double('handler', setup: nil, receive: nil, finish: nil)
+  end
+
+  describe '.start' do
+    subject { described_class.start(config) }
+
+    it 'starts an EventMachine-backed client instance' do
+      expect(HTTPkit::Connection::EventMachine)
+        .to receive(:start_client).with(config, described_class) { client }
+      expect(subject).to be(client)
+    end
+  end
+
+  describe '#initialize' do
+    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))
+    end
+
+    specify do
+      expect(handler).to have_received(:setup)
+        .with(config, subject, connection)
+    end
+  end
+
+  describe '#request' do
+    let(:request) do
+      double('request', body: double(closed: double('closed', fulfill: nil)))
+    end
+    let(:response) { double('response') }
+    let(:served)   { double('served', sync: response) }
+
+    before do
+      allow(HTTPkit::Request).to receive(:new)     { request }
+      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(subject).to be(response)
+    end
+  end
+
+  describe '#perform' do
+    let(:request)       { double('request', add_extra_headers: nil) }
+    let(:closed_reason) { nil }
+
+    before do
+      allow(connection.closed).to receive(:pending?) { closed_reason.nil? }
+      allow(connection.closed).to receive(:reason)   { closed_reason }
+
+      @fibers = []
+      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(request).to have_received(:add_extra_headers)
+        .with('User-Agent' => "httpkit/#{HTTPkit::VERSION}",
+              'Host'       => "#{config[:address]}:#{config[:port]}")
+    end
+
+    describe 'with closed connection' do
+      let(:closed_reason) { double }
+
+      it 'rejects the request' do
+        expect(subject).to        be_rejected
+        expect(subject.reason).to be(closed_reason)
+        expect(connection).to_not have_received(:serialize)
+      end
+    end
+  end
+
+  describe '#receive' do
+    let(:request)        { open_request }
+    let(:other_request)  { open_request }
+    let(:response)       { open_response }
+    let(:other_response) { open_response }
+
+    describe 'with outstanding request' do
+      let!(:served)       { client.perform(request) }
+      let!(:other_served) { client.perform(other_request) }
+
+      subject! do
+        client.receive(response)
+        client.receive(other_response)
+      end
+
+      it 'correlates response with request, and notifies handlers' do
+        expect(served).to       be_fulfilled
+        expect(served.value).to be(response)
+        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)
+      end
+    end
+
+    describe 'wiring', reactor: true do
+      let(:request)  { closed_request }
+      let(:response) { open_response }
+
+      before do
+        client.perform(request)
+
+        allow(client).to receive(:finish)
+      end
+
+      subject! do
+        client.receive(response)
+        response.close
+        tick
+      end
+
+      it 'wires up #finish' do
+        client.should have_received(:finish).with(request)
+      end
+    end
+
+    [:fulfill, :reject].each do |action|
+      describe "after #{action}ed response" do
+        let(:request)  { WeakRef.new(closed_request) }
+        let(:response) { WeakRef.new(open_response) }
+
+        before do
+          client.perform(request.__getobj__)
+          client.receive(response.__getobj__)
+        end
+
+        subject do
+          response.finished.send(action)
+          tick
+          RSpec::Mocks.teardown
+          GC.start
+        end
+
+        xit 'cleans up' do
+          expect { subject }.to change { request.weakref_alive? }.to(false)
+        end
+      end
+    end
+  end
+
+  describe '#finish' do
+    let(:request)        { open_request }
+    let(:other_request)  { open_request }
+    let(:response)       { open_response }
+
+    before do
+      client.perform(request)
+      client.perform(other_request)
+    end
+
+    subject! do
+      client.finish(request)
+      client.receive(response)
+    end
+
+    it 'removes the request' do
+      expect(handler).to have_received(:receive).with(other_request, response)
+    end
+
+    it 'notifies the handlers' do
+      expect(handler).to have_received(:finish).with(request)
+    end
+  end
+
+  describe '#teardown' do
+    let(:requests)  { [closed_request, closed_request] }
+    let(:responses) { [open_response] }
+    let(:reason)    { double('reason') }
+
+    let!(:served) do
+      requests.map { |request| client.perform(request) }
+    end
+
+    before do
+      client.receive(responses[0])
+    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.reason).to be(reason)
+      expect(served[1]).to                    be_rejected
+      expect(served[1].reason).to             be(reason)
+    end
+  end
+end

data/spec/unit/connection/eventmachine_spec.rb

@@ -0,0 +1,211 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe HTTPkit::Connection::EventMachine do
+  let(:connection) { described_class.allocate }
+  let(:callback)   { double('callback', call: nil) }
+  let(:parser)     { double('parser', :<< => nil) }
+  let(:serializer) { double('serializer', setup_body: nil, serialize: nil) }
+  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(HTTPkit::Support::Message).to receive(:build) { message }
+
+    connection.instance_variable_set(:@signature, 123)
+
+    # XXX: initialize separately, EM::Connection overloads .new
+    #      this smell tells us that we should decouple from EM::Connection
+    connection.send(:initialize, callback)
+  end
+
+  describe '.start_client' do
+    let(:config)       { { address: double, port: double } }
+    let(:client_class) { double('client_class', new: client) }
+    let(:client)       { double }
+
+    before do
+      allow(EM).to receive(:connect) { connection }
+    end
+
+    subject! { described_class.start_client(config, client_class) }
+
+    it 'starts a Client connection' do
+      expect(EM).to           have_received(:connect)
+        .with(config[:address], config[:port], described_class)
+      expect(client_class).to have_received(:new)
+        .with(config, connection)
+
+      expect(subject).to be(client)
+    end
+  end
+
+  describe '.start_server' do
+    let(:config)       { { address: double, port: double } }
+    let(:server_class) { double('server_class', new: nil) }
+
+    before do
+      allow(EM).to receive(:start_server) { |*, cb| cb.call(connection) }
+    end
+
+    subject! { described_class.start_server(config, server_class) }
+
+    it 'starts a Client connection' do
+      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)
+    end
+  end
+
+  describe '#initialize' do
+    subject! { connection }
+
+    it 'creates parser' do
+      expect(HTTP::Parser).to have_received(:new).with(connection)
+    end
+
+    it 'calls back' do
+      expect(callback).to have_received(:call).with(connection)
+    end
+
+    describe 'without callback' do
+      let(:connection) { described_class.allocate }
+
+      subject! { connection.send(:initialize) }
+
+      it 'is happy as well' do
+        expect(connection).to be_a(described_class)
+      end
+    end
+  end
+
+  describe '#serialize' do
+    let(:writer) { connection.method(:send_data) }
+
+    subject! { connection.serialize(message) }
+
+    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)
+    end
+  end
+
+  describe '#close' do
+    subject! { connection.close }
+
+    it 'closes the connection' do
+      expect(connection).to have_received(:close_connection_after_writing)
+      expect(connection.closed).to be_pending
+    end
+
+    describe 'with reason' do
+      let(:reason) { double('reason') }
+
+      subject! { connection.close(reason) }
+
+      it 'rejects the promise' do
+        expect(connection.closed).to        be_rejected
+        expect(connection.closed.reason).to be(reason)
+        expect(connection).to have_received(:close_connection_after_writing)
+      end
+    end
+  end
+
+  describe '#receive_data' do
+    let(:data) { double }
+
+    subject { connection.receive_data(data) }
+
+    it 'feeds the parser' do
+      subject
+      expect(parser).to have_received(:<<).with(data)
+    end
+
+    describe 'on error' do
+      let(:error) { RuntimeError.new }
+
+      before do
+        allow(parser).to     receive(:<<) { raise error }
+        allow(connection).to receive(:close)
+      end
+
+      it 'closes the connection' do
+        subject
+        expect(connection).to have_received(:close).with(error)
+      end
+    end
+  end
+
+  describe '#unbind' do
+    subject! { connection.unbind }
+
+    it 'fulfills the promise' do
+      expect(connection.closed).to       be_fulfilled
+      expect(connection.closed.value).to be(nil)
+    end
+
+    describe 'with reason' do
+      let(:reason) { double('reason') }
+
+      subject! { connection.unbind(reason) }
+
+      it 'rejects the promise' do
+        expect(connection.closed).to        be_rejected
+        expect(connection.closed.reason).to be(reason)
+      end
+    end
+  end
+
+  describe '#on_headers_complete' do
+    let(:parse) { double('parse', call: nil) }
+
+    before { connection.on_message = parse }
+
+    subject! { connection.on_headers_complete(nil) }
+
+    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)
+    end
+  end
+
+  describe '#on_body' do
+    let(:progress) { [] }
+    let(:chunks)   { %w[body chunk] }
+
+    before do
+      connection.on_message = proc {}
+      connection.on_headers_complete(nil)
+    end
+
+    subject! do
+      message.body.closed.on_progress { |chunk| progress << chunk }
+      connection.on_body(chunks[0])
+      connection.on_body(chunks[1])
+      message.close
+    end
+
+    it 'passes chunk to message body' do
+      expect(message.body.to_s).to eq(chunks.join)
+      expect(progress).to          eq(chunks)
+    end
+  end
+
+  describe '#on_message_complete' do
+    before do
+      connection.on_message = proc {}
+      connection.on_headers_complete(nil)
+    end
+
+    subject! { connection.on_message_complete }
+
+    it 'closes the body' do
+      expect(message.body.closed).to be_fulfilled
+    end
+  end
+end

data/spec/unit/connection/status_spec.rb

@@ -0,0 +1,83 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe HTTPkit::Connection::Status do
+  let(:closed) { HTTPkit::Promise.new }
+  let(:connection) { double('connection', close: nil, closed: closed) }
+
+  let(:object) do
+    Object.new.tap do |obj|
+      obj.extend(described_class)
+      obj.instance_variable_set(:@connection, connection)
+    end
+  end
+
+  describe '#close with reason' do
+    subject! { object.close }
+
+    it 'forwards to @connection' do
+      expect(connection).to have_received(:close).with(nil)
+    end
+  end
+
+  describe '#close with reason' do
+    let(:reason) { double }
+
+    subject! { object.close(reason) }
+
+    it 'forwards to @connection' do
+      expect(connection).to have_received(:close).with(reason)
+    end
+  end
+
+  describe '#closed?' do
+    subject { object.closed? }
+    it { should be(false) }
+
+    describe 'if rejected' do
+      before { closed.reject }
+      it { should be(true) }
+    end
+
+    describe 'if fulfilled' do
+      before { closed.reject }
+      it { should be(true) }
+    end
+  end
+
+  describe '#error?' do
+    subject { object.error? }
+    it { should be(false) }
+
+    describe 'if rejected' do
+      before { closed.reject }
+      it { should be(true) }
+    end
+  end
+
+  describe '#network_fault?' do
+    subject { object.network_fault? }
+    it { should be(false) }
+
+    describe 'if rejected with ENETUNREACH' do
+      before { closed.reject(Errno::ENETUNREACH) }
+      it { should be(true) }
+    end
+
+    describe 'if rejected with ENOTCONN' do
+      before { closed.reject(Errno::ENOTCONN) }
+      it { should be(true) }
+    end
+  end
+
+  describe '#timeout?' do
+    subject { object.timeout? }
+    it { should be(false) }
+
+    describe 'if rejected with ENETUNREACH' do
+      before { closed.reject(Errno::ETIMEDOUT) }
+      it { should be(true) }
+    end
+  end
+end

data/spec/unit/httpkit_spec.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe HTTPkit, '#run', reactor: false do
+  subject! do
+    HTTPkit.run do
+      @reactor = EM.reactor_running?
+      @fiber   = Fiber.current
+    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
+
+  it 'stops the EventMachine reactor' do
+    expect(EM.reactor_running?).to be(false)
+  end
+end
+
+describe HTTPkit, '#stop', reactor: false 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

data/spec/unit/promise_spec.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe HTTPkit::Promise do
+  let(:promise) { described_class.new }
+
+  describe '#defer' do
+    before do
+      allow(EM).to receive(:reactor_running?) { running }
+      allow(EM).to receive(:next_tick)        { |&block| block.call }
+
+      promise.then { @called = true }
+    end
+
+    subject! { promise.fulfill }
+
+    describe 'with reactor' do
+      let(:running) { true }
+
+      it 'schedules the block for the next reactor iteration' do
+        expect(@called).to be(true)
+      end
+    end
+
+    describe 'without reactor' do
+      let(:running) { false }
+
+      it 'does nothing' do
+        expect(@called).not_to be(true)
+      end
+    end
+  end
+
+  describe '#wait', reactor: true do
+    let(:promise2) { described_class.new }
+
+    before do
+      promise.then { @fulfilled = true }
+      promise2.then(nil, proc { @rejected = true })
+
+      EM.next_tick { promise.fulfill }
+      promise.then { promise2.reject }
+    end
+
+    subject! do
+      promise.wait
+      promise2.wait
+    end
+
+    it 'suspends the fiber until the promise state changes' do
+      expect(@fulfilled).to be(true)
+      expect(@rejected).to  be(true)
+    end
+  end
+end

data/spec/unit/request_spec.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe HTTPkit::Request do
+  describe '#initialize' do
+    subject do
+      HTTPkit::Request.new(:get, '/a?b=c',
+                           { 'Key' => 'value' }, 'hello').freeze
+    end
+
+    its(:http_method) { should be(:get) }
+    its(:uri) { should eq('/a?b=c') }
+    its(:headers) { should eq('Key' => 'value') }
+
+    specify { expect(subject.body.read).to eq('hello') }
+
+    describe 'defaults' do
+      subject { HTTPkit::Request.new(:get, '/') }
+
+      its(:headers) { should eq({}) }
+      its(:http_version) { should eq(1.1) }
+
+      specify { expect(subject.body.read).to be_empty }
+    end
+  end
+
+  describe '#http_version=' do
+    subject { HTTPkit::Request.new(:get, '/') }
+
+    before { subject.http_version = 1.0 }
+
+    its(:http_version) { should eq(1.0) }
+  end
+end