p8-castronaut 0.6.1.1

data/vendor/rack/test/spec_rack_showexceptions.rb

@@ -0,0 +1,21 @@
+require 'test/spec'
+
+require 'rack/showexceptions'
+require 'rack/mock'
+
+context "Rack::ShowExceptions" do
+  specify "catches exceptions" do
+    res = nil
+    req = Rack::MockRequest.new(Rack::ShowExceptions.new(lambda { |env|
+                                                           raise RuntimeError
+                                                         }))
+    lambda {
+      res = req.get("/")
+    }.should.not.raise
+    res.should.be.a.server_error
+    res.status.should.equal 500
+
+    res.should =~ /RuntimeError/
+    res.should =~ /ShowExceptions/
+  end
+end

data/vendor/rack/test/spec_rack_showstatus.rb

@@ -0,0 +1,72 @@
+require 'test/spec'
+
+require 'rack/showstatus'
+require 'rack/mock'
+
+context "Rack::ShowStatus" do
+  specify "should provide a default status message" do
+    req = Rack::MockRequest.new(Rack::ShowStatus.new(lambda { |env|
+                                                       [404, {"Content-Type" => "text/plain", "Content-Length" => "0"}, []]
+                                                     }))
+
+    res = req.get("/", :lint => true)
+    res.should.be.not_found
+    res.should.be.not.empty
+
+    res["Content-Type"].should.equal("text/html")
+    res.should =~ /404/
+    res.should =~ /Not Found/
+  end
+
+  specify "should let the app provide additional information" do
+    req = Rack::MockRequest.new(Rack::ShowStatus.new(lambda { |env|
+                                                       env["rack.showstatus.detail"] = "gone too meta."
+                                                       [404, {"Content-Type" => "text/plain", "Content-Length" => "0"}, []]
+                                                     }))
+
+    res = req.get("/", :lint => true)
+    res.should.be.not_found
+    res.should.be.not.empty
+
+    res["Content-Type"].should.equal("text/html")
+    res.should =~ /404/
+    res.should =~ /Not Found/
+    res.should =~ /too meta/
+  end
+
+  specify "should not replace existing messages" do
+    req = Rack::MockRequest.new(Rack::ShowStatus.new(lambda { |env|
+                                                       [404, {"Content-Type" => "text/plain", "Content-Length" => "4"}, ["foo!"]]
+                                                     }))
+    res = req.get("/", :lint => true)
+    res.should.be.not_found
+
+    res.body.should == "foo!"
+  end
+
+  specify "should pass on original headers" do
+    headers = {"WWW-Authenticate" => "Basic blah"}
+
+    req = Rack::MockRequest.new(Rack::ShowStatus.new(lambda { |env| [401, headers, []] }))
+    res = req.get("/", :lint => true)
+
+    res["WWW-Authenticate"].should.equal("Basic blah")
+  end
+
+  specify "should replace existing messages if there is detail" do
+    req = Rack::MockRequest.new(Rack::ShowStatus.new(lambda { |env|
+                                                       env["rack.showstatus.detail"] = "gone too meta."
+                                                       [404, {"Content-Type" => "text/plain", "Content-Length" => "4"}, ["foo!"]]
+                                                     }))
+
+    res = req.get("/", :lint => true)
+    res.should.be.not_found
+    res.should.be.not.empty
+
+    res["Content-Type"].should.equal("text/html")
+    res["Content-Length"].should.not.equal("4")
+    res.should =~ /404/
+    res.should =~ /too meta/
+    res.body.should.not =~ /foo/
+  end
+end

data/vendor/rack/test/spec_rack_static.rb

@@ -0,0 +1,37 @@
+require 'test/spec'
+
+require 'rack/static'
+require 'rack/mock'
+
+class DummyApp
+  def call(env)
+    [200, {}, "Hello World"]
+  end
+end
+
+context "Rack::Static" do
+  root = File.expand_path(File.dirname(__FILE__))
+  OPTIONS = {:urls => ["/cgi"], :root => root}
+
+  setup do
+    @request = Rack::MockRequest.new(Rack::Static.new(DummyApp.new, OPTIONS))
+  end
+
+  specify "serves files" do
+    res = @request.get("/cgi/test")
+    res.should.be.ok
+    res.body.should =~ /ruby/
+  end
+
+  specify "404s if url root is known but it can't find the file" do
+    res = @request.get("/cgi/foo")
+    res.should.be.not_found
+  end
+
+  specify "calls down the chain if url root is not known" do
+    res = @request.get("/something/else")
+    res.should.be.ok
+    res.body.should == "Hello World"
+  end
+
+end

