hatetepe 0.3.1 → 0.4.0

data/spec/integration/server/keep_alive_spec.rb

@@ -0,0 +1,99 @@
+require "spec_helper"
+require "hatetepe/cli"
+require "hatetepe/server"
+
+describe Hatetepe::Server, "with Keep-Alive" do
+  before do
+    $stderr = StringIO.new
+    
+    FakeFS.activate!
+    File.open "config.ru", "w" do |f|
+      f.write 'run proc {|env| [200, {"Content-Type" => "text/plain"}, []] }'
+    end
+  end
+  
+  after do
+    $stderr = STDERR
+    
+    FakeFS.deactivate!
+    FakeFS::FileSystem.clear
+  end
+  
+  let :client do
+    Hatetepe::Client.start :host => "127.0.0.1", :port => 30001
+  end
+  
+  let :server do
+    Hatetepe::Server.any_instance
+  end
+  
+  it "keeps the connection open for 1 seconds by default" do
+    command "-p 30001", 1.1 do
+      client
+      EM::Synchrony.sleep 0.95
+      client.should_not be_closed
+      EM::Synchrony.sleep 0.1
+      client.should be_closed
+    end
+  end
+  
+  describe "and :timeout option" do
+    it "times out the connection after the specified amount of time" do
+      command "-p 30001 -t 0.5", 0.6 do
+        client
+        EM::Synchrony.sleep 0.45
+        client.should_not be_closed
+        EM::Synchrony.sleep 0.1
+        client.should be_closed_by_remote
+      end
+    end
+  end
+  
+  describe "and :timeout option set to 0" do
+    it "keeps the connection open until the client closes it" do
+      command "-p 30001 -t 0", 2 do
+        client
+        EM::Synchrony.sleep 1.95
+        client.should_not be_closed
+      end
+    end
+  end
+  
+  it "closes the connection if the client sends Connection: close" do
+    command "-p 30001" do
+      client.get("/", "Connection" => "close").tap do |response|
+        response.headers["Connection"].should == "close"
+        EM::Synchrony.sync response.body
+        client.should be_closed_by_remote
+      end
+    end
+  end
+  
+  it "sends Connection: keep-alive if the client also sends it" do
+    command "-p 30001" do
+      client.get("/", "Connection" => "keep-alive").tap do |response|
+        response.headers["Connection"].should == "keep-alive"
+      end
+    end
+  end
+  
+  ["1.0", "0.9"].each do |version|
+    describe "and an HTTP #{version} client" do
+      after { ENV.delete "DEBUG_KEEP_ALIVE" }
+      
+      it "closes the connection after one request" do
+        pending "http_parser.rb doesn't parse HTTP/0.9" if version == "0.9"
+        
+        ENV["DEBUG_KEEP_ALIVE"] = "yes please"
+        
+        command "-p 30001" do
+          client.get("/", {"Connection" => ""}, nil, version).tap do |response|
+            response.headers["Connection"].should == "close"
+            EM::Synchrony.sync response.body
+            client.should be_closed_by_remote
+          end
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -3,41 +3,66 @@ begin
 rescue LoadError; end
 
 require "em-synchrony"
-require "em-synchrony/em-http"
 require "fakefs/safe"
 
