hatetepe 0.0.4 → 0.2.0

data/spec/unit/events_spec.rb

@@ -0,0 +1,96 @@
+require "spec_helper"
+require "hatetepe/events"
+
+describe Hatetepe::Events do
+  let(:klass) {
+    Class.new {
+      include Hatetepe::Events
+      event :foo
+    }
+  }
+  let(:obj) { klass.new }
+  
+  context "#event(name, *args)" do
+    let(:args) { ["arg#1", "arg#2", "arg#3"] }
+    let(:called) { [] }
+    
+    before {
+      obj.on_foo {|*args| called << [:bar, args] }
+      obj.on_foo {|*args| called << [:baz, args] }
+    }
+    
+    it "calls the listeners" do
+      obj.event :foo, *args
+      called.should == [[:bar, args], [:baz, args]]
+    end
+  end
+  
+  context "#event!(name, *args)" do
+    let(:args) { [:foo, "arg#1", "arg#2"] }
+    
+    it "forwards to #event" do
+      obj.should_receive(:event).with(*args)
+      obj.event! *args
+    end
+    
+    it "changes the state to specified name" do
+      obj.on_foo {
+        obj.foo?.should be_true
+      }
+      obj.event! :foo
+    end
+  end
+  
+  context ".event(name, *more_names)" do
+    before { klass.event :bar, :baz }
+    
+    it "adds #on_name method" do
+      obj.should respond_to(:on_bar)
+    end
+    
+    it "adds #name? method" do
+      obj.should respond_to(:bar?)
+    end
+    
+    it "calls itself for each additional name" do
+      obj.should respond_to(:on_baz)
+      obj.should respond_to(:baz?)
+    end
+  end
+  
+  context "#on_name {|*args| ... }" do
+    let(:block) { proc {} }
+    
+    it "adds the block to the listener stack" do
+      obj.on_foo &block
+      obj.on_foo.should include(block)
+    end
+  end
+  
+  context "#on_name" do
+    let(:blocks) { [proc {}, proc {}] }
+    
+    it "returns the listener stack" do
+      obj.on_foo &blocks[0]
+      obj.on_foo &blocks[1]
+      
+      obj.on_foo.should == blocks
+    end
+    
+    it "returns an empty stack if no listeners have been added yet" do
+      obj.on_foo.should be_empty
+    end
+  end
+  
+  context "#name?" do
+    it "returns true if the state equals :name" do
+      obj.stub :state => :foo
+      obj.foo?.should be_true
+    end
+    
+    it "returns false if the state doesn't equal :name" do
+      obj.stub :state => :bar
+      obj.foo?.should be_false
+    end
+  end
+end

data/spec/unit/parser_spec.rb