data/vendor/rack/test/spec_rack_thin.rb

@@ -0,0 +1,90 @@
+require 'test/spec'
+
+begin
+require 'rack/handler/thin'
+require 'testrequest'
+require 'timeout'
+  
+context "Rack::Handler::Thin" do
+  include TestRequest::Helpers
+  
+  setup do
+    @app = Rack::Lint.new(TestRequest.new)
+    Thin::Logging.silent = true
+    @thread = Thread.new do
+      Rack::Handler::Thin.run(@app, :Host => @host='0.0.0.0', :Port => @port=9201) do |server|
+        @server = server
+      end
+    end
+    Thread.pass until @server && @server.running?
+  end
+
+  specify "should respond" do
+    lambda {
+      GET("/")
+    }.should.not.raise
+  end
+
+  specify "should be a Thin" do
+    GET("/")
+    status.should.be 200
+    response["SERVER_SOFTWARE"].should =~ /thin/
+    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("/")
+    response["rack.version"].should.equal [0,3]
+    response["rack.multithread"].should.be false
+    response["rack.multiprocess"].should.be false
+    response["rack.run_once"].should.be false
+  end
+
+  specify "should have CGI headers on GET" do
+    GET("/")
+    response["REQUEST_METHOD"].should.equal "GET"
+    response["REQUEST_PATH"].should.equal "/"
+    response["PATH_INFO"].should.be.equal "/"
+    response["QUERY_STRING"].should.equal ""
+    response["test.postdata"].should.equal ""
+
+    GET("/test/foo?quux=1")
+    response["REQUEST_METHOD"].should.equal "GET"
+    response["REQUEST_PATH"].should.equal "/test/foo"
+    response["PATH_INFO"].should.equal "/test/foo"
+    response["QUERY_STRING"].should.equal "quux=1"
+  end
+
+  specify "should have CGI headers on POST" do
+    POST("/", {"rack-form-data" => "23"}, {'X-test-header' => '42'})
+    status.should.equal 200
+    response["REQUEST_METHOD"].should.equal "POST"
+    response["REQUEST_PATH"].should.equal "/"
+    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
+
+  teardown do
+    @server.stop!
+    @thread.kill
+  end
+end
+
+rescue LoadError
+  $stderr.puts "Skipping Rack::Handler::Thin tests (Thin is required). `gem install thin` and try again."
+end

data/vendor/rack/test/spec_rack_urlmap.rb