-RSpec.configure {|config|
-  config.before(:all) {
-    EM.class_eval {
+RSpec.configure do |config|
+  config.before :each do
+    ENV["RACK_ENV"] = "testing"
+  end
+  
+  config.before :all do
+    EM.class_eval do
       class << self
         attr_reader :spec_hooks
         def synchrony_with_hooks(blk = nil, tail = nil, &block)
           synchrony_without_hooks do
             (blk || block).call
-            @spec_hooks.each {|sh| sh.call }
+            @spec_hooks.each &:call
           end
         end
         alias_method :synchrony_without_hooks, :synchrony
         alias_method :synchrony, :synchrony_with_hooks
       end
-    }
-  }
+    end
+  end
   
-  config.after(:all) {
-    EM.class_eval {
+  config.after :all do
+    EM.class_eval do
       class << self
         remove_method :spec_hooks
         alias_method :synchrony, :synchrony_without_hooks
         remove_method :synchrony_with_hooks
       end
-    }
-  }
+    end
+  end
   
-  config.before(:each) {
+  config.before :each do
     EM.instance_variable_set :@spec_hooks, []
-  }
+  end
   
-  config.after(:each) {
+  config.after :each do
     EM.instance_variable_set :@spec_hooks, nil
-  }
-}
+  end
+  
+  def secure_reactor(timeout = 0.05, &expectations)
+    finished = false
+    location = caller[0]
+    
+    EM.spec_hooks << proc do
+      EM.add_timer(timeout) do
+        EM.stop
+        fail "Timeout exceeded" unless finished
+      end
+    end
+    EM.spec_hooks << proc do
+      expectations.call
+      finished = true
+      EM.next_tick { EM.stop }
+    end
+  end
+  
+  def command(opts, timeout = 0.5, &expectations)
+    secure_reactor timeout, &expectations
+    Hatetepe::CLI.start opts.split
+  end
+end

data/spec/unit/app_spec.rb

@@ -1,9 +1,9 @@
 require "spec_helper"
-require "hatetepe/app"
+require "hatetepe/server"
 
-describe Hatetepe::App do
+describe Hatetepe::Server::App do
   let(:inner_app) { stub "inner app", :call => response }
