hatetepe 0.0.4 → 0.2.0

data/spec/spec_helper.rb

@@ -0,0 +1,37 @@
+begin
+  require "awesome_print"
+rescue LoadError; end
+
+require "em-synchrony"
+require "em-synchrony/em-http"
+require "fakefs/safe"
+
+RSpec.configure {|config|
+  config.before {
+    EM.class_eval {
+      @spec_hooks = []
+      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 }
+          end
+        end
+        alias_method :synchrony_without_hooks, :synchrony
+        alias_method :synchrony, :synchrony_with_hooks
+      end
+    }
+  }
+  
+  config.after {
+    EM.class_eval {
+      @spec_hooks = nil
+      class << self
+        remove_method :spec_hooks
+        alias_method :synchrony, :synchrony_without_hooks
+        remove_method :synchrony_with_hooks
+      end
+    }
+  }
+}

data/spec/unit/app_spec.rb

@@ -0,0 +1,108 @@
+require "spec_helper"
+require "hatetepe/app"
+
+describe Hatetepe::App do
+  let(:inner_app) { stub "inner app", :call => response }
+  let(:app) { Hatetepe::App.new inner_app }
+  let(:env) {
+    {
+      "stream.start" => stub("stream.start", :call => nil),
+      "stream.send" => stub("stream.send", :call => nil),
+      "stream.close" => stub("stream.close", :call => nil)
+    }
+  }
+  
+  let(:status) { 123 }
+  let(:headers) { stub "headers" }
+  let(:body) { [stub("chunk#1"), stub("chunk#2")] }
+  let(:response) { [status, headers, body] }
+  
+  context "#initialize(inner_app)" do
+    it "keeps the inner app" do
+      Hatetepe::App.new(inner_app).app.should equal(inner_app)
+    end
+  end
+  
+  context "#call(env)" do
+    it "sets env[async.callback] before #call'ing inner_app" do
+      app.call env
+      
+      app.should_receive(:postprocess) {|e, res|
+        e.should equal(env)
+        res.should equal(response)
+      }
+      env["async.callback"].call response
+    end
+    
+    it "calls #postprocess with the return of inner_app#call(env)" do
+      inner_app.stub :call => response
+      app.should_receive(:postprocess) {|e, res|
+        e.should equal(env)
+        res.should equal(response)
+      }
+      
+      app.call env
+    end
+    
+    let(:error_response) {
+      [500, {"Content-Type" => "text/html"}, ["Internal Server Error"]]
+    }
+    
+    it "responds with 500 when catching an exception" do
+      inner_app.stub(:call) { raise }
+      app.should_receive(:postprocess) {|e, res|
+        res.should == error_response
+      }
+      
+      app.call env
+    end
+    
+    let(:async_response) { [-1, {}, []] }
+    
+    it "catches :async for Thin compatibility" do
+      inner_app.stub(:call) { throw :async }
+      app.should_receive(:postprocess) {|e, res|
+        res.should == async_response
+      }
+      
+      app.call env
+    end
+  end
+  
+  context "#postprocess(env, response)" do
+    it "does nothing if the response status is lighter than 0" do
+      env["stream.start"].should_not_receive :call
+      app.postprocess env, [-1]
+    end
+    
+    it "starts the response stream" do
+      env["stream.start"].should_receive(:call).with([status, headers])
+      app.postprocess env, [status, headers, []]
+    end
+    
+    it "streams the body" do
+      env["stream.send"].should_receive(:call).with(body[0])
+      env["stream.send"].should_receive(:call).with(body[1])
+      app.postprocess env, [status, headers, body]
+    end
+    
+    it "doesn't stream the body if it equals Rack::STREAMING" do
+      env["stream.send"].should_not_receive :call
+      app.postprocess env, [status, headers, Rack::STREAMING]
+    end
+    
+    it "closes the response stream after streaming the body" do
+      env["stream.close"].should_receive :call
+      app.postprocess env, [status, headers, body]
+    end
+    
+    it "closes the response even if streaming the body fails" do
+      body.should_receive(:each).and_raise
+      env["stream.close"].should_receive :call
+      
+      proc {
+        app.postprocess env, [status, headers, body]
+      }.should raise_error
+    end
+  end
+end

