rack 1.6.13 → 2.1.4.3

data/test/spec_etag.rb

@@ -1,107 +0,0 @@
-require 'rack/etag'
-require 'rack/lint'
-require 'rack/mock'
-require 'time'
-
-describe Rack::ETag do
-  def etag(app, *args)
-    Rack::Lint.new Rack::ETag.new(app, *args)
-  end
-  
-  def request
-    Rack::MockRequest.env_for
-  end
-  
-  def sendfile_body
-    res = ['Hello World']
-    def res.to_path ; "/tmp/hello.txt" ; end
-    res
-  end
-
-  should "set ETag if none is set if status is 200" do
-    app = lambda { |env| [200, {'Content-Type' => 'text/plain'}, ["Hello, World!"]] }
-    response = etag(app).call(request)
-    response[1]['ETag'].should.equal "W/\"65a8e27d8879283831b664bd8b7f0ad4\""
-  end
-
-  should "set ETag if none is set if status is 201" do
-    app = lambda { |env| [201, {'Content-Type' => 'text/plain'}, ["Hello, World!"]] }
-    response = etag(app).call(request)
-    response[1]['ETag'].should.equal "W/\"65a8e27d8879283831b664bd8b7f0ad4\""
-  end
-
-  should "set Cache-Control to 'max-age=0, private, must-revalidate' (default) if none is set" do
-    app = lambda { |env| [201, {'Content-Type' => 'text/plain'}, ["Hello, World!"]] }
-    response = etag(app).call(request)
-    response[1]['Cache-Control'].should.equal 'max-age=0, private, must-revalidate'
-  end
-
-  should "set Cache-Control to chosen one if none is set" do
-    app = lambda { |env| [201, {'Content-Type' => 'text/plain'}, ["Hello, World!"]] }
-    response = etag(app, nil, 'public').call(request)
-    response[1]['Cache-Control'].should.equal 'public'
-  end
-
-  should "set a given Cache-Control even if digest could not be calculated" do
-    app = lambda { |env| [200, {'Content-Type' => 'text/plain'}, []] }
-    response = etag(app, 'no-cache').call(request)
-    response[1]['Cache-Control'].should.equal 'no-cache'
-  end
-
-  should "not set Cache-Control if it is already set" do
-    app = lambda { |env| [201, {'Content-Type' => 'text/plain', 'Cache-Control' => 'public'}, ["Hello, World!"]] }
-    response = etag(app).call(request)
-    response[1]['Cache-Control'].should.equal 'public'
-  end
-
-  should "not set Cache-Control if directive isn't present" do
-    app = lambda { |env| [200, {'Content-Type' => 'text/plain'}, ["Hello, World!"]] }
-    response = etag(app, nil, nil).call(request)
-    response[1]['Cache-Control'].should.equal nil
-  end
-
-  should "not change ETag if it is already set" do
-    app = lambda { |env| [200, {'Content-Type' => 'text/plain', 'ETag' => '"abc"'}, ["Hello, World!"]] }
-    response = etag(app).call(request)
-    response[1]['ETag'].should.equal "\"abc\""
-  end
-
-  should "not set ETag if body is empty" do
-    app = lambda { |env| [200, {'Content-Type' => 'text/plain', 'Last-Modified' => Time.now.httpdate}, []] }
-    response = etag(app).call(request)
-    response[1]['ETag'].should.be.nil
-  end
-
-  should "not set ETag if Last-Modified is set" do
-    app = lambda { |env| [200, {'Content-Type' => 'text/plain', 'Last-Modified' => Time.now.httpdate}, ["Hello, World!"]] }
-    response = etag(app).call(request)
-    response[1]['ETag'].should.be.nil
-  end
-
-  should "not set ETag if a sendfile_body is given" do
-    app = lambda { |env| [200, {'Content-Type' => 'text/plain'}, sendfile_body] }
-    response = etag(app).call(request)
-    response[1]['ETag'].should.be.nil
-  end
-
-  should "not set ETag if a status is not 200 or 201" do
-    app = lambda { |env| [401, {'Content-Type' => 'text/plain'}, ['Access denied.']] }
-    response = etag(app).call(request)
-    response[1]['ETag'].should.be.nil
-  end
-
-  should "not set ETag if no-cache is given" do
-    app = lambda { |env| [200, {'Content-Type' => 'text/plain', 'Cache-Control' => 'no-cache, must-revalidate'}, ['Hello, World!']] }
-    response = etag(app).call(request)
-    response[1]['ETag'].should.be.nil
-  end
-
-  should "close the original body" do
-    body = StringIO.new
-    app = lambda { |env| [200, {}, body] }
-    response = etag(app).call(request)
-    body.should.not.be.closed
-    response[2].close
-    body.should.be.closed
-  end
-end