@@ -0,0 +1,215 @@
+require "spec_helper"
+require "hatetepe/parser"
+
+describe Hatetepe::Parser do
+  let(:parser) { Hatetepe::Parser.new }
+  
+  context "#initialize" do
+    it "calls #reset" do
+      Hatetepe::Parser.allocate.tap {|ins|
+        ins.should_receive :reset
+        ins.__send__ :initialize
+      }
+    end
+  end
+  
+  context "#initialize {|instance| ... }" do
+    it "yields the new instance" do
+      instance = nil
+      Hatetepe::Parser.new {|ins|
+        instance = ins
+      }.should equal(instance)
+    end
+    
+    it "evals the block in its original context" do
+      expected, actual = nil, nil
+      Object.new.instance_eval {
+        expected = self
+        ::Hatetepe::Parser.new {|ins|
+          actual = self
+        }
+      }
+      
+      actual.should equal(expected)
+    end
+  end
+  
+  context "#initialize {|| ... }" do
+    it "evals the block in the new instance' context" do
+      actual = nil
+      expected = Hatetepe::Parser.new {
+        actual = self
+      }
+      
+      actual.should equal(expected)
+    end
+  end
+  
+  context "#reset" do
+    before { parser << "GET / HTTP/1.1\r\n\r\n" }
+    
+    it "resets the message" do
+      parser.reset
+      parser.message.should be_nil
+    end
+    
+    it "resets the state to :reset" do
+      parser.reset
+      parser.reset?.should be_true
+    end
+  end
+  
+  context "#<<(data)" do
+    it "raises a ParserError if parsing fails" do
+      expect {
+        parser << "herp derp\r\n"
+      }.to raise_error(Hatetepe::ParserError)
+    end
+  end
+  
+  let(:block) {
+    stub("block").tap {|blk|
+      blk.stub :to_proc => proc {|*args| blk.call *args }
+    }
+  }
+  
+  let(:do_request) {
+    parser << "POST / HTTP/1.1\r\n"
+    parser << "Transfer-Encoding: chunked\r\n"
+    parser << "Bar: baz\r\n"
+    parser << "\r\n"
+    parser << "6\r\n"
+    parser << "Hello!\r\n"
+    parser << "0\r\n"
+    parser << "\r\n"
+  }
+  
+  let(:do_response) {
+    parser << "HTTP/1.1 200 OK\r\n"
+    parser << "\r\n"
+  }
+  
+  context "#on_request {|request| ... }" do
+    it "evals the block when a request line comes in" 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
+      }
+      
+      parser.on_request &block
+      do_request
+    end
+    
+    it "changes the state to :request" do
+      block.should_receive(:call) {
+        parser.request?.should be_true
+      }
+      
+      parser.on_request &block
+      do_request
+    end
+  end
+  
+  context "#on_response {|response| ... }" do
+    it "evals the block when a response line comes in" do
+      block.should_receive(:call) {|response|
+        response.should equal(parser.message)
+        
+        response.status.should == 200
+        response.http_version.should == "1.1"
+      }
+      
+      parser.on_response &block
+      do_response
+    end
+    
+    it "changes the state to :response" do
+      block.should_receive(:call) {
+        parser.response?.should be_true
+      }
+      
+      parser.on_response &block
+      do_response
+    end
+  end
+  
+  context "#on_headers {|headers| ... }" do
+    it "evals the block when the headers are complete" do
+      block.should_receive(:call) {|headers|
+        headers.should equal(parser.message.headers)
+        
+        headers["Transfer-Encoding"].should == "chunked"
+        headers["Bar"].should == "baz"
+      }
+      
+      parser.on_headers &block
+      do_request
+    end
+    
+    it "changes the state to :headers" do
+      block.should_receive(:call) {
+        parser.headers?.should be_true
+      }
+      
+      parser.on_headers &block
+      do_request
+    end
+  end
+  
+  context "#on_body {|body| ... }" do
+    it "evals the block when the body starts" do
+      block.should_receive(:call) {|body|
+        body.should equal(parser.message.body)
+        
+        body.should be_empty
+      }
+      
+      parser.on_body &block
+      do_request
+      
+      parser.message.body.tap {|b|
+        b.rewind
+        b.length.should == 6
+        b.read.should == "Hello!"
+      }
+    end
+    
+    it "changes the state to :body" do
+      block.should_receive(:call) {
+        parser.body?.should be_true
+      }
+      
+      parser.on_body &block
+      do_request
+    end
+  end
+  
+  context "#on_complete { ... }" do
+    it "evals the block when the message is completely parsed" do
+      block.should_receive(:call)
+      
+      parser.on_complete &block
+      do_request
+    end
+    
+    it "changes the state to :complete" do
+      block.should_receive(:call) {
+        parser.complete?.should be_true
+      }
+      
+      parser.on_complete &block
+      do_request
+    end
+    
+    it "finishes the body" do
+      parser.on_body {|body|
+        body.should_receive :close_write
+      }
+      do_request
+    end
+  end
+end

data/spec/unit/rack_handler_spec.rb

