rity 0.0.1 → 0.0.2

data/.rspec

@@ -0,0 +1 @@
+--color

data/README.md

@@ -6,10 +6,11 @@ Rity is a lightweight Ruby webserver that runs inside an EventMachine loop and p
 TODO
 ----
 
-- Tests (!)
 - Command Line Interface
-- Logging
+- Let Request handle parsing and building errors
+- More robust error handling in general
 - Proxying via EM.enable_proxy
 - Rack Handler
 - Support for keep-alive connections
 - Investigate MVM support in JRuby/Rubinius/MRI
+- Support for SPDY

data/Rakefile

@@ -1,11 +1,9 @@
 require "bundler"
 Bundler.setup :default
 
-task :default => :test
+task :default => :spec
 
-require "rake/testtask"
-Rake::TestTask.new :test do |t|
-  t.test_files = FileList["test/*_test.rb"]
-end
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new :spec
 
 Bundler::GemHelper.install_tasks

data/lib/rity/connection.rb

@@ -5,34 +5,34 @@ require "rity/request"
 
 module Rity
   class Connection < EM::Connection
-    def initialize(app)
-      @app = app
-      @requests = []
-    end
+    attr_accessor :app, :log
+    attr_reader :requests, :parser, :builder, :responder
     
     def post_init
-      request = nil
+      @requests, request = [], nil
+      
       @parser = Hatetepe::Parser.new do |p|
         p.on_request do |verb, url|
           request = Request.new(@app, verb, url)
+          request.log = log
           @requests.push(request)
-          request.callback &@responder.method(:resume)
+          @requests.last.callback &@responder.method(:resume)
         end
         
         p.on_header do |name, value|
-          request.add_header(name, value)
+          @requests.last.add_header(name, value)
         end
         
         p.on_headers_complete do
-          request.precall
+          @requests.last.precall
         end
         
         p.on_body_chunk do |chunk|
-          request.add_body_chunk(chunk)
+          @requests.last.add_body_chunk(chunk)
         end
         
         p.on_complete do
-          request.call
+          @requests.last.call
         end
       end
       

data/lib/rity/request.rb

@@ -9,6 +9,7 @@ module Rity
   class Request
     include EM::Deferrable
     
+    attr_reader :log
     attr_reader :app, :env, :response
     
     def initialize(app, verb, url)
@@ -17,10 +18,15 @@ module Rity
         "REQUEST_METHOD" => verb,
         "REQUEST_URI" => url,
         "rack.input" => StringIO.new,
-        "async.callback" => method(:postcall)
+        "async.callback" => method(:postcall),
       }
     end
     
+    def log=(log)
+      @log = log
+      @env["rack.logger"] = log
+    end
+    
     def add_body_chunk(chunk)
       env["rack.input"] << chunk
     end
@@ -48,6 +54,7 @@ module Rity
     def postcall(response)
       return if @response || response[0] < 0
       @response = response
+      log.info("#{response[0]} - #{env["REQUEST_METHOD"]} #{env["REQUEST_URI"]}") if log
       succeed
     end
     

data/lib/rity/server.rb

@@ -1,5 +1,6 @@
 require "eventmachine"
 require "em-synchrony"
+require "logger"
 
 require "rity/connection"
 
@@ -13,7 +14,13 @@ module Rity
         EM.epoll
         
         puts "Binding to #{address}:#{port}"
-        EM.start_server address, port, Connection, app
+        EM.start_server address, port, Connection do |conn|
+          conn.app = app
+          conn.log = Logger.new(STDERR)
+          conn.log.formatter = proc do |severity, time, progname, message|
+            "[#{time}] #{severity}: #{message}\n"
+          end
+        end
       end
     end
   end

data/lib/rity/version.rb

@@ -1,3 +1,3 @@
 module Rity
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/myapp.rb

@@ -6,7 +6,7 @@ require "awesome_print"
 
 class MyApp
   def call(env)
-    raise "Error, Error!"
+    #raise "Error, Error!"
     
     response = [200, {"Content-Type" => "text/html"}, ["Hello!"]]
     return response

data/rity.gemspec

@@ -18,6 +18,8 @@ Gem::Specification.new do |s|
   s.add_dependency "rack"
   s.add_dependency "async-rack"
   s.add_dependency "thor"
+  
+  s.add_development_dependency "rspec"
 
   s.files         = `git ls-files`.split("\n") - [".gitignore"]
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require "bundler"
+Bundler.setup :default
+
+require "rity"
+require "rspec"
+require "awesome_print"

data/spec/unit/connection_spec.rb

