hatetepe 0.5.2 → 0.6.0.pre

data/spec/unit/client_spec.rb

@@ -1,211 +1,170 @@
-require "spec_helper"
-require "hatetepe/client"
+# encoding: utf-8
 
-describe Hatetepe::Client do
-  let :config do
-    {
-      :host => "127.0.0.1",
-      :port => 4242
-    }
-  end
+require 'spec_helper'
 
-  let :client do
-    Object.new.tap do |client|
-      client.extend(Hatetepe::Client)
-      client.stub(:send_data)
-      client.stub(:comm_inactivity_timeout=)
-      client.stub(:pending_connect_timeout=)
-      client.stub(:send_request) { response }
+describe Hatetepe::Client do
+  let(:client) { described_class.new(config) }
 
-      client.send(:initialize, config)
-      client.post_init
-    end
+  let(:config) do
+    { address: localhost, port: random_port, handlers: [handler_class] }
+  end
+  let(:connection) do
+    double('connection', parse: nil,
+                         closed: double('closed', then: nil),
+                         serialize: nil,
+                         close: nil)
   end
+  let(:handler_class) { double('handler_class', new: handler) }
+  let(:handler)       { double('handler', post_init: nil, receive: nil) }
 
-  describe ".start" do
-    it "starts a new client" do
-      EM.should_receive(:connect).
-         with(config[:host], config[:port], Hatetepe::Client, config).
-         and_return(client)
-      Hatetepe::Client.start(config).should equal(client)
-    end
+  before do
+    allow(EM).to receive(:connect) { connection }
   end
 
-  describe "#stop" do
-    it "waits for all requests to finish and closes the connection" do
-      client.should_receive(:wait).ordered
-      client.should_receive(:stop!).ordered
-      client.stop
+  describe '#initialize' do
+    subject! { client }
+
+    its(:config) { should be(config) }
+
+    specify do
+      expect(EM).to                have_received(:connect)
+        .with(config[:address], config[:port],
+              Hatetepe::Connection::EventMachine)
+      expect(connection).to        have_received(:parse)
+        .with(subject.method(:receive))
+      expect(connection.closed).to have_received(:then)
+        .with(subject.method(:teardown))
     end
-  end
 
-  describe "#stop!" do
-    it "closes the connection" do
-      client.should_receive(:close_connection)
-      client.stop!
+    specify do
+      expect(handler_class).to have_received(:new)
+        .with(config, subject, connection)
+      expect(handler).to       have_received(:post_init)
     end
   end
 
-  describe "#wait" do
-    let :requests do
-      [ Hatetepe::Request.new(:get, "/"), Hatetepe::Request.new(:post, "/") ]
+  describe '#request' do
+    let(:request) do
+      double('request', finished: double('finished', fulfill: nil),
+                        served:   double('served', sync: response))
     end
+    let(:response) { double('response') }
 
     before do
-      client.unstub(:send_request)
-      client << requests[0]
-      client << requests[1]
-    end
-
-    it "waits for all requests to finish" do
-      returned = false
-      Fiber.new do
-        client.wait
-        returned = true
-      end.resume
-
-      returned.should be_false
-
-      requests.each(&:succeed)
-      returned.should be_true
+      allow(Hatetepe::Request).to receive(:new) { request }
+      allow(client).to        receive(:perform)
     end
-  end
 
-  describe ".request" do
-    let(:client)   { double("client", request: res, stop: nil)  }
-    let(:headers)  { double("headers") }
-    let(:body)     { double("body") }
-    let(:res)      { double("response") }
-    let(:response) { Hatetepe::Client.request(:put, "/test", headers, body) }
+    subject! { client.request(:head, '/wat') }
 
-    before { Hatetepe::Client.stub(start: client) }
+    specify do
+      expect(Hatetepe::Request).to    have_received(:new).with(:head, '/wat')
+      expect(request.finished).to have_received(:fulfill)
+      expect(client).to           have_received(:perform).with(request)
 
-    it "it returns the response" do
-      client.should_receive(:request).with(:put, URI("/test"), headers, body)
-      response.should equal(res)
+      expect(subject).to be(response)
     end
   end
 
-  describe "#request" do
-    let(:body)     { [ "Hello,", " world!" ]            }
-    let(:headers)  { { "Content-Type" => "text/plain" } }
-    let(:request)  { double("request")                    }
-    let(:response) { double("response")                   }
+  describe '#perform' do
+    let(:request) { double('request') }
 
     before do
-      client.stub(:<<)
-      Hatetepe::Request.stub(:new => request)
+      @fibers = []
+      allow(handler).to    receive(:perform) { @fibers << Fiber.current }
+      allow(connection).to receive(:serialize) { @fibers << Fiber.current }
     end
 
