rack 1.6.13 → 2.0.0.alpha

data/test/spec_methodoverride.rb

@@ -1,111 +0,0 @@
-require 'stringio'
-require 'rack/methodoverride'
-require 'rack/mock'
-
-describe Rack::MethodOverride do
-  def app
-    Rack::Lint.new(Rack::MethodOverride.new(lambda {|e|
-      [200, {"Content-Type" => "text/plain"}, []]
-    }))
-  end
-
-  should "not affect GET requests" do
-    env = Rack::MockRequest.env_for("/?_method=delete", :method => "GET")
-    app.call env
-
-    env["REQUEST_METHOD"].should.equal "GET"
-  end
-
-  should "modify REQUEST_METHOD for POST requests when _method parameter is set" do
-    env = Rack::MockRequest.env_for("/", :method => "POST", :input => "_method=put")
-    app.call env
-
-    env["REQUEST_METHOD"].should.equal "PUT"
-  end
-
-  if RUBY_VERSION >= "1.9"
-    should "set rack.errors for invalid UTF8 _method values" do
-      errors = StringIO.new
-      env = Rack::MockRequest.env_for("/",
-        :method => "POST",
-        :input => "_method=\xBF".force_encoding("ASCII-8BIT"),
-        "rack.errors" => errors)
-
-      app.call env
-
-      errors.rewind
-      errors.read.should.equal "Invalid string for method\n"
-      env["REQUEST_METHOD"].should.equal "POST"
-    end
-  end
-
-  should "modify REQUEST_METHOD for POST requests when X-HTTP-Method-Override is set" do
-    env = Rack::MockRequest.env_for("/",
-            :method => "POST",
-            "HTTP_X_HTTP_METHOD_OVERRIDE" => "PATCH"
-          )
-    app.call env
-
-    env["REQUEST_METHOD"].should.equal "PATCH"
-  end
-
-  should "not modify REQUEST_METHOD if the method is unknown" do
-    env = Rack::MockRequest.env_for("/", :method => "POST", :input => "_method=foo")
-    app.call env
-
-    env["REQUEST_METHOD"].should.equal "POST"
-  end
-
-  should "not modify REQUEST_METHOD when _method is nil" do
-    env = Rack::MockRequest.env_for("/", :method => "POST", :input => "foo=bar")
-    app.call env
-
-    env["REQUEST_METHOD"].should.equal "POST"
-  end
-
-  should "store the original REQUEST_METHOD prior to overriding" do
-    env = Rack::MockRequest.env_for("/",
-            :method => "POST",
-            :input  => "_method=options")
-    app.call env
-
-    env["rack.methodoverride.original_method"].should.equal "POST"
-  end
-
-  should "not modify REQUEST_METHOD when given invalid multipart form data" do
-    input = <<EOF
---AaB03x\r
-content-disposition: form-data; name="huge"; filename="huge"\r
-EOF
-    env = Rack::MockRequest.env_for("/",
-                      "CONTENT_TYPE" => "multipart/form-data, boundary=AaB03x",
-                      "CONTENT_LENGTH" => input.size.to_s,
-                      :method => "POST", :input => input)
-    app.call env
-
-    env["REQUEST_METHOD"].should.equal "POST"
-  end
-
-  should "write error to RACK_ERRORS when given invalid multipart form data" do
-    input = <<EOF
---AaB03x\r
-content-disposition: form-data; name="huge"; filename="huge"\r
-EOF
-    env = Rack::MockRequest.env_for("/",
-                      "CONTENT_TYPE" => "multipart/form-data, boundary=AaB03x",
-                      "CONTENT_LENGTH" => input.size.to_s,
-                      "rack.errors" => StringIO.new,
-                      :method => "POST", :input => input)
-    Rack::MethodOverride.new(proc { [200, {"Content-Type" => "text/plain"}, []] }).call env
-
-    env["rack.errors"].rewind
-    env["rack.errors"].read.should =~ /Bad request content body/
-  end
-
-  should "not modify REQUEST_METHOD for POST requests when the params are unparseable" do
-    env = Rack::MockRequest.env_for("/", :method => "POST", :input => "(%bad-params%)")
-    app.call env
-
-    env["REQUEST_METHOD"].should.equal "POST"
-  end
-end

data/test/spec_mongrel.rb