@@ -0,0 +1,112 @@
+require "spec_helper"
+
+describe Rity::Connection do
+  before do
+    @conn = Rity::Connection.new("blah")
+    @app = stub("app")
+    @conn.app = @app
+  end
+  
+  it "has an app, requests and a logger" do
+    @conn.app.should == @app
+    @conn.should have(0).requests
+    
+    log = stub("log")
+    @conn.log = log
+    @conn.log.should == log
+  end
+  
+  it "passes incoming data to the parser" do
+    @conn.parser.should_receive(:<<).with("asdfg")
+    @conn.receive_data("asdfg")
+  end
+  
+  it "closes the connection if parsing fails" do
+    @conn.should_receive(:close_connection)
+    @conn.receive_data("this will definitely fail!")
+  end
+  
+  it "creates a new request as soon as headers are parsed" do
+    request, log = stub("request", :callback => nil), stub("log")
+    @conn.log = log
+    
+    Rity::Request.should_receive(:new).with(@conn.app, "GET", "/").and_return(request)
+    request.should_receive(:log=).with(log)
+    
+    @conn.parser.on_request[0].call("GET", "/")
+    @conn.requests[0].should == request
+  end
+  
+  it "adds the responder as request's callback" do
+    @conn.responder.should_receive(:resume)
+    @conn.parser.on_request[0].call("GET", "/")
+    @conn.requests[0].succeed
+  end
+  
+  it "adds each parsed header to the request" do
+    @conn.requests.push(Rity::Request.new(nil, nil, nil))
+    @conn.requests.last.should_receive(:add_header).with("Asd", "123")
+    @conn.parser.on_header[0].call("Asd", "123")
+  end
+  
+  it "calls the request's #precall method when headers are finished" do
+    @conn.requests.push(Rity::Request.new(nil, nil, nil))
+    @conn.requests.last.should_receive(:precall)
+    @conn.parser.on_headers_complete[0].call
+  end
+  
+  it "adds each parsed body chunk to the request" do
+    @conn.requests.push(Rity::Request.new(nil, nil, nil))
+    @conn.requests.last.should_receive(:add_body_chunk).with("asdf")
+    @conn.parser.on_body_chunk[0].call("asdf")
+  end
+  
+  it "calls the request's #call method when the whole message is parsed" do
+    @conn.requests.push(Rity::Request.new(nil, nil, nil))
+    @conn.requests.last.should_receive(:call)
+    @conn.parser.on_complete[0].call()
+  end
+  
+  describe "the responder" do
+    it "pushes the request's response to the builder" do
+      @conn.requests.push(Rity::Request.new(nil, nil, nil))
+      response = stub("response")
+      @conn.requests[0].stub(:response => response)
+      
+      @conn.builder.should_receive(:response).with(response)
+      @conn.responder.resume
+    end
+    
+    it "doesn't push the response until it's ready" do
+      @conn.requests.push(Rity::Request.new(nil, nil, nil))
+      @conn.builder.should_not_receive(:response)
+      @conn.responder.resume
+    end
+    
+    it "pushes responses in the order the resp. requests came in" do
+      request1, request2 = mock("request1"), mock("request2")
+      response1, response2 = stub("response1"), stub("response2")
+      @conn.requests.push(request1, request2)
+      
+      request1.stub(:response => nil)
+      request2.stub(:response => response2)
+      @conn.builder.should_not_receive(:response)
+      @conn.responder.resume
+      
+      request1.stub(:response => response1)
+      request2.stub(:response => nil)
+      @conn.builder.rspec_reset
+      @conn.builder.should_receive(:response).with(response1)
+      @conn.responder.resume
+      
+      @conn.requests.should_not include(request1)
+      
+      request2.stub(:response => response2)
+      @conn.builder.rspec_reset
+      @conn.builder.should_receive(:response).with(response2)
+      @conn.responder.resume
+      
+      @conn.requests.should be_empty
+    end
+  end
+end

data/spec/unit/request_spec.rb

