edgar-rack 1.2.1

data/test/spec_session_pool.rb

@@ -0,0 +1,200 @@
+require 'thread'
+require 'rack/mock'
+require 'rack/session/pool'
+
+describe 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
+
+  session_id = lambda do |env|
+    Rack::Response.new(env["rack.session"].inspect).to_a
+  end
+
+  nothing = lambda do |env|
+    Rack::Response.new("Nothing").to_a
+  end
+
+  drop_session = lambda do |env|
+    env['rack.session.options'][:drop] = true
+    incrementor.call(env)
+  end
+
+  renew_session = lambda do |env|
+    env['rack.session.options'][:renew] = true
+    incrementor.call(env)
+  end
+
+  defer_session = lambda do |env|
+    env['rack.session.options'][:defer] = true
+    incrementor.call(env)
+  end
+
+  it "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
+
+  it "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
+
+  it "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
+
+  it "does not send the same session id if it did not change" do
+    pool = Rack::Session::Pool.new(incrementor)
+    req = Rack::MockRequest.new(pool)
+
+    res0 = req.get("/")
+    cookie = res0["Set-Cookie"][session_match]
+    res0.body.should.equal '{"counter"=>1}'
+    pool.pool.size.should.equal 1
+
+    res1 = req.get("/", "HTTP_COOKIE" => cookie)
+    res1["Set-Cookie"].should.be.nil
+    res1.body.should.equal '{"counter"=>2}'
+    pool.pool.size.should.equal 1
+
+    res2 = req.get("/", "HTTP_COOKIE" => cookie)
+    res2["Set-Cookie"].should.be.nil
+    res2.body.should.equal '{"counter"=>3}'
+    pool.pool.size.should.equal 1
+  end
+
+  it "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)
+
+    res1 = req.get("/")
+    session = (cookie = res1["Set-Cookie"])[session_match]
+    res1.body.should.equal '{"counter"=>1}'
+    pool.pool.size.should.equal 1
+
+    res2 = dreq.get("/", "HTTP_COOKIE" => cookie)
+    res2["Set-Cookie"].should.be.nil
+    res2.body.should.equal '{"counter"=>2}'
+    pool.pool.size.should.equal 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.equal 1
+  end
+
+  it "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)
+
+    res1 = req.get("/")
+    session = (cookie = res1["Set-Cookie"])[session_match]
+    res1.body.should.equal '{"counter"=>1}'
+    pool.pool.size.should.equal 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"=>2}'
+    pool.pool.size.should.equal 1
+
+    res3 = req.get("/", "HTTP_COOKIE" => new_cookie)
+    res3.body.should.equal '{"counter"=>3}'
+    pool.pool.size.should.equal 1
+
+    res4 = req.get("/", "HTTP_COOKIE" => cookie)
+    res4.body.should.equal '{"counter"=>1}'
+    pool.pool.size.should.equal 2
+  end
+
+  it "omits cookie with :defer option" do
+    pool = Rack::Session::Pool.new(incrementor)
+    defer = Rack::Utils::Context.new(pool, defer_session)
+    dreq = Rack::MockRequest.new(defer)
+
+    res1 = dreq.get("/")
+    res1["Set-Cookie"].should.equal nil
+    res1.body.should.equal '{"counter"=>1}'
+    pool.pool.size.should.equal 1
+  end
+
+  # anyone know how to do this better?
+  it "should merge sessions when multithreaded" do
+    unless $DEBUG
+      1.should.equal 1
+      next
+    end
+
+    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 |resp|
+      resp['Set-Cookie'].should.equal cookie
+      resp.body.should.include '"counter"=>2'
+    end
+
+    session = pool.pool[sess_id]
+    session.size.should.equal tnum+1 # counter
+    session['counter'].should.equal 2 # meeeh
+  end
+
+  it "does not return a cookie if cookie was not read/written" do
+    app = Rack::Session::Cookie.new(nothing)
+    res = Rack::MockRequest.new(app).get("/")
+    res["Set-Cookie"].should.be.nil
+  end
+
+  it "does not return a cookie if cookie was not written (only read)" do
+    app = Rack::Session::Cookie.new(session_id)
+    res = Rack::MockRequest.new(app).get("/")
+    res["Set-Cookie"].should.be.nil
+  end
+
+  it "returns even if not read/written if :expire_after is set" do
+    app = Rack::Session::Cookie.new(nothing, :expire_after => 3600)
+    res = Rack::MockRequest.new(app).get("/")
+    res["Set-Cookie"].should.not.be.nil
+  end
+end

data/test/spec_showexceptions.rb

