3mix-castronaut 0.5.0.2

data/vendor/rack/test/spec_rack_handler.rb

@@ -0,0 +1,24 @@
+require 'test/spec'
+
+require 'rack/handler'
+
+context "Rack::Handler" do
+  class Rack::Handler::Lobster; end
+  class RockLobster; end
+
+  specify "has registered default handlers" do
+    Rack::Handler.get('cgi').should.equal Rack::Handler::CGI
+    Rack::Handler.get('fastcgi').should.equal Rack::Handler::FastCGI
+    Rack::Handler.get('mongrel').should.equal Rack::Handler::Mongrel
+    Rack::Handler.get('webrick').should.equal Rack::Handler::WEBrick
+  end
+
+  specify "should get unregistered handler by name" do
+    Rack::Handler.get('lobster').should.equal Rack::Handler::Lobster
+  end
+
+  specify "should register custom handler" do
+    Rack::Handler.register('rock_lobster', 'RockLobster')
+    Rack::Handler.get('rock_lobster').should.equal RockLobster
+  end
+end

data/vendor/rack/test/spec_rack_lint.rb

@@ -0,0 +1,303 @@
+require 'test/spec'
+require 'stringio'
+
+require 'rack/lint'
+require 'rack/mock'
+
+context "Rack::Lint" do
+  def env(*args)
+    Rack::MockRequest.env_for("/", *args)
+  end
+
+  specify "passes valid request" do
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       [200, {"Content-type" => "test/plain", "Content-length" => "3"}, "foo"]
+                     }).call(env({}))
+    }.should.not.raise
+  end
+
+  specify "notices fatal errors" do
+    lambda { Rack::Lint.new(nil).call }.should.raise(Rack::Lint::LintError).
+      message.should.match(/No env given/)
+  end
+
+  specify "notices environment errors" do
+    lambda { Rack::Lint.new(nil).call 5 }.should.raise(Rack::Lint::LintError).
+      message.should.match(/not a Hash/)
+
+    lambda {
+      e = env
+      e.delete("REQUEST_METHOD")
+      Rack::Lint.new(nil).call(e)
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/missing required key REQUEST_METHOD/)
+
+    lambda {
+      e = env
+      e.delete("SERVER_NAME")
+      Rack::Lint.new(nil).call(e)
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/missing required key SERVER_NAME/)
+
+
+    lambda {
+      Rack::Lint.new(nil).call(env("HTTP_CONTENT_TYPE" => "text/plain"))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/contains HTTP_CONTENT_TYPE/)
+
+    lambda {
+      Rack::Lint.new(nil).call(env("HTTP_CONTENT_LENGTH" => "42"))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/contains HTTP_CONTENT_LENGTH/)
+
+    lambda {
+      Rack::Lint.new(nil).call(env("FOO" => Object.new))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/non-string value/)
+
+    lambda {
+      Rack::Lint.new(nil).call(env("rack.version" => "0.2"))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/must be an Array/)
+
+    lambda {
+      Rack::Lint.new(nil).call(env("rack.url_scheme" => "gopher"))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/url_scheme unknown/)
+
+    lambda {
+      Rack::Lint.new(nil).call(env("REQUEST_METHOD" => "FUCKUP"))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/REQUEST_METHOD unknown/)
+
+    lambda {
+      Rack::Lint.new(nil).call(env("SCRIPT_NAME" => "howdy"))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/must start with/)
+
+    lambda {
+      Rack::Lint.new(nil).call(env("PATH_INFO" => "../foo"))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/must start with/)
+
+    lambda {
+      Rack::Lint.new(nil).call(env("CONTENT_LENGTH" => "xcii"))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/Invalid CONTENT_LENGTH/)
+
+    lambda {
+      e = env
+      e.delete("PATH_INFO")
+      e.delete("SCRIPT_NAME")
+      Rack::Lint.new(nil).call(e)
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/One of .* must be set/)
+
+    lambda {
+      Rack::Lint.new(nil).call(env("SCRIPT_NAME" => "/"))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/cannot be .* make it ''/)
+  end
+
+  specify "notices input errors" do
+    lambda {
+      Rack::Lint.new(nil).call(env("rack.input" => ""))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/does not respond to #gets/)
+  end
+
+  specify "notices error errors" do
+    lambda {
+      Rack::Lint.new(nil).call(env("rack.errors" => ""))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/does not respond to #puts/)
+  end
+
+  specify "notices status errors" do
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       ["cc", {}, ""]
+                     }).call(env({}))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/must be >=100 seen as integer/)
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       [42, {}, ""]
+                     }).call(env({}))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/must be >=100 seen as integer/)
+  end
+
+  specify "notices header errors" do
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       [200, Object.new, ""]
+                     }).call(env({}))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.equal("headers object should respond to #each, but doesn't (got Object as headers)")
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       [200, {true=>false}, ""]
+                     }).call(env({}))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.equal("header key must be a string, was TrueClass")
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       [200, {"Status" => "404"}, ""]
+                     }).call(env({}))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/must not contain Status/)
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       [200, {"Content-Type:" => "text/plain"}, ""]
+                     }).call(env({}))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/must not contain :/)
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       [200, {"Content-" => "text/plain"}, ""]
+                     }).call(env({}))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/must not end/)
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       [200, {"..%%quark%%.." => "text/plain"}, ""]
+                     }).call(env({}))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.equal("invalid header name: ..%%quark%%..")
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       [200, {"Foo" => Object.new}, ""]
+                     }).call(env({}))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.equal("header values must respond to #each, but the value of 'Foo' doesn't (is Object)")
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       [200, {"Foo" => [1,2,3]}, ""]
+                     }).call(env({}))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.equal("header values must consist of Strings, but 'Foo' also contains a Fixnum")
+
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       [200, {"Foo-Bar" => "text\000plain"}, ""]
+                     }).call(env({}))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/invalid header/)
+  end
+
+  specify "notices content-type errors" do
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       [200, {"Content-length" => "0"}, ""]
+                     }).call(env({}))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/No Content-Type/)
+  end
+
+  specify "notices body errors" do
+    lambda {
+      status, header, body = Rack::Lint.new(lambda { |env|
+                               [200, {"Content-type" => "text/plain","Content-length" => "3"}, [1,2,3]]
+                             }).call(env({}))
+      body.each { |part| }
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/yielded non-string/)
+  end
+
+  specify "notices input handling errors" do
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       env["rack.input"].gets("\r\n")
+                       [201, {"Content-type" => "text/plain", "Content-length" => "0"}, ""]
+                     }).call(env({}))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/gets called with arguments/)
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       env["rack.input"].read("foo")
+                       [201, {"Content-type" => "text/plain", "Content-length" => "0"}, ""]
+                     }).call(env({}))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/read called with non-integer argument/)
+
+    weirdio = Object.new
+    class << weirdio
+      def gets
+        42
+      end
+
+      def read
+        23
+      end
+
+      def each
+        yield 23
+        yield 42
+      end
+    end
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       env["rack.input"].gets
+                       [201, {"Content-type" => "text/plain", "Content-length" => "0"}, ""]
+                     }).call(env("rack.input" => weirdio))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/gets didn't return a String/)
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       env["rack.input"].each { |x| }
+                       [201, {"Content-type" => "text/plain", "Content-length" => "0"}, ""]
+                     }).call(env("rack.input" => weirdio))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/each didn't yield a String/)
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       env["rack.input"].read
+                       [201, {"Content-type" => "text/plain", "Content-length" => "0"}, ""]
+                     }).call(env("rack.input" => weirdio))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/read didn't return a String/)
+
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       env["rack.input"].close
+                       [201, {"Content-type" => "text/plain", "Content-length" => "0"}, ""]
+                     }).call(env({}))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/close must not be called/)
+  end
+
+  specify "notices error handling errors" do
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       env["rack.errors"].write(42)
+                       [201, {"Content-type" => "text/plain", "Content-length" => "0"}, ""]
+                     }).call(env({}))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/write not called with a String/)
+
+    lambda {
+      Rack::Lint.new(lambda { |env|
+                       env["rack.errors"].close
+                       [201, {"Content-type" => "text/plain", "Content-length" => "0"}, ""]
+                     }).call(env({}))
+    }.should.raise(Rack::Lint::LintError).
+      message.should.match(/close must not be called/)
+  end
+
+end