data/test/spec_fastcgi.rb

@@ -1,107 +0,0 @@
-begin
-require File.expand_path('../testrequest', __FILE__)
-require 'rack/handler/fastcgi'
-
-describe Rack::Handler::FastCGI do
-  extend TestRequest::Helpers
-
-  @host = '127.0.0.1'
-  @port = 9203
-
-  if `which lighttpd` && !$?.success?
-    raise "lighttpd not found"
-  end
-
-  # Keep this first.
-  $pid = fork {
-    ENV['RACK_ENV'] = 'deployment'
-    ENV['RUBYLIB'] = [
-      File.expand_path('../../lib', __FILE__),
-      ENV['RUBYLIB'],
-    ].compact.join(':')
-
-    Dir.chdir(File.expand_path("../cgi", __FILE__)) do
-      exec "lighttpd -D -f lighttpd.conf"
-    end
-  }
-
-  should "respond" do
-    sleep 1
-    GET("/test")
-    response.should.not.be.nil
-  end
-
-  should "respond via rackup server" do
-    GET("/sample_rackup.ru")
-    status.should.equal 200
-  end
-
-  should "be a lighttpd" do
-    GET("/test.fcgi")
-    status.should.equal 200
-    response["SERVER_SOFTWARE"].should =~ /lighttpd/
-    response["HTTP_VERSION"].should.equal "HTTP/1.1"
-    response["SERVER_PROTOCOL"].should.equal "HTTP/1.1"
-    response["SERVER_PORT"].should.equal @port.to_s
-    response["SERVER_NAME"].should.equal @host
-  end
-
-  should "have rack headers" do
-    GET("/test.fcgi")
-    response["rack.version"].should.equal [1,3]
-    response["rack.multithread"].should.be.false
-    response["rack.multiprocess"].should.be.true
-    response["rack.run_once"].should.be.false
-  end
-
-  should "have CGI headers on GET" do
-    GET("/test.fcgi")
-    response["REQUEST_METHOD"].should.equal "GET"
-    response["SCRIPT_NAME"].should.equal "/test.fcgi"
-    response["REQUEST_PATH"].should.equal "/"
-    response["PATH_INFO"].should.equal ""
-    response["QUERY_STRING"].should.equal ""
-    response["test.postdata"].should.equal ""
-
-    GET("/test.fcgi/foo?quux=1")
-    response["REQUEST_METHOD"].should.equal "GET"
-    response["SCRIPT_NAME"].should.equal "/test.fcgi"
-    response["REQUEST_PATH"].should.equal "/"
-    response["PATH_INFO"].should.equal "/foo"
-    response["QUERY_STRING"].should.equal "quux=1"
-  end
-
-  should "have CGI headers on POST" do
-    POST("/test.fcgi", {"rack-form-data" => "23"}, {'X-test-header' => '42'})
-    status.should.equal 200
-    response["REQUEST_METHOD"].should.equal "POST"
-    response["SCRIPT_NAME"].should.equal "/test.fcgi"
-    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.fcgi", {:user => "ruth", :passwd => "secret"})
-    response["HTTP_AUTHORIZATION"].should.equal "Basic cnV0aDpzZWNyZXQ="
-  end
-
-  should "set status" do
-    GET("/test.fcgi?secret")
-    status.should.equal 403
-    response["rack.url_scheme"].should.equal "http"
-  end
-
-  # Keep this last.
-  should "shutdown" do
-    Process.kill 15, $pid
-    Process.wait($pid).should.equal $pid
-  end
-end
-
-rescue RuntimeError
-  $stderr.puts "Skipping Rack::Handler::FastCGI tests (lighttpd is required). Install lighttpd and try again."
-rescue LoadError
-  $stderr.puts "Skipping Rack::Handler::FastCGI tests (FCGI is required). `gem install fcgi` and try again."
-end

