hatetepe 0.3.1 → 0.4.0

data/spec/unit/connection_spec.rb

@@ -0,0 +1,64 @@
+require "spec_helper"
+require "hatetepe/connection"
+
+describe Hatetepe::Connection do
+  let(:conn) { Hatetepe::Connection.allocate }
+  
+  let(:peername) { "\x02\x00\x86\xF6\x7F\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00" }
+  let(:address) { "127.0.0.1" }
+  let(:port) { 34550 }
+  
+  before { conn.stub :get_peername => peername }
+  
+  it "inherits from EM::Connection" do
+    conn.should be_an(EM::Connection)
+  end
+  
+  describe "#remote_address" do
+    it "returns the remote peer's address" do
+      conn.remote_address.should == address
+    end
+  end
+  
+  describe "#remote_port" do
+    it "returns the remote peer's port" do
+      conn.remote_port.should == port
+    end
+  end
+  
+  describe "#close_connection" do
+    before { EM::Connection.any_instance.stub :close_connection }
+    
+    it "sets the closed-by-self flag" do
+      pending "How to test a call to super?"
+      
+      conn.close_connection
+      conn.should be_closed
+      conn.should be_closed_by_self
+    end
+    
+    let(:arg) { stub "arg" }
+    
+    it "calls EM::Connection.close_connection" do
+      pending "How to test a call to super?"
+      
+      EM::Connection.any_instance.should_receive(:close_connection).with arg
+      conn.close_connection arg
+    end
+  end
+  
+  describe "#unbind" do
+    it "sets the closed-by-remote flag" do
+      conn.unbind
+      conn.should be_closed
+      conn.should be_closed_by_remote
+    end
+    
+    it "doesn't overwrite an existing closed-by flag" do
+      conn.stub :closed? => true
+      conn.unbind
+      conn.should be_closed
+      conn.should_not be_closed_by_remote
+    end
+  end
+end

data/spec/unit/parser_spec.rb

@@ -90,14 +90,15 @@ describe Hatetepe::Parser do
   }
   
   context "#on_request {|request| ... }" do
-    it "evals the block when a request line comes in" do
+    it "evals the block when the request headers have arrived" do
       block.should_receive(:call) {|request|
         request.should equal(parser.message)
         
         request.verb.should == "POST"
         request.uri.should == "/"
         request.http_version.should == "1.1"
-        request.headers.should be_empty
+        request.headers.should == {"Transfer-Encoding" => "chunked",
+                                   "Bar" => "baz"}
       }
       
       parser.on_request &block

data/spec/unit/proxy_spec.rb

@@ -1,16 +1,16 @@
 require "spec_helper"
-require "hatetepe/proxy"
+require "hatetepe/server"
 
-describe Hatetepe::Proxy do
+describe Hatetepe::Server::Proxy do
   let(:app) { stub "app" }
   
   describe "#initialize(app)" do
     it "sets the app" do
-      Hatetepe::Proxy.new(app).app.should equal(app)
+      Hatetepe::Server::Proxy.new(app).app.should equal(app)
     end
   end
   
-  let(:proxy) { Hatetepe::Proxy.new app }
+  let(:proxy) { Hatetepe::Server::Proxy.new app }
   let(:target) { stub "target" }
   let(:env) { {} }
   let(:client) { stub "client", :<< => nil }
@@ -133,22 +133,13 @@ describe Hatetepe::Proxy do
       proxy.build_request(env, target).uri.should == "/bar/foo"
     end
     
-    it "sets X-Forwarded-For header" do
-      xff = proxy.build_request(env, target).headers["X-Forwarded-For"]
-      env["REMOTE_ADDR"].should == xff
-    end
-    
-    it "adds the target to Host header" do
-      host = "localhost:3000"
-      proxy.build_request(env, target).headers["Host"].should == host
-      
-      base_request.headers["Host"] = host
-      host = "localhost:3000, localhost:3000"
-      proxy.build_request(env, target).headers["Host"].should == host
-    end
-    
     it "builds a new request" do
       proxy.build_request(env, target).should_not equal(base_request)
     end
