hatetepe 0.5.0.pre.1 → 0.5.0.pre.2

data/lib/hatetepe/body.rb

@@ -71,6 +71,17 @@ module Hatetepe
     #
     # @return [undefined]
     def rewind
+      sync
+      rewind!
+    end
+
+    # Rewinds underlying IO without blocking
+    #
+    # TODO this is a hack. the whole blocking/rewinding stuff needs to be
+    #      more though out.
+    #
+    # @api protected
+    def rewind!
       io.rewind
     end
     

data/lib/hatetepe/client.rb

@@ -56,7 +56,7 @@ module Hatetepe::Client
 
     @queue = []
 
-    @app = method(:send_request)
+    @app = proc {|request| send_request(request) }
 
     self.comm_inactivity_timeout = config[:timeout]
     self.pending_connect_timeout = config[:connect_timeout]
@@ -104,7 +104,9 @@ module Hatetepe::Client
         response.body.close_write
       end
 
-      if !response || response.failure?
+      if !response
+        request.fail(nil, self)
+      elsif response.failure?
         request.fail(response)
       else
         request.succeed(response)
@@ -128,7 +130,7 @@ module Hatetepe::Client
   #
   # @api public
   def request(verb, uri, headers = {}, body = [])
-    request =  Hatetepe::Request.new(verb, uri, headers, body)
+    request =  Hatetepe::Request.new(verb, URI(uri), headers, body)
     self    << request
     EM::Synchrony.sync(request)
   end
@@ -182,6 +184,11 @@ module Hatetepe::Client
 
   # @api public
   def self.request(verb, uri, headers = {}, body = [])
+    uri    = URI(uri)
+    client = start(host: uri.host, port: uri.port)
+    client.request(verb, uri, headers, body)
+  ensure
+    client.stop
   end
 
   # Feeds the request into the builder and blocks while waiting for the
@@ -248,4 +255,17 @@ module Hatetepe::Client
       raise "Received response but didn't expect one: #{response.status}"
     end
   end
+
+  module VerbMethods
+    [
+      :get, :head, :options, :put, :post, :delete, :patch, :connect
+    ].each do |verb|
+      define_method(verb) do |uri, headers = {}, body = []|
+        request(verb, uri, headers, body)
+      end
+    end
+  end
+
+  include VerbMethods
+  extend VerbMethods
 end

data/lib/hatetepe/parser.rb

@@ -57,7 +57,7 @@ module Hatetepe
     end
     
     def complete
-      message.body.rewind
+      message.body.rewind!
       message.body.close_write unless message.body.closed_write?
       event! :complete
     end

data/lib/hatetepe/version.rb

@@ -1,3 +1,3 @@
 module Hatetepe
-  VERSION = "0.5.0.pre.1"
+  VERSION = "0.5.0.pre.2"
 end

data/spec/unit/body_spec.rb

@@ -88,11 +88,10 @@ describe Hatetepe::Body do
   end
   
   context "#rewind" do
-    let(:rewind) { stub "rewind" }
-    
-    it "forwards to io#rewind" do
-      body.io.stub :rewind => rewind
-      body.rewind.should equal(rewind)
+    it "blocks and forwards to io#rewind" do
+      body.should_receive(:sync).ordered
+      body.io.should_receive(:rewind).ordered
+      body.rewind
     end
   end
   

data/spec/unit/client_spec.rb

@@ -1,74 +1,165 @@
 require "spec_helper"
 require "hatetepe/client"
 
-describe Hatetepe::Client, "(public API)" do
-  describe ".start"
+describe Hatetepe::Client do
+  let :config do
+    {
+      :host => "127.0.0.1",
+      :port => 4242
+    }
+  end
 
-  describe "#stop"
+  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 "#stop!"
+      client.send(:initialize, config)
+      client.post_init
+    end
+  end
 
-  describe "#wait"
+  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
+  end
 
-  describe ".request"
+  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
+    end
+  end
 
-  describe "#request"
+  describe "#stop!" do
+    it "closes the connection" do
+      client.should_receive(:close_connection)
+      client.stop!
+    end
+  end
 
-  describe "#<<" do
-    let :config do
-      {
-        :host => "127.0.0.1",
-        :port => 4242
-      }
+  describe "#wait" do
+    let :requests do
+      [ Hatetepe::Request.new(:get, "/"), Hatetepe::Request.new(:post, "/") ]
     end
 