data/vendor/rack/test/spec_rack_lobster.rb

@@ -0,0 +1,45 @@
+require 'test/spec'
+
+require 'rack/lobster'
+require 'rack/mock'
+
+context "Rack::Lobster::LambdaLobster" do
+  specify "should be a single lambda" do
+    Rack::Lobster::LambdaLobster.should.be.kind_of Proc
+  end
+  
+  specify "should look like a lobster" do
+    res = Rack::MockRequest.new(Rack::Lobster::LambdaLobster).get("/")
+    res.should.be.ok
+    res.body.should.include "(,(,,(,,,("
+    res.body.should.include "?flip"
+  end
+
+  specify "should be flippable" do
+    res = Rack::MockRequest.new(Rack::Lobster::LambdaLobster).get("/?flip")
+    res.should.be.ok
+    res.body.should.include "(,,,(,,(,("
+  end
+end
+
+context "Rack::Lobster" do
+  specify "should look like a lobster" do
+    res = Rack::MockRequest.new(Rack::Lobster.new).get("/")
+    res.should.be.ok
+    res.body.should.include "(,(,,(,,,("
+    res.body.should.include "?flip"
+    res.body.should.include "crash"
+  end
+
+  specify "should be flippable" do
+    res = Rack::MockRequest.new(Rack::Lobster.new).get("/?flip=left")
+    res.should.be.ok
+    res.body.should.include "(,,,(,,(,("
+  end
+
+  specify "should provide crashing for testing purposes" do
+    lambda {
+      Rack::MockRequest.new(Rack::Lobster.new).get("/?flip=crash")
+    }.should.raise
+  end
+end