data/spec/unit/body_spec.rb

@@ -0,0 +1,198 @@
+require "spec_helper"
+require "hatetepe/body"
+
+describe Hatetepe::Body do
+  let(:body) { Hatetepe::Body.new }
+  
+  it "is deferrable" do
+    body.should respond_to(:callback)
+  end
+  
+  context "#initialize" do
+    it "leaves the IO stream empty" do
+      body.io.length.should be_zero
+    end
+  end
+  
+  context "#initialize(string)" do
+    let(:body) { Hatetepe::Body.new "herp derp" }
+    
+    it "writes the passed string" do
+      body.length.should equal(9)
+      body.io.read.should == "herp derp"
+    end
+  end
+  
+  context "#sync" do
+    let(:conn) { stub "conn", :paused? => true }
+    
+    it "resumes the source connection if any" do
+      body.source = conn
+
+      conn.should_receive :resume
+      Fiber.new { body.succeed }.resume
+      body.sync
+    end
+    
+    it "forwards to EM::Synchrony.sync(body)" do
+      EM::Synchrony.should_receive(:sync).with(body)
+      body.sync
+    end
+  end
+  
+  context "#length" do
+    let(:length) { stub "length" }
+    
+    it "forwards to io#length" do
+      body.io.stub :length => length
+      body.length.should equal(length)
+    end
+  end
+  
+  context "#empty?" do
+    it "returns true if length is zero" do
+      body.stub :length => 0
+      body.empty?.should be_true
+    end
+    
+    it "returns false if length is non-zero" do
+      body.stub :length => 42
+      body.empty?.should be_false
+    end
+  end
+  
+  context "#pos" do
+    let(:pos) { stub "pos" }
+    
+    it "forwards to io#pos" do
+      body.io.stub :pos => pos
+      body.pos.should equal(pos)
+    end
+  end
+  
+  context "#rewind" do
+    let(:rewind) { stub "rewind" }
+    
+    it "forwards to io#rewind" do
+      body.io.stub :rewind => rewind
+      body.rewind.should equal(rewind)
+    end
+  end
+  
+  context "#close_write" do
+    it "forwards to io#close_write" do
+      ret = stub("return")
+      body.io.should_receive(:close_write) { ret }
+      
+      body.close_write.should equal(ret)
+    end
+    
+    it "succeeds the body" do
+      body.should_receive :succeed
+      body.close_write
+    end
+  end
+  
+  context "#closed_write?" do
+    it "forwards to io#closed_write?" do
+      ret = stub("return")
+      body.io.should_receive(:closed_write?) { ret }
+      
+      body.closed_write?.should equal(ret)
+    end
+  end
+  
+  context "#each {|chunk| ... }" do
+    it "yields each written chunk until the body succeeds" do
+      chunks = ["111", "222"]
+      received, succeeded = [], false
+      
+      body << chunks[0]
+      Fiber.new {
+        body.each {|chunk| received << chunk }
+        succeeded = true
+      }.resume
+      received.should == chunks.values_at(0)
+      succeeded.should be_false
+      
+      body << chunks[1]
+      received.should == chunks
+      succeeded.should be_false
+      
+      body.succeed
+      succeeded.should be_true
+    end
+  end
+  
+  context "#read(length, buffer)" do
+    it "waits for the body to succeed" do
+      ret, read = nil, false
+      
+      Fiber.new { body.read; read = true }.resume
+      read.should be_false
+      
+      body.succeed
+      read.should be_true
+    end
+    
+    it "rewinds the body" do
+      body.succeed
+      
+      body.should_receive :rewind
+      body.read
+    end
+    
+    it "forwards to io#read" do
+      body.succeed
+      args, ret = [stub("arg#1"), stub("arg#2")], stub("ret")
+
+      body.io.should_receive(:read).with(*args) { ret }
+      body.read(*args).should equal(ret)
+    end
+  end
+  
+  context "#gets" do
+    it "waits for the body to succeed" do
+      ret, read = nil, false
+      
+      Fiber.new { body.gets; read = true }.resume
+      read.should be_false
+      
+      body.succeed
+      read.should be_true
+    end
+    
+    it "rewinds the body" do
+      body.succeed
+      
+      body.should_receive :rewind
+      body.gets
+    end
+    
+    it "forwards to io#gets" do
+      body.succeed
+      ret = stub("ret")
+
+      body.io.should_receive(:gets) { ret }
+      body.gets.should equal(ret)
+    end
+  end
+  
+  context "#write(chunk)" do
+    it "forwards to io#write" do
+      arg, ret = stub("arg"), stub("ret")
+      body.io.should_receive(:write).with(arg) { ret }
+      
+      body.write(arg).should equal(ret)
+    end
+  end
+  
+  context "#<<(chunk)" do
+    it "forwards to io#<<" do
+      arg, ret = stub("arg"), stub("ret")
+      body.io.should_receive(:<<).with(arg) { ret }
+      
+      body.<<(arg).should equal(ret)
+    end
+  end
+end