+    
+    it "sets version to HTTP/1.1" do
+      base_request.http_version = "1.0"
+      proxy.build_request(env, target).http_version.should == "1.1"
+    end
   end
 end

data/spec/unit/rack_handler_spec.rb

@@ -31,17 +31,6 @@ describe Rack::Handler::Hatetepe do
       Rack::Handler::Hatetepe.run app, options
     end
     
-    it "yields the server" do
-      Hatetepe::Server.stub :start => server
-      
-      srvr = nil
-      Rack::Handler::Hatetepe.run(app) {|s|
-        srvr = s
-        EM.stop
-      }
-      srvr.should equal(server)
-    end
-    
     it "can be stopped by sending SIGTERM or SIGINT" do
       EM.should_receive(:synchrony) {|&block| block.call }
       
@@ -63,8 +52,9 @@ describe Rack::Handler::Hatetepe do
       Hatetepe::Server.should_receive(:start) {|opts|
         opts[:host].should == "0.0.0.0"
         opts[:port].should == 8080
+        EM.stop
       }
-      Rack::Handler::Hatetepe.run(app) { EM.stop }
+      Rack::Handler::Hatetepe.run app
     end
   end
 end

data/spec/unit/server_spec.rb

@@ -5,16 +5,13 @@ describe Hatetepe::Server do
   let(:server) {
     Hatetepe::Server.allocate.tap {|s|
       s.send :initialize, config
+      s.stub :comm_inactivity_timeout=
       s.post_init
       s.requests << request
     }
   }
-  let(:request) { stub "request", :to_hash => env }
-  let(:env) {
-    {
-      "rack.input" => Hatetepe::Body.new
-    }
-  }
+  let(:request) { Hatetepe::Request.new :get, "/" }
+  let(:env) { request.to_h }
   
   let(:app) { stub "app" }
   let(:host) { "127.0.4.1" }
@@ -25,10 +22,24 @@ describe Hatetepe::Server do
       :app => app,
       :host => host,
       :port => port,
-      :errors => errors
+      :errors => errors,
+      :timeout => 0.0123
     }
   }
   
+  before do
+    server.stub :sockaddr => [42424, "127.0.42.1"]
+    @old_env, ENV["RACK_ENV"] = ENV["RACK_ENV"], "testing"
+  end
+  
+  after do
+    ENV["RACK_ENV"] = @old_env
+  end
+  
+  it "inherits from Hatetepe::Connection" do
+    server.should be_a(Hatetepe::Connection)
+  end
+  
   context ".start(config)" do
     it "starts an EventMachine server" do
       args = [host, port, Hatetepe::Server, config]
@@ -40,23 +51,11 @@ describe Hatetepe::Server do
   
   context "#initialize(config)" do
     let(:server) { Hatetepe::Server.allocate }
-    let(:builder) { stub "app builder", :to_app => to_app }
-    let(:to_app) { stub "to_app" }
-
-    it "builds the app" do
-      Rack::Builder.stub :new => builder
-      builder.should_receive(:use).with Hatetepe::Pipeline
-      builder.should_receive(:use).with Hatetepe::App
-      builder.should_receive(:use).with Hatetepe::Proxy
-      builder.should_receive(:run).with app
-      
-      server.send :initialize, config
-      server.app.should equal(to_app)
-    end
     
     it "sets up the error stream" do
       server.send :initialize, config
       server.errors.should equal(errors)
+      server.config[:errors].should be_nil
     end
     
     it "uses stderr as default error stream" do
@@ -64,30 +63,63 @@ describe Hatetepe::Server do
       server.send :initialize, config
       server.errors.should equal($stderr)
     end
+    
+    it "assumes a default connection inactivity timeout of 1 seconds" do
+      server.send :initialize, {}
+      server.config[:timeout].should equal(1)
+    end
   end
   
   context "#post_init" do