@@ -0,0 +1,132 @@
+require "spec_helper"
+
+describe Rity::Request do
+  before do
+    @app = proc {|env|}
+    @request = Rity::Request.new(@app, "GET", "/")
+  end
+  
+  it "is deferrable" do
+    @request.should respond_to(:callback)
+    @request.should respond_to(:succeed)
+  end
+  
+  it "initializes the env hash" do
+    @request.env["REQUEST_METHOD"].should == "GET"
+    @request.env["REQUEST_URI"].should == "/"
+    StringIO.should === @request.env["rack.input"]
+    @request.env["async.callback"].should respond_to(:call)
+  end
+  
+  it "puts the logger into the env hash" do
+    log = stub("log")
+    @request.log = log
+    @request.env["rack.logger"].should == log
+  end
+  
+  it "calls the app and stores its response" do
+    response = [303, {"Content-Type" => "text/html"}, ["foo bar"]]
+    @app.should_receive(:call).with(@request.env).and_return(response)
+    @request.should_receive(:succeed)
+    @request.call
+    @request.response.should == response
+  end
+  
+  it "fetches async responses" do
+    response = [-1, {}, []]
+    async_response = [200, {}, "okokok"]
+    @app.should_receive(:call).with(@request.env).and_return(response)
+    
+    @request.call
+    
+    @request.should_receive(:succeed)
+    @request.env["async.callback"].call(async_response)
+    @request.response.should == async_response
+  end
+  
+  it "calls the app in a separate fiber" do
+    outer_fiber = Fiber.current
+    inner_fiber = nil
+    @app.singleton_class.send(:define_method, :call) do |env|
+      inner_fiber = Fiber.current
+    end
+    @request.call
+    
+    outer_fiber.should_not == inner_fiber
+  end
+  
+  it "rescues errors in app's #call" do
+    @app.should_receive(:call) do
+      raise "error"
+    end
+    @request.should_receive(:succeed)
+    @request.call
+    
+    @request.response[0].should == 500
+    @request.response[1].should == {"Content-Type" => "text/html"}
+    @request.response[2].should == ["<h1>Internal Server Error</h1>"]
+  end
+  
+  it "rescues errors in app's #precall" do
+    @app.should_receive(:precall) do
+      raise "error"
+    end
+    @request.should_receive(:succeed)
+    @request.precall
+    
+    @request.response[0].should == 500
+    @request.response[1].should == {"Content-Type" => "text/html"}
+    @request.response[2].should == ["<h1>Internal Server Error</h1>"]
+  end
+  
+  it "calls the app's #precall method if it exists" do
+    called = false
+    request = @request
+    @app.singleton_class.send(:define_method, :precall) do |env|
+      env.should == request.env
+      called = true
+    end
+    
+    @app.stub(:respond_to? => false)
+    @request.precall
+    called.should be_false
+    
+    @app.stub(:respond_to? => true)
+    @request.precall
+    called.should be_true
+  end
+  
+  it "calls the app's #precall method in a separate fiber" do
+    outer_fiber = Fiber.current
+    inner_fiber = nil
+    @app.singleton_class.send(:define_method, :precall) do |env|
+      inner_fiber = Fiber.current
+    end
+    @request.precall
+    
+    outer_fiber.should_not == inner_fiber
+  end
+  
+  it "adds headers to the env hash" do
+    @request.add_header("Content-Type", "text/html; charset=utf-8")
+    @request.env["HTTP_CONTENT_TYPE"].should == "text/html; charset=utf-8"
+  end
+  
+  it "adds data to the body" do
+    @request.add_body_chunk "asdf"
+    @request.env["rack.input"].string.should == "asdf"
+    
+    @request.add_body_chunk "foo"
+    @request.env["rack.input"].string.should == "asdffoo"
+  end
+  
+  it "rewinds the body and closes its input before calling the app" do
+    @request.add_body_chunk "asdf"
+    @app.should_receive(:call) do |env|
+      env["rack.input"].closed_write?.should be_true
+      env["rack.input"].pos.should == 0
+    end
+    
+    @request.call
+  end
+end

metadata

@@ -2,7 +2,7 @@
 name: rity
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors: 
 - Lars Gierth
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-07 00:00:00 Z
+date: 2011-06-09 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: eventmachine
@@ -78,6 +78,17 @@ dependencies:
   type: :runtime
   prerelease: false
   version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id007
 description: Rity is a lightweight Ruby webserver that runs inside an EventMachine loop and puts each request into a fiber.
 email: 
 - lars.gierth@gmail.com
@@ -88,6 +99,7 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- .rspec
 - Gemfile
 - LICENSE
 - README.md
@@ -101,6 +113,9 @@ files:
 - lib/rity/version.rb
 - myapp.rb
 - rity.gemspec
+- spec/spec_helper.rb
+- spec/unit/connection_spec.rb
+- spec/unit/request_spec.rb
 homepage: https://github.com/lgierth/rity
 licenses: []
 
@@ -114,7 +129,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: -1038596497
+      hash: 34399981
       segments: 
       - 0
       version: "0"
@@ -123,7 +138,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: -1038596497
+      hash: 34399981
       segments: 
       - 0
       version: "0"