rack 2.0.6 → 2.2.3

data/test/spec_lobster.rb

@@ -1,59 +0,0 @@
-require 'minitest/autorun'
-require 'rack/lobster'
-require 'rack/lint'
-require 'rack/mock'
-
-module LobsterHelpers
-  def lobster
-    Rack::MockRequest.new Rack::Lint.new(Rack::Lobster.new)
-  end
-
-  def lambda_lobster
-    Rack::MockRequest.new Rack::Lint.new(Rack::Lobster::LambdaLobster)
-  end
-end
-
-describe Rack::Lobster::LambdaLobster do
-  include LobsterHelpers
-
-  it "be a single lambda" do
-    Rack::Lobster::LambdaLobster.must_be_kind_of Proc
-  end
-
-  it "look like a lobster" do
-    res = lambda_lobster.get("/")
-    res.must_be :ok?
-    res.body.must_include "(,(,,(,,,("
-    res.body.must_include "?flip"
-  end
-
-  it "be flippable" do
-    res = lambda_lobster.get("/?flip")
-    res.must_be :ok?
-    res.body.must_include "(,,,(,,(,("
-  end
-end
-
-describe Rack::Lobster do
-  include LobsterHelpers
-
-  it "look like a lobster" do
-    res = lobster.get("/")
-    res.must_be :ok?
-    res.body.must_include "(,(,,(,,,("
-    res.body.must_include "?flip"
-    res.body.must_include "crash"
-  end
-
-  it "be flippable" do
-    res = lobster.get("/?flip=left")
-    res.must_be :ok?
-    res.body.must_include "),,,),,),)"
-  end
-
-  it "provide crashing for testing purposes" do
-    lambda {
-      lobster.get("/?flip=crash")
-    }.must_raise RuntimeError
-  end
-end

data/test/spec_lock.rb

@@ -1,204 +0,0 @@
-require 'minitest/autorun'
-require 'rack/lint'
-require 'rack/lock'
-require 'rack/mock'
-
-class Lock
-  attr_reader :synchronized
-
-  def initialize
-    @synchronized = false
-  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
-  include LockHelpers
-
-  describe 'Proxy' do
-    include LockHelpers
-
-    it '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.must_equal %w{ hi mom }
-    end
-
-    it '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.must_respond_to :to_path
-      body.to_path.must_equal "/tmp/hello.txt"
-    end
-
-    it '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.wont_respond_to :to_path
-    end
-  end
-
-  it '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.must_equal false
-    response.close
-    response.close_called.must_equal true
-  end
-
-  it "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.must_equal false
-    response = app.call(env)[2]
-    lock.synchronized.must_equal true
-    response.close
-    lock.synchronized.must_equal false
-  end
-
-  it "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].must_equal body[0]
-    res[1].must_equal body[1]
-    res[2].to_enum.to_a.must_equal ["hi", "mom"]
-  end
-
-  it "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.must_equal false
-    app.call(env)
-    lock.synchronized.must_equal true
-  end
-
-  it "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) }.must_raise Exception
-    lock.synchronized.must_equal false
-  end
-
-  it "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) }.must_throw :bacon
-    lock.synchronized.must_equal false
-  end
-
-  it "set multithread flag to false" do
-    app = lock_app(lambda { |env|
-      env['rack.multithread'].must_equal false
-      [200, {"Content-Type" => "text/plain"}, %w{ a b c }]
-    }, false)
-    env = Rack::MockRequest.env_for("/")
-    env['rack.multithread'].must_equal true
-    _, _, body = app.call(env)
-    body.close
-    env['rack.multithread'].must_equal true
-  end
-
-  it "reset original multithread flag when exiting lock" do
-    app = Class.new(Rack::Lock) {
-      def call(env)
-        env['rack.multithread'].must_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
-
-  it 'not unlock if an error is raised before the mutex is locked' do
-    lock = Class.new do
-      def initialize() @unlocked = false end
-      def unlocked?() @unlocked end
-      def lock() raise Exception end
-      def unlock() @unlocked = true end
-    end.new
-    env = Rack::MockRequest.env_for("/")
-    app = lock_app(proc { [200, {"Content-Type" => "text/plain"}, []] }, lock)
-    lambda { app.call(env) }.must_raise Exception
-    lock.unlocked?.must_equal false
-  end
-
-  it "not reset the environment while the body is proxied" do
-    proxy = Class.new do
-      attr_reader :env
-      def initialize(env) @env = env end
-    end
-    app = Rack::Lock.new lambda { |env| [200, {"Content-Type" => "text/plain"}, proxy.new(env)] }
-    response = app.call(Rack::MockRequest.env_for("/"))[2]
-    response.env['rack.multithread'].must_equal false
-  end
-
-  it "unlock if an exception occurs before returning" do
-    lock = Lock.new
-    env  = Rack::MockRequest.env_for("/")
-    app  = lock_app(proc { [].freeze }, lock)
-    lambda { app.call(env) }.must_raise Exception
-    lock.synchronized.must_equal false
-  end
-
-  it "not replace the environment" do
-    env  = Rack::MockRequest.env_for("/")
-    app  = lock_app(lambda { |inner_env| [200, {"Content-Type" => "text/plain"}, [inner_env.object_id.to_s]] })
-
-    _, _, body = app.call(env)
-
-    body.to_enum.to_a.must_equal [env.object_id.to_s]
-  end
-end

data/test/spec_logger.rb

@@ -1,24 +0,0 @@
-require 'minitest/autorun'
-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!"]]
-  }
-
-  it "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.must_match(/INFO -- : Program started/)
-    errors.string.must_match(/WARN -- : Nothing to do/)
-  end
-end

