rack 1.6.13 → 2.1.4.3

data/test/spec_lock.rb

@@ -1,164 +0,0 @@
-require 'rack/lint'
-require 'rack/lock'
-require 'rack/mock'
-
-class Lock
-  attr_reader :synchronized
-
-  def initialize
-    @synchronized = false
-  end
-
-  def synchronize
-    @synchronized = true
-    yield
-  end
-
-  def lock
-    @synchronized = true
-  end
-
-  def unlock
-    @synchronized = false
-  end
-end
-
-module LockHelpers
-  def lock_app(app, lock = Lock.new)
-    app = if lock
-      Rack::Lock.new app, lock
-    else
-      Rack::Lock.new app
-    end
-    Rack::Lint.new app
-  end
-end
-
-describe Rack::Lock do
-  extend LockHelpers
-
-  describe 'Proxy' do
-    extend LockHelpers
-
-    should 'delegate each' do
-      env      = Rack::MockRequest.env_for("/")
-      response = Class.new {
-        attr_accessor :close_called
-        def initialize; @close_called = false; end
-        def each; %w{ hi mom }.each { |x| yield x }; end
-      }.new
-
-      app = lock_app(lambda { |inner_env| [200, {"Content-Type" => "text/plain"}, response] })
-      response = app.call(env)[2]
-      list = []
-      response.each { |x| list << x }
-      list.should.equal %w{ hi mom }
-    end
-
-    should 'delegate to_path' do
-      lock = Lock.new
-      env  = Rack::MockRequest.env_for("/")
-
-      res = ['Hello World']
-      def res.to_path ; "/tmp/hello.txt" ; end
-
-      app = Rack::Lock.new(lambda { |inner_env| [200, {"Content-Type" => "text/plain"}, res] }, lock)
-      body = app.call(env)[2]
-
-      body.should.respond_to :to_path
-      body.to_path.should.equal "/tmp/hello.txt"
-    end
-
-    should 'not delegate to_path if body does not implement it' do
-      env  = Rack::MockRequest.env_for("/")
-
-      res = ['Hello World']
-
-      app = lock_app(lambda { |inner_env| [200, {"Content-Type" => "text/plain"}, res] })
-      body = app.call(env)[2]
-
-      body.should.not.respond_to :to_path
-    end
-  end
-
-  should 'call super on close' do
-    env      = Rack::MockRequest.env_for("/")
-    response = Class.new {
-      attr_accessor :close_called
-      def initialize; @close_called = false; end
-      def close; @close_called = true; end
-    }.new
-
-    app = lock_app(lambda { |inner_env| [200, {"Content-Type" => "text/plain"}, response] })
-    app.call(env)
-    response.close_called.should.equal false
-    response.close
-    response.close_called.should.equal true
-  end
-
-  should "not unlock until body is closed" do
-    lock     = Lock.new
-    env      = Rack::MockRequest.env_for("/")
-    response = Object.new
-    app      = lock_app(lambda { |inner_env| [200, {"Content-Type" => "text/plain"}, response] }, lock)
-    lock.synchronized.should.equal false
-    response = app.call(env)[2]
-    lock.synchronized.should.equal true
-    response.close
-    lock.synchronized.should.equal false
-  end
-
-  should "return value from app" do
-    env  = Rack::MockRequest.env_for("/")
-    body = [200, {"Content-Type" => "text/plain"}, %w{ hi mom }]
-    app  = lock_app(lambda { |inner_env| body })
-
-    res = app.call(env)
-    res[0].should.equal body[0]
-    res[1].should.equal body[1]
-    res[2].to_enum.to_a.should.equal ["hi", "mom"]
-  end
-
-  should "call synchronize on lock" do
-    lock = Lock.new
-    env = Rack::MockRequest.env_for("/")
-    app = lock_app(lambda { |inner_env| [200, {"Content-Type" => "text/plain"}, %w{ a b c }] }, lock)
-    lock.synchronized.should.equal false
-    app.call(env)
-    lock.synchronized.should.equal true
-  end
-
-  should "unlock if the app raises" do
-    lock = Lock.new
-    env = Rack::MockRequest.env_for("/")
-    app = lock_app(lambda { raise Exception }, lock)
-    lambda { app.call(env) }.should.raise(Exception)
-    lock.synchronized.should.equal false
-  end
-
-  should "unlock if the app throws" do
-    lock = Lock.new
-    env = Rack::MockRequest.env_for("/")
-    app = lock_app(lambda {|_| throw :bacon }, lock)
-    lambda { app.call(env) }.should.throw(:bacon)
-    lock.synchronized.should.equal false
-  end
-
-  should "set multithread flag to false" do
-    app = lock_app(lambda { |env|
-      env['rack.multithread'].should.equal false
-      [200, {"Content-Type" => "text/plain"}, %w{ a b c }]
-    }, false)
-    app.call(Rack::MockRequest.env_for("/"))
-  end
-
-  should "reset original multithread flag when exiting lock" do
-    app = Class.new(Rack::Lock) {
-      def call(env)
-        env['rack.multithread'].should.equal true
-        super
-      end
-    }.new(lambda { |env| [200, {"Content-Type" => "text/plain"}, %w{ a b c }] })
-    Rack::Lint.new(app).call(Rack::MockRequest.env_for("/"))
-  end
-end

