rack 1.0.1 → 2.2.21

data/test/spec_rack_session_pool.rb

@@ -1,172 +0,0 @@
-require 'test/spec'
-
-require 'rack/session/pool'
-require 'rack/mock'
-require 'rack/response'
-require 'thread'
-
-context "Rack::Session::Pool" do
-  session_key = Rack::Session::Pool::DEFAULT_OPTIONS[:key]
-  session_match = /#{session_key}=[0-9a-fA-F]+;/
-  incrementor = lambda do |env|
-    env["rack.session"]["counter"] ||= 0
-    env["rack.session"]["counter"] += 1
-    Rack::Response.new(env["rack.session"].inspect).to_a
-  end
-  drop_session = proc do |env|
-    env['rack.session.options'][:drop] = true
-    incrementor.call(env)
-  end
-  renew_session = proc do |env|
-    env['rack.session.options'][:renew] = true
-    incrementor.call(env)
-  end
-  defer_session = proc do |env|
-    env['rack.session.options'][:defer] = true
-    incrementor.call(env)
-  end
-
-  specify "creates a new cookie" do
-    pool = Rack::Session::Pool.new(incrementor)
-    res = Rack::MockRequest.new(pool).get("/")
-    res["Set-Cookie"].should.match session_match
-    res.body.should.equal '{"counter"=>1}'
-  end
-
-  specify "determines session from a cookie" do
-    pool = Rack::Session::Pool.new(incrementor)
-    req = Rack::MockRequest.new(pool)
-    cookie = req.get("/")["Set-Cookie"]
-    req.get("/", "HTTP_COOKIE" => cookie).
-      body.should.equal '{"counter"=>2}'
-    req.get("/", "HTTP_COOKIE" => cookie).
-      body.should.equal '{"counter"=>3}'
-  end
-
-  specify "survives nonexistant cookies" do
-    pool = Rack::Session::Pool.new(incrementor)
-    res = Rack::MockRequest.new(pool).
-      get("/", "HTTP_COOKIE" => "#{session_key}=blarghfasel")
-    res.body.should.equal '{"counter"=>1}'
-  end
-
-  specify "deletes cookies with :drop option" do
-    pool = Rack::Session::Pool.new(incrementor)
-    req = Rack::MockRequest.new(pool)
-    drop = Rack::Utils::Context.new(pool, drop_session)
-    dreq = Rack::MockRequest.new(drop)
-
-    res0 = req.get("/")
-    session = (cookie = res0["Set-Cookie"])[session_match]
-    res0.body.should.equal '{"counter"=>1}'
-    pool.pool.size.should.be 1
-
-    res1 = req.get("/", "HTTP_COOKIE" => cookie)
-    res1["Set-Cookie"][session_match].should.equal session
-    res1.body.should.equal '{"counter"=>2}'
-    pool.pool.size.should.be 1
-
-    res2 = dreq.get("/", "HTTP_COOKIE" => cookie)
-    res2["Set-Cookie"].should.equal nil
-    res2.body.should.equal '{"counter"=>3}'
-    pool.pool.size.should.be 0
-
-    res3 = req.get("/", "HTTP_COOKIE" => cookie)
-    res3["Set-Cookie"][session_match].should.not.equal session
-    res3.body.should.equal '{"counter"=>1}'
-    pool.pool.size.should.be 1
-  end
-
-  specify "provides new session id with :renew option" do
-    pool = Rack::Session::Pool.new(incrementor)
-    req = Rack::MockRequest.new(pool)
-    renew = Rack::Utils::Context.new(pool, renew_session)
-    rreq = Rack::MockRequest.new(renew)
-
-    res0 = req.get("/")
-    session = (cookie = res0["Set-Cookie"])[session_match]
-    res0.body.should.equal '{"counter"=>1}'
-    pool.pool.size.should.be 1
-
-    res1 = req.get("/", "HTTP_COOKIE" => cookie)
-    res1["Set-Cookie"][session_match].should.equal session
-    res1.body.should.equal '{"counter"=>2}'
-    pool.pool.size.should.be 1
-
-    res2 = rreq.get("/", "HTTP_COOKIE" => cookie)
-    new_cookie = res2["Set-Cookie"]
-    new_session = new_cookie[session_match]
-    new_session.should.not.equal session
-    res2.body.should.equal '{"counter"=>3}'
-    pool.pool.size.should.be 1
-
-    res3 = req.get("/", "HTTP_COOKIE" => new_cookie)
-    res3["Set-Cookie"][session_match].should.equal new_session
-    res3.body.should.equal '{"counter"=>4}'
-    pool.pool.size.should.be 1
-  end
-
-  specify "omits cookie with :defer option" do
-    pool = Rack::Session::Pool.new(incrementor)
-    req = Rack::MockRequest.new(pool)
-    defer = Rack::Utils::Context.new(pool, defer_session)
-    dreq = Rack::MockRequest.new(defer)
-
-    res0 = req.get("/")
-    session = (cookie = res0["Set-Cookie"])[session_match]
-    res0.body.should.equal '{"counter"=>1}'
-    pool.pool.size.should.be 1
-
-    res1 = req.get("/", "HTTP_COOKIE" => cookie)
-    res1["Set-Cookie"][session_match].should.equal session
-    res1.body.should.equal '{"counter"=>2}'
-    pool.pool.size.should.be 1
-
-    res2 = dreq.get("/", "HTTP_COOKIE" => cookie)
-    res2["Set-Cookie"].should.equal nil
-    res2.body.should.equal '{"counter"=>3}'
-    pool.pool.size.should.be 1
-
-    res3 = req.get("/", "HTTP_COOKIE" => cookie)
-    res3["Set-Cookie"][session_match].should.equal session
-    res3.body.should.equal '{"counter"=>4}'
-    pool.pool.size.should.be 1
-  end
-
-  # anyone know how to do this better?
-  specify "multithread: should merge sessions" do
-    next unless $DEBUG
-    warn 'Running multithread tests for Session::Pool'
-    pool = Rack::Session::Pool.new(incrementor)
-    req = Rack::MockRequest.new(pool)
-
-    res = req.get('/')
-    res.body.should.equal '{"counter"=>1}'
-    cookie = res["Set-Cookie"]
-    sess_id = cookie[/#{pool.key}=([^,;]+)/,1]
-
-    delta_incrementor = lambda do |env|
-      # emulate disconjoinment of threading
-      env['rack.session'] = env['rack.session'].dup
-      Thread.stop
-      env['rack.session'][(Time.now.usec*rand).to_i] = true
-      incrementor.call(env)
-    end
-    tses = Rack::Utils::Context.new pool, delta_incrementor
-    treq = Rack::MockRequest.new(tses)
-    tnum = rand(7).to_i+5
-    r = Array.new(tnum) do
-      Thread.new(treq) do |run|
-        run.get('/', "HTTP_COOKIE" => cookie, 'rack.multithread' => true)
-      end
-    end.reverse.map{|t| t.run.join.value }
-    r.each do |res|
-      res['Set-Cookie'].should.equal cookie
-      res.body.should.include '"counter"=>2'
-    end
-
-    session = pool.pool[sess_id]
-    session.size.should.be tnum+1 # counter
-    session['counter'].should.be 2 # meeeh
-  end
-end

data/test/spec_rack_showexceptions.rb

@@ -1,21 +0,0 @@
-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/test/spec_rack_showstatus.rb

@@ -1,72 +0,0 @@
-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/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/test/spec_rack_thin.rb

@@ -1,91 +0,0 @@
-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)
-    @server = nil
-    Thin::Logging.silent = true
-    @thread = Thread.new do
-      Rack::Handler::Thin.run(@app, :Host => @host='0.0.0.0', :Port => @port=9204) 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 "9204"
-    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/test/spec_rack_urlmap.rb

@@ -1,185 +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://subdomain.foo.org/" => lambda { |env|
-                             [200,
-                              { "Content-Type" => "text/plain",
-                                "X-Position" => "subdomain.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_HOST" => "subdomain.foo.org", "SERVER_NAME" => "foo.org")
-    res.should.be.ok
-    res["X-Position"].should.equal "subdomain.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