rack 1.6.13 → 2.0.0.alpha

data/test/spec_lobster.rb

@@ -1,3 +1,4 @@
+require 'minitest/autorun'
 require 'rack/lobster'
 require 'rack/lint'
 require 'rack/mock'
@@ -13,46 +14,46 @@ module LobsterHelpers
 end
 
 describe Rack::Lobster::LambdaLobster do
-  extend LobsterHelpers
-  
-  should "be a single lambda" do
-    Rack::Lobster::LambdaLobster.should.be.kind_of Proc
+  include LobsterHelpers
+
+  it "be a single lambda" do
+    Rack::Lobster::LambdaLobster.must_be_kind_of Proc
   end
 
-  should "look like a lobster" do
+  it "look like a lobster" do
     res = lambda_lobster.get("/")
-    res.should.be.ok
-    res.body.should.include "(,(,,(,,,("
-    res.body.should.include "?flip"
+    res.must_be :ok?
+    res.body.must_include "(,(,,(,,,("
+    res.body.must_include "?flip"
   end
 
-  should "be flippable" do
+  it "be flippable" do
     res = lambda_lobster.get("/?flip")
-    res.should.be.ok
-    res.body.should.include "(,,,(,,(,("
+    res.must_be :ok?
+    res.body.must_include "(,,,(,,(,("
   end
 end
 
 describe Rack::Lobster do
-  extend LobsterHelpers
-  
-  should "look like a lobster" do
+  include LobsterHelpers
+
+  it "look like a lobster" do
     res = lobster.get("/")
-    res.should.be.ok
-    res.body.should.include "(,(,,(,,,("
-    res.body.should.include "?flip"
-    res.body.should.include "crash"
+    res.must_be :ok?
+    res.body.must_include "(,(,,(,,,("
+    res.body.must_include "?flip"
+    res.body.must_include "crash"
   end
 
-  should "be flippable" do
+  it "be flippable" do
     res = lobster.get("/?flip=left")
-    res.should.be.ok
-    res.body.should.include "),,,),,),)"
+    res.must_be :ok?
+    res.body.must_include "),,,),,),)"
   end
 
-  should "provide crashing for testing purposes" do
+  it "provide crashing for testing purposes" do
     lambda {
       lobster.get("/?flip=crash")
-    }.should.raise
+    }.must_raise RuntimeError
   end
 end

data/test/spec_lock.rb

@@ -1,3 +1,4 @@
+require 'minitest/autorun'
 require 'rack/lint'
 require 'rack/lock'
 require 'rack/mock'
@@ -9,11 +10,6 @@ class Lock
     @synchronized = false
   end
 
-  def synchronize
-    @synchronized = true
-    yield
-  end
-
   def lock
     @synchronized = true
   end
@@ -35,12 +31,12 @@ module LockHelpers
 end
 
 describe Rack::Lock do
-  extend LockHelpers
+  include LockHelpers
 
   describe 'Proxy' do
-    extend LockHelpers
+    include LockHelpers
 