data/spec/unit/client_spec.rb

@@ -0,0 +1,270 @@
+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")
+    }
+  }
+  
+  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
+  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" }
+    
+    before {
+      Hatetepe::Client.stub(:start) { client }
+    }
+    
+    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
+    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
+    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
+    end
+  }
+  
+  context "#initialize(config)" do
+    let(:client) { Hatetepe::Client.allocate }
+    
+    it "sets the config" do
+      client.send :initialize, config
+      client.config.should equal(config)
+    end
+  end
+  
+  context "#post_init" do
+    let(:client) {
+      Hatetepe::Client.allocate.tap {|c|
+        c.send :initialize, config
+      }
+    }
+    let(:requests) {
+      [true, nil, nil].map {|response|
+        Hatetepe::Request.new("GET", "/").tap {|request|
+          request.response = response
+        }
+      }
+    }
+    let(:response) { stub "response" }
+    
+    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
+    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
+    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
+    end
+  end
+  
+  context "#<<(request)" do
+    let(:request) { Hatetepe::Request.new "GET", "/" }
+    let(:builder) { client.builder }
+    
+    it "forces a new Host header" do
+      builder.should_receive(:header) {|key, value|
+        value.should == "foohost:12345"
+      }
+      client << request
+    end
+    
+    it "adds the request to #requests" do
+      client << request
+      client.requests.last.should equal(request)
+    end
+    
+    it "feeds the builder" do
+      request.body.write "asdf"
+      
+      builder.should_receive(:request).with request.verb, request.uri
+      builder.should_receive(:headers).with request.headers
+      builder.should_receive(:body).with request.body
+      builder.should_receive(:complete)
+      
+      client << request
+    end
+    
+    it "wraps the builder feeding within a Fiber" do
+      outer, inner = Fiber.current, nil
+      builder.should_receive(:request) {
+        inner = Fiber.current
+      }
+      
+      builder.stub :headers
+      builder.stub :body
+      builder.should_receive(:complete) {
+        inner.should equal(Fiber.current)
+      }
+      
+      client << request
+      outer.should_not equal(inner)
+    end
+  end
+  
+  context "#receive_data(data)" do
+    let(:chunk) { stub "chunk" }
+    
+    it "feeds the parser" do
+      client.parser.should_receive(:<<).with chunk
+      client.receive_data chunk
+    end
+  end
+  
+  context "#stop" do
+    it "closes the connection" do
+      client.should_receive :close_connection_after_writing
+      client.stop
+    end
+  end
+  
+  context "#responses" do
+    let(:requests) {
+      4.times.map {|i| stub "request##{i}", :response => responses[i] }
+    }
+    let(:responses) {
+      2.times.map {|i| stub "response##{i}" }
+    }
+    
+    before {
+      client.stub :requests => requests
+    }
+    
+    it "returns all requests' responses" do
+      client.responses.should == responses
+    end
+  end
+end