hatetepe 0.6.0.pre → 0.6.0.pre.1

data/spec/integration/smoke_spec.rb

@@ -11,11 +11,11 @@ describe 'Smoke test' do
   it 'exchanges request and response' do
     expect(response.status).to  be(200)
     expect(response.headers).to include('Content-Length' => '1')
-    expect(response.body).to    eq('/')
+    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        eq('')
+    expect(request.body.to_s).to   eq('')
   end
 end

data/spec/integration/streaming_spec.rb

@@ -5,25 +5,26 @@ require 'spec_helper'
 describe 'Request body streaming' do
   include_context :server_client_pair
 
-  let(:bodies) { [] }
   let(:chunks) { [] }
 
   before do
     client.perform(request)
     tick(2)
-    intercepted_requests[0].finished.on_progress do |chunk|
-      bodies << intercepted_requests[0].body.dup
-      chunks << chunk
-    end
+    Fiber.new do
+      intercepted_requests[0].body.each do |chunk|
+        chunks << chunk
+      end
+    end.resume
   end
 
-  let(:request) { default_request }
+  let(:request) { open_request }
 
   subject! do
     %w[foo bar baz].each do |chunk|
-      request.finished.progress(chunk)
+      request.body.closed.progress(chunk)
       tick
     end
+    request.close
     tick
   end
 
@@ -31,7 +32,6 @@ describe 'Request body streaming' do
     expect(intercepted_requests[0].headers)
       .to include('Transfer-Encoding' => 'chunked')
 
-    expect(bodies).to eq(%w[foo foobar foobarbaz])
     expect(chunks).to eq(%w[foo bar baz])
   end
 end
@@ -39,7 +39,6 @@ end
 describe 'Response body streaming' do
   include_context :server_client_pair
 
-  let(:bodies) { [] }
   let(:chunks) { [] }
 
   let(:response) { client.request(:get, '/streaming') }
@@ -47,15 +46,12 @@ describe 'Response body streaming' do
   subject! { response }
 
   before do
-    response.finished.on_progress do |chunk|
-      bodies << response.body.dup
+    response.body.each do |chunk|
       chunks << chunk
     end
-    response.finished.sync
   end
 
   it 'progressively receives the body' do
-    expect(bodies).to eq(%w[foo foobar foobarbaz])
     expect(chunks).to eq(%w[foo bar baz])
   end
 end

data/spec/support/handler.rb

@@ -4,28 +4,24 @@ class SpecHandler
   def initialize(config, server, connection)
   end
 
-  def serve(request)
-    response = response_for(request)
-    request.served.fulfill(response)
+  def serve(request, served)
+    served.fulfill(response_for(request))
   end
 
   private
 
   def response_for(request)
     case request.uri
-    when '/'          then root_response.tap(&fulfill)
-    when '/sleep'     then sleep_response.tap(&fulfill)
-    when '/close'     then close_response.tap(&fulfill)
+    when '/sleep'     then sleep_response
+    when '/close'     then close_response
     when '/streaming' then streaming_response
+    else                   echo_response(request)
     end
   end
 
-  def fulfill
-    proc { |response| response.finished.fulfill }
-  end
-
-  def root_response
-    Hatetepe::Response.new(200, { 'Content-Type' => 'text/plain' }, '/')
+  def echo_response(request)
+    Hatetepe::Response.new(200, { 'Content-Type' => 'text/plain' },
+                           request.uri)
   end
 
   def sleep_response
@@ -41,14 +37,14 @@ class SpecHandler
   end
 
   def streaming_response
-    response = Hatetepe::Response.new(200, 'Content-Type' => 'text/plain')
+    response = Hatetepe::Response.new(200, { 'Content-Type' => 'text/plain' },
+                                      Hatetepe::Body.new)
     SpecHelper.defer do
       %w[foo bar baz].each do |chunk|
         SpecHelper.tick(2)
-        response.body << chunk
-        response.finished.progress(chunk)
+        response.body.closed.progress(chunk)
       end
-      response.finished.fulfill
+      response.close
     end
     response
   end

data/spec/support/helper.rb

@@ -24,20 +24,20 @@ module SpecHelper
   end
   module_function :defer
 
-  def default_request(http_method = :get, uri = '/', headers = {})
-    Hatetepe::Request.new(http_method, uri, headers)
+  def open_request(http_method = :get, uri = '/', headers = {})
+    Hatetepe::Request.new(http_method, uri, headers, Hatetepe::Body.new)
   end
 