-    it "sends the request" do
-      Hatetepe::Request.should_receive(:new) do |verb, uri, headers, body|
-        verb.should                           eq(:head)
-        uri.path.should                       eq("/test")
-        uri.query.should                      eq("key=value")
-        headers["Content-Type"].should        eq("text/plain")
-        Enumerator.new(body).to_a.join.should eq("Hello, world!")
-
-        request
-      end
-
-      client.should_receive(:<<).with(request)
-      EM::Synchrony.should_receive(:sync).with(request)
+    subject! { client.perform(request) }
 
-      client.request(:head, "/test?key=value", headers, body)
-    end
+    specify do
+      expect(handler).to    have_received(:perform).with(request)
+      expect(connection).to have_received(:serialize).with(request)
 
-    it "returns the response" do
-      EM::Synchrony.stub(:sync => response)
-      client.request(:get, "/").should equal(response)
+      expect(@fibers).not_to   include(Fiber.current)
+      expect(@fibers.uniq).to  be_one
     end
   end
 
-  describe "#request!" do
-    subject do
-      proc { client.request!(:get, "/") }
+  describe '#close' do
+    subject! { client.close }
+
+    specify do
+      expect(connection).to have_received(:close)
     end
+  end
 
-    let(:status)   { 200 }
-    let(:response) { double("response", :status => status) }
+  describe '#receive' do
+    let(:request)  { default_request }
+    let(:response) { default_response }
 
-    before do
-      client.stub(:request).with(:get, "/", {}, []) { response }
-    end
+    describe 'with outstanding request' do
+      before { client.perform(request) }
 
-    it "forwards to #request" do
-      subject.call.should eq(response)
-    end
+      subject! { client.receive(response) }
 
-    describe "for a 4xx response" do
-      let(:status) { 404 }
+      it 'correlates response with request, and notifies handlers' do
+        expect(request.served).to       be_fulfilled
+        expect(request.served.value).to be(response)
 
-      it "raises a ClientError" do
-        subject.should raise_error(Hatetepe::ClientError)
+        expect(handler).to have_received(:receive).with(request, response)
       end
     end
 
-    describe "for a 5xx response" do
-      let(:status) { 502 }
+    describe 'without outstanding request' do
+      subject { client.receive(response) }
 
-      it "raises a ServerError" do
-        subject.should raise_error(Hatetepe::ServerError)
+      it 'fails' do
+        expect { subject }.to raise_error(Hatetepe::ClientError, /correlate/)
       end
     end
 
