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

data/spec/unit/promise_spec.rb

@@ -50,7 +50,7 @@ describe HTTPkit::Promise do
 
     it 'suspends the fiber until the promise state changes' do
       expect(@fulfilled).to be(true)
-      expect(@rejected).to  be(true)
+      expect(@rejected).to be(true)
     end
   end
 end

data/spec/unit/request_spec.rb

@@ -13,7 +13,7 @@ describe HTTPkit::Request do
     its(:uri) { should eq('/a?b=c') }
     its(:headers) { should eq('Key' => 'value') }
 
-    specify { expect(subject.body.read).to eq('hello') }
+    specify { expect(subject.body.to_s).to eq('hello') }
 
     describe 'defaults' do
       subject { HTTPkit::Request.new(:get, '/') }
@@ -21,15 +21,7 @@ describe HTTPkit::Request do
       its(:headers) { should eq({}) }
       its(:http_version) { should eq(1.1) }
 
-      specify { expect(subject.body.read).to be_empty }
+      specify { expect(subject.body.to_s).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

data/spec/unit/response_spec.rb

@@ -11,7 +11,7 @@ describe HTTPkit::Response do
     its(:status) { should be(200) }
     its(:headers) { should eq('Key' => 'value') }
 
-    specify { expect(subject.body.read).to eq('hello') }
+    specify { expect(subject.body.to_s).to eq('hello') }
 
     its(:status_name) { should eq('OK') }
 
@@ -21,7 +21,7 @@ describe HTTPkit::Response do
       its(:headers) { should eq({}) }
       its(:http_version) { should eq(1.1) }
 
-      specify { expect(subject.body.read).to be_empty }
+      specify { expect(subject.body.to_s).to be_empty }
     end
 
     describe 'unknown status' do
@@ -32,20 +32,12 @@ describe HTTPkit::Response do
     end
   end
 
-  describe '#http_version=' do
-    subject { HTTPkit::Response.new(200) }
-
-    before { subject.http_version = 1.0 }
-
-    its(:http_version) { should eq(1.0) }
-  end
-
   describe 'with 1xx status' do
     subject { HTTPkit::Response.new(100) }
 
     its(:status_class) { should be(1) }
 
-    it { should     be_informational }
+    it { should be_informational }
     it { should_not be_successful }
     it { should_not be_redirection }
     it { should_not be_client_error }
@@ -64,7 +56,7 @@ describe HTTPkit::Response do
     its(:status_class) { should be(2) }
 
     it { should_not be_informational }
-    it { should     be_successful }
+    it { should be_successful }
     it { should_not be_redirection }
     it { should_not be_client_error }
     it { should_not be_server_error }
@@ -77,7 +69,7 @@ describe HTTPkit::Response do
 
     it { should_not be_informational }
     it { should_not be_successful }
-    it { should     be_redirection }
+    it { should be_redirection }
     it { should_not be_client_error }
     it { should_not be_server_error }
   end
@@ -90,7 +82,7 @@ describe HTTPkit::Response do
     it { should_not be_informational }
     it { should_not be_successful }
     it { should_not be_redirection }
-    it { should     be_client_error }
+    it { should be_client_error }
     it { should_not be_server_error }
   end
 
@@ -103,6 +95,6 @@ describe HTTPkit::Response do
     it { should_not be_successful }
     it { should_not be_redirection }
     it { should_not be_client_error }
-    it { should     be_server_error }
+    it { should be_server_error }
   end
 end

data/spec/unit/serializer_spec.rb

@@ -0,0 +1,83 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe HTTPkit::Serializer do
+  shared_context :serializer do
+    let(:yielded_chunks) { [] }
+    let(:writer) { proc { |chunk| yielded_chunks << chunk } }
+
+    subject! { described_class.new(message, writer).serialize }
+
+    it 'serializes' do
+      expect(yielded_chunks).to eq(chunks)
+    end
+  end
+
+  describe 'with simple request' do
+    let(:message) do
+      HTTPkit::Request.new(:get, '/asd?k=v', { 'Key' => 'value' }, 'hello')
+    end
+
+    let(:chunks) do
+      ["GET /asd?k=v HTTP/1.1\r\n",
+       "Key: value\r\n\r\n",
+       'hello']
+    end
+
+    include_context :serializer
+  end
+
+  describe 'with simple response' do
+    let(:message) do
+      HTTPkit::Response.new(200, { 'Key' => 'value' }, 'hello')
+    end
+
+    let(:chunks) do
+      ["HTTP/1.1 200 OK\r\n",
+       "Key: value\r\n\r\n",
+       'hello']
+    end
+
+    include_context :serializer
+  end
+
+  describe 'with empty body' do
+    let(:message) do
+      HTTPkit::Response.new(200, 'Key' => 'value')
+    end
+
+    let(:chunks) do
+      ["HTTP/1.1 200 OK\r\n",
+       "Key: value\r\n\r\n",
+       '']
+    end
+
+    include_context :serializer
+  end
+
+  describe 'with unbounded body', reactor: true do
+    let(:message) do
+      HTTPkit::Response.new(200, {}, HTTPkit::Body.new)
+    end
+
+    # With a smaller body it's more difficult to test the base 16 conversion.
+    let(:hello) { 'hello' * 204 }
+
+    let(:chunks) do
+      ["HTTP/1.1 200 OK\r\n",
+       "\r\n",
+       "3fc\r\n#{hello}\r\n",
+       "0\r\n\r\n"]
+    end
+
+    before do
+      EM.next_tick do
+        message.body.write(hello)
+        message.close
+      end
+    end
+
+    include_context :serializer
+  end
+end

data/spec/unit/server/{keep_alive_spec.rb → keep_alive_handler_spec.rb}

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe HTTPkit::Server::KeepAlive do
+describe HTTPkit::Server::KeepAliveHandler do
   let(:config)     { double('config') }
   let(:server)     { double('server') }
   let(:connection) { double('connection') }
@@ -18,7 +18,10 @@ describe HTTPkit::Server::KeepAlive do
   before { object.setup(config, server, connection) }
 
   describe '#close_connection?' do
-    before { object.serve(request, served) }
+    before do
+      allow(request).to receive(:sequence).with(server) { 1 }
+      object.serve(request, served)
+    end
 
     let(:subject) { object.send(:close_connection?, request) }
 

data/spec/unit/server/mandatory_handler_spec.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe HTTPkit::Server::MandatoryHandler do
+  describe '#respond' do
+    let(:handler) { described_class.new }
+    let(:response) { HTTPkit::Response.new(200, headers) }
+    let(:headers) { {} }
+
+    subject! do
+      handler.respond(nil, response) { |_, res| @response = res }
+    end
+
+    # XXX: remove time-dependence
+    it 'sets Server and Date headers' do
+      expect(@response.headers['Server']).to eq("httpkit/#{HTTPkit::VERSION}")
+      expect(@response.headers['Date']).to eq(Time.now.httpdate)
+    end
+
+    describe 'with Server or Date header set to anything' do
+      let(:headers) { { 'Server' => nil, 'Date' => nil } }
+
+      it 'does not override' do
+        expect(@response.headers['Server']).to be(nil)
+        expect(@response.headers['Date']).to be(nil)
+      end
+    end
+  end
+end

data/spec/unit/server/timeouts_handler_spec.rb

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

data/spec/unit/server_spec.rb

@@ -40,6 +40,18 @@ describe HTTPkit::Server do
 
     it 'sets up handlers' do
       expect(handler).to have_received(:setup).with(config, server, 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::Server::MandatoryHandler)
+        expect(config[:handlers][1])
+          .to be_a(HTTPkit::Server::BodyHandler)
+      end
     end
   end
 
@@ -48,7 +60,7 @@ describe HTTPkit::Server do
     let(:response) { open_response }
 
     before do
-      allow(server).to  receive(:respond)
+      allow(server).to receive(:respond)
       allow(handler).to receive(:serve) { |_, served|
         @served = served
         @fiber = Fiber.current
@@ -64,7 +76,7 @@ describe HTTPkit::Server do
     end
 
     it 'notifies the handlers' do
-      expect(handler).to    have_received(:serve)
+      expect(handler).to have_received(:serve)
         .with(request, kind_of(HTTPkit::Promise))
       expect(@fiber).not_to be(Fiber.current)
     end
@@ -75,44 +87,24 @@ describe HTTPkit::Server do
     let(:request)  { open_request }
     let(:response) { open_response(200, headers) }
 
+    before { allow(server).to receive(:finish) }
+
     subject! { server.respond(request, response) }
 
     it 'writes response to underlying connection' do
-      expect(connection).to have_received(:serialize).with(response)
+      expect(connection)
+        .to have_received(:serialize).with(kind_of(response.class))
     end
 
     it 'notifies the handlers' do
-      expect(handler).to have_received(:respond).with(request, response)
+      expect(handler)
+        .to have_received(:respond).with(kind_of(request.class),
+                                         kind_of(response.class))
     end
 
-    it 'sets Server and Date headers' do
-      expect(headers['Server']).to eq("httpkit/#{HTTPkit::VERSION}")
-      expect(headers['Date']).to eq(Time.now.httpdate)
-    end
-
-    describe 'with Server or Date header set to anything' do
-      let(:headers) { { 'Server' => nil, 'Date' => nil } }
-
-      it 'does not override' do
-        expect(headers['Server']).to be(nil)
-        expect(headers['Date']).to   be(nil)
-      end
-    end
-
-    describe 'wiring', reactor: true do
-      let(:request)  { closed_request }
-      let(:response) { open_response }
-
-      before do
-        allow(server).to receive(:finish)
-
-        response.close
-        tick
-      end
-
-      it 'wires up #finish' do
-        expect(server).to have_received(:finish).with(request)
-      end
+    it 'wires up #finish' do
+      expect(server)
+        .to have_received(:finish).with(kind_of(request.class))
     end
   end
 
@@ -125,4 +117,6 @@ describe HTTPkit::Server do
       expect(handler).to have_received(:finish).with(request)
     end
   end
+
+  describe '#setup_connection'
 end

data/spec/unit/support/handler_manager_spec.rb

@@ -4,18 +4,49 @@ require 'spec_helper'
 
 describe HTTPkit::Support::HandlerManager do
   let(:handler) { double('handler', message: nil) }
-  let(:manager) { described_class.new([handler]) }
+  let(:handler2) { double('handler2', message: nil) }
+  let(:manager) { described_class.new([handler, handler2]) }
 
-  describe '#notify' do
+  describe '#invoke' do
     let(:args) { [double, double] }
+    let(:args2) { [double, double] }
 
-    subject! do
-      manager.notify(:message, *args)
-      manager.notify(:nope)
+    describe 'with arguments' do
+      subject! do
+        manager.invoke(:nonexisting)
+        manager.invoke(:message, *args)
+      end
+
+      it 'sends message to the handlers' do
+        expect(handler).to have_received(:message).with(*args)
+        expect(handler2).to have_received(:message).with(*args)
+      end
+
+      it 'returns the arguments' do
+        expect(subject).to eq(args)
+      end
     end
 
-    it 'notifies the handlers' do
-      expect(handler).to have_received(:message).with(*args)
+    describe 'with yielding handler' do
+      let(:non_array) { double }
+
+      before do
+        allow(handler).to receive(:message).and_yield(*args2)
+        allow(handler2).to receive(:message).and_yield(non_array)
+      end
+
+      subject! do
+        manager.invoke(:message, *args)
+      end
+
+      it 'updates arguments for next handler' do
+        expect(handler).to have_received(:message).with(*args)
+        expect(handler2).to have_received(:message).with(*args2)
+      end
+
+      it 'returns the updated arguments' do
+        expect(subject).to eq([non_array])
+      end
     end
   end
 end

data/spec/unit/support/message_spec.rb

@@ -63,15 +63,34 @@ describe HTTPkit::Support::Message do
     end
   end
 
-  describe '#add_extra_headers' do
-    subject! { message.add_extra_headers(foo: '456', bar: '789') }
+  describe '.build' do
+    before do
+      allow(message).to receive(:body_present?) { true }
+      allow(message).to receive(:body_included?) { true }
+    end
+
+    shared_context :message do
+      describe 'without body present' do
+        before do
+          allow(message).to receive(:body_present?) { false }
+        end
 
-    it 'adds the headers that do not exist yet' do
-      expect(message.headers).to eq(foo: '456', bar: '123')
+        it 'closes the message' do
+          expect(subject).to be_closed
+        end
+      end
+
+      describe 'without body included' do
+        before do
+          allow(message).to receive(:body_included?) { false }
+        end
+
+        it 'closes the message' do
+          expect(subject).to be_closed
+        end
+      end
     end
-  end
 
-  describe '.build' do
     before do
       allow(HTTPkit::Body).to receive(:new) { body }
     end
@@ -81,17 +100,20 @@ describe HTTPkit::Support::Message do
         Struct.new(:http_method, :request_url, :headers, :http_version)
           .new('GET', '/', { 'Key' => 'value' }, [1, 1])
       end
-      let(:args) { [:get, '/', { 'Key' => 'value' }, body] }
-      let(:request) { double }
+      let(:args) { [:get, '/', { 'Key' => 'value' }, body, 1.1] }
+
+      before do
+        allow(HTTPkit::Request)
+          .to receive(:new).with(*args).and_return(message)
+      end
 
       subject { HTTPkit::Support::Message.build(parser) }
 
-      it 'returns a Request object' do
-        expect(HTTPkit::Request)
-          .to receive(:new).with(*args).and_return(request)
-        expect(request).to receive(:http_version=).with(1.1)
-        expect(subject).to be(request)
+      it 'returns the Request object' do
+        expect(subject).to be(message)
       end
+
+      include_context :message
     end
 
     describe 'given a parser holding a response' do
@@ -99,17 +121,20 @@ describe HTTPkit::Support::Message do
         Struct.new(:http_method, :status_code, :headers, :http_version)
           .new(nil, 200, { 'Key' => 'value' }, [1, 0])
       end
-      let(:args) { [200, { 'Key' => 'value' }, body] }
-      let(:response) { double }
+      let(:args) { [200, { 'Key' => 'value' }, body, 1.0] }
 
       subject { HTTPkit::Support::Message.build(parser) }
 
-      it 'returns a Response object' do
-        expect(HTTPkit::Response)
-          .to receive(:new).with(*args).and_return(response)
-        expect(response).to receive(:http_version=).with(1.0)
-        expect(subject).to be(response)
+      before do
+        allow(HTTPkit::Response)
+          .to receive(:new).with(*args).and_return(message)
+      end
+
+      it 'returns the Response object' do
+        expect(subject).to be(message)
       end
+
+      include_context :message
     end
   end
 end