data/test/spec_file.rb

@@ -1,221 +0,0 @@
-require 'rack/file'
-require 'rack/lint'
-require 'rack/mock'
-
-describe Rack::File do
-  DOCROOT = File.expand_path(File.dirname(__FILE__)) unless defined? DOCROOT
-
-  def file(*args)
-    Rack::Lint.new Rack::File.new(*args)
-  end
-
-  should "serve files" do
-    res = Rack::MockRequest.new(file(DOCROOT)).get("/cgi/test")
-
-    res.should.be.ok
-    res.should =~ /ruby/
-  end
-
-  should "set Last-Modified header" do
-    res = Rack::MockRequest.new(file(DOCROOT)).get("/cgi/test")
-
-    path = File.join(DOCROOT, "/cgi/test")
-
-    res.should.be.ok
-    res["Last-Modified"].should.equal File.mtime(path).httpdate
-  end
-
-  should "return 304 if file isn't modified since last serve" do
-    path = File.join(DOCROOT, "/cgi/test")
-    res = Rack::MockRequest.new(file(DOCROOT)).
-      get("/cgi/test", 'HTTP_IF_MODIFIED_SINCE' => File.mtime(path).httpdate)
-
-    res.status.should.equal 304
-    res.body.should.be.empty
-  end
-
-  should "return the file if it's modified since last serve" do
-    path = File.join(DOCROOT, "/cgi/test")
-    res = Rack::MockRequest.new(file(DOCROOT)).
-      get("/cgi/test", 'HTTP_IF_MODIFIED_SINCE' => (File.mtime(path) - 100).httpdate)
-
-    res.should.be.ok
-  end
-
-  should "serve files with URL encoded filenames" do
-    res = Rack::MockRequest.new(file(DOCROOT)).get("/cgi/%74%65%73%74") # "/cgi/test"
-
-    res.should.be.ok
-    res.should =~ /ruby/
-  end
-
-  should "allow safe directory traversal" do
-    req = Rack::MockRequest.new(file(DOCROOT))
-
-    res = req.get('/cgi/../cgi/test')
-    res.should.be.successful
-
-    res = req.get('.')
-    res.should.be.not_found
-
-    res = req.get("test/..")
-    res.should.be.not_found
-  end
-
-  should "not allow unsafe directory traversal" do
-    req = Rack::MockRequest.new(file(DOCROOT))
-
-    res = req.get("/../README.rdoc")
-    res.should.be.client_error
-
-    res = req.get("../test/spec_file.rb")
-    res.should.be.client_error
-
-    res = req.get("../README.rdoc")
-    res.should.be.client_error
-
-    res.should.be.not_found
-  end
-
-  should "allow files with .. in their name" do
-    req = Rack::MockRequest.new(file(DOCROOT))
-    res = req.get("/cgi/..test")
-    res.should.be.not_found
-
-    res = req.get("/cgi/test..")
-    res.should.be.not_found
-
-    res = req.get("/cgi../test..")
-    res.should.be.not_found
-  end
-
-  should "not allow unsafe directory traversal with encoded periods" do
-    res = Rack::MockRequest.new(file(DOCROOT)).get("/%2E%2E/README")
-
-    res.should.be.client_error?
-    res.should.be.not_found
-  end
-
-  should "allow safe directory traversal with encoded periods" do
-    res = Rack::MockRequest.new(file(DOCROOT)).get("/cgi/%2E%2E/cgi/test")
-
-    res.should.be.successful
-  end
-
-  should "404 if it can't find the file" do
-    res = Rack::MockRequest.new(file(DOCROOT)).get("/cgi/blubb")
-
-    res.should.be.not_found
-  end
-
-  should "detect SystemCallErrors" do
-    res = Rack::MockRequest.new(file(DOCROOT)).get("/cgi")
-
-    res.should.be.not_found
-  end
-
-  should "return bodies that respond to #to_path" do
-    env = Rack::MockRequest.env_for("/cgi/test")
-    status, _, body = Rack::File.new(DOCROOT).call(env)
-
-    path = File.join(DOCROOT, "/cgi/test")
-
-    status.should.equal 200
-    body.should.respond_to :to_path
-    body.to_path.should.equal path
-  end
-
-  should "return correct byte range in body" do
-    env = Rack::MockRequest.env_for("/cgi/test")
-    env["HTTP_RANGE"] = "bytes=22-33"
-    res = Rack::MockResponse.new(*file(DOCROOT).call(env))
-
-    res.status.should.equal 206
-    res["Content-Length"].should.equal "12"
-    res["Content-Range"].should.equal "bytes 22-33/193"
-    res.body.should.equal "-*- ruby -*-"
-  end
-
-  should "return error for unsatisfiable byte range" do
-    env = Rack::MockRequest.env_for("/cgi/test")
-    env["HTTP_RANGE"] = "bytes=1234-5678"
-    res = Rack::MockResponse.new(*file(DOCROOT).call(env))
-
-    res.status.should.equal 416
-    res["Content-Range"].should.equal "bytes */193"
-  end
-
-  should "support custom http headers" do
-    env = Rack::MockRequest.env_for("/cgi/test")
-    status, heads, _ = file(DOCROOT, 'Cache-Control' => 'public, max-age=38',
-     'Access-Control-Allow-Origin' => '*').call(env)
-
-    status.should.equal 200
-    heads['Cache-Control'].should.equal 'public, max-age=38'
-    heads['Access-Control-Allow-Origin'].should.equal '*'
-  end
-
-  should "support not add custom http headers if none are supplied" do
-    env = Rack::MockRequest.env_for("/cgi/test")
-    status, heads, _ = file(DOCROOT).call(env)
-
-    status.should.equal 200
-    heads['Cache-Control'].should.equal nil
-    heads['Access-Control-Allow-Origin'].should.equal nil
-  end
-
-  should "only support GET, HEAD, and OPTIONS requests" do
-    req = Rack::MockRequest.new(file(DOCROOT))
-
-    forbidden = %w[post put patch delete]
-    forbidden.each do |method|
-      res = req.send(method, "/cgi/test")
-      res.should.be.client_error
-      res.should.be.method_not_allowed
-      res.headers['Allow'].split(/, */).sort.should == %w(GET HEAD OPTIONS)
-    end
-
-    allowed = %w[get head options]
-    allowed.each do |method|
-      res = req.send(method, "/cgi/test")
-      res.should.be.successful
-    end
-  end
-
-  should "set Allow correctly for OPTIONS requests" do
-    req = Rack::MockRequest.new(file(DOCROOT))
-    res = req.options('/cgi/test')
-    res.should.be.successful
-    res.headers['Allow'].should.not.equal nil
-    res.headers['Allow'].split(/, */).sort.should == %w(GET HEAD OPTIONS)
-  end
-
-  should "set Content-Length correctly for HEAD requests" do
-    req = Rack::MockRequest.new(Rack::Lint.new(Rack::File.new(DOCROOT)))
-    res = req.head "/cgi/test"
-    res.should.be.successful
-    res['Content-Length'].should.equal "193"
-  end
-
-  should "default to a mime type of text/plain" do
-    req = Rack::MockRequest.new(Rack::Lint.new(Rack::File.new(DOCROOT)))
-    res = req.get "/cgi/test"
-    res.should.be.successful
-    res['Content-Type'].should.equal "text/plain"
-  end
-
-  should "allow the default mime type to be set" do
-    req = Rack::MockRequest.new(Rack::Lint.new(Rack::File.new(DOCROOT, nil, 'application/octet-stream')))
-    res = req.get "/cgi/test"
-    res.should.be.successful
-    res['Content-Type'].should.equal "application/octet-stream"
-  end
-
-  should "not set Content-Type if the mime type is not set" do
-    req = Rack::MockRequest.new(Rack::Lint.new(Rack::File.new(DOCROOT, nil, nil)))
-    res = req.get "/cgi/test"
-    res.should.be.successful
-    res['Content-Type'].should.equal nil
-  end
-
-end

