rack 2.0.4 → 2.1.0

data/test/spec_etag.rb

@@ -1,108 +0,0 @@
-require 'minitest/autorun'
-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
-
-  it "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'].must_equal "W/\"dffd6021bb2bd5b0af676290809ec3a5\""
-  end
-
-  it "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'].must_equal "W/\"dffd6021bb2bd5b0af676290809ec3a5\""
-  end
-
-  it "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'].must_equal 'max-age=0, private, must-revalidate'
-  end
-
-  it "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'].must_equal 'public'
-  end
-
-  it "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'].must_equal 'no-cache'
-  end
-
-  it "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'].must_equal 'public'
-  end
-
-  it "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'].must_be_nil
-  end
-
-  it "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'].must_equal "\"abc\""
-  end
-
-  it "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'].must_be_nil
-  end
-
-  it "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'].must_be_nil
-  end
-
-  it "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'].must_be_nil
-  end
-
-  it "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'].must_be_nil
-  end
-
-  it "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'].must_be_nil
-  end
-
-  it "close the original body" do
-    body = StringIO.new
-    app = lambda { |env| [200, {}, body] }
-    response = etag(app).call(request)
-    body.wont_be :closed?
-    response[2].close
-    body.must_be :closed?
-  end
-end

data/test/spec_events.rb

@@ -1,133 +0,0 @@
-require 'helper'
-require 'rack/events'
-
-module Rack
-  class TestEvents < Rack::TestCase
-    class EventMiddleware
-      attr_reader :events
-
-      def initialize events
-        @events = events
-      end
-
-      def on_start req, res
-        events << [self, __method__]
-      end
-
-      def on_commit req, res
-        events << [self, __method__]
-      end
-
-      def on_send req, res
-        events << [self, __method__]
-      end
-
-      def on_finish req, res
-        events << [self, __method__]
-      end
-
-      def on_error req, res, e
-        events << [self, __method__]
-      end
-    end
-
-    def test_events_fire
-      events = []
-      ret = [200, {}, []]
-      app = lambda { |env| events << [app, :call]; ret }
-      se = EventMiddleware.new events
-      e = Events.new app, [se]
-      triple = e.call({})
-      response_body = []
-      triple[2].each { |x| response_body << x }
-      triple[2].close
-      triple[2] = response_body
-      assert_equal ret, triple
-      assert_equal [[se, :on_start],
-                    [app, :call],
-                    [se, :on_commit],
-                    [se, :on_send],
-                    [se, :on_finish],
-      ], events
-    end
-
-    def test_send_and_finish_are_not_run_until_body_is_sent
-      events = []
-      ret = [200, {}, []]
-      app = lambda { |env| events << [app, :call]; ret }
-      se = EventMiddleware.new events
-      e = Events.new app, [se]
-      triple = e.call({})
-      assert_equal [[se, :on_start],
-                    [app, :call],
-                    [se, :on_commit],
-      ], events
-    end
-
-    def test_send_is_called_on_each
-      events = []
-      ret = [200, {}, []]
-      app = lambda { |env| events << [app, :call]; ret }
-      se = EventMiddleware.new events
-      e = Events.new app, [se]
-      triple = e.call({})
-      triple[2].each { |x| }
-      assert_equal [[se, :on_start],
-                    [app, :call],
-                    [se, :on_commit],
-                    [se, :on_send],
-      ], events
-    end
-
-    def test_finish_is_called_on_close
-      events = []
-      ret = [200, {}, []]
-      app = lambda { |env| events << [app, :call]; ret }
-      se = EventMiddleware.new events
-      e = Events.new app, [se]
-      triple = e.call({})
-      triple[2].each { |x| }
-      triple[2].close
-      assert_equal [[se, :on_start],
-                    [app, :call],
-                    [se, :on_commit],
-                    [se, :on_send],
-                    [se, :on_finish],
-      ], events
-    end
-
-    def test_finish_is_called_in_reverse_order
-      events = []
-      ret = [200, {}, []]
-      app = lambda { |env| events << [app, :call]; ret }
-      se1 = EventMiddleware.new events
-      se2 = EventMiddleware.new events
-      se3 = EventMiddleware.new events
-
-      e = Events.new app, [se1, se2, se3]
-      triple = e.call({})
-      triple[2].each { |x| }
-      triple[2].close
-
-      groups = events.group_by { |x| x.last }
-      assert_equal groups[:on_start].map(&:first), groups[:on_finish].map(&:first).reverse
-      assert_equal groups[:on_commit].map(&:first), groups[:on_finish].map(&:first)
-      assert_equal groups[:on_send].map(&:first), groups[:on_finish].map(&:first)
-    end
-
-    def test_finish_is_called_if_there_is_an_exception
-      events = []
-      ret = [200, {}, []]
-      app = lambda { |env| raise }
-      se = EventMiddleware.new events
-      e = Events.new app, [se]
-      assert_raises(RuntimeError) do
-        e.call({})
-      end
-      assert_equal [[se, :on_start],
-                    [se, :on_error],
-                    [se, :on_finish],
-      ], events
-    end
-  end
-end