-    let(:server) {
-      Hatetepe::Server.allocate.tap {|s| s.post_init }
-    }
+    let :server do
+      Hatetepe::Server.allocate.tap do |s|
+        s.send :initialize, config
+        s.stub :comm_inactivity_timeout=
+      end
+    end
     
     it "sets up the request queue" do
+      server.post_init
       server.requests.should be_an(Array)
       server.requests.should be_empty
     end
     
     it "sets up the parser" do
+      server.post_init
       server.parser.should respond_to(:<<)
       server.parser.on_request[0].should == server.requests.method(:<<)
     end
     
     it "sets up the builder" do
+      server.post_init
       server.builder.on_write[0].should == server.method(:send_data)
     end
+    
+    it "builds the app" do
+      server.post_init
+      server.app.should be_a(Hatetepe::Server::Pipeline)
+      server.app.app.should be_a(Hatetepe::Server::App)
+      server.app.app.app.should be_a(Hatetepe::Server::KeepAlive)
+      server.app.app.app.app.should be_a(Hatetepe::Server::Proxy)
+      server.app.app.app.app.app.should equal(app)
+    end
+    
+    it "starts the connection inactivity tracking" do
+      server.should_receive(:comm_inactivity_timeout=).with 0.0123
+      server.post_init
+    end
+    
+    it "enables request processing" do
+      server.post_init
+      server.processing_enabled.should be_true
+    end
   end
   
   context "#receive_data(data)" do
-    before { server.stub :close_connection_after_writing }
+    before do
+      ENV.delete "RACK_ENV"
+      server.stub :close_connection
+    end
     
     it "feeds data into the parser" do
       data = stub("data")
@@ -102,13 +134,29 @@ describe Hatetepe::Server do
       server.receive_data "irrelevant data"
     end
     
+    it "re-raises parsing errors if RACK_ENV is testing" do
+      ENV["RACK_ENV"] = "testing"
+      server.parser.should_receive(:<<).and_raise Hatetepe::ParserError
+      
+      expect {
+        server.receive_data "irrelevant data"
+      }.to raise_error(Hatetepe::ParserError)
+    end
+    
     it "closes the connection when catching an exception" do
-      server.parser.should_receive(:<<).and_raise
+      server.parser.should_receive(:<<).and_raise Exception
       server.should_receive :close_connection_after_writing
       
       server.receive_data ""
     end
     