data/test/spec_handler.rb

@@ -1,72 +0,0 @@
-require 'rack/handler'
-
-class Rack::Handler::Lobster; end
-class RockLobster; end
-
-describe Rack::Handler do
-  it "has registered default handlers" do
-    Rack::Handler.get('cgi').should.equal Rack::Handler::CGI
-    Rack::Handler.get('webrick').should.equal Rack::Handler::WEBrick
-
-    begin
-      Rack::Handler.get('fastcgi').should.equal Rack::Handler::FastCGI
-    rescue LoadError
-    end
-
-    begin
-      Rack::Handler.get('mongrel').should.equal Rack::Handler::Mongrel
-    rescue LoadError
-    end
-  end
-
-  should "raise LoadError if handler doesn't exist" do
-    lambda {
-      Rack::Handler.get('boom')
-    }.should.raise(LoadError)
-  end
-
-  should "raise LoadError if handler isn't nested under Rack::Handler" do
-    # Feature-detect whether Ruby can do non-inherited const lookups.
-    # If it can't, then Rack::Handler may lookup non-handler toplevel
-    # constants, so the best we can do is no-op here and not test it.
-    begin
-      Rack::Handler._const_get('Object', false)
-    rescue NameError
-      lambda {
-        Rack::Handler.get('Object')
-      }.should.raise(LoadError)
-    end
-  end
-
-  should "get unregistered, but already required, handler by name" do
-    Rack::Handler.get('Lobster').should.equal Rack::Handler::Lobster
-  end
-
-  should "register custom handler" do
-    Rack::Handler.register('rock_lobster', 'RockLobster')
-    Rack::Handler.get('rock_lobster').should.equal RockLobster
-  end
-
-  should "not need registration for properly coded handlers even if not already required" do
-    begin
-      $LOAD_PATH.push File.expand_path('../unregistered_handler', __FILE__)
-      Rack::Handler.get('Unregistered').should.equal Rack::Handler::Unregistered
-      lambda {
-        Rack::Handler.get('UnRegistered')
-      }.should.raise LoadError
-      Rack::Handler.get('UnregisteredLongOne').should.equal Rack::Handler::UnregisteredLongOne
-    ensure
-      $LOAD_PATH.delete File.expand_path('../unregistered_handler', __FILE__)
-    end
-  end
-
-  should "allow autoloaded handlers to be registered properly while being loaded" do
-    path = File.expand_path('../registering_handler', __FILE__)
-    begin
-      $LOAD_PATH.push path
-      Rack::Handler.get('registering_myself').should.equal Rack::Handler::RegisteringMyself
-    ensure
-      $LOAD_PATH.delete path
-    end
-  end
-end