data/test/spec_fastcgi.rb

@@ -1,85 +0,0 @@
-require 'helper'
-
-if defined? LIGHTTPD_PID
-
-require File.expand_path('../testrequest', __FILE__)
-require 'rack/handler/fastcgi'
-
-describe Rack::Handler::FastCGI do
-  include TestRequest::Helpers
-
-  before do
-    @host = '127.0.0.1'
-    @port = 9203
-  end
-
-  it "respond" do
-    sleep 1
-    GET("/test")
-    response.wont_be :nil?
-  end
-
-  it "respond via rackup server" do
-    GET("/sample_rackup.ru")
-    status.must_equal 200
-  end
-
-  it "be a lighttpd" do
-    GET("/test.fcgi")
-    status.must_equal 200
-    response["SERVER_SOFTWARE"].must_match(/lighttpd/)
-    response["HTTP_VERSION"].must_equal "HTTP/1.1"
-    response["SERVER_PROTOCOL"].must_equal "HTTP/1.1"
-    response["SERVER_PORT"].must_equal @port.to_s
-    response["SERVER_NAME"].must_equal @host
-  end
-
-  it "have rack headers" do
-    GET("/test.fcgi")
-    response["rack.version"].must_equal [1,3]
-    assert_equal false, response["rack.multithread"]
-    assert_equal true, response["rack.multiprocess"]
-    assert_equal false, response["rack.run_once"]
-  end
-
-  it "have CGI headers on GET" do
-    GET("/test.fcgi")
-    response["REQUEST_METHOD"].must_equal "GET"
-    response["SCRIPT_NAME"].must_equal "/test.fcgi"
-    response["REQUEST_PATH"].must_equal "/"
-    response["PATH_INFO"].must_equal ""
-    response["QUERY_STRING"].must_equal ""
-    response["test.postdata"].must_equal ""
-
-    GET("/test.fcgi/foo?quux=1")
-    response["REQUEST_METHOD"].must_equal "GET"
-    response["SCRIPT_NAME"].must_equal "/test.fcgi"
-    response["REQUEST_PATH"].must_equal "/"
-    response["PATH_INFO"].must_equal "/foo"
-    response["QUERY_STRING"].must_equal "quux=1"
-  end
-
-  it "have CGI headers on POST" do
-    POST("/test.fcgi", {"rack-form-data" => "23"}, {'X-test-header' => '42'})
-    status.must_equal 200
-    response["REQUEST_METHOD"].must_equal "POST"
-    response["SCRIPT_NAME"].must_equal "/test.fcgi"
-    response["REQUEST_PATH"].must_equal "/"
-    response["QUERY_STRING"].must_equal ""
-    response["HTTP_X_TEST_HEADER"].must_equal "42"
-    response["test.postdata"].must_equal "rack-form-data=23"
-  end
-
-  it "support HTTP auth" do
-    GET("/test.fcgi", {:user => "ruth", :passwd => "secret"})
-    response["HTTP_AUTHORIZATION"].must_equal "Basic cnV0aDpzZWNyZXQ="
-  end
-
-  it "set status" do
-    GET("/test.fcgi?secret")
-    status.must_equal 403
-    response["rack.url_scheme"].must_equal "http"
-  end
-end
-
-end # if defined? LIGHTTPD_PID

data/test/spec_file.rb