data/vendor/rack/test/spec_rack_mock.rb

@@ -0,0 +1,152 @@
+require 'yaml'
+require 'rack/mock'
+require 'rack/request'
+require 'rack/response'
+
+app = lambda { |env|
+  req = Rack::Request.new(env)
+  
+  env["mock.postdata"] = env["rack.input"].read
+  if req.GET["error"]
+    env["rack.errors"].puts req.GET["error"]
+    env["rack.errors"].flush
+  end
+  
+  Rack::Response.new(env.to_yaml,
+                     req.GET["status"] || 200,
+                     "Content-Type" => "text/yaml").finish
+}
+
+context "Rack::MockRequest" do
+  specify "should return a MockResponse" do
+    res = Rack::MockRequest.new(app).get("")
+    res.should.be.kind_of Rack::MockResponse
+  end
+
+  specify "should be able to only return the environment" do
+    env = Rack::MockRequest.env_for("")
+    env.should.be.kind_of Hash
+    env.should.include "rack.version"
+  end
+
+  specify "should provide sensible defaults" do
+    res = Rack::MockRequest.new(app).request
+
+    env = YAML.load(res.body)
+    env["REQUEST_METHOD"].should.equal "GET"
+    env["SERVER_NAME"].should.equal "example.org"
+    env["SERVER_PORT"].should.equal "80"
+    env["QUERY_STRING"].should.equal ""
+    env["PATH_INFO"].should.equal "/"
+    env["SCRIPT_NAME"].should.equal ""
+    env["rack.url_scheme"].should.equal "http"
+    env["mock.postdata"].should.be.empty
+  end
+
+  specify "should allow GET/POST/PUT/DELETE" do
+    res = Rack::MockRequest.new(app).get("", :input => "foo")
+    env = YAML.load(res.body)
+    env["REQUEST_METHOD"].should.equal "GET"
+
+    res = Rack::MockRequest.new(app).post("", :input => "foo")
+    env = YAML.load(res.body)
+    env["REQUEST_METHOD"].should.equal "POST"
+
+    res = Rack::MockRequest.new(app).put("", :input => "foo")
+    env = YAML.load(res.body)
+    env["REQUEST_METHOD"].should.equal "PUT"
+
+    res = Rack::MockRequest.new(app).delete("", :input => "foo")
+    env = YAML.load(res.body)
+    env["REQUEST_METHOD"].should.equal "DELETE"
+
+    Rack::MockRequest.env_for("/", :method => "OPTIONS")["REQUEST_METHOD"].
+      should.equal "OPTIONS"
+  end
+
+  specify "should allow posting" do
+    res = Rack::MockRequest.new(app).get("", :input => "foo")
+    env = YAML.load(res.body)
+    env["mock.postdata"].should.equal "foo"
+
+    res = Rack::MockRequest.new(app).post("", :input => StringIO.new("foo"))
+    env = YAML.load(res.body)
+    env["mock.postdata"].should.equal "foo"
+  end
+
+  specify "should use all parts of an URL" do
+    res = Rack::MockRequest.new(app).
+      get("https://bla.example.org:9292/meh/foo?bar")
+    res.should.be.kind_of Rack::MockResponse
+
+    env = YAML.load(res.body)
+    env["REQUEST_METHOD"].should.equal "GET"
+    env["SERVER_NAME"].should.equal "bla.example.org"
+    env["SERVER_PORT"].should.equal "9292"
+    env["QUERY_STRING"].should.equal "bar"
+    env["PATH_INFO"].should.equal "/meh/foo"
+    env["rack.url_scheme"].should.equal "https"
+  end
+
+  specify "should behave valid according to the Rack spec" do
+    lambda {
+      res = Rack::MockRequest.new(app).
+        get("https://bla.example.org:9292/meh/foo?bar", :lint => true)
+    }.should.not.raise(Rack::Lint::LintError)
+  end
+end
+
+context "Rack::MockResponse" do
+  specify "should provide access to the HTTP status" do
+    res = Rack::MockRequest.new(app).get("")
+    res.should.be.successful
+    res.should.be.ok
+
+    res = Rack::MockRequest.new(app).get("/?status=404")
+    res.should.not.be.successful
+    res.should.be.client_error
+    res.should.be.not_found
+
+    res = Rack::MockRequest.new(app).get("/?status=501")
+    res.should.not.be.successful
+    res.should.be.server_error
+
+    res = Rack::MockRequest.new(app).get("/?status=307")
+    res.should.be.redirect
+
+    res = Rack::MockRequest.new(app).get("/?status=201", :lint => true)
+    res.should.be.empty
+  end
+
+  specify "should provide access to the HTTP headers" do
+    res = Rack::MockRequest.new(app).get("")
+    res.should.include "Content-Type"
+    res.headers["Content-Type"].should.equal "text/yaml"
+    res.original_headers["Content-Type"].should.equal "text/yaml"
+    res["Content-Type"].should.equal "text/yaml"
+    res.content_type.should.equal "text/yaml"
+    res.content_length.should.be.nil
+    res.location.should.be.nil
+  end
+
+  specify "should provide access to the HTTP body" do
+    res = Rack::MockRequest.new(app).get("")
+    res.body.should =~ /rack/
+    res.should =~ /rack/
+    res.should.match(/rack/)
+    res.should.satisfy { |r| r.match(/rack/) }
+  end
+
+  specify "should provide access to the Rack errors" do
+    res = Rack::MockRequest.new(app).get("/?error=foo", :lint => true)
+    res.should.be.ok
+    res.errors.should.not.be.empty
+    res.errors.should.include "foo"
+  end
+
+  specify "should optionally make Rack errors fatal" do
+    lambda {
+      Rack::MockRequest.new(app).get("/?error=foo", :fatal => true)
+    }.should.raise(Rack::MockRequest::FatalWarning)
+  end
+end