-    should 'delegate each' do
+    it 'delegate each' do
       env      = Rack::MockRequest.env_for("/")
       response = Class.new {
         attr_accessor :close_called
@@ -52,10 +48,10 @@ describe Rack::Lock do
       response = app.call(env)[2]
       list = []
       response.each { |x| list << x }
-      list.should.equal %w{ hi mom }
+      list.must_equal %w{ hi mom }
     end
 
-    should 'delegate to_path' do
+    it 'delegate to_path' do
       lock = Lock.new
       env  = Rack::MockRequest.env_for("/")
 
@@ -65,11 +61,11 @@ describe Rack::Lock do
       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"
+      body.must_respond_to :to_path
+      body.to_path.must_equal "/tmp/hello.txt"
     end
 
-    should 'not delegate to_path if body does not implement it' do
+    it 'not delegate to_path if body does not implement it' do
       env  = Rack::MockRequest.env_for("/")
 
       res = ['Hello World']
@@ -77,11 +73,11 @@ describe Rack::Lock do
       app = lock_app(lambda { |inner_env| [200, {"Content-Type" => "text/plain"}, res] })
       body = app.call(env)[2]
 
-      body.should.not.respond_to :to_path
+      body.wont_respond_to :to_path
     end
   end
 
-  should 'call super on close' do
+  it 'call super on close' do
     env      = Rack::MockRequest.env_for("/")
     response = Class.new {
       attr_accessor :close_called
@@ -91,74 +87,108 @@ describe Rack::Lock do
 
     app = lock_app(lambda { |inner_env| [200, {"Content-Type" => "text/plain"}, response] })
     app.call(env)
-    response.close_called.should.equal false
+    response.close_called.must_equal false
     response.close
-    response.close_called.should.equal true
+    response.close_called.must_equal true
   end
 
-  should "not unlock until body is closed" do
+  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.should.equal false
+    lock.synchronized.must_equal false
     response = app.call(env)[2]
-    lock.synchronized.should.equal true
+    lock.synchronized.must_equal true
     response.close
-    lock.synchronized.should.equal false
+    lock.synchronized.must_equal false
   end
 
-  should "return value from app" do
+  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].should.equal body[0]
-    res[1].should.equal body[1]
-    res[2].to_enum.to_a.should.equal ["hi", "mom"]
+    res[0].must_equal body[0]
+    res[1].must_equal body[1]
+    res[2].to_enum.to_a.must_equal ["hi", "mom"]
   end
 
-  should "call synchronize on lock" do
+  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.should.equal false
+    lock.synchronized.must_equal false
     app.call(env)
-    lock.synchronized.should.equal true
+    lock.synchronized.must_equal true
   end
 
-  should "unlock if the app raises" do
+  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) }.should.raise(Exception)
-    lock.synchronized.should.equal false
+    lambda { app.call(env) }.must_raise Exception
+    lock.synchronized.must_equal false
   end
 
-  should "unlock if the app throws" do
+  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) }.should.throw(:bacon)
-    lock.synchronized.should.equal false
+    lambda { app.call(env) }.must_throw :bacon
+    lock.synchronized.must_equal false
   end
 
-  should "set multithread flag to false" do
+  it "set multithread flag to false" do
     app = lock_app(lambda { |env|
-      env['rack.multithread'].should.equal false
+      env['rack.multithread'].must_equal false
       [200, {"Content-Type" => "text/plain"}, %w{ a b c }]
     }, false)
-    app.call(Rack::MockRequest.env_for("/"))
+    env = Rack::MockRequest.env_for("/")
+    env['rack.multithread'].must_equal true
+    app.call(env)
+    env['rack.multithread'].must_equal true
   end
 
-  should "reset original multithread flag when exiting lock" do
+  it "reset original multithread flag when exiting lock" do
     app = Class.new(Rack::Lock) {
       def call(env)
-        env['rack.multithread'].should.equal true
+        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
 end

data/test/spec_logger.rb

@@ -1,3 +1,4 @@
+require 'minitest/autorun'
 require 'stringio'
 require 'rack/lint'
 require 'rack/logger'
@@ -13,11 +14,11 @@ describe Rack::Logger do
     [200, {'Content-Type' => 'text/plain'}, ["Hello, World!"]]
   }
 
-  should "conform to Rack::Lint" do
+  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.should.match(/INFO -- : Program started/)
-    errors.string.should.match(/WARN -- : Nothing to do/)
+    errors.string.must_match(/INFO -- : Program started/)
+    errors.string.must_match(/WARN -- : Nothing to do/)
   end
 end

data/test/spec_media_type.rb

@@ -0,0 +1,42 @@
+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_equal 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

@@ -0,0 +1,83 @@
+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 "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)
+    begin
+      app.call env
+    rescue EOFError
+    end
+
+    env["REQUEST_METHOD"].must_equal "POST"
+  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 +1,51 @@
+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).should.equal fallback
+    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).should.equal 'application/octet-stream'
+    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')).should.equal 'image/jpeg'
+    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).should.equal nil
+    Rack::Mime.mime_type('.nothing', nil).must_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
+    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/*').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
+    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', '*').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
+    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').should.equal true
-    Rack::Mime.match?('text/plain', '*/plain').should.equal true
+    Rack::Mime.match?('text/html', '*/html').must_equal true
+    Rack::Mime.match?('text/plain', '*/plain').must_equal true
   end
 
 end
-