@@ -1,264 +0,0 @@
-require 'minitest/autorun'
-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
-
-  it 'serves files with + in the file name' do
-    Dir.mktmpdir do |dir|
-      File.write File.join(dir, "you+me.txt"), "hello world"
-      app = file(dir)
-      env = Rack::MockRequest.env_for("/you+me.txt")
-      status,_,body = app.call env
-
-      assert_equal 200, status
-
-      str = ''
-      body.each { |x| str << x }
-      assert_match "hello world", str
-    end
-  end
-
-  it "serve files" do
-    res = Rack::MockRequest.new(file(DOCROOT)).get("/cgi/test")
-
-    res.must_be :ok?
-    assert_match(res, /ruby/)
-  end
-
-  it "set Last-Modified header" do
-    res = Rack::MockRequest.new(file(DOCROOT)).get("/cgi/test")
-
-    path = File.join(DOCROOT, "/cgi/test")
-
-    res.must_be :ok?
-    res["Last-Modified"].must_equal File.mtime(path).httpdate
-  end
-
-  it "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.must_equal 304
-    res.body.must_be :empty?
-  end
-
-  it "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.must_be :ok?
-  end
-
-  it "serve files with URL encoded filenames" do
-    res = Rack::MockRequest.new(file(DOCROOT)).get("/cgi/%74%65%73%74") # "/cgi/test"
-
-    res.must_be :ok?
-    # res.must_match(/ruby/)    # nope
-    # (/ruby/).must_match res   # This is wierd, but an oddity of minitest
-    # assert_match(/ruby/, res) # nope
-    assert_match(res, /ruby/)
-  end
-
-  it "serve uri with URL encoded null byte (%00) in filenames" do
-    res = Rack::MockRequest.new(file(DOCROOT)).get("/cgi/test%00")
-    res.must_be :bad_request?
-  end
-
-  it "allow safe directory traversal" do
-    req = Rack::MockRequest.new(file(DOCROOT))
-
-    res = req.get('/cgi/../cgi/test')
-    res.must_be :successful?
-
-    res = req.get('.')
-    res.must_be :not_found?
-
-    res = req.get("test/..")
-    res.must_be :not_found?
-  end
-
-  it "not allow unsafe directory traversal" do
-    req = Rack::MockRequest.new(file(DOCROOT))
-
-    res = req.get("/../README.rdoc")
-    res.must_be :client_error?
-
-    res = req.get("../test/spec_file.rb")
-    res.must_be :client_error?
-
-    res = req.get("../README.rdoc")
-    res.must_be :client_error?
-
-    res.must_be :not_found?
-  end
-
-  it "allow files with .. in their name" do
-    req = Rack::MockRequest.new(file(DOCROOT))
-    res = req.get("/cgi/..test")
-    res.must_be :not_found?
-
-    res = req.get("/cgi/test..")
-    res.must_be :not_found?
-
-    res = req.get("/cgi../test..")
-    res.must_be :not_found?
-  end
-
-  it "not allow unsafe directory traversal with encoded periods" do
-    res = Rack::MockRequest.new(file(DOCROOT)).get("/%2E%2E/README")
-
-    res.must_be :client_error?
-    res.must_be :not_found?
-  end
-
-  it "allow safe directory traversal with encoded periods" do
-    res = Rack::MockRequest.new(file(DOCROOT)).get("/cgi/%2E%2E/cgi/test")
-
-    res.must_be :successful?
-  end
-
-  it "404 if it can't find the file" do
-    res = Rack::MockRequest.new(file(DOCROOT)).get("/cgi/blubb")
-
-    res.must_be :not_found?
-  end
-
-  it "detect SystemCallErrors" do
-    res = Rack::MockRequest.new(file(DOCROOT)).get("/cgi")
-
-    res.must_be :not_found?
-  end
-
-  it "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.must_equal 200
-    body.must_respond_to :to_path
-    body.to_path.must_equal path
-  end
-
-  it "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.must_equal 206
-    res["Content-Length"].must_equal "12"
-    res["Content-Range"].must_equal "bytes 22-33/193"
-    res.body.must_equal "-*- ruby -*-"
-  end
-
-  it "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.must_equal 416
-    res["Content-Range"].must_equal "bytes */193"
-  end
-
-  it "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.must_equal 200
-    heads['Cache-Control'].must_equal 'public, max-age=38'
-    heads['Access-Control-Allow-Origin'].must_equal '*'
-  end
-
-  it "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.must_equal 200
-    heads['Cache-Control'].must_be_nil
-    heads['Access-Control-Allow-Origin'].must_be_nil
-  end
-
-  it "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.must_be :client_error?
-      res.must_be :method_not_allowed?
-      res.headers['Allow'].split(/, */).sort.must_equal %w(GET HEAD OPTIONS)
-    end
-
-    allowed = %w[get head options]
-    allowed.each do |method|
-      res = req.send(method, "/cgi/test")
-      res.must_be :successful?
-    end
-  end
-
-  it "set Allow correctly for OPTIONS requests" do
-    req = Rack::MockRequest.new(file(DOCROOT))
-    res = req.options('/cgi/test')
-    res.must_be :successful?
-    res.headers['Allow'].wont_equal nil
-    res.headers['Allow'].split(/, */).sort.must_equal %w(GET HEAD OPTIONS)
-  end
-
-  it "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.must_be :successful?
-    res['Content-Length'].must_equal "193"
-  end
-
-  it "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.must_be :successful?
-    res['Content-Type'].must_equal "text/plain"
-  end
-
-  it "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.must_be :successful?
-    res['Content-Type'].must_equal "application/octet-stream"
-  end
-
-  it "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.must_be :successful?
-    res['Content-Type'].must_be_nil
-  end
-
-  it "return error when file not found for head request" do
-    res = Rack::MockRequest.new(file(DOCROOT)).head("/cgi/missing")
-    res.must_be :not_found?
-    res.body.must_be :empty?
-  end
-
-  class MyFile < Rack::File
-    def response_body
-      "hello world"
-    end
-  end
-
-  it "behaves gracefully if response_body is present" do
-    file = Rack::Lint.new MyFile.new(DOCROOT)
-    res  = Rack::MockRequest.new(file).get("/cgi/test")
-
-    res.must_be :ok?
-  end
-
-end