-    describe "if no response could be received" do
-      it "raises a ServerError" do
-        client.stub(:request) { nil }
-        subject.should raise_error(Hatetepe::RequestError)
+    [:fulfill, :reject].each do |action|
+      describe "after #{action}ed response" do
+        let(:request)  { WeakRef.new(finished_request) }
+        let(:response) { WeakRef.new(default_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
+
+        it 'cleans up' do
+          if RUBY_VERSION == '1.9.3' && RUBY_PATCHLEVEL == 392
+            expect { subject }.to change { request.weakref_alive? }.to(false)
+          else
+            pending
+          end
+        end
       end
     end
   end
 
-  describe "#<<" do
-    let :request do
-      Hatetepe::Request.new :head, "/test"
-    end
-
-    describe "if the response is a success" do
-      let(:response) { Hatetepe::Response.new(307) }
+  describe '#teardown' do
+    let(:requests)  { [finished_request, finished_request] }
+    let(:responses) { [default_response] }
+    let(:reason)    { double }
 
-      it "succeeds the request" do
-        request.should_receive(:succeed).with(response)
-        client << request
-      end
-    end
-
-    describe "if the response is a failure" do
-      let(:response) { Hatetepe::Response.new(502) }
-
-      it "fails the request" do
-        request.should_receive(:fail).with(response)
-        client << request
-      end
+    before do
+      client.perform(requests[0])
+      client.perform(requests[1])
+      client.receive(responses[0])
     end
 
-    describe "if there is no response" do
-      let(:response) { nil }
+    subject! { client.teardown(reason) }
 
-      it "fails the request" do
-        request.should_receive(:fail)
-        client << request
-      end
+    it 'rejects outstanding requests and responses' do
+      expect(responses[0].finished).to        be_rejected
+      expect(responses[0].finished.reason).to be(reason)
+      expect(requests[1].served).to           be_rejected
+      expect(requests[1].served.reason).to    be(reason)
     end
   end
 end
-
-describe Hatetepe::Client, "(EventMachine API)" do
-  describe "#initialize"
-
-  describe "#post_init"
-
-  describe "#receive_data"
-
-  describe "#unbind"
-end
-
-describe Hatetepe::Client, "(private API)" do
-  describe "#send_request"
-
-  describe "#receive_response"
-end

data/spec/unit/connection/eventmachine_spec.rb

@@ -0,0 +1,146 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Hatetepe::Connection::EventMachine do
+  let(:connection) { described_class.allocate }
+  let(:callback)   { double('callback', call: nil) }
+  let(:parser)     { double('parser', :<< => nil) }
+  let(:serializer) { double('serializer', serialize: nil) }
+  let(:message)    { default_request }
+
+  before do
+    allow(connection).to             receive(:close_connection_after_writing)
+    allow(HTTP::Parser).to           receive(:new)   { parser }
+    allow(Hatetepe::Serializer).to       receive(:new)   { serializer }
+    allow(Hatetepe::Support::Message).to receive(:build) { message }
+
+    connection.instance_variable_set(:@signature, 123)
+
+    # initialize separately, EM::Connection overloads .new
+    # this smell tells us that we should decouple from EM::Connection
+    connection.send(:initialize, callback)
+  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(Hatetepe::Serializer).to have_received(:new).with(message, writer)
+      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)
+    end
+  end
+
+  describe '#receive_data' do
+    let(:data) { double }
+
+    subject! { connection.receive_data(data) }
+
+    it 'feeds the parser' do
+      expect(parser).to have_received(:<<).with(data)
+    end
+  end
+
+  describe '#unbind' do
+    let(:reason) { double('reason') }
+
+    describe 'following #close' do
+      before { connection.close }
+
+      subject! { connection.unbind(reason) }
+
+      it 'fulfills the promise' do
+        expect(connection.closed).to       be_fulfilled
+        expect(connection.closed.value).to be(:self)
+      end
+    end
+
+    describe 'following remote termination' do
+      subject! { connection.unbind(reason) }
+
+      it 'fulfills the promise' do
+        expect(connection.closed).to be_fulfilled
+        expect(connection.closed.value).to be(reason)
+      end
+    end
+  end
+
+  describe '#on_headers_complete' do
+    let(:parse) { double('parse', call: nil) }
+
+    before { connection.parse(parse) }
+
+    subject! { connection.on_headers_complete(nil) }
+
+    it 'builds the message and passes it on' do
+      expect(Hatetepe::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.parse(proc {})
+      connection.on_headers_complete(nil)
+    end
+
+    subject! do
+      message.finished.on_progress { |chunk| progress << chunk }
+      connection.on_body(chunks[0])
+      connection.on_body(chunks[1])
+    end
+
+    it 'passes chunk to message body' do
+      expect(message.body).to eq(chunks.join)
+      expect(progress).to     eq(chunks)
+    end
+  end
+
+  describe '#on_message_complete' do
+    before do
+      connection.parse(proc {})
+      connection.on_headers_complete(nil)
+    end
+
+    subject! { connection.on_message_complete }
+
+    it 'fulfills the promise' do
+      expect(message.finished).to be_fulfilled
+    end
+  end
+end

data/spec/unit/request_spec.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Hatetepe::Request do
+  describe '#initialize' do
+    subject do
+      Hatetepe::Request.new(:get, '/', { 'Key' => 'value' }, 'hello').freeze
+    end
+
+    its(:http_method) { should be(:get) }
+    its(:uri) { should eq('/') }
+    its(:headers) { should eq('Key' => 'value') }
+    its(:body) { should eq('hello') }
+
+    its(:finished) { should be_a(Hatetepe::Promise) }
+    its(:served) { should be_a(Hatetepe::Promise) }
+
+    describe 'defaults' do
+      subject { Hatetepe::Request.new(:get, '/') }
+
+      its(:headers) { should eq({}) }
+      its(:body) { should eq('') }
+      its(:http_version) { should eq(1.1) }
+    end
+  end
+
+  describe '#http_version=' do
+    subject { Hatetepe::Request.new(:get, '/') }
+
+    before { subject.http_version = 1.0 }
+
+    its(:http_version) { should eq(1.0) }
+  end
+end

data/spec/unit/response_spec.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Hatetepe::Response do
+  describe '#initialize' do
+    subject do
+      Hatetepe::Response.new(200, { 'Key' => 'value' }, 'hello').freeze
+    end
+
+    its(:status) { should be(200) }
+    its(:headers) { should eq('Key' => 'value') }
+    its(:body) { should eq('hello') }
+
+    its(:finished) { should be_a(Hatetepe::Promise) }
+
+    its(:status_name) { should eq('OK') }
+
+    describe 'defaults' do
+      subject { Hatetepe::Response.new(200) }
+
+      its(:headers) { should eq({}) }
+      its(:body) { should eq('') }
+      its(:http_version) { should eq(1.1) }
+    end
+
+    describe 'unknown status' do
+      subject { Hatetepe::Response.new(-1) }
+
+      its(:status) { should be(-1) }
+      its(:status_name) { should eq('Unknown Status') }
+    end
+  end
+
+  describe '#http_version=' do
+    subject { Hatetepe::Response.new(200) }
+
+    before { subject.http_version = 1.0 }
+
+    its(:http_version) { should eq(1.0) }
+  end
+end