data/test/spec_media_type.rb

@@ -1,42 +0,0 @@
-require 'minitest/autorun'
-require 'rack/media_type'
-
-describe Rack::MediaType do
-  before { @empty_hash = {} }
-
-  describe 'when content_type nil' do
-    before { @content_type = nil }
-
-    it '#type is nil' do
-      Rack::MediaType.type(@content_type).must_be_nil
-    end
-
-    it '#params is empty' do
-      Rack::MediaType.params(@content_type).must_equal @empty_hash
-    end
-  end
-
-  describe 'when content_type contains only media_type' do
-    before { @content_type = 'application/text' }
-
-    it '#type is application/text' do
-      Rack::MediaType.type(@content_type).must_equal 'application/text'
-    end
-
-    it  '#params is empty' do
-      Rack::MediaType.params(@content_type).must_equal @empty_hash
-    end
-  end
-
-  describe 'when content_type contains media_type and params' do
-    before { @content_type = 'application/text;CHARSET="utf-8"' }
-
-    it '#type is application/text' do
-      Rack::MediaType.type(@content_type).must_equal 'application/text'
-    end
-
-    it '#params has key "charset" with value "utf-8"' do
-      Rack::MediaType.params(@content_type)['charset'].must_equal 'utf-8'
-    end
-  end
-end

data/test/spec_method_override.rb

@@ -1,110 +0,0 @@
-require 'minitest/autorun'
-require 'stringio'
-require 'rack/method_override'
-require 'rack/mock'
-
-describe Rack::MethodOverride do
-  def app
-    Rack::Lint.new(Rack::MethodOverride.new(lambda {|e|
-      [200, {"Content-Type" => "text/plain"}, []]
-    }))
-  end
-
-  it "not affect GET requests" do
-    env = Rack::MockRequest.env_for("/?_method=delete", :method => "GET")
-    app.call env
-
-    env["REQUEST_METHOD"].must_equal "GET"
-  end
-
-  it "sets rack.errors for invalid UTF8 _method values" do
-    errors = StringIO.new
-    env = Rack::MockRequest.env_for("/",
-      :method => "POST",
-      :input => "_method=\xBF".b,
-      Rack::RACK_ERRORS => errors)
-
-    app.call env
-
-    errors.rewind
-    errors.read.must_equal "Invalid string for method\n"
-    env["REQUEST_METHOD"].must_equal "POST"
-  end
-
-  it "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"].must_equal "PUT"
-  end
-
-  it "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"].must_equal "PATCH"
-  end
-
-  it "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"].must_equal "POST"
-  end
-
-  it "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"].must_equal "POST"
-  end
-
-  it "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"].must_equal "POST"
-  end
-
-  it "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"].must_equal "POST"
-  end
-
-  it "writes 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::RACK_ERRORS => StringIO.new,
-                      :method => "POST", :input => input)
-    Rack::MethodOverride.new(proc { [200, {"Content-Type" => "text/plain"}, []] }).call env
-
-    env[Rack::RACK_ERRORS].rewind
-    env[Rack::RACK_ERRORS].read.must_match /Bad request content body/
-  end
-
-  it "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"].must_equal "POST"
-  end
-end

data/test/spec_mime.rb

@@ -1,51 +0,0 @@
-require 'minitest/autorun'
-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).must_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).must_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')).must_equal 'image/jpeg'
-  end
-
-  it "should support null fallbacks" do
-    Rack::Mime.mime_type('.nothing', nil).must_be_nil
-  end
-
-  it "should match exact mimes" do
-    Rack::Mime.match?('text/html', 'text/html').must_equal true
-    Rack::Mime.match?('text/html', 'text/meme').must_equal false
-    Rack::Mime.match?('text', 'text').must_equal true
-    Rack::Mime.match?('text', 'binary').must_equal false
-  end
-
-  it "should match class wildcard mimes" do
-    Rack::Mime.match?('text/html', 'text/*').must_equal true
-    Rack::Mime.match?('text/plain', 'text/*').must_equal true
-    Rack::Mime.match?('application/json', 'text/*').must_equal false
-    Rack::Mime.match?('text/html', 'text').must_equal true
-  end
-
-  it "should match full wildcards" do
-    Rack::Mime.match?('text/html', '*').must_equal true
-    Rack::Mime.match?('text/plain', '*').must_equal true
-    Rack::Mime.match?('text/html', '*/*').must_equal true
-    Rack::Mime.match?('text/plain', '*/*').must_equal true
-  end
-
-  it "should match type wildcard mimes" do
-    Rack::Mime.match?('text/html', '*/html').must_equal true
-    Rack::Mime.match?('text/plain', '*/plain').must_equal true
-  end
-
-end