@@ -0,0 +1,70 @@
+require "spec_helper"
+require "rack/handler/hatetepe"
+
+describe Rack::Handler::Hatetepe do
+  let(:app) { stub "app" }
+  let(:options) {
+    {
+      :Host => stub("host"),
+      :Port => stub("port")
+    }
+  }
+  let(:server) { stub "server" }
+  
+  describe ".run(app, options) {|server| ... }" do
+    before {
+      EM.stub :epoll
+      Signal.stub :trap
+      Hatetepe::Server.stub :start
+    }
+    
+    it "starts an Hatetepe server" do
+      EM.should_receive(:run) {|&block|
+        EM.should_receive(:epoll)
+        Hatetepe::Server.should_receive(:start) {|opts|
+          opts[:host].should equal(options[:Host])
+          opts[:port].should equal(options[:Port])
+          opts[:app].should equal(app)
+        }
+        block.call
+      }
+      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(:run) {|&block| block.call }
+      
+      trapped_signals = []
+      Signal.should_receive(:trap).twice {|sig, &block|
+        trapped_signals << sig
+        EM.should_receive :stop
+        block.call
+      }
+      Rack::Handler::Hatetepe.run app
+      
+      trapped_signals.should include("TERM")
+      trapped_signals.should include("INT")
+    end
+  end
+  
+  describe ".run(app) {|server| ... }" do
+    it "defaults Host to 0.0.0.0 and Port to 8080" do
+      Hatetepe::Server.should_receive(:start) {|opts|
+        opts[:host].should == "0.0.0.0"
+        opts[:port].should == 8080
+      }
+      Rack::Handler::Hatetepe.run(app) { EM.stop }
+    end
+  end
+end

data/spec/unit/server_spec.rb