data/test/spec_head.rb

@@ -1,45 +0,0 @@
-require 'rack/head'
-require 'rack/lint'
-require 'rack/mock'
-
-describe Rack::Head do
-
-  def test_response(headers = {})
-    body = StringIO.new "foo"
-    app = lambda do |env|
-      [200, {"Content-type" => "test/plain", "Content-length" => "3"}, body]
-    end
-    request = Rack::MockRequest.env_for("/", headers)
-    response = Rack::Lint.new(Rack::Head.new(app)).call(request)
-
-    return response, body
-  end
-
-  should "pass GET, POST, PUT, DELETE, OPTIONS, TRACE requests" do
-    %w[GET POST PUT DELETE OPTIONS TRACE].each do |type|
-      resp, _ = test_response("REQUEST_METHOD" => type)
-
-      resp[0].should.equal(200)
-      resp[1].should.equal({"Content-type" => "test/plain", "Content-length" => "3"})
-      resp[2].to_enum.to_a.should.equal(["foo"])
-    end
-  end
-
-  should "remove body from HEAD requests" do
-    resp, _ = test_response("REQUEST_METHOD" => "HEAD")
-
-    resp[0].should.equal(200)
-    resp[1].should.equal({"Content-type" => "test/plain", "Content-length" => "3"})
-    resp[2].to_enum.to_a.should.equal([])
-  end
-
-  should "close the body when it is removed" do
-    resp, body = test_response("REQUEST_METHOD" => "HEAD")
-    resp[0].should.equal(200)
-    resp[1].should.equal({"Content-type" => "test/plain", "Content-length" => "3"})
-    resp[2].to_enum.to_a.should.equal([])
-    body.should.not.be.closed
-    resp[2].close
-    body.should.be.closed
-  end
-end