@@ -1,182 +0,0 @@
-begin
-require 'rack'
-require 'rack/handler/mongrel'
-require File.expand_path('../testrequest', __FILE__)
-require 'timeout'
-
-Thread.abort_on_exception = true
-$tcp_defer_accept_opts = nil
-$tcp_cork_opts = nil
-
-describe Rack::Handler::Mongrel do
-  extend TestRequest::Helpers
-
-  @server = Mongrel::HttpServer.new(@host='127.0.0.1', @port=9201)
-  @server.register('/test',
-                  Rack::Handler::Mongrel.new(Rack::Lint.new(TestRequest.new)))
-  @server.register('/stream',
-                  Rack::Handler::Mongrel.new(Rack::Lint.new(StreamingRequest)))
-  @acc = @server.run
-
-  should "respond" do
-    lambda {
-      GET("/test")
-    }.should.not.raise
-  end
-
-  should "be a Mongrel" do
-    GET("/test")
-    status.should.equal 200
-    response["SERVER_SOFTWARE"].should =~ /Mongrel/
-    response["HTTP_VERSION"].should.equal "HTTP/1.1"
-    response["SERVER_PROTOCOL"].should.equal "HTTP/1.1"
-    response["SERVER_PORT"].should.equal "9201"
-    response["SERVER_NAME"].should.equal "127.0.0.1"
-  end
-
-  should "have rack headers" do
-    GET("/test")
-    response["rack.version"].should.equal [1,3]
-    response["rack.multithread"].should.be.true
-    response["rack.multiprocess"].should.be.false
-    response["rack.run_once"].should.be.false
-  end
-
-  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 "/test"
-    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["SCRIPT_NAME"].should.equal "/test"
-    response["REQUEST_PATH"].should.equal "/test/foo"
-    response["PATH_INFO"].should.equal "/foo"
-    response["QUERY_STRING"].should.equal "quux=1"
-  end
-
-  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 "/test"
-    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
-
-  should "provide a .run" do
-    block_ran = false
-    Thread.new {
-      Rack::Handler::Mongrel.run(lambda {}, {:Host => '127.0.0.1', :Port => 9211}) { |server|
-        server.should.be.kind_of Mongrel::HttpServer
-        block_ran = true
-      }
-    }
-    sleep 1
-    block_ran.should.be.true
-  end
-
-  should "provide a .run that maps a hash" do
-    block_ran = false
-    Thread.new {
-      map = {'/'=>lambda{},'/foo'=>lambda{}}
-      Rack::Handler::Mongrel.run(map, :map => true, :Host => '127.0.0.1', :Port => 9221) { |server|
-        server.should.be.kind_of Mongrel::HttpServer
-        server.classifier.uris.size.should.equal 2
-        server.classifier.uris.should.not.include '/arf'
-        server.classifier.uris.should.include '/'
-        server.classifier.uris.should.include '/foo'
-        block_ran = true
-      }
-    }
-    sleep 1
-    block_ran.should.be.true
-  end
-
-  should "provide a .run that maps a urlmap" do
-    block_ran = false
-    Thread.new {
-      map = Rack::URLMap.new({'/'=>lambda{},'/bar'=>lambda{}})
-      Rack::Handler::Mongrel.run(map, {:map => true, :Host => '127.0.0.1', :Port => 9231}) { |server|
-        server.should.be.kind_of Mongrel::HttpServer
-        server.classifier.uris.size.should.equal 2
-        server.classifier.uris.should.not.include '/arf'
-        server.classifier.uris.should.include '/'
-        server.classifier.uris.should.include '/bar'
-        block_ran = true
-      }
-    }
-    sleep 1
-    block_ran.should.be.true
-  end
-
-  should "provide a .run that maps a urlmap restricting by host" do
-    block_ran = false
-    Thread.new {
-      map = Rack::URLMap.new({
-        '/' => lambda{},
-        '/foo' => lambda{},
-        '/bar' => lambda{},
-        'http://127.0.0.1/' => lambda{},
-        'http://127.0.0.1/bar' => lambda{},
-        'http://falsehost/arf' => lambda{},
-        'http://falsehost/qux' => lambda{}
-      })
-      opt = {:map => true, :Port => 9241, :Host => '127.0.0.1'}
-      Rack::Handler::Mongrel.run(map, opt) { |server|
-        server.should.be.kind_of Mongrel::HttpServer
-        server.classifier.uris.should.include '/'
-        server.classifier.handler_map['/'].size.should.equal 2
-        server.classifier.uris.should.include '/foo'
-        server.classifier.handler_map['/foo'].size.should.equal 1
-        server.classifier.uris.should.include '/bar'
-        server.classifier.handler_map['/bar'].size.should.equal 2
-        server.classifier.uris.should.not.include '/qux'
-        server.classifier.uris.should.not.include '/arf'
-        server.classifier.uris.size.should.equal 3
-        block_ran = true
-      }
-    }
-    sleep 1
-    block_ran.should.be.true
-  end
-
-  should "stream #each part of the response" do
-    body = ''
-    begin
-      Timeout.timeout(1) do
-        Net::HTTP.start(@host, @port) do |http|
-          get = Net::HTTP::Get.new('/stream')
-          http.request(get) do |response|
-            response.read_body { |part| body << part }
-          end
-        end
-      end
-    rescue Timeout::Error
-    end
-    body.should.not.be.empty
-  end
-
-  @acc.raise Mongrel::StopServer
-end
-
-rescue LoadError
-  warn "Skipping Rack::Handler::Mongrel tests (Mongrel is required). `gem install mongrel` and try again."
-end