@@ -0,0 +1,175 @@
+require 'test/spec'
+
+require 'rack/urlmap'
+require 'rack/mock'
+
+context "Rack::URLMap" do
+  specify "dispatches paths correctly" do
+    app = lambda { |env|
+      [200, {
+        'X-ScriptName' => env['SCRIPT_NAME'],
+        'X-PathInfo' => env['PATH_INFO'],
+        'Content-Type' => 'text/plain'
+      }, [""]]
+    }
+    map = Rack::URLMap.new({
+      'http://foo.org/bar' => app,
+      '/foo' => app,
+      '/foo/bar' => app
+    })
+
+    res = Rack::MockRequest.new(map).get("/")
+    res.should.be.not_found
+
+    res = Rack::MockRequest.new(map).get("/qux")
+    res.should.be.not_found
+
+    res = Rack::MockRequest.new(map).get("/foo")
+    res.should.be.ok
+    res["X-ScriptName"].should.equal "/foo"
+    res["X-PathInfo"].should.equal ""
+
+    res = Rack::MockRequest.new(map).get("/foo/")
+    res.should.be.ok
+    res["X-ScriptName"].should.equal "/foo"
+    res["X-PathInfo"].should.equal "/"
+
+    res = Rack::MockRequest.new(map).get("/foo/bar")
+    res.should.be.ok
+    res["X-ScriptName"].should.equal "/foo/bar"
+    res["X-PathInfo"].should.equal ""
+
+    res = Rack::MockRequest.new(map).get("/foo/bar/")
+    res.should.be.ok
+    res["X-ScriptName"].should.equal "/foo/bar"
+    res["X-PathInfo"].should.equal "/"
+
+    res = Rack::MockRequest.new(map).get("/foo/quux", "SCRIPT_NAME" => "/bleh")
+    res.should.be.ok
+    res["X-ScriptName"].should.equal "/bleh/foo"
+    res["X-PathInfo"].should.equal "/quux"
+
+    res = Rack::MockRequest.new(map).get("/bar", 'HTTP_HOST' => 'foo.org')
+    res.should.be.ok
+    res["X-ScriptName"].should.equal "/bar"
+    res["X-PathInfo"].should.be.empty
+
+    res = Rack::MockRequest.new(map).get("/bar/", 'HTTP_HOST' => 'foo.org')
+    res.should.be.ok
+    res["X-ScriptName"].should.equal "/bar"
+    res["X-PathInfo"].should.equal '/'
+  end
+
+
+  specify "dispatches hosts correctly" do
+    map = Rack::URLMap.new("http://foo.org/" => lambda { |env|
+                             [200,
+                              { "Content-Type" => "text/plain",
+                                "X-Position" => "foo.org",
+                                "X-Host" => env["HTTP_HOST"] || env["SERVER_NAME"],
+                              }, [""]]},
+                           "http://bar.org/" => lambda { |env|
+                             [200,
+                              { "Content-Type" => "text/plain",
+                                "X-Position" => "bar.org",
+                                "X-Host" => env["HTTP_HOST"] || env["SERVER_NAME"],
+                              }, [""]]},
+                           "/" => lambda { |env|
+                             [200,
+                              { "Content-Type" => "text/plain",
+                                "X-Position" => "default.org",
+                                "X-Host" => env["HTTP_HOST"] || env["SERVER_NAME"],
+                              }, [""]]}
+                           )
+
+    res = Rack::MockRequest.new(map).get("/")
+    res.should.be.ok
+    res["X-Position"].should.equal "default.org"
+
+    res = Rack::MockRequest.new(map).get("/", "HTTP_HOST" => "bar.org")
+    res.should.be.ok
+    res["X-Position"].should.equal "bar.org"
+
+    res = Rack::MockRequest.new(map).get("/", "HTTP_HOST" => "foo.org")
+    res.should.be.ok
+    res["X-Position"].should.equal "foo.org"
+
+    res = Rack::MockRequest.new(map).get("http://foo.org/")
+    res.should.be.ok
+    res["X-Position"].should.equal "default.org"
+
+    res = Rack::MockRequest.new(map).get("/", "HTTP_HOST" => "example.org")
+    res.should.be.ok
+    res["X-Position"].should.equal "default.org"
+
+    res = Rack::MockRequest.new(map).get("/",
+                                         "HTTP_HOST" => "example.org:9292",
+                                         "SERVER_PORT" => "9292")
+    res.should.be.ok
+    res["X-Position"].should.equal "default.org"
+  end
+
+  specify "should be nestable" do
+    map = Rack::URLMap.new("/foo" =>
+      Rack::URLMap.new("/bar" =>
+        Rack::URLMap.new("/quux" =>  lambda { |env|
+                           [200,
+                            { "Content-Type" => "text/plain",
+                              "X-Position" => "/foo/bar/quux",
+                              "X-PathInfo" => env["PATH_INFO"],
+                              "X-ScriptName" => env["SCRIPT_NAME"],
+                            }, [""]]}
+                         )))
+
+    res = Rack::MockRequest.new(map).get("/foo/bar")
+    res.should.be.not_found
+
+    res = Rack::MockRequest.new(map).get("/foo/bar/quux")
+    res.should.be.ok
+    res["X-Position"].should.equal "/foo/bar/quux"
+    res["X-PathInfo"].should.equal ""
+    res["X-ScriptName"].should.equal "/foo/bar/quux"
+  end
+
+  specify "should route root apps correctly" do
+    map = Rack::URLMap.new("/" => lambda { |env|
+                             [200,
+                              { "Content-Type" => "text/plain",
+                                "X-Position" => "root",
+                                "X-PathInfo" => env["PATH_INFO"],
+                                "X-ScriptName" => env["SCRIPT_NAME"]
+                              }, [""]]},
+                           "/foo" => lambda { |env|
+                             [200,
+                              { "Content-Type" => "text/plain",
+                                "X-Position" => "foo",
+                                "X-PathInfo" => env["PATH_INFO"],
+                                "X-ScriptName" => env["SCRIPT_NAME"]
+                              }, [""]]}
+                           )
+
+    res = Rack::MockRequest.new(map).get("/foo/bar")
+    res.should.be.ok
+    res["X-Position"].should.equal "foo"
+    res["X-PathInfo"].should.equal "/bar"
+    res["X-ScriptName"].should.equal "/foo"
+
+    res = Rack::MockRequest.new(map).get("/foo")
+    res.should.be.ok
+    res["X-Position"].should.equal "foo"
+    res["X-PathInfo"].should.equal ""
+    res["X-ScriptName"].should.equal "/foo"
+
+    res = Rack::MockRequest.new(map).get("/bar")
+    res.should.be.ok
+    res["X-Position"].should.equal "root"
+    res["X-PathInfo"].should.equal "/bar"
+    res["X-ScriptName"].should.equal ""
+
+    res = Rack::MockRequest.new(map).get("")
+    res.should.be.ok
+    res["X-Position"].should.equal "root"
+    res["X-PathInfo"].should.equal "/"
+    res["X-ScriptName"].should.equal ""
+  end
+end