@@ -0,0 +1,87 @@
+require 'rack/showexceptions'
+require 'rack/mock'
+
+describe Rack::ShowExceptions do
+  it "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
+
+  it "responds with plain text on AJAX requests accepting anything but HTML" do
+    res = nil
+
+    req = Rack::MockRequest.new(
+      Rack::ShowExceptions.new(
+        lambda{|env| raise RuntimeError, "It was never supposed to work" }
+    ))
+
+    lambda{
+      res = req.get("/", "HTTP_X_REQUESTED_WITH" => "XMLHttpRequest")
+    }.should.not.raise
+
+    res.should.be.a.server_error
+    res.status.should.equal 500
+
+    res.content_type.should.equal "text/plain"
+
+    res.body.should.include "RuntimeError: It was never supposed to work\n"
+    res.body.should.include __FILE__
+  end
+
+  it "responds with HTML on AJAX requests accepting HTML" do
+    res = nil
+
+    req = Rack::MockRequest.new(
+      Rack::ShowExceptions.new(
+        lambda{|env| raise RuntimeError, "It was never supposed to work" }
+    ))
+
+    lambda{
+      res = req.get("/", "HTTP_X_REQUESTED_WITH" => "XMLHttpRequest", "HTTP_ACCEPT" => "text/html")
+    }.should.not.raise
+
+    res.should.be.a.server_error
+    res.status.should.equal 500
+
+    res.content_type.should.equal "text/html"
+
+    res.body.should.include "RuntimeError"
+    res.body.should.include "It was never supposed to work"
+    res.body.should.include Rack::Utils.escape_html(__FILE__)
+  end
+
+  it "handles exceptions without a backtrace" 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/
+    res.should =~ /unknown location/
+  end
+end

data/test/spec_showstatus.rb

@@ -0,0 +1,79 @@
+require 'rack/showstatus'
+require 'rack/mock'
+
+describe Rack::ShowStatus do
+  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
+
+  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
+
+  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
+
+  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
+
+  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_static.rb

@@ -0,0 +1,48 @@
+require 'rack/static'
+require 'rack/mock'
+
+class DummyApp
+  def call(env)
+    [200, {}, ["Hello World"]]
+  end
+end
+
+describe Rack::Static do
+  root = File.expand_path(File.dirname(__FILE__))
+
+  OPTIONS = {:urls => ["/cgi"], :root => root}
+  HASH_OPTIONS = {:urls => {"/cgi/sekret" => 'cgi/test'}, :root => root}
+
+  @request = Rack::MockRequest.new(Rack::Static.new(DummyApp.new, OPTIONS))
+  @hash_request = Rack::MockRequest.new(Rack::Static.new(DummyApp.new, HASH_OPTIONS))
+
+  it "serves files" do
+    res = @request.get("/cgi/test")
+    res.should.be.ok
+    res.body.should =~ /ruby/
+  end
+
+  it "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
+
+  it "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
+
+  it "serves hidden files" do
+    res = @hash_request.get("/cgi/sekret")
+    res.should.be.ok
+    res.body.should =~ /ruby/
+  end
+
+  it "calls down the chain if the URI is not specified" do
+    res = @hash_request.get("/something/else")
+    res.should.be.ok
+    res.body.should == "Hello World"
+  end
+
+end

data/test/spec_thin.rb

@@ -0,0 +1,86 @@
+begin
+require 'rack/handler/thin'
+require File.expand_path('../testrequest', __FILE__)
+require 'timeout'
+
+describe Rack::Handler::Thin do
+  extend TestRequest::Helpers
+
+  @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?
+
+  should "respond" do
+    GET("/")
+    response.should.not.be.nil
+  end
+
+  should "be a Thin" do
+    GET("/")
+    status.should.equal 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
+
+  should "have rack headers" do
+    GET("/")
+    response["rack.version"].should.equal [1,0]
+    response["rack.multithread"].should.equal false
+    response["rack.multiprocess"].should.equal false
+    response["rack.run_once"].should.equal false
+  end
+
+  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
+
+  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
+
+  should "support HTTP auth" do
+    GET("/test", {:user => "ruth", :passwd => "secret"})
+    response["HTTP_AUTHORIZATION"].should.equal "Basic cnV0aDpzZWNyZXQ="
+  end
+
+  should "set status" do
+    GET("/test?secret")
+    status.should.equal 403
+    response["rack.url_scheme"].should.equal "http"
+  end
+
+  @server.stop!
+  @thread.kill
+end
+
+rescue LoadError
+  $stderr.puts "Skipping Rack::Handler::Thin tests (Thin is required). `gem install thin` and try again."
+end