data/test/spec_session_persisted_secure_secure_session_hash.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-require 'minitest/global_expectations/autorun'
-require 'rack/session/abstract/id'
-
-describe Rack::Session::Abstract::PersistedSecure::SecureSessionHash do
-  attr_reader :hash
-
-  def setup
-    super
-    @store = Class.new do
-      def load_session(req)
-        [Rack::Session::SessionId.new("id"), { foo: :bar, baz: :qux }]
-      end
-      def session_exists?(req)
-        true
-      end
-    end
-    @hash = Rack::Session::Abstract::PersistedSecure::SecureSessionHash.new(@store.new, nil)
-  end
-
-  it "returns keys" do
-    assert_equal ["foo", "baz"], hash.keys
-  end
-
-  it "returns values" do
-    assert_equal [:bar, :qux], hash.values
-  end
-
-  describe "#[]" do
-    it "returns value for a matching key" do
-      assert_equal :bar, hash[:foo]
-    end
-
-    it "returns value for a 'session_id' key" do
-      assert_equal "id", hash['session_id']
-    end
-
-    it "returns nil value for missing 'session_id' key" do
-      store = @store.new
-      def store.load_session(req)
-        [nil, {}]
-      end
-      @hash = Rack::Session::Abstract::PersistedSecure::SecureSessionHash.new(store, nil)
-      assert_nil hash['session_id']
-    end
-  end
-
-  describe "#fetch" do
-    it "returns value for a matching key" do
-      assert_equal :bar, hash.fetch(:foo)
-    end
-
-    it "works with a default value" do
-      assert_equal :default, hash.fetch(:unknown, :default)
-    end
-
-    it "works with a block" do
-      assert_equal :default, hash.fetch(:unkown) { :default }
-    end
-
-    it "it raises when fetching unknown keys without defaults" do
-      lambda { hash.fetch(:unknown) }.must_raise KeyError
-    end
-  end
-
-  describe "#stringify_keys" do
-    it "returns hash or session hash with keys stringified" do
-      assert_equal({ "foo" => :bar, "baz" => :qux }, hash.send(:stringify_keys, hash).to_h)
-    end
-  end
-end
-

data/test/spec_showexceptions.rb

@@ -1,98 +0,0 @@
-require 'rack/showexceptions'
-require 'rack/lint'
-require 'rack/mock'
-
-describe Rack::ShowExceptions do
-  def show_exceptions(app)
-    Rack::Lint.new Rack::ShowExceptions.new(app)
-  end
-  
-  it "catches exceptions" do
-    res = nil
-
-    req = Rack::MockRequest.new(
-      show_exceptions(
-        lambda{|env| raise RuntimeError }
-    ))
-
-    lambda{
-      res = req.get("/", "HTTP_ACCEPT" => "text/html")
-    }.should.not.raise
-
-    res.should.be.a.server_error
-    res.status.should.equal 500
-
-    res.should =~ /RuntimeError/
-    res.should =~ /ShowExceptions/
-  end
-
-  it "responds with HTML only to requests accepting HTML" do
-    res = nil
-
-    req = Rack::MockRequest.new(
-      show_exceptions(
-        lambda{|env| raise RuntimeError, "It was never supposed to work" }
-    ))
-
-    [
-      # Serve text/html when the client accepts text/html
-      ["text/html", ["/", {"HTTP_ACCEPT" => "text/html"}]],
-      ["text/html", ["/", {"HTTP_ACCEPT" => "*/*"}]],
-      # Serve text/plain when the client does not accept text/html
-      ["text/plain", ["/"]],
-      ["text/plain", ["/", {"HTTP_ACCEPT" => "application/json"}]]
-    ].each do |exmime, rargs|
-      lambda{
-        res = req.get(*rargs)
-      }.should.not.raise
-
-      res.should.be.a.server_error
-      res.status.should.equal 500
-
-      res.content_type.should.equal exmime
-
-      res.body.should.include "RuntimeError"
-      res.body.should.include "It was never supposed to work"
-
-      if exmime == "text/html"
-        res.body.should.include '</html>'
-      else
-        res.body.should.not.include '</html>'
-      end
-    end
-  end
-
-  it "handles exceptions without a backtrace" do
-    res = nil
-
-    req = Rack::MockRequest.new(
-      show_exceptions(
-        lambda{|env| raise RuntimeError, "", [] }
-      )
-    )
-
-    lambda{
-      res = req.get("/", "HTTP_ACCEPT" => "text/html")
-    }.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
-
-  it "knows to prefer plaintext for non-html" do
-    # We don't need an app for this
-    exc = Rack::ShowExceptions.new(nil)
-
-    [
-      [{ "HTTP_ACCEPT" => "text/plain" }, true],
-      [{ "HTTP_ACCEPT" => "text/foo" }, true],
-      [{ "HTTP_ACCEPT" => "text/html" }, false]
-    ].each do |env, expected|
-      expected.should.equal exc.prefers_plaintext?(env)
-    end
-  end
-end