data/vendor/rack/test/spec_rack_utils.rb

@@ -0,0 +1,176 @@
+require 'test/spec'
+
+require 'rack/utils'
+require 'rack/lint'
+require 'rack/mock'
+
+context "Rack::Utils" do
+  specify "should escape correctly" do
+    Rack::Utils.escape("fo<o>bar").should.equal "fo%3Co%3Ebar"
+    Rack::Utils.escape("a space").should.equal "a+space"
+    Rack::Utils.escape("q1!2\"'w$5&7/z8)?\\").
+      should.equal "q1%212%22%27w%245%267%2Fz8%29%3F%5C"
+  end
+
+  specify "should unescape correctly" do
+    Rack::Utils.unescape("fo%3Co%3Ebar").should.equal "fo<o>bar"
+    Rack::Utils.unescape("a+space").should.equal "a space"
+    Rack::Utils.unescape("a%20space").should.equal "a space"
+    Rack::Utils.unescape("q1%212%22%27w%245%267%2Fz8%29%3F%5C").
+      should.equal "q1!2\"'w$5&7/z8)?\\"
+  end
+
+  specify "should parse query strings correctly" do
+    Rack::Utils.parse_query("foo=bar").should.equal "foo" => "bar"
+    Rack::Utils.parse_query("foo=bar&foo=quux").
+      should.equal "foo" => ["bar", "quux"]
+    Rack::Utils.parse_query("foo=1&bar=2").
+      should.equal "foo" => "1", "bar" => "2"
+    Rack::Utils.parse_query("my+weird+field=q1%212%22%27w%245%267%2Fz8%29%3F").
+      should.equal "my weird field" => "q1!2\"'w$5&7/z8)?"
+  end
+  
+  specify "should build query strings correctly" do
+    Rack::Utils.build_query("foo" => "bar").should.equal "foo=bar"
+    Rack::Utils.build_query("foo" => ["bar", "quux"]).
+      should.equal "foo=bar&foo=quux"
+    Rack::Utils.build_query("foo" => "1", "bar" => "2").
+      should.equal "foo=1&bar=2"
+    Rack::Utils.build_query("my weird field" => "q1!2\"'w$5&7/z8)?").
+      should.equal "my+weird+field=q1%212%22%27w%245%267%2Fz8%29%3F"
+  end
+
+  specify "should figure out which encodings are acceptable" do
+    helper = lambda do |a, b|
+      request = Rack::Request.new(Rack::MockRequest.env_for("", "HTTP_ACCEPT_ENCODING" => a))
+      Rack::Utils.select_best_encoding(a, b)
+    end
+
+    helper.call(%w(), [["x", 1]]).should.equal(nil)
+    helper.call(%w(identity), [["identity", 0.0]]).should.equal(nil)
+    helper.call(%w(identity), [["*", 0.0]]).should.equal(nil)
+
+    helper.call(%w(identity), [["compress", 1.0], ["gzip", 1.0]]).should.equal("identity")
+
+    helper.call(%w(compress gzip identity), [["compress", 1.0], ["gzip", 1.0]]).should.equal("compress")
+    helper.call(%w(compress gzip identity), [["compress", 0.5], ["gzip", 1.0]]).should.equal("gzip")
+
+    helper.call(%w(foo bar identity), []).should.equal("identity")
+    helper.call(%w(foo bar identity), [["*", 1.0]]).should.equal("foo")
+    helper.call(%w(foo bar identity), [["*", 1.0], ["foo", 0.9]]).should.equal("bar")
+
+    helper.call(%w(foo bar identity), [["foo", 0], ["bar", 0]]).should.equal("identity")
+    helper.call(%w(foo bar baz identity), [["*", 0], ["identity", 0.1]]).should.equal("identity")
+  end
+end
+
+context "Rack::Utils::HeaderHash" do
+  specify "should retain header case" do
+    h = Rack::Utils::HeaderHash.new("Content-MD5" => "d5ff4e2a0 ...")
+    h['ETag'] = 'Boo!'
+    h.to_hash.should.equal "Content-MD5" => "d5ff4e2a0 ...", "ETag" => 'Boo!'
+  end
+
+  specify "should check existence of keys case insensitively" do
+    h = Rack::Utils::HeaderHash.new("Content-MD5" => "d5ff4e2a0 ...")
+    h.should.include 'content-md5'
+    h.should.not.include 'ETag'
+  end
+
+  specify "should merge case-insensitively" do
+    h = Rack::Utils::HeaderHash.new("ETag" => 'HELLO', "content-length" => '123')
+    merged = h.merge("Etag" => 'WORLD', 'Content-Length' => '321', "Foo" => 'BAR')
+    merged.should.equal "Etag"=>'WORLD', "Content-Length"=>'321', "Foo"=>'BAR'
+  end
+
+  specify "should overwrite case insensitively and assume the new key's case" do
+    h = Rack::Utils::HeaderHash.new("Foo-Bar" => "baz")
+    h["foo-bar"] = "bizzle"
+    h["FOO-BAR"].should.equal "bizzle"
+    h.length.should.equal 1
+    h.to_hash.should.equal "foo-bar" => "bizzle"
+  end
+
+  specify "should be converted to real Hash" do
+    h = Rack::Utils::HeaderHash.new("foo" => "bar")
+    h.to_hash.should.be.instance_of Hash
+  end
+end
+
+context "Rack::Utils::Context" do
+  test_app1 = Object.new
+  def test_app1.context app
+    Rack::Utils::Context.new self, app do |env|
+      app.call env
+    end
+  end
+  test_app2 = Object.new
+  def test_app2.context env; end
+  test_app3 = Object.new
+  test_target1 = proc{|e| e.to_s+' world' }
+  test_target2 = proc{|e| e.to_i+2 }
+  test_target3 = proc{|e| nil }
+  test_target4 = proc{|e| [200,{'Content-Type'=>'text/plain', 'Content-Length'=>'0'},['']] }
+  test_target5 = Object.new
+
+  specify "should perform checks on both arguments" do
+    lambda { Rack::Utils::Context.new(nil, nil){} }.should.raise
+    lambda { Rack::Utils::Context.new(test_app1, nil){} }.should.raise
+    lambda { Rack::Utils::Context.new(nil, test_target1){} }.should.raise
+    lambda { Rack::Utils::Context.new(test_app1, test_target1){} }.should.not.raise
+    lambda { Rack::Utils::Context.new(test_app3, test_target1){} }.should.raise
+    lambda { Rack::Utils::Context.new(test_app1, test_target5){} }.should.raise
+    lambda { test_app1.context(nil){} }.should.raise
+    lambda { test_app1.context(test_target1){} }.should.not.raise
+    lambda { test_app1.context(test_target5){} }.should.raise
+  end
+
+  specify "should set context correctly" do
+    c1 = Rack::Utils::Context.new(test_app1, test_target1){}
+    c1.for.should.equal test_app1
+    c1.app.should.equal test_target1
+    c2 = Rack::Utils::Context.new(test_app1, test_target2){}
+    c2.for.should.equal test_app1
+    c2.app.should.equal test_target2
+    c3 = Rack::Utils::Context.new(test_app2, test_target3){}
+    c3.for.should.equal test_app2
+    c3.app.should.equal test_target3
+    c4 = Rack::Utils::Context.new(test_app2, test_target4){}
+    c4.for.should.equal test_app2
+    c4.app.should.equal test_target4
+  end
+
+  specify "should alter app on recontexting" do
+    c1 = Rack::Utils::Context.new(test_app1, test_target1){}
+    c1.for.should.equal test_app1
+    c1.app.should.equal test_target1
+    c2 = c1.context(test_target2)
+    c2.for.should.equal test_app1
+    c2.app.should.not.equal test_target1
+    c2.app.should.equal test_target2
+    c3 = c2.context(test_target3)
+    c3.for.should.equal test_app1
+    c3.app.should.not.equal test_target2
+    c3.app.should.equal test_target3
+    c4 = c3.context(test_target4)
+    c4.for.should.equal test_app1
+    c4.app.should.not.equal test_target3
+    c4.app.should.equal test_target4
+  end
+
+  specify "should run different apps" do
+    c1 = test_app1.context(test_target1)
+    c2 = c1.context test_target2
+    c3 = c2.context test_target3
+    c4 = c3.context test_target4
+    a4 = Rack::Lint.new c4
+    r1 = c1.call('hello')
+    r1.should.equal 'hello world'
+    r2 = c2.call(2)
+    r2.should.equal 4
+    r3 = c3.call(:misc_symbol)
+    r3.should.be.nil
+    r4 = Rack::MockRequest.new(a4).get('/')
+    r4.status.should.be 200
+  end
+end