+    it "re-raises caught exceptions" do
+      ENV["RACK_ENV"] = "testing"
+      server.parser.should_receive(:<<).and_raise Exception
+      
+      expect { server.receive_data "" }.to raise_error(Exception)
+    end
+    
     it "logs caught exceptions" do
       server.parser.should_receive(:<<).and_raise "error message"
       errors.should_receive(:<<) {|str|
@@ -121,6 +169,11 @@ describe Hatetepe::Server do
   end
   
   context "#process" do
+    before do
+      request.stub :to_h => env
+      app.stub :call => [-1]
+    end
+    
     it "puts useful stuff into env[]" do
       app.should_receive(:call) {|e|
         e.should equal(env)
@@ -135,6 +188,9 @@ describe Hatetepe::Server do
         e["SERVER_NAME"].should == host
         e["SERVER_NAME"].should_not equal(host)
         e["SERVER_PORT"].should == String(port)
+        e["REMOTE_ADDR"].should == server.remote_address
+        e["REMOTE_ADDR"].should_not equal(server.remote_address)
+        e["REMOTE_PORT"].should == String(server.remote_port)
         e["HTTP_HOST"].should == "#{host}:#{port}"
         
         [-1]
@@ -150,6 +206,32 @@ describe Hatetepe::Server do
       }
       server.process
     end
+    
+    it "is a no-op if processing is disabled" do
+      server.processing_enabled = false
+      app.should_not_receive :call
+      server.process
+    end
+    
+    let(:another_request) { Hatetepe::Request.new :get, "/asdf" }
+    
+    it "disables the connection timeout until the last request is finished" do
+      server.requests << another_request
+      
+      server.should_receive(:comm_inactivity_timeout=).with 0
+      server.process
+      
+      server.should_not_receive(:comm_inactivity_timeout=).with config[:timeout]
+      server.requests.delete request
+      request.succeed
+      
+      server.rspec_verify
+      server.rspec_reset
+      
+      server.should_receive(:comm_inactivity_timeout=).with config[:timeout]
+      server.requests.delete another_request
+      another_request.succeed
+    end
   end
   
   context "env[stream.start].call(response)" do
@@ -176,22 +258,11 @@ describe Hatetepe::Server do
       server.process
     end
     
+    # TODO this should be moved to a Server::Pipeline spec
     it "waits for the previous request's response to finish" do
       server.builder.should_not_receive :response
       server.process
     end
-    
-    it "initiates the response" do
-      server.builder.should_receive(:response_line) {|code|
-        code.should equal(response[0])
-      }
-      server.builder.should_receive(:headers) {|headers|
-        headers["Key"].should equal(response[1]["Key"])
-        headers["Server"].should == "hatetepe/#{Hatetepe::VERSION}"
-      }
-      previous.succeed
-      server.process
-    end
   end
   
   context "env[stream.send].call(chunk)" do
@@ -206,55 +277,78 @@ describe Hatetepe::Server do
   
   context "env[stream.close].call" do
     before {
-      server.stub :close_connection
       server.builder.stub :complete
       request.stub :succeed
     }
     
-    it "completes the response" do
-      server.builder.should_receive :complete
+    it "leaves the connection open" do
+      server.should_not_receive :close_connection
       app.stub(:call) {|e|
+        server.requests << stub("another request")
         e["stream.close"].call
         [-1]
       }
       server.process
     end
     
-    it "succeeds the request" do
-      request.should_receive :succeed
+    it "deletes itself and stream.send from env[] to prevent multiple calls" do
       app.stub(:call) {|e|
         e["stream.close"].call
+        e.key?("stream.send").should be_false
+        e.key?("stream.close").should be_false
         [-1]
       }
       server.process
     end
+  end
+  
+  context "#start_response(response)" do
+    let(:previous) { EM::DefaultDeferrable.new }
+    let(:response) { [200, {"Key" => "value"}, Rack::STREAMING] }
     
-    it "leaves the connection open" do
-      server.should_not_receive :close_connection
-      app.stub(:call) {|e|
-        server.requests << stub("another request")
-        e["stream.close"].call
-        [-1]
+    before {
+      server.requests.unshift previous
+      app.stub(:call) {|e| response }
+      request.stub :succeed
+      server.builder.stub :response_line
+      server.builder.stub :headers
+    }
+    
+    it "initiates the response" do
+      server.builder.should_receive(:response_line) {|code|
+        code.should equal(response[0])
       }
+      server.builder.should_receive(:headers) {|headers|
+        headers["Key"].should equal(response[1]["Key"])
+        headers["Server"].should == "hatetepe/#{Hatetepe::VERSION}"
+      }
+      previous.succeed
       server.process
     end
-    
-    it "closes the connection if there are no more requests" do
-      server.should_receive(:close_connection).with true
-      app.stub(:call) {|e|
+  end
+  
+  context "#close_response(request)" do
+    before do
+      server.builder.stub :complete
+      request.stub :succeed
+      app.stub :call do |e|
         e["stream.close"].call
         [-1]
-      }
+      end
+    end
+    
+    it "removes the request from the request queue" do
       server.process
+      server.requests.should be_empty
     end
     
-    it "deletes itself and stream.send from env[] to prevent multiple calls" do
-      app.stub(:call) {|e|
-        e["stream.close"].call
-        e.key?("stream.send").should be_false
-        e.key?("stream.close").should be_false
-        [-1]
-      }
+    it "completes the response" do
+      server.builder.should_receive :complete
+      server.process
+    end
+    
+    it "succeeds the request" do
+      request.should_receive :succeed
       server.process
     end
   end