@@ -0,0 +1,255 @@
+require "spec_helper"
+require "hatetepe/server"
+
+describe Hatetepe::Server do
+  let(:server) {
+    Hatetepe::Server.allocate.tap {|s|
+      s.send :initialize, config
+      s.post_init
+      s.requests << request
+    }
+  }
+  let(:request) { stub "request", :to_hash => env }
+  let(:env) {
+    {
+      "rack.input" => Hatetepe::Body.new
+    }
+  }
+  
+  let(:app) { stub "app" }
+  let(:host) { "127.0.4.1" }
+  let(:port) { 8081 }
+  let(:errors) { stub "errors", :<< => nil, :flush => nil }
+  let(:config) {
+    {
+      :app => app,
+      :host => host,
+      :port => port,
+      :errors => errors
+    }
+  }
+  
+  context ".start(config)" do
+    it "starts an EventMachine server" do
+      args = [host, port, Hatetepe::Server, config]
+      EM.should_receive(:start_server).with(*args) { server }
+      
+      Hatetepe::Server.start(config).should equal(server)
+    end
+  end
+  
+  context "#initialize(config)" do
+    let(:server) { Hatetepe::Server.allocate }
+    let(:builder) { stub "app builder" }
+
+    it "builds the app" do
+      Rack::Builder.stub :new => builder
+      builder.should_receive(:use).with Hatetepe::App
+      builder.should_receive(:run).with app
+      
+      server.send :initialize, config
+      server.app.should equal(builder)
+    end
+    
+    it "sets up the error stream" do
+      server.send :initialize, config
+      server.errors.should equal(errors)
+    end
+    
+    it "uses stderr as default error stream" do
+      config.delete :errors
+      server.send :initialize, config
+      server.errors.should equal($stderr)
+    end
+  end
+  
+  context "#post_init" do
+    let(:server) {
+      Hatetepe::Server.allocate.tap {|s| s.post_init }
+    }
+    
+    it "sets up the request queue" do
+      server.requests.should be_an(Array)
+      server.requests.should be_empty
+    end
+    
+    it "sets up the parser" do
+      server.parser.should respond_to(:<<)
+      server.parser.on_request[0].should == server.requests.method(:<<)
+    end
+    
+    it "sets up the builder" do
+      server.builder.on_write[0].should == server.method(:send_data)
+    end
+  end
+  
+  context "#receive_data(data)" do
+    before { server.stub :close_connection_after_writing }
+    
+    it "feeds data into the parser" do
+      data = stub("data")
+      server.parser.should_receive(:<<).with data
+      server.receive_data data
+    end
+    
+    it "closes the connection if parsing fails" do
+      server.parser.should_receive(:<<).and_raise(Hatetepe::ParserError)
+      server.should_receive :close_connection
+      
+      server.receive_data "irrelevant data"
+    end
+    
+    it "closes the connection when catching an exception" do
+      server.parser.should_receive(:<<).and_raise
+      server.should_receive :close_connection_after_writing
+      
+      server.receive_data ""
+    end
+    
+    it "logs caught exceptions" do
+      server.parser.should_receive(:<<).and_raise "error message"
+      errors.should_receive(:<<) {|str|
+        str.should include("error message")
+      }
+      errors.should_receive :flush
+      
+      server.receive_data ""
+    end
+  end
+  
+  context "#process" do
+    it "puts useful stuff into env[]" do
+      app.should_receive(:call) {|e|
+        e.should equal(env)
+        e["rack.url_scheme"].should == "http"
+        e["hatetepe.connection"].should equal(server)
+        e["rack.input"].source.should equal(server)
+        e["rack.errors"].should equal(server.errors)
+        e["rack.multithread"].should be_false
+        e["rack.multiprocess"].should be_false
+        e["rack.run_once"].should be_false
+        
+        e["SERVER_NAME"].should == host
+        e["SERVER_NAME"].should_not equal(host)
+        e["SERVER_PORT"].should == String(port)
+        e["HTTP_HOST"].should == "#{host}:#{port}"
+        
+        [-1]
+      }
+      server.process
+    end
+    
+    it "calls the app within a new Fiber" do
+      outer_fiber = Fiber.current
+      app.should_receive(:call) {
+        Fiber.current.should_not equal(outer_fiber)
+        [-1]
+      }
+      server.process
+    end
+  end
+  
+  context "env[stream.start].call(response)" do
+    let(:previous) { EM::DefaultDeferrable.new }
+    let(:response) {
+      [200, {"Key" => "value"}, Rack::STREAMING]
+    }
+    
+    before {
+      server.requests.unshift previous
+      app.stub(:call) {|e| response }
+      request.stub :succeed
+      server.builder.stub :response
+    }
+    
+    it "deletes itself from env[] to prevent multiple calls" do
+      app.stub(:call) {|e|
+        e["stream.start"].call response
+        e.key?("stream.start").should be_false
+        [-1]
+      }
+      previous.succeed
+      server.process
+    end
+    
+    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) {|res|
+        res[0].should equal(response[0])
+        res[1]["Key"].should equal(response[1]["Key"])
+        res[1]["Server"].should == "hatetepe/#{Hatetepe::VERSION}"
+      }
+      previous.succeed
+      server.process
+    end
+  end
+  
+  context "env[stream.send].call(chunk)" do
+    it "passes data to the builder" do
+      app.stub(:call) {|e|
+        e["stream.send"].should == server.builder.method(:body)
+        [-1]
+      }
+      server.process
+    end
+  end
+  
+  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
+      app.stub(:call) {|e|
+        e["stream.close"].call
+        [-1]
+      }
+      server.process
+    end
+    
+    it "succeeds the request" do
+      request.should_receive :succeed
+      app.stub(:call) {|e|
+        e["stream.close"].call
+        [-1]
+      }
+      server.process
+    end
+    
+    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 "closes the connection if there are no more requests" do
+      server.should_receive(:close_connection).with true
+      app.stub(:call) {|e|
+        e["stream.close"].call
+        [-1]
+      }
+      server.process
+    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]
+      }
+      server.process
+    end
+  end
+end