data/test/spec_logger.rb

@@ -1,23 +0,0 @@
-require 'stringio'
-require 'rack/lint'
-require 'rack/logger'
-require 'rack/mock'
-
-describe Rack::Logger do
-  app = lambda { |env|
-    log = env['rack.logger']
-    log.debug("Created logger")
-    log.info("Program started")
-    log.warn("Nothing to do!")
-
-    [200, {'Content-Type' => 'text/plain'}, ["Hello, World!"]]
-  }
-
-  should "conform to Rack::Lint" do
-    errors = StringIO.new
-    a = Rack::Lint.new(Rack::Logger.new(app))
-    Rack::MockRequest.new(a).get('/', 'rack.errors' => errors)
-    errors.string.should.match(/INFO -- : Program started/)
-    errors.string.should.match(/WARN -- : Nothing to do/)
-  end
-end

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_mime.rb

@@ -1,51 +0,0 @@
-require 'rack/mime'
-
-describe Rack::Mime do
-
-  it "should return the fallback mime-type for files with no extension" do
-    fallback = 'image/jpg'
-    Rack::Mime.mime_type(File.extname('no_ext'), fallback).should.equal fallback
-  end
-
-  it "should always return 'application/octet-stream' for unknown file extensions" do
-    unknown_ext = File.extname('unknown_ext.abcdefg')
-    Rack::Mime.mime_type(unknown_ext).should.equal 'application/octet-stream'
-  end
-
-  it "should return the mime-type for a given extension" do
-    # sanity check. it would be infeasible test every single mime-type.
-    Rack::Mime.mime_type(File.extname('image.jpg')).should.equal 'image/jpeg'
-  end
-
-  it "should support null fallbacks" do
-    Rack::Mime.mime_type('.nothing', nil).should.equal nil
-  end
-
-  it "should match exact mimes" do
-    Rack::Mime.match?('text/html', 'text/html').should.equal true
-    Rack::Mime.match?('text/html', 'text/meme').should.equal false
-    Rack::Mime.match?('text', 'text').should.equal true
-    Rack::Mime.match?('text', 'binary').should.equal false
-  end
-
-  it "should match class wildcard mimes" do
-    Rack::Mime.match?('text/html', 'text/*').should.equal true
-    Rack::Mime.match?('text/plain', 'text/*').should.equal true
-    Rack::Mime.match?('application/json', 'text/*').should.equal false
-    Rack::Mime.match?('text/html', 'text').should.equal true
-  end
-
-  it "should match full wildcards" do
-    Rack::Mime.match?('text/html', '*').should.equal true
-    Rack::Mime.match?('text/plain', '*').should.equal true
-    Rack::Mime.match?('text/html', '*/*').should.equal true
-    Rack::Mime.match?('text/plain', '*/*').should.equal true
-  end
-
-  it "should match type wildcard mimes" do
-    Rack::Mime.match?('text/html', '*/html').should.equal true
-    Rack::Mime.match?('text/plain', '*/plain').should.equal true
-  end
-
-end
-