-  let(:app) { Hatetepe::App.new inner_app }
+  let(:app) { Hatetepe::Server::App.new inner_app }
   let(:env) {
     {
       "stream.start" => proc {},
@@ -19,7 +19,7 @@ describe Hatetepe::App do
   
   context "#initialize(inner_app)" do
     it "keeps the inner app" do
-      Hatetepe::App.new(inner_app).app.should equal(inner_app)
+      Hatetepe::Server::App.new(inner_app).app.should equal(inner_app)
     end
   end
   
@@ -48,7 +48,9 @@ describe Hatetepe::App do
       [500, {"Content-Type" => "text/html"}, ["Internal Server Error"]]
     }
     
-    it "responds with 500 when catching an exception" do
+    it "responds with 500 when catching an error" do
+      ENV.delete "RACK_ENV"
+      
       inner_app.stub(:call) { raise }
       app.should_receive(:postprocess) {|e, res|
         res.should == error_response
@@ -57,6 +59,15 @@ describe Hatetepe::App do
       app.call env
     end
     
+    describe "if server's :env option is testing" do
+      let(:error) { StandardError.new }
+      
+      it "doesn't catch errors" do
+        inner_app.stub(:call) { raise error }
+        expect { app.call env }.to raise_error(error)
+      end
+    end
+    
     let(:async_response) { [-1, {}, []] }
     
     it "catches :async for Thin compatibility" do

data/spec/unit/builder_spec.rb

@@ -78,7 +78,7 @@ describe Hatetepe::Builder do
     before { builder.send :initialize }
     
     it "is a shortcut for #request_line, #headers, #body, #complete" do
-      builder.should_receive(:request_line).with req[0], req[1]
+      builder.should_receive(:request_line).with req[0], req[1], "1.1"
       builder.should_receive(:headers).with req[2]
       builder.should_receive(:body).with req[3]
       builder.should_receive :complete
@@ -86,7 +86,7 @@ describe Hatetepe::Builder do
     end
     
     it "doesn't require a body (fourth element)" do
-      builder.should_receive(:request_line).with req[0], req[1]
+      builder.should_receive(:request_line).with req[0], req[1], "1.1"
       builder.should_receive(:headers).with req[2]
       builder.should_not_receive :body
       builder.request req[0..2]
@@ -142,7 +142,7 @@ describe Hatetepe::Builder do
     before { builder.send :initialize }
     
     it "is a shortcut for #response_line, #headers, #body, #complete" do
-      builder.should_receive(:response_line).with res[0]
+      builder.should_receive(:response_line).with res[0], "1.1"
       builder.should_receive(:headers).with res[1]
       builder.should_receive(:body).with res[2]
       builder.should_receive :complete
@@ -150,7 +150,7 @@ describe Hatetepe::Builder do
     end
     
     it "doesn't require a body (third element)" do
-      builder.should_receive(:response_line).with res[0]
+      builder.should_receive(:response_line).with res[0], "1.1"
       builder.should_receive(:headers).with res[1]
       builder.should_not_receive :body
       builder.response res[0..1]

data/spec/unit/client/pipeline_spec.rb

@@ -0,0 +1,40 @@
+require "spec_helper"
+require "hatetepe/client"
+
+describe Hatetepe::Client::Pipeline do
+  let(:app) { stub "app", :call => nil }
+  let(:pipeline) { Hatetepe::Client::Pipeline.new app }
+  
+  describe "#initialize(app)" do
+    it "sets the app" do
+      pipeline.app.should equal(app)
+    end
+  end
+  
+  let(:requests) {
+    [stub("previous_request"), stub("request")]
+  }
+  let(:lock) { stub "lock" }
+  let(:pending) { {requests.first.object_id => lock} }
+  let(:client) do
+    stub "client", :requests => requests, :pending_transmission => pending
+  end
+  let(:response) { stub "response" }
+  
+  before do
+    requests.last.stub :connection => client
+    EM::Synchrony.stub :sync
+  end
+  
+  describe "#call(request)" do
+    it "waits until the previous request has been transmitted" do
+      EM::Synchrony.should_receive(:sync).with lock
+      pipeline.call requests.last
+    end
+    
+    it "calls the app" do
+      app.should_receive(:call).with(requests.last) { response }
+      pipeline.call(requests.last).should equal(response)
+    end
+  end
+end

data/spec/unit/client_spec.rb

@@ -2,252 +2,408 @@ require "spec_helper"
 require "hatetepe/client"
 
 describe Hatetepe::Client do
-  let(:client) {
-    Hatetepe::Client.allocate.tap {|c|
-      c.send :initialize, config
-      c.stub :send_data
-      c.post_init
-    }
-  }
-  let(:config) {
-    {
-      :host => stub("host", :to_s => "foohost"),
-      :port => stub("port", :to_s => "12345")
-    }
-  }
+  let(:client) do
+    Hatetepe::Client.allocate.tap {|c| c.send :initialize, config }
+  end
+  let(:config) { stub "config" }
   
-  context ".start(config)" do
-    it "attaches a socket to the EventMachine reactor" do
-      EM.should_receive(:connect) {|host, port, klass, cfg|
-        host.should equal(cfg[:host])
-        port.should equal(cfg[:port])
-        klass.should equal(Hatetepe::Client)
-        cfg.should equal(config)
-        client
-      }
-      Hatetepe::Client.start(config).should equal(client)
-    end
+  let(:uri) { "http://example.net:8080/foo" }
+  let(:parsed_uri) { URI.parse uri }
+  let(:request) { Hatetepe::Request.new *request_as_array }
+  let(:request_as_array) { ["GET", "/foo", {"Host" => "example.net:8080"}, [], "1.1"] }
+  let(:headers) { {} }
+  let(:body) { stub "body" }
+  let(:response) { Hatetepe::Response.new 200 }
+  
+  it "inherits from Hatetepe::Connection" do
+    client.should be_a(Hatetepe::Connection)
   end
   
-  context ".request(verb, uri, headers, body)" do
-    let(:verb) { stub "verb" }
-    let(:uri) { "http://foo.bar/baz?key=value" }
-    let(:headers) { stub "headers", :[]= => nil, :[] => nil }
-    let(:body) { stub "body" }
+  describe "#initialize(config)" do
+    it "sets the config" do
+      client.config.should equal(config)
+    end
     
-    before {
-      Hatetepe::Client.stub(:start) { client }
-    }
+    it "creates the builder and parser" do
+      client.parser.should be_a(Hatetepe::Parser)
+      client.builder.should be_a(Hatetepe::Builder)
+    end
     
-    it "starts a client" do
-      Fiber.new {
-        Hatetepe::Client.should_receive(:start) {|config|
-          config[:port].should == URI.parse(uri).port
-          config[:host].should == URI.parse(uri).host
-          client
-        }
-        Hatetepe::Client.request "GET", uri
-      }.resume
-    end
-    
-    let(:user_agent) { stub "user agent" }
-    
-    it "sets an appropriate User-Agent header if there is none" do
-      Fiber.new {
-        client.should_receive(:<<) {|request|
-          request.headers["User-Agent"].should == "hatetepe/#{Hatetepe::VERSION}"
-        }
-        Hatetepe::Client.request "GET", uri
-        
-        client.should_receive(:<<) {|request|
-          request.headers["User-Agent"].should equal(user_agent)
-        }
-        Hatetepe::Client.request "GET", uri, "User-Agent" => user_agent
-      }.resume
-    end
-    
-    it "uses an empty, write-closed Body as default" do
-      Fiber.new {
-        client.should_receive(:<<) {|request|
-          request.body.closed_write?.should be_true
-          request.body.should be_empty
-        }
-        Hatetepe::Client.request verb, uri
-      }.resume
-    end
-    
-    it "sends the request" do
-      Fiber.new {
-        client.should_receive(:<<) {|request|
-          request.verb.should equal(verb)
-          request.uri.should == URI.parse(uri).request_uri
-          request.headers.should equal(headers)
-          request.body.should equal(body)
-        }
-        Hatetepe::Client.request verb, uri, headers, body
-      }.resume
-    end
-    
-    it "waits for the request to succeed" do
-      request, succeeded = nil, false
-      Fiber.new {
-        client.should_receive(:<<) {|req| request = req }
-        Hatetepe::Client.request verb, uri
-        succeeded = true
-      }.resume
-      
-      succeeded.should be_false
-      request.succeed
-      succeeded.should be_true
+    it "creates the requests list" do
+      client.requests.should be_an(Array)
+      client.requests.should be_empty
+    end
+    
+    it "creates the lists of requests pending transmission or response" do
+      client.pending_transmission.should be_a(Hash)
+      client.pending_transmission.should be_empty
+      client.pending_response.should be_a(Hash)
+      client.pending_response.should be_empty
+    end
+    
+    it "builds the app" do
+      client.app.should be_a(Hatetepe::Client::KeepAlive)
+      client.app.app.should be_a(Hatetepe::Client::Pipeline)
+      client.app.app.app.should == client.method(:send_request)
     end
   end
   
-  [:get, :head].each {|verb|
-    context ".#{verb}(uri, headers)" do
-      let(:uri) { stub "uri" }
-      let(:headers) { stub "headers" }
-      let(:response) { stub "response" }
-      
-      it "forwards to .request('#{verb.to_s.upcase}')" do
-        Hatetepe::Client.should_receive(:request) {|verb, urii, hedders|
-          verb.should == verb.to_s.upcase
-          urii.should equal(uri)
-          hedders.should equal(headers)
-          response
-        }
-        Hatetepe::Client.send(verb, uri, headers).should equal(response)
-      end
+  describe "#post_init" do
+    it "wires the builder and parser" do
+      client.post_init
+      client.builder.on_write[0].should == client.method(:send_data)
+      client.parser.on_response[0].should == client.method(:receive_response)
     end
-  }
+    
+    it "enables processing" do
+      client.post_init
+      client.processing_enabled.should be_true
+    end
+  end
   
-  [:options, :post, :put, :delete, :trace, :connect].each {|verb|
-    context ".#{verb}(uri, headers, body)" do
-      let(:uri) { stub "uri" }
-      let(:headers) { stub "headers" }
-      let(:response) { stub "response" }
-      let(:body) { stub "body" }
-      
-      it "forwards to .request('#{verb.to_s.upcase}')" do
-        Hatetepe::Client.should_receive(:request) {|verb, urii, hedders, bodeh|
-          verb.should == verb.to_s.upcase
-          urii.should equal(uri)
-          hedders.should equal(headers)
-          bodeh.should equal(body)
-          response
-        }
-        Hatetepe::Client.send(verb, uri, headers, body).should equal(response)
-      end
+  describe "#receive_data(data)" do
+    let(:data) { stub "data" }
+    
+    it "feeds the data into the parser" do
+      client.parser.should_receive(:<<).with data
+      client.receive_data data
+    end
+    
+    let(:error) { StandardError.new "alarm! eindringlinge! alarm!" }
+    
+    it "stops the client if it catches an error" do
+      client.parser.should_receive(:<<).and_raise error
+      client.should_receive :close_connection
+      proc { client.receive_data data }.should raise_error(error)
     end
-  }
+  end
   
-  context "#initialize(config)" do
-    let(:client) { Hatetepe::Client.allocate }
+  describe "#send_request(request)" do
+    let(:entry) { stub "entry" }
     
-    it "sets the config" do
-      client.send :initialize, config
-      client.config.should equal(config)
+    before do
+      client.pending_transmission[request.object_id] = entry
+      client.builder.stub :request
+      entry.stub :succeed
+      EM::Synchrony.stub :sync
+    end
+    
+    it "feeds the request into the builder" do
+      client.builder.should_receive(:request).with request_as_array
+      client.send_request request
+    end
+    
+    it "succeeds the request's entry in the pending transmission list" do
+      entry.should_receive :succeed
+      client.send_request request
+    end
+    
+    it "adds the request to the pending response list and waits" do
+      EM::Synchrony.should_receive(:sync) do |syncee|
+        syncee.should respond_to(:succeed)
+        client.pending_response[request.object_id].should equal(syncee)
+      end
+      client.send_request request
+    end
+    
+    it "returns the waiting result" do
+      EM::Synchrony.should_receive(:sync).and_return response
+      client.send_request(request).should equal(response)
+    end
+    
+    it "makes sure the request gets removed from the pending response list" do
+      EM::Synchrony.should_receive(:sync).and_raise StandardError
+      client.send_request request rescue nil
+      client.pending_response.should be_empty
     end
   end
   
-  context "#post_init" do
-    let(:client) {
-      Hatetepe::Client.allocate.tap {|c|
-        c.send :initialize, config
-      }
-    }
+  describe "#receive_response(response)" do
     let(:requests) {
-      [true, nil, nil].map {|response|
-        Hatetepe::Request.new("GET", "/").tap {|request|
-          request.response = response
-        }
-      }
+      [
+        stub("request_with_response", :response => stub("response")),
+        request,
+        stub("another_request", :response => nil)
+      ]
     }
-    let(:response) { stub "response", :body => Hatetepe::Body.new }
+    let(:id) { requests[1].object_id }
     
-    before {
-      client.post_init
-      client.requests.push *requests
-    }
-    
-    context "'s on_response handler" do
-      it "associates the response with a request" do
-        client.parser.on_response[0].call response
-        requests[1].response.should equal(response)
-      end
+    before do
+      client.stub :requests => requests
+      client.pending_response[id] = stub("entry", :succeed => nil)
     end
     
-    context "'s on_headers handler" do
-      it "succeeds the response's request" do
-        requests[1].response = response
-        requests[1].should_receive(:succeed).with response
-        client.parser.on_headers[0].call
-      end
+    it "succeeds the pending response list entry of the first request without a response" do
+      client.pending_response[id].should_receive(:succeed).with response
+      client.receive_response response
     end
     
-    context "'s on_write handler" do
-      it "forwards to EM's send_data" do
-        client.builder.on_write[0].should == client.method(:send_data)
-      end
+    it "associates the response with the corresponding request" do
+      client.receive_response response
+      request.response.should equal(response)
     end
   end
   
-  context "#<<(request)" do
-    let(:request) { Hatetepe::Request.new "GET", "/" }
-    let(:builder) { client.builder }
+  describe "#<<(request)" do
+    let(:fiber) { stub "fiber", :resume => nil }
+    let(:app) { stub "app", :call => response }
     
-    it "forces a new Host header" do
-      builder.should_receive(:header) {|key, value|
-        value.should == "foohost:12345"
-      }
+    before do
+      client.processing_enabled = true
+      client.stub :app => app
+      Fiber.stub(:new) {|blk| blk.call; fiber }
+    end
+    
+    it "sets the request's connection" do
+      request.should_receive(:connection=).with client
       client << request
     end
     
-    it "adds the request to #requests" do
+    it "adds the request to the requests list" do
+      app.should_receive :call do
+        client.requests[-1].should equal(request)
+      end
       client << request
-      client.requests.last.should equal(request)
+      client.requests.should be_empty
     end
     
-    it "feeds the builder" do
-      request.body.write "asdf"
-      
-      builder.should_receive(:request_line).with request.verb, request.uri
-      builder.should_receive(:headers).with request.headers
-      builder.should_receive(:body).with request.body
-      builder.should_receive(:complete)
+    it "fails and ignores the request if processing is disabled" do
+      client.processing_enabled = false
+      request.should_receive :fail
+      app.should_not_receive :call
       
       client << request
+      request.connection.should equal(client)
     end
     
-    it "wraps the builder feeding within a Fiber" do
-      outer, inner = Fiber.current, nil
-      builder.should_receive(:request_line) {
-        inner = Fiber.current
-      }
-      
-      builder.stub :headers
-      builder.stub :body
-      builder.should_receive(:complete) {
-        inner.should equal(Fiber.current)
-      }
-      
+    it "adds the request to the pending transmission list" do
+      app.should_receive :call do |req|
+        client.pending_transmission[req.object_id].should respond_to(:succeed)
+      end
+      client << request
+    end
+    
+    it "calls the app" do
+      app.should_receive(:call).with request
       client << request
-      outer.should_not equal(inner)
+    end
+    
+    it "sets the response" do
+      request.should_receive(:response=).with response
+      client << request
+    end
+    
+    it "succeeds the request if the response status indicates success" do
+      request.should_receive(:succeed).with response
+      client << request
+    end
+    
+    it "fails the request if the response status indicates failure" do
+      response.status = 403
+      request.should_receive(:fail).with response
+      client << request
+    end
+    
+    it "fails the request if no response has been received" do
+      app.stub :call => nil
+      request.should_receive(:fail).with nil
+      client << request
+    end
+    
+    it "makes sure the request gets removed from the pending transmission list" do
+      app.should_receive(:call).and_raise StandardError
+      client << request rescue nil
+      client.pending_transmission.should be_empty
     end
   end
   
-  context "#receive_data(data)" do
-    let(:chunk) { stub "chunk" }
+  describe "#request(verb, uri, headers, body)" do
+    let :config do
+      {
+        :host => "example.org",
+        :port => 8080
+      }
+    end
+    
+    before do
+      EM::Synchrony.stub :sync
+      client.stub :<<
+    end
+    
+    it "sets a Host header if none is set" do
+      client.should_receive :<< do |request|
+        request.headers["Host"].should == "example.org:8080"
+      end
+      client.request :get, uri
+    end
+    
+    it "sets the User-Agent header" do
+      client.should_receive :<< do |request|
+        request.headers["User-Agent"].should == "hatetepe/#{Hatetepe::VERSION}"
+      end
+      client.request :get, uri
+    end
+    
+    let(:user_agent) { stub "user-agent" }
+    
+    it "doesn't override an existing User-Agent header" do
+      client.should_receive :<< do |request|
+        request.headers["User-Agent"].should equal(user_agent)
+      end
+      client.request :get, uri, "User-Agent" => user_agent
+    end
+    
+    describe "with Content-Type: application/x-www-form-urlencoded" do
+      let :headers do
+        {"Content-Type" => "application/x-www-form-urlencoded"}
+      end
+      
+      let :body do
+        [
+          stub("body#1", :length => 12),
+          stub("body#2", :length => 13),
+          stub("body#3", :length => 14)
+        ]
+      end
+      
+      it "computes the body's length" do
+        client.should_receive :<< do |request|
+          request.headers["Content-Length"].should equal(39)
+        end
+        client.request :get, uri, headers, body
+      end
+      
+      it "sets Content-Length to 0 if no body was passed" do
+        client.should_receive :<< do |request|
+          request.headers["Content-Length"].should equal(0)
+        end
+        client.request :get, uri, headers
+      end
+    end
+    
+    it "doesn't close the body" do
+      body.should_not_receive :close_write
+      client.request :get, uri, {}, body
+    end
+    
+    it "passes the request to #<<" do
+      client.should_receive :<< do |request|
+        request.verb.should == "GET"
+        request.uri.should == uri
+        request.headers.should == headers
+        request.body.should == [body]
+      end
+      client.request :get, uri, headers, body
+    end
     
-    it "feeds the parser" do
-      client.parser.should_receive(:<<).with chunk
-      client.receive_data chunk
+    it "waits until the requests succeeds" do
+      EM::Synchrony.should_receive(:sync).with kind_of(Hatetepe::Request)
+      client.request :get, uri
+    end
+    
+    it "closes the response body if the request's method was HEAD" do
+      Hatetepe::Request.any_instance.stub :response => response
+      response.body.should_receive :close_write
+      client.request :head, uri
+    end
+    
+    it "returns the response" do
+      Hatetepe::Request.any_instance.stub :response => response
+      client.request(:get, uri).should equal(response)
     end
   end
   
-  context "#stop" do
-    it "closes the connection" do
+  describe "#stop" do
+    before do
+      response.stub :body => stub("body")
+      client.stub :requests => [request,
+                                stub("another_request", :response => response)]
+      client.stub :close_connection
+    end
+    
+    it "waits for the last request to complete and then stops" do
+      EM::Synchrony.should_receive(:sync).with(client.requests.last) { response }
+      EM::Synchrony.should_receive(:sync).with response.body
       client.should_receive :close_connection
       client.stop
     end
   end
+  
+  describe "#wrap_body(body)" do
+    let(:body) { stub "body" }
+    
+    it "doesn't modify a body that responds to #each" do
+      body.stub :each
+      client.wrap_body(body).should equal(body)
+    end
+    
+    it "makes a body that responds to #read enumerable" do
+      body.stub :read => stub("#read")
+      client.wrap_body(body).should == [body.read]
+    end
+    
+    it "makes other bodies enumerable" do
+      client.wrap_body(body).should == [body]
+    end
+    
+    it "makes an empty body enumerable" do
+      client.wrap_body(nil).should == []
+    end
+  end
+  
+  describe ".start(config)" do
+    let(:config) { {:host => "0.0.0.0", :port => 1234} }
+    let(:client) { stub "client" }
+    
+    it "starts an EventMachine connection and returns it" do
+      EM.should_receive(:connect).with(config[:host], config[:port],
+                                       Hatetepe::Client, config) { client }
+      Hatetepe::Client.start(config).should equal(client)
+    end
+  end
+  
+  describe ".request(verb, uri, headers, body)" do
+    let(:client) { stub "client" }
+    
+    before do
+      Hatetepe::Client.stub :start => client
+      client.stub :request => response, :stop => nil
+    end
+    
+    it "starts a client" do
+      Hatetepe::Client.should_receive(:start).with :host => parsed_uri.host,
+                                                   :port => parsed_uri.port
+      Hatetepe::Client.request :get, uri
+    end
+    
+    it "feeds the request into the client and returns the response" do
+      client.should_receive(:request).with(:get, parsed_uri.request_uri,
+                                           headers, body) { response }
+      Hatetepe::Client.request(:get, uri, headers, body).should equal(response)
+    end
+    
+    it "stops the client when the response has finished" do
+      client.should_receive :stop
+      Hatetepe::Client.request :get, uri
+    end
+  end
+  
+  [:get, :head, :post, :put, :delete,
+   :options, :trace, :connect].each do |verb|
+     describe "##{verb}(uri, headers, body)" do
+       it "delegates to #request" do
+         client.should_receive(:request).with(verb, uri, headers, body) { response }
+         client.send(verb, uri, headers, body).should equal(response)
+       end
+     end
+     
+     describe ".#{verb}(uri, headers, body)" do
+       let(:client) { Hatetepe::Client }
+       
+       it "delegates to .request" do
+         client.should_receive(:request).with(verb, uri, headers, body) { response }
+         client.send(verb, uri, headers, body).should equal(response)
+       end
+     end
+   end
 end