sinatra 0.2.2 → 0.3.0

data/vendor/rack/test/spec_rack_static.rb

@@ -1,37 +0,0 @@
-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_urlmap.rb

@@ -1,175 +0,0 @@
-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

@@ -1,57 +0,0 @@
-require 'rack/utils'
-
-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 queries 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("my+weird+field=q1%212%22%27w%245%267%2Fz8%29%3F").
-      should.equal "my weird field" => "q1!2\"'w$5&7/z8)?"
-  end
-end
-
-context "Rack::Utils::HeaderHash" do
-  specify "should capitalize on all accesses" do
-    h = Rack::Utils::HeaderHash.new("foo" => "bar")
-    h["foo"].should.equal "bar"
-    h["Foo"].should.equal "bar"
-    h["FOO"].should.equal "bar"
-
-    h.to_hash.should.equal "Foo" => "bar"
-
-    h["bar-zzle"] = "quux"
-
-    h.to_hash.should.equal "Foo" => "bar", "Bar-Zzle" => "quux"
-  end
-
-  specify "should capitalize correctly" do
-    h = Rack::Utils::HeaderHash.new
-
-    h.capitalize("foo").should.equal "Foo"
-    h.capitalize("foo-bar").should.equal "Foo-Bar"
-    h.capitalize("foo_bar").should.equal "Foo_Bar"
-    h.capitalize("foo bar").should.equal "Foo Bar"
-    h.capitalize("foo-bar-quux").should.equal "Foo-Bar-Quux"
-    h.capitalize("foo-bar-2quux").should.equal "Foo-Bar-2quux"
-  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

data/vendor/rack/test/spec_rack_webrick.rb

@@ -1,106 +0,0 @@
-require 'test/spec'
-
-require 'rack/handler/webrick'
-require 'rack/lint'
-require 'testrequest'
-
-Thread.abort_on_exception = true
-
-context "Rack::Handler::WEBrick" do
-  include TestRequest::Helpers
-  
-  setup do
-    @server = WEBrick::HTTPServer.new(:Host => @host='0.0.0.0',
-                                      :Port => @port=9202,
-                                      :Logger => WEBrick::Log.new(nil, WEBrick::BasicLog::WARN),
-                                      :AccessLog => [])
-    @server.mount "/test", Rack::Handler::WEBrick,
-      Rack::Lint.new(TestRequest.new)
-    Thread.new { @server.start }
-    trap(:INT) { @server.shutdown }
-  end
-
-  specify "should respond" do
-    lambda {
-      GET("/test")
-    }.should.not.raise
-  end
-
-  specify "should be a WEBrick" do
-    GET("/test")
-    status.should.be 200
-    response["SERVER_SOFTWARE"].should =~ /WEBrick/
-    response["HTTP_VERSION"].should.equal "HTTP/1.1"
-    response["SERVER_PROTOCOL"].should.equal "HTTP/1.1"
-    response["SERVER_PORT"].should.equal "9202"
-    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 "/"
-    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 "/"
-    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 "/"
-    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
-    catch(:done) {
-      Rack::Handler::WEBrick.run(lambda {},
-                                 {:Port => 9210,
-                                   :Logger => WEBrick::Log.new(nil, WEBrick::BasicLog::WARN),
-                                   :AccessLog => []}) { |server|
-        block_ran = true
-        server.should.be.kind_of WEBrick::HTTPServer
-        @s = server
-        throw :done
-      }
-    }
-    block_ran.should.be true
-    @s.shutdown
-  end
-
-  teardown do
-    @server.shutdown
-  end
-end

data/vendor/rack/test/testrequest.rb

@@ -1,43 +0,0 @@
-require 'yaml'
-require 'net/http'
-
-class TestRequest
-  def call(env)
-    status = env["QUERY_STRING"] =~ /secret/ ? 403 : 200
-    env["test.postdata"] = env["rack.input"].read
-    [status, {"Content-Type" => "text/yaml"}, [env.to_yaml]]
-  end
-
-  module Helpers
-    attr_reader :status, :response
-
-    def GET(path, header={})
-      Net::HTTP.start(@host, @port) { |http|
-        user = header.delete(:user)
-        passwd = header.delete(:passwd)
-
-        get = Net::HTTP::Get.new(path, header)
-        get.basic_auth user, passwd  if user && passwd
-        http.request(get) { |response|
-          @status = response.code.to_i
-          @response = YAML.load(response.body)
-        }
-      }
-    end
-
-    def POST(path, formdata={}, header={})
-      Net::HTTP.start(@host, @port) { |http|
-        user = header.delete(:user)
-        passwd = header.delete(:passwd)
-
-        post = Net::HTTP::Post.new(path, header)
-        post.form_data = formdata
-        post.basic_auth user, passwd  if user && passwd
-        http.request(post) { |response|
-          @status = response.code.to_i
-          @response = YAML.load(response.body)
-        }
-      }
-    end
-  end
-end