-  def finished_request(*args)
-    default_request(*args).tap { |request| request.finished.fulfill }
+  def closed_request(*args)
+    open_request(*args).tap(&:close)
   end
 
-  def default_response(status = 200, headers = {})
-    Hatetepe::Response.new(status, headers)
+  def open_response(status = 200, headers = {})
+    Hatetepe::Response.new(status, headers, Hatetepe::Body.new)
   end
 
-  def finished_response(*args)
-    default_response(*args).tap { |response| response.finished.fulfill }
+  def closed_response(*args)
+    open_response(*args).tap(&:close)
   end
 
   def localhost

data/spec/unit/client_spec.rb

@@ -15,7 +15,7 @@ describe Hatetepe::Client do
                          close: nil)
   end
   let(:handler_class) { double('handler_class', new: handler) }
-  let(:handler)       { double('handler', post_init: nil, receive: nil) }
+  let(:handler)       { double('handler', setup: nil, receive: nil) }
 
   before do
     allow(EM).to receive(:connect) { connection }
@@ -39,28 +39,27 @@ describe Hatetepe::Client do
     specify do
       expect(handler_class).to have_received(:new)
         .with(config, subject, connection)
-      expect(handler).to       have_received(:post_init)
+      expect(handler).to       have_received(:setup)
     end
   end
 
   describe '#request' do
     let(:request) do
-      double('request', finished: double('finished', fulfill: nil),
-                        served:   double('served', sync: response))
+      double('request', body: double(closed: double('closed', fulfill: nil)))
     end
     let(:response) { double('response') }
+    let(:served)   { double('served', sync: response) }
 
     before do
-      allow(Hatetepe::Request).to receive(:new) { request }
-      allow(client).to        receive(:perform)
+      allow(Hatetepe::Request).to receive(:new)     { request }
+      allow(client).to            receive(:perform) { served }
     end
 
     subject! { client.request(:head, '/wat') }
 
     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)
+      expect(Hatetepe::Request).to have_received(:new).with(:head, '/wat')
+      expect(client).to            have_received(:perform).with(request)
 
       expect(subject).to be(response)
     end
@@ -95,17 +94,17 @@ describe Hatetepe::Client do
   end
 
   describe '#receive' do
-    let(:request)  { default_request }
-    let(:response) { default_response }
+    let(:request)  { open_request }
+    let(:response) { open_response }
 
     describe 'with outstanding request' do
-      before { client.perform(request) }
+      let!(:served) { client.perform(request) }
 
       subject! { client.receive(response) }
 
       it 'correlates response with request, and notifies handlers' do
-        expect(request.served).to       be_fulfilled
-        expect(request.served.value).to be(response)
+        expect(served).to       be_fulfilled
+        expect(served.value).to be(response)
 
         expect(handler).to have_received(:receive).with(request, response)
       end
@@ -121,8 +120,8 @@ describe Hatetepe::Client do
 
     [:fulfill, :reject].each do |action|
       describe "after #{action}ed response" do
-        let(:request)  { WeakRef.new(finished_request) }
-        let(:response) { WeakRef.new(default_response) }
+        let(:request)  { WeakRef.new(closed_request) }
+        let(:response) { WeakRef.new(open_response) }
 
         before do
           client.perform(request.__getobj__)
@@ -148,23 +147,25 @@ describe Hatetepe::Client do
   end
 
   describe '#teardown' do
-    let(:requests)  { [finished_request, finished_request] }
-    let(:responses) { [default_response] }
+    let(:requests)  { [closed_request, closed_request] }
+    let(:responses) { [open_response] }
     let(:reason)    { double }
 
+    let!(:served) do
+      requests.map { |request| client.perform(request) }
+    end
+
     before do
-      client.perform(requests[0])
-      client.perform(requests[1])
       client.receive(responses[0])
     end
 
     subject! { client.teardown(reason) }
 
     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)
+      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

@@ -7,7 +7,7 @@ describe Hatetepe::Connection::EventMachine do
   let(:callback)   { double('callback', call: nil) }
   let(:parser)     { double('parser', :<< => nil) }
   let(:serializer) { double('serializer', serialize: nil) }
-  let(:message)    { default_request }
+  let(:message)    { open_request }
 
   before do
     allow(connection).to             receive(:close_connection_after_writing)
@@ -17,8 +17,8 @@ describe Hatetepe::Connection::EventMachine do
 
     connection.instance_variable_set(:@signature, 123)
 