data/vendor/rack/test/spec_rack_mongrel.rb

@@ -0,0 +1,170 @@
+require 'test/spec'
+
+begin
+require 'rack/handler/mongrel'
+require 'rack/urlmap'
+require 'rack/lint'
+require 'testrequest'
+
+Thread.abort_on_exception = true
+$tcp_defer_accept_opts = nil
+$tcp_cork_opts = nil
+
+context "Rack::Handler::Mongrel" do
+  include TestRequest::Helpers
+  
+  setup do
+    server = Mongrel::HttpServer.new(@host='0.0.0.0', @port=9201)
+    server.register('/test',
+                    Rack::Handler::Mongrel.new(Rack::Lint.new(TestRequest.new)))
+    @acc = server.run
+  end
+
+  specify "should respond" do
+    lambda {
+      GET("/test")
+    }.should.not.raise
+  end
+
+  specify "should be a Mongrel" do
+    GET("/test")
+    status.should.be 200
+    response["SERVER_SOFTWARE"].should =~ /Mongrel/
+    response["HTTP_VERSION"].should.equal "HTTP/1.1"
+    response["SERVER_PROTOCOL"].should.equal "HTTP/1.1"
+    response["SERVER_PORT"].should.equal "9201"
+    response["SERVER_NAME"].should.equal "0.0.0.0"
+  end
+
+  specify "should have rack headers" do
+    GET("/test")
+    response["rack.version"].should.equal [0,1]
+    response["rack.multithread"].should.be true
+    response["rack.multiprocess"].should.be false
+    response["rack.run_once"].should.be false
+  end
+
+  specify "should have CGI headers on GET" do
+    GET("/test")
+    response["REQUEST_METHOD"].should.equal "GET"
+    response["SCRIPT_NAME"].should.equal "/test"
+    response["REQUEST_PATH"].should.equal "/test"
+    response["PATH_INFO"].should.be.nil
+    response["QUERY_STRING"].should.equal ""
+    response["test.postdata"].should.equal ""
+
+    GET("/test/foo?quux=1")
+    response["REQUEST_METHOD"].should.equal "GET"
+    response["SCRIPT_NAME"].should.equal "/test"
+    response["REQUEST_PATH"].should.equal "/test/foo"
+    response["PATH_INFO"].should.equal "/foo"
+    response["QUERY_STRING"].should.equal "quux=1"
+  end
+
+  specify "should have CGI headers on POST" do
+    POST("/test", {"rack-form-data" => "23"}, {'X-test-header' => '42'})
+    status.should.equal 200
+    response["REQUEST_METHOD"].should.equal "POST"
+    response["SCRIPT_NAME"].should.equal "/test"
+    response["REQUEST_PATH"].should.equal "/test"
+    response["QUERY_STRING"].should.equal ""
+    response["HTTP_X_TEST_HEADER"].should.equal "42"
+    response["test.postdata"].should.equal "rack-form-data=23"
+  end
+
+  specify "should support HTTP auth" do
+    GET("/test", {:user => "ruth", :passwd => "secret"})
+    response["HTTP_AUTHORIZATION"].should.equal "Basic cnV0aDpzZWNyZXQ="
+  end
+
+  specify "should set status" do
+    GET("/test?secret")
+    status.should.equal 403
+    response["rack.url_scheme"].should.equal "http"
+  end
+
+  specify "should provide a .run" do
+    block_ran = false
+    Thread.new {
+      Rack::Handler::Mongrel.run(lambda {}, {:Port => 9211}) { |server|
+        server.should.be.kind_of Mongrel::HttpServer
+        block_ran = true
+      }
+    }
+    sleep 1
+    block_ran.should.be true
+  end
+
+  specify "should provide a .run that maps a hash" do
+    block_ran = false
+    Thread.new {
+      map = {'/'=>lambda{},'/foo'=>lambda{}}
+      Rack::Handler::Mongrel.run(map, :map => true, :Port => 9221) { |server|
+        server.should.be.kind_of Mongrel::HttpServer
+        server.classifier.uris.size.should.be 2
+        server.classifier.uris.should.not.include '/arf'
+        server.classifier.uris.should.include '/'
+        server.classifier.uris.should.include '/foo'
+        block_ran = true
+      }
+    }
+    sleep 1
+    block_ran.should.be true
+  end
+
+  specify "should provide a .run that maps a urlmap" do
+    block_ran = false
+    Thread.new {
+      map = Rack::URLMap.new({'/'=>lambda{},'/bar'=>lambda{}})
+      Rack::Handler::Mongrel.run(map, {:map => true, :Port => 9231}) { |server|
+        server.should.be.kind_of Mongrel::HttpServer
+        server.classifier.uris.size.should.be 2
+        server.classifier.uris.should.not.include '/arf'
+        server.classifier.uris.should.include '/'
+        server.classifier.uris.should.include '/bar'
+        block_ran = true
+      }
+    }
+    sleep 1
+    block_ran.should.be true
+  end
+
+  specify "should provide a .run that maps a urlmap restricting by host" do
+    block_ran = false
+    Thread.new {
+      map = Rack::URLMap.new({
+        '/' => lambda{},
+        '/foo' => lambda{},
+        '/bar' => lambda{},
+        'http://localhost/' => lambda{},
+        'http://localhost/bar' => lambda{},
+        'http://falsehost/arf' => lambda{},
+        'http://falsehost/qux' => lambda{}
+      })
+      opt = {:map => true, :Port => 9241, :Host => 'localhost'}
+      Rack::Handler::Mongrel.run(map, opt) { |server|
+        server.should.be.kind_of Mongrel::HttpServer
+        server.classifier.uris.should.include '/'
+        server.classifier.handler_map['/'].size.should.be 2
+        server.classifier.uris.should.include '/foo'
+        server.classifier.handler_map['/foo'].size.should.be 1
+        server.classifier.uris.should.include '/bar'
+        server.classifier.handler_map['/bar'].size.should.be 2
+        server.classifier.uris.should.not.include '/qux'
+        server.classifier.uris.should.not.include '/arf'
+        server.classifier.uris.size.should.be 3
+        block_ran = true
+      }
+    }
+    sleep 1
+    block_ran.should.be true
+  end
+
+  teardown do
+    @acc.raise Mongrel::StopServer
+  end
+end
+
+rescue LoadError
+  $stderr.puts "Skipping Rack::Handler::Mongrel tests (Mongrel is required). `gem install mongrel` and try again."
+end