-    let :subject do
-      client = Object.new.extend(Hatetepe::Client)
-      client.stub(:send_data)
-      client.stub(:comm_inactivity_timeout=)
-      client.stub(:pending_connect_timeout=)
-      client.send(:initialize, config)
-      client.post_init
-      client
+    before do
+      client.unstub(:send_request)
+      client << requests[0]
+      client << requests[1]
     end
 
-    let :request do
-      Hatetepe::Request.new :head, "/test"
+    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
     end
+  end
+
+  describe ".request" do
+    let(:client)   { stub("client", request: res, stop: nil)  }
+    let(:headers)  { stub("headers") }
+    let(:body)     { stub("body") }
+    let(:res)      { stub("response") }
+    let(:response) { Hatetepe::Client.request(:put, "/test", headers, body) }
+
+    before { Hatetepe::Client.stub(start: client) }
+
+    it "it returns the response" do
+      client.should_receive(:request).with(:put, URI("/test"), headers, body)
+      response.should equal(res)
+    end
+
+    it "stops the client afterwards" do
+      client.should_receive(:stop)
+      response
+    end
+  end
+
+  describe "#request" do
+    let(:body)     { [ "Hello,", " world!" ]            }
+    let(:headers)  { { "Content-Type" => "text/plain" } }
+    let(:request)  { stub("request")                    }
+    let(:response) { stub("response")                   }
+
+    before do
+      client.stub(:<<)
+      Hatetepe::Request.stub(:new => request)
+    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!")
 
-    it "calls the app in a Fiber" do
-      fiber = Fiber.current
-      subject.app.should_receive :call do
-        Fiber.current.should_not equal(fiber)
+        request
       end
 
-      subject << request
+      client.should_receive(:<<).with(request)
+      EM::Synchrony.should_receive(:sync).with(request)
+
+      client.request(:head, "/test?key=value", headers, body)
+    end
+
+    it "returns the response" do
+      EM::Synchrony.stub(:sync => response)
+      client.request(:get, "/").should equal(response)
+    end
+  end
+
+  describe "#<<" do
+    let :request do
+      Hatetepe::Request.new :head, "/test"
     end
 
-    it "fails the request if the response is a failure" do
-      subject.app.stub :call => Hatetepe::Response.new(400)
-      request.should_receive(:fail).with(subject.app.call)
+    describe "if the response is a success" do
+      let(:response) { Hatetepe::Response.new(307) }
 
-      subject << request
+      it "succeeds the request" do
+        request.should_receive(:succeed).with(response)
+        client << request
+      end
     end
 
-    it "fails the request if there is no response (yet)" do
-      subject.app.stub :call => nil
-      request.should_receive(:fail).with(nil)
+    describe "if the response is a failure" do
+      let(:response) { Hatetepe::Response.new(502) }
 
-      subject << request
+      it "fails the request" do
+        request.should_receive(:fail).with(response)
+        client << request
+      end
     end
 
-    it "succeeds the request if the response is a success" do
-      subject.app.stub :call => Hatetepe::Response.new(303)
-      request.should_receive(:succeed).with(subject.app.call)
+    describe "if there is no response" do
+      let(:response) { nil }
 
-      subject << request
+      it "fails the request" do
+        request.should_receive(:fail).with(nil, client)
+        client << request
+      end
     end
   end
 end
 
-describe Hatetepe::Client, "EventMachine API" do
+describe Hatetepe::Client, "(EventMachine API)" do
   describe "#initialize"
 
   describe "#post_init"
@@ -78,7 +169,7 @@ describe Hatetepe::Client, "EventMachine API" do
   describe "#unbind"
 end
 
-describe Hatetepe::Client, "private API" do
+describe Hatetepe::Client, "(private API)" do
   describe "#send_request"
 
   describe "#receive_response"

data/spec/unit/parser_spec.rb

@@ -209,7 +209,7 @@ describe Hatetepe::Parser do
     
     it "finishes the body" do
       parser.on_body {|body|
-        body.should_receive :rewind
+        body.should_receive :rewind!
         body.should_receive :close_write
       }
       do_request

data/spec/unit/server_spec.rb

@@ -2,6 +2,7 @@
 
 require "spec_helper"
 require "hatetepe/server"
+require "rack/lint"
 
 describe Hatetepe::Server, "(public API)" do
   describe ".start(config, &app)" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hatetepe
 version: !ruby/object:Gem::Version
-  version: 0.5.0.pre.1
+  version: 0.5.0.pre.2
   prerelease: 6
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-01 00:00:00.000000000 Z
+date: 2012-06-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: http_parser.rb
@@ -206,7 +206,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.21
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: The HTTP toolkit