data/test/spec_mock.rb

@@ -1,297 +0,0 @@
-require 'yaml'
-require 'rack/lint'
-require 'rack/mock'
-require 'stringio'
-
-app = Rack::Lint.new(lambda { |env|
-  req = Rack::Request.new(env)
-
-  env["mock.postdata"] = env["rack.input"].read
-  if req.GET["error"]
-    env["rack.errors"].puts req.GET["error"]
-    env["rack.errors"].flush
-  end
-
-  body = req.head? ? "" : env.to_yaml
-  Rack::Response.new(body,
-                     req.GET["status"] || 200,
-                     "Content-Type" => "text/yaml").finish
-})
-
-describe Rack::MockRequest do
-  should "return a MockResponse" do
-    res = Rack::MockRequest.new(app).get("")
-    res.should.be.kind_of Rack::MockResponse
-  end
-
-  should "be able to only return the environment" do
-    env = Rack::MockRequest.env_for("")
-    env.should.be.kind_of Hash
-    env.should.include "rack.version"
-  end
-
-  should "return an environment with a path" do
-    env = Rack::MockRequest.env_for("http://www.example.com/parse?location[]=1&location[]=2&age_group[]=2")
-    env["QUERY_STRING"].should.equal "location[]=1&location[]=2&age_group[]=2"
-    env["PATH_INFO"].should.equal "/parse"
-    env.should.be.kind_of Hash
-    env.should.include "rack.version"
-  end
-
-  should "provide sensible defaults" do
-    res = Rack::MockRequest.new(app).request
-
-    env = YAML.load(res.body)
-    env["REQUEST_METHOD"].should.equal "GET"
-    env["SERVER_NAME"].should.equal "example.org"
-    env["SERVER_PORT"].should.equal "80"
-    env["QUERY_STRING"].should.equal ""
-    env["PATH_INFO"].should.equal "/"
-    env["SCRIPT_NAME"].should.equal ""
-    env["rack.url_scheme"].should.equal "http"
-    env["mock.postdata"].should.be.empty
-  end
-
-  should "allow GET/POST/PUT/DELETE/HEAD" do
-    res = Rack::MockRequest.new(app).get("", :input => "foo")
-    env = YAML.load(res.body)
-    env["REQUEST_METHOD"].should.equal "GET"
-
-    res = Rack::MockRequest.new(app).post("", :input => "foo")
-    env = YAML.load(res.body)
-    env["REQUEST_METHOD"].should.equal "POST"
-
-    res = Rack::MockRequest.new(app).put("", :input => "foo")
-    env = YAML.load(res.body)
-    env["REQUEST_METHOD"].should.equal "PUT"
-
-    res = Rack::MockRequest.new(app).patch("", :input => "foo")
-    env = YAML.load(res.body)
-    env["REQUEST_METHOD"].should.equal "PATCH"
-
-    res = Rack::MockRequest.new(app).delete("", :input => "foo")
-    env = YAML.load(res.body)
-    env["REQUEST_METHOD"].should.equal "DELETE"
-    
-    Rack::MockRequest.env_for("/", :method => "HEAD")["REQUEST_METHOD"].
-      should.equal "HEAD"
-
-    Rack::MockRequest.env_for("/", :method => "OPTIONS")["REQUEST_METHOD"].
-      should.equal "OPTIONS"
-  end
-
-  should "set content length" do
-    env = Rack::MockRequest.env_for("/", :input => "foo")
-    env["CONTENT_LENGTH"].should.equal "3"
-  end
-
-  should "allow posting" do
-    res = Rack::MockRequest.new(app).get("", :input => "foo")
-    env = YAML.load(res.body)
-    env["mock.postdata"].should.equal "foo"
-
-    res = Rack::MockRequest.new(app).post("", :input => StringIO.new("foo"))
-    env = YAML.load(res.body)
-    env["mock.postdata"].should.equal "foo"
-  end
-
-  should "use all parts of an URL" do
-    res = Rack::MockRequest.new(app).
-      get("https://bla.example.org:9292/meh/foo?bar")
-    res.should.be.kind_of Rack::MockResponse
-
-    env = YAML.load(res.body)
-    env["REQUEST_METHOD"].should.equal "GET"
-    env["SERVER_NAME"].should.equal "bla.example.org"
-    env["SERVER_PORT"].should.equal "9292"
-    env["QUERY_STRING"].should.equal "bar"
-    env["PATH_INFO"].should.equal "/meh/foo"
-    env["rack.url_scheme"].should.equal "https"
-  end
-
-  should "set SSL port and HTTP flag on when using https" do
-    res = Rack::MockRequest.new(app).
-      get("https://example.org/foo")
-    res.should.be.kind_of Rack::MockResponse
-
-    env = YAML.load(res.body)
-    env["REQUEST_METHOD"].should.equal "GET"
-    env["SERVER_NAME"].should.equal "example.org"
-    env["SERVER_PORT"].should.equal "443"
-    env["QUERY_STRING"].should.equal ""
-    env["PATH_INFO"].should.equal "/foo"
-    env["rack.url_scheme"].should.equal "https"
-    env["HTTPS"].should.equal "on"
-  end
-
-  should "prepend slash to uri path" do
-    res = Rack::MockRequest.new(app).
-      get("foo")
-    res.should.be.kind_of Rack::MockResponse
-
-    env = YAML.load(res.body)
-    env["REQUEST_METHOD"].should.equal "GET"
-    env["SERVER_NAME"].should.equal "example.org"
-    env["SERVER_PORT"].should.equal "80"
-    env["QUERY_STRING"].should.equal ""
-    env["PATH_INFO"].should.equal "/foo"
-    env["rack.url_scheme"].should.equal "http"
-  end
-
-  should "properly convert method name to an uppercase string" do
-    res = Rack::MockRequest.new(app).request(:get)
-    env = YAML.load(res.body)
-    env["REQUEST_METHOD"].should.equal "GET"
-  end
-
-  should "accept params and build query string for GET requests" do
-    res = Rack::MockRequest.new(app).get("/foo?baz=2", :params => {:foo => {:bar => "1"}})
-    env = YAML.load(res.body)
-    env["REQUEST_METHOD"].should.equal "GET"
-    env["QUERY_STRING"].should.include "baz=2"
-    env["QUERY_STRING"].should.include "foo[bar]=1"
-    env["PATH_INFO"].should.equal "/foo"
-    env["mock.postdata"].should.equal ""
-  end
-
-  should "accept raw input in params for GET requests" do
-    res = Rack::MockRequest.new(app).get("/foo?baz=2", :params => "foo[bar]=1")
-    env = YAML.load(res.body)
-    env["REQUEST_METHOD"].should.equal "GET"
-    env["QUERY_STRING"].should.include "baz=2"
-    env["QUERY_STRING"].should.include "foo[bar]=1"
-    env["PATH_INFO"].should.equal "/foo"
-    env["mock.postdata"].should.equal ""
-  end
-
-  should "accept params and build url encoded params for POST requests" do
-    res = Rack::MockRequest.new(app).post("/foo", :params => {:foo => {:bar => "1"}})
-    env = YAML.load(res.body)
-    env["REQUEST_METHOD"].should.equal "POST"
-    env["QUERY_STRING"].should.equal ""
-    env["PATH_INFO"].should.equal "/foo"
-    env["CONTENT_TYPE"].should.equal "application/x-www-form-urlencoded"
-    env["mock.postdata"].should.equal "foo[bar]=1"
-  end
-
-  should "accept raw input in params for POST requests" do
-    res = Rack::MockRequest.new(app).post("/foo", :params => "foo[bar]=1")
-    env = YAML.load(res.body)
-    env["REQUEST_METHOD"].should.equal "POST"
-    env["QUERY_STRING"].should.equal ""
-    env["PATH_INFO"].should.equal "/foo"
-    env["CONTENT_TYPE"].should.equal "application/x-www-form-urlencoded"
-    env["mock.postdata"].should.equal "foo[bar]=1"
-  end
-
-  should "accept params and build multipart encoded params for POST requests" do
-    files = Rack::Multipart::UploadedFile.new(File.join(File.dirname(__FILE__), "multipart", "file1.txt"))
-    res = Rack::MockRequest.new(app).post("/foo", :params => { "submit-name" => "Larry", "files" => files })
-    env = YAML.load(res.body)
-    env["REQUEST_METHOD"].should.equal "POST"
-    env["QUERY_STRING"].should.equal ""
-    env["PATH_INFO"].should.equal "/foo"
-    env["CONTENT_TYPE"].should.equal "multipart/form-data; boundary=AaB03x"
-    # The gsub accounts for differences in YAMLs affect on the data.
-    env["mock.postdata"].gsub("\r", "").length.should.equal 206
-  end
-
-  should "behave valid according to the Rack spec" do
-    lambda {
-      Rack::MockRequest.new(app).
-        get("https://bla.example.org:9292/meh/foo?bar", :lint => true)
-    }.should.not.raise(Rack::Lint::LintError)
-  end
-
-  should "call close on the original body object" do
-    called = false
-    body   = Rack::BodyProxy.new(['hi']) { called = true }
-    capp   = proc { |e| [200, {'Content-Type' => 'text/plain'}, body] }
-    called.should.equal false
-    Rack::MockRequest.new(capp).get('/', :lint => true)
-    called.should.equal true
-  end
-
-  if "<3".respond_to? :b
-    should "defaults encoding to ASCII 8BIT" do
-      req = Rack::MockRequest.env_for("/foo")
-
-      keys = [
-        Rack::REQUEST_METHOD,
-        "SERVER_NAME",
-        "SERVER_PORT",
-        Rack::QUERY_STRING,
-        Rack::PATH_INFO,
-        "rack.url_scheme",
-        "HTTPS"
-      ]
-
-      keys.each do |k|
-        req[k].encoding.should.equal Encoding::ASCII_8BIT
-      end
-    end
-  end
-end
-
-describe Rack::MockResponse do
-  should "provide access to the HTTP status" do
-    res = Rack::MockRequest.new(app).get("")
-    res.should.be.successful
-    res.should.be.ok
-
-    res = Rack::MockRequest.new(app).get("/?status=404")
-    res.should.not.be.successful
-    res.should.be.client_error
-    res.should.be.not_found
-
-    res = Rack::MockRequest.new(app).get("/?status=501")
-    res.should.not.be.successful
-    res.should.be.server_error
-
-    res = Rack::MockRequest.new(app).get("/?status=307")
-    res.should.be.redirect
-
-    res = Rack::MockRequest.new(app).get("/?status=201", :lint => true)
-    res.should.be.empty
-  end
-
-  should "provide access to the HTTP headers" do
-    res = Rack::MockRequest.new(app).get("")
-    res.should.include "Content-Type"
-    res.headers["Content-Type"].should.equal "text/yaml"
-    res.original_headers["Content-Type"].should.equal "text/yaml"
-    res["Content-Type"].should.equal "text/yaml"
-    res.content_type.should.equal "text/yaml"
-    res.content_length.should.not.equal 0
-    res.location.should.be.nil
-  end
-
-  should "provide access to the HTTP body" do
-    res = Rack::MockRequest.new(app).get("")
-    res.body.should =~ /rack/
-    res.should =~ /rack/
-    res.should.match(/rack/)
-    res.should.satisfy { |r| r.match(/rack/) }
-  end
-
-  should "provide access to the Rack errors" do
-    res = Rack::MockRequest.new(app).get("/?error=foo", :lint => true)
-    res.should.be.ok
-    res.errors.should.not.be.empty
-    res.errors.should.include "foo"
-  end
-
-  should "allow calling body.close afterwards" do
-    # this is exactly what rack-test does
-    body = StringIO.new("hi")
-    res = Rack::MockResponse.new(200, {}, body)
-    body.close if body.respond_to?(:close)
-    res.body.should == 'hi'
-  end
-
-  should "optionally make Rack errors fatal" do
-    lambda {
-      Rack::MockRequest.new(app).get("/?error=foo", :fatal => true)
-    }.should.raise(Rack::MockRequest::FatalWarning)
-  end
-end