-    # initialize separately, EM::Connection overloads .new
-    # this smell tells us that we should decouple from EM::Connection
+    # XXX: initialize separately, EM::Connection overloads .new
+    #      this smell tells us that we should decouple from EM::Connection
     connection.send(:initialize, callback)
   end
 
@@ -120,14 +120,15 @@ describe Hatetepe::Connection::EventMachine do
     end
 
     subject! do
-      message.finished.on_progress { |chunk| progress << chunk }
+      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 eq(chunks.join)
-      expect(progress).to     eq(chunks)
+      expect(message.body.to_s).to eq(chunks.join)
+      expect(progress).to          eq(chunks)
     end
   end
 
@@ -139,8 +140,8 @@ describe Hatetepe::Connection::EventMachine do
 
     subject! { connection.on_message_complete }
 
-    it 'fulfills the promise' do
-      expect(message.finished).to be_fulfilled
+    it 'closes the body' do
+      expect(message.body.closed).to be_fulfilled
     end
   end
 end

data/spec/unit/request_spec.rb

@@ -5,23 +5,23 @@ require 'spec_helper'
 describe Hatetepe::Request do
   describe '#initialize' do
     subject do
-      Hatetepe::Request.new(:get, '/', { 'Key' => 'value' }, 'hello').freeze
+      Hatetepe::Request.new(:get, '/a?b=c',
+                            { 'Key' => 'value' }, 'hello').freeze
     end
 
     its(:http_method) { should be(:get) }
-    its(:uri) { should eq('/') }
+    its(:uri) { should eq('/a?b=c') }
     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) }
+    specify { expect(subject.body.read).to eq('hello') }
 
     describe 'defaults' do
       subject { Hatetepe::Request.new(:get, '/') }
 
       its(:headers) { should eq({}) }
-      its(:body) { should eq('') }
       its(:http_version) { should eq(1.1) }
+
+      specify { expect(subject.body.read).to be_empty }
     end
   end
 

data/spec/unit/response_spec.rb

@@ -10,9 +10,8 @@ describe Hatetepe::Response do
 
     its(:status) { should be(200) }
     its(:headers) { should eq('Key' => 'value') }
-    its(:body) { should eq('hello') }
 
-    its(:finished) { should be_a(Hatetepe::Promise) }
+    specify { expect(subject.body.read).to eq('hello') }
 
     its(:status_name) { should eq('OK') }
 
@@ -20,8 +19,9 @@ describe Hatetepe::Response do
       subject { Hatetepe::Response.new(200) }
 
       its(:headers) { should eq({}) }
-      its(:body) { should eq('') }
       its(:http_version) { should eq(1.1) }
+
+      specify { expect(subject.body.read).to be_empty }
     end
 
     describe 'unknown status' do

data/spec/unit/server/keep_alive_spec.rb

@@ -0,0 +1,67 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Hatetepe::Server::KeepAlive do
+  let(:config)     { double('config') }
+  let(:server)     { double('server') }
+  let(:connection) { double('connection') }
+
+  let(:object)  { described_class.new(config, server, connection) }
+  let(:request) do
+    double('request', http_version: http_version,
+                      headers: { 'Connection' => header })
+  end
+  let(:served)   { double('served', value: response) }
+  let(:response) { double('response', headers: { 'Connection' => header }) }
+
+  describe '#close_connection?' do
+    before { object.serve(request, served) }
+
+    let(:subject) { object.send(:close_connection?, request) }
+
+    describe 'with HTTP/1.0 request' do
+      let(:http_version) { 1.0 }
+
+      describe 'and no header' do
+        let(:header) { nil }
+
+        it { should be(true) }
+      end
+
+      describe 'and Connection: close' do
+        let(:header) { 'close' }
+
+        it { should be(true) }
+      end
+
+      describe 'and Connection: keep-alive' do
+        let(:header) { 'keep-alive' }
+
+        it { should be(false) }
+      end
+    end
+
+    describe 'with HTTP/1.1 request' do
+      let(:http_version) { 1.1 }
+
+      describe 'and no header' do
+        let(:header) { nil }
+
+        it { should be(false) }
+      end
+
+      describe 'and Connection: close' do
+        let(:header) { 'close' }
+
+        it { should be(true) }
+      end
+
+      describe 'and Connection: keep-alive' do
+        let(:header) { 'keep-alive' }
+
+        it { should be(false) }
+      end
+    end
+  end
+end