rack 1.6.13 → 2.0.9.3

data/test/spec_deflater.rb

@@ -1,3 +1,4 @@
+require 'minitest/autorun'
 require 'stringio'
 require 'time'  # for Time#httpdate
 require 'rack/deflater'
@@ -32,7 +33,7 @@ describe Rack::Deflater do
   # [options] hash of request options, i.e.
   #           'app_status' - what status dummy app should return (may be changed by deflater at some point)
   #           'app_body' - what body dummy app should return (may be changed by deflater at some point)
-  #           'request_headers' - extra reqest headers to be sent
+  #           'request_headers' - extra request headers to be sent
   #           'response_headers' - extra response headers to be returned
   #           'deflater_options' - options passed to deflater middleware
   # [block] useful for doing some extra verification
@@ -52,7 +53,7 @@ describe Rack::Deflater do
     )
 
     # verify status
-    status.should.equal(expected_status)
+    status.must_equal expected_status
 
     # verify body
     unless options['skip_body_verify']
@@ -73,63 +74,98 @@ describe Rack::Deflater do
         body_text
       end
 
-      deflated_body.should.equal(expected_body)
+      deflated_body.must_equal expected_body
     end
 
     # yield full response verification
     yield(status, headers, body) if block_given?
   end
 
-  should 'be able to deflate bodies that respond to each' do
+  # automatic gzip detection (streamable)
+  def auto_inflater
+    Zlib::Inflate.new(32 + Zlib::MAX_WBITS)
+  end
+
+  def deflate_or_gzip
+    {'deflate, gzip' => 'gzip'}
+  end
+
+  it 'be able to deflate bodies that respond to each' do
     app_body = Object.new
     class << app_body; def each; yield('foo'); yield('bar'); end; end
 
-    verify(200, 'foobar', 'deflate', { 'app_body' => app_body }) do |status, headers, body|
-      headers.should.equal({
-        'Content-Encoding' => 'deflate',
+    verify(200, 'foobar', deflate_or_gzip, { 'app_body' => app_body }) do |status, headers, body|
+      headers.must_equal({
+        'Content-Encoding' => 'gzip',
         'Vary' => 'Accept-Encoding',
         'Content-Type' => 'text/plain'
       })
     end
   end
 
-  should 'flush deflated chunks to the client as they become ready' do
+  it 'flush deflated chunks to the client as they become ready' do
     app_body = Object.new
     class << app_body; def each; yield('foo'); yield('bar'); end; end
 
-    verify(200, app_body, 'deflate', { 'skip_body_verify' => true }) do |status, headers, body|
-      headers.should.equal({
-        'Content-Encoding' => 'deflate',
+    verify(200, app_body, deflate_or_gzip, { 'skip_body_verify' => true }) do |status, headers, body|
+      headers.must_equal({
+        'Content-Encoding' => 'gzip',
         'Vary' => 'Accept-Encoding',
         'Content-Type' => 'text/plain'
       })
 
       buf = []
-      inflater = Zlib::Inflate.new(-Zlib::MAX_WBITS)
+      inflater = auto_inflater
       body.each { |part| buf << inflater.inflate(part) }
       buf << inflater.finish
 
-      buf.delete_if { |part| part.empty? }.join.should.equal('foobar')
+      buf.delete_if { |part| part.empty? }.join.must_equal 'foobar'
+    end
+  end
+
+  it 'does not raise when a client aborts reading' do
+    app_body = Object.new
+    class << app_body; def each; yield('foo'); yield('bar'); end; end
+    opts = { 'skip_body_verify' => true }
+    verify(200, app_body, 'gzip', opts) do |status, headers, body|
+      headers.must_equal({
+        'Content-Encoding' => 'gzip',
+        'Vary' => 'Accept-Encoding',
+        'Content-Type' => 'text/plain'
+      })
+
+      buf = []
+      inflater = auto_inflater
+      FakeDisconnect = Class.new(RuntimeError)
+      assert_raises(FakeDisconnect, "not Zlib::DataError not raised") do
+        body.each do |part|
+          tmp = inflater.inflate(part)
+          buf << tmp if tmp.bytesize > 0
+          raise FakeDisconnect
+        end
+      end
+      inflater.finish
+      buf.must_equal(%w(foo))
     end
   end
 
   # TODO: This is really just a special case of the above...
-  should 'be able to deflate String bodies' do
-    verify(200, 'Hello world!', 'deflate') do |status, headers, body|
-      headers.should.equal({
-        'Content-Encoding' => 'deflate',
+  it 'be able to deflate String bodies' do
+    verify(200, 'Hello world!', deflate_or_gzip) do |status, headers, body|
+      headers.must_equal({
+        'Content-Encoding' => 'gzip',
         'Vary' => 'Accept-Encoding',
         'Content-Type' => 'text/plain'
       })
     end
   end
 
-  should 'be able to gzip bodies that respond to each' do
+  it 'be able to gzip bodies that respond to each' do
     app_body = Object.new
     class << app_body; def each; yield('foo'); yield('bar'); end; end
 
     verify(200, 'foobar', 'gzip', { 'app_body' => app_body }) do |status, headers, body|
-      headers.should.equal({
+      headers.must_equal({
         'Content-Encoding' => 'gzip',
         'Vary' => 'Accept-Encoding',
         'Content-Type' => 'text/plain'
@@ -137,12 +173,12 @@ describe Rack::Deflater do
     end
   end
 
-  should 'flush gzipped chunks to the client as they become ready' do
+  it 'flush gzipped chunks to the client as they become ready' do
     app_body = Object.new
     class << app_body; def each; yield('foo'); yield('bar'); end; end
 
     verify(200, app_body, 'gzip', { 'skip_body_verify' => true }) do |status, headers, body|
-      headers.should.equal({
+      headers.must_equal({
         'Content-Encoding' => 'gzip',
         'Vary' => 'Accept-Encoding',
         'Content-Type' => 'text/plain'
@@ -153,26 +189,26 @@ describe Rack::Deflater do
       body.each { |part| buf << inflater.inflate(part) }
       buf << inflater.finish
 
-      buf.delete_if { |part| part.empty? }.join.should.equal('foobar')
+      buf.delete_if { |part| part.empty? }.join.must_equal 'foobar'
     end
   end
 
-  should 'be able to fallback to no deflation' do
+  it 'be able to fallback to no deflation' do
     verify(200, 'Hello world!', 'superzip') do |status, headers, body|
-      headers.should.equal({
+      headers.must_equal({
         'Vary' => 'Accept-Encoding',
         'Content-Type' => 'text/plain'
       })
     end
   end
 
-  should 'be able to skip when there is no response entity body' do
+  it 'be able to skip when there is no response entity body' do
     verify(304, '', { 'gzip' => nil }, { 'app_body' => [] }) do |status, headers, body|
-      headers.should.equal({})
+      headers.must_equal({})
     end
   end
 
-  should 'handle the lack of an acceptable encoding' do
+  it 'handle the lack of an acceptable encoding' do
     app_body = 'Hello world!'
     not_found_body1 = 'An acceptable encoding for the requested resource / could not be found.'
     not_found_body2 = 'An acceptable encoding for the requested resource /foo/bar could not be found.'
@@ -192,21 +228,21 @@ describe Rack::Deflater do
     }
 
     verify(406, not_found_body1, 'identity;q=0', options1) do |status, headers, body|
-      headers.should.equal({
+      headers.must_equal({
         'Content-Type' => 'text/plain',
         'Content-Length' => not_found_body1.length.to_s
       })
     end
 
     verify(406, not_found_body2, 'identity;q=0', options2) do |status, headers, body|
-      headers.should.equal({
+      headers.must_equal({
         'Content-Type' => 'text/plain',
         'Content-Length' => not_found_body2.length.to_s
       })
     end
   end
 
-  should 'handle gzip response with Last-Modified header' do
+  it 'handle gzip response with Last-Modified header' do
     last_modified = Time.now.httpdate
     options = {
       'response_headers' => {
@@ -216,7 +252,7 @@ describe Rack::Deflater do
     }
 
     verify(200, 'Hello World!', 'gzip', options) do |status, headers, body|
-      headers.should.equal({
+      headers.must_equal({
         'Content-Encoding' => 'gzip',
         'Vary' => 'Accept-Encoding',
         'Last-Modified' => last_modified,
@@ -225,7 +261,7 @@ describe Rack::Deflater do
     end
   end
 
-  should 'do nothing when no-transform Cache-Control directive present' do
+  it 'do nothing when no-transform Cache-Control directive present' do
     options = {
       'response_headers' => {
         'Content-Type' => 'text/plain',
@@ -233,11 +269,11 @@ describe Rack::Deflater do
       }
     }
     verify(200, 'Hello World!', { 'gzip' => nil }, options) do |status, headers, body|
-      headers.should.not.include 'Content-Encoding'
+      headers.wont_include 'Content-Encoding'
     end
   end
 
-  should 'do nothing when Content-Encoding already present' do
+  it 'do nothing when Content-Encoding already present' do
     options = {
       'response_headers' => {
         'Content-Type' => 'text/plain',
@@ -247,17 +283,17 @@ describe Rack::Deflater do
     verify(200, 'Hello World!', { 'gzip' => nil }, options)
   end
 
-  should 'deflate when Content-Encoding is identity' do
+  it 'deflate when Content-Encoding is identity' do
     options = {
       'response_headers' => {
         'Content-Type' => 'text/plain',
         'Content-Encoding' => 'identity'
       }
     }
-    verify(200, 'Hello World!', 'deflate', options)
+    verify(200, 'Hello World!', deflate_or_gzip, options)
   end
 
-  should "deflate if content-type matches :include" do
+  it "deflate if content-type matches :include" do
     options = {
       'response_headers' => {
         'Content-Type' => 'text/plain'
@@ -269,7 +305,7 @@ describe Rack::Deflater do
     verify(200, 'Hello World!', 'gzip', options)
   end
 
-  should "deflate if content-type is included it :include" do
+  it "deflate if content-type is included it :include" do
     options = {
       'response_headers' => {
         'Content-Type' => 'text/plain; charset=us-ascii'
@@ -281,7 +317,7 @@ describe Rack::Deflater do
     verify(200, 'Hello World!', 'gzip', options)
   end
 
-  should "not deflate if content-type is not set but given in :include" do
+  it "not deflate if content-type is not set but given in :include" do
     options = {
       'deflater_options' => {
         :include => %w(text/plain)
@@ -290,7 +326,7 @@ describe Rack::Deflater do
     verify(304, 'Hello World!', { 'gzip' => nil }, options)
   end
 
-  should "not deflate if content-type do not match :include" do
+  it "not deflate if content-type do not match :include" do
     options = {
       'response_headers' => {
         'Content-Type' => 'text/plain'
@@ -302,16 +338,16 @@ describe Rack::Deflater do
     verify(200, 'Hello World!', { 'gzip' => nil }, options)
   end
 
-  should "deflate response if :if lambda evaluates to true" do
+  it "deflate response if :if lambda evaluates to true" do
     options = {
       'deflater_options' => {
         :if => lambda { |env, status, headers, body| true }
       }
     }
-    verify(200, 'Hello World!', 'deflate', options)
+    verify(200, 'Hello World!', deflate_or_gzip, options)
   end
 
-  should "not deflate if :if lambda evaluates to false" do
+  it "not deflate if :if lambda evaluates to false" do
     options = {
       'deflater_options' => {
         :if => lambda { |env, status, headers, body| false }
@@ -320,20 +356,20 @@ describe Rack::Deflater do
     verify(200, 'Hello World!', { 'gzip' => nil }, options)
   end
 
-  should "check for Content-Length via :if" do
-    body = 'Hello World!'
-    body_len = body.length
+  it "check for Content-Length via :if" do
+    response = 'Hello World!'
+    response_len = response.length
     options = {
       'response_headers' => {
-        'Content-Length' => body_len.to_s
+        'Content-Length' => response_len.to_s
       },
       'deflater_options' => {
         :if => lambda { |env, status, headers, body|
-          headers['Content-Length'].to_i >= body_len
+          headers['Content-Length'].to_i >= response_len
         }
       }
     }
 
-    verify(200, body, 'gzip', options)
+    verify(200, response, 'gzip', options)
   end
 end

data/test/spec_directory.rb

@@ -1,77 +1,129 @@
+require 'minitest/autorun'
 require 'rack/directory'
 require 'rack/lint'
 require 'rack/mock'
+require 'tempfile'
+require 'fileutils'
 
 describe Rack::Directory do
   DOCROOT = File.expand_path(File.dirname(__FILE__)) unless defined? DOCROOT
   FILE_CATCH = proc{|env| [200, {'Content-Type'=>'text/plain', "Content-Length" => "7"}, ['passed!']] }
-  app = Rack::Lint.new(Rack::Directory.new(DOCROOT, FILE_CATCH))
 
-  should "serve directory indices" do
+  attr_reader :app
+
+  def setup
+    @app = Rack::Lint.new(Rack::Directory.new(DOCROOT, FILE_CATCH))
+  end
+
+  it 'serves directories with + in the name' do
+    Dir.mktmpdir do |dir|
+      plus_dir = "foo+bar"
+      full_dir = File.join(dir, plus_dir)
+      FileUtils.mkdir full_dir
+      FileUtils.touch File.join(full_dir, "omg.txt")
+      app = Rack::Directory.new(dir, FILE_CATCH)
+      env = Rack::MockRequest.env_for("/#{plus_dir}/")
+      status,_,body = app.call env
+
+      assert_equal 200, status
+
+      str = ''
+      body.each { |x| str << x }
+      assert_match "foo+bar", str
+    end
+  end
+
+  it "serve directory indices" do
     res = Rack::MockRequest.new(Rack::Lint.new(app)).
       get("/cgi/")
 
-    res.should.be.ok
-    res.should =~ /<html><head>/
+    res.must_be :ok?
+    assert_match(res, /<html><head>/)
   end
 
-  should "pass to app if file found" do
+  it "pass to app if file found" do
     res = Rack::MockRequest.new(Rack::Lint.new(app)).
       get("/cgi/test")
 
-    res.should.be.ok
-    res.should =~ /passed!/
+    res.must_be :ok?
+    assert_match(res, /passed!/)
   end
 
-  should "serve uri with URL encoded filenames" do
+  it "serve uri with URL encoded filenames" do
     res = Rack::MockRequest.new(Rack::Lint.new(app)).
       get("/%63%67%69/") # "/cgi/test"
 
-    res.should.be.ok
-    res.should =~ /<html><head>/
+    res.must_be :ok?
+    assert_match(res, /<html><head>/)
 
     res = Rack::MockRequest.new(Rack::Lint.new(app)).
       get("/cgi/%74%65%73%74") # "/cgi/test"
 
-    res.should.be.ok
-    res.should =~ /passed!/
+    res.must_be :ok?
+    assert_match(res, /passed!/)
+  end
+
+  it "serve uri with URL encoded null byte (%00) in filenames" do
+    res = Rack::MockRequest.new(Rack::Lint.new(app))
+      .get("/cgi/test%00")
+
+    res.must_be :bad_request?
   end
 
-  should "not allow directory traversal" do
+  it "not allow directory traversal" do
     res = Rack::MockRequest.new(Rack::Lint.new(app)).
       get("/cgi/../test")
 
-    res.should.be.forbidden
+    res.must_be :forbidden?
 
     res = Rack::MockRequest.new(Rack::Lint.new(app)).
       get("/cgi/%2E%2E/test")
 
-    res.should.be.forbidden
+    res.must_be :forbidden?
   end
 
-  should "404 if it can't find the file" do
+  it "404 if it can't find the file" do
     res = Rack::MockRequest.new(Rack::Lint.new(app)).
       get("/cgi/blubb")
 
-    res.should.be.not_found
+    res.must_be :not_found?
   end
 
-  should "uri escape path parts" do # #265, properly escape file names
+  it "uri escape path parts" do # #265, properly escape file names
     mr = Rack::MockRequest.new(Rack::Lint.new(app))
 
     res = mr.get("/cgi/test%2bdirectory")
 
-    res.should.be.ok
-    res.body.should =~ %r[/cgi/test%2Bdirectory/test%2Bfile]
+    res.must_be :ok?
+    res.body.must_match(%r[/cgi/test\+directory/test\+file])
 
     res = mr.get("/cgi/test%2bdirectory/test%2bfile")
-    res.should.be.ok
+    res.must_be :ok?
+  end
+
+  it "correctly escape script name with spaces" do
+    Dir.mktmpdir do |dir|
+      space_dir = "foo bar"
+      full_dir = File.join(dir, space_dir)
+      FileUtils.mkdir full_dir
+      FileUtils.touch File.join(full_dir, "omg omg.txt")
+      app = Rack::Directory.new(dir, FILE_CATCH)
+      env = Rack::MockRequest.env_for(Rack::Utils.escape_path("/#{space_dir}/"))
+      status,_,body = app.call env
+
+      assert_equal 200, status
+
+      str = ''
+      body.each { |x| str << x }
+      assert_match "/foo%20bar/omg%20omg.txt", str
+    end
   end
 
-  should "correctly escape script name" do
+  it "correctly escape script name" do
+    _app = app
     app2 = Rack::Builder.new do
       map '/script-path' do
-        run app
+        run _app
       end
     end
 
@@ -79,10 +131,18 @@ describe Rack::Directory do
 
     res = mr.get("/script-path/cgi/test%2bdirectory")
 
-    res.should.be.ok
-    res.body.should =~ %r[/script-path/cgi/test%2Bdirectory/test%2Bfile]
+    res.must_be :ok?
+    res.body.must_match(%r[/script-path/cgi/test\+directory/test\+file])
+
+    res = mr.get("/script-path/cgi/test+directory/test+file")
+    res.must_be :ok?
+  end
+
+  it "return error when file not found for head request" do
+    res = Rack::MockRequest.new(Rack::Lint.new(app)).
+      head("/cgi/missing")
 
-    res = mr.get("/script-path/cgi/test%2bdirectory/test%2bfile")
-    res.should.be.ok
+    res.must_be :not_found?
+    res.body.must_be :empty?
   end
 end

data/test/spec_etag.rb

@@ -1,3 +1,4 @@
+require 'minitest/autorun'
 require 'rack/etag'
 require 'rack/lint'
 require 'rack/mock'
@@ -7,101 +8,101 @@ 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
 
-  should "set ETag if none is set if status is 200" do
+  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'].should.equal "W/\"65a8e27d8879283831b664bd8b7f0ad4\""
+    response[1]['ETag'].must_equal "W/\"dffd6021bb2bd5b0af676290809ec3a5\""
   end
 
-  should "set ETag if none is set if status is 201" do
+  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'].should.equal "W/\"65a8e27d8879283831b664bd8b7f0ad4\""
+    response[1]['ETag'].must_equal "W/\"dffd6021bb2bd5b0af676290809ec3a5\""
   end
 
-  should "set Cache-Control to 'max-age=0, private, must-revalidate' (default) if none is set" do
+  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'].should.equal 'max-age=0, private, must-revalidate'
+    response[1]['Cache-Control'].must_equal 'max-age=0, private, must-revalidate'
   end
 
-  should "set Cache-Control to chosen one if none is set" do
+  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'].should.equal 'public'
+    response[1]['Cache-Control'].must_equal 'public'
   end
 
-  should "set a given Cache-Control even if digest could not be calculated" do
+  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'].should.equal 'no-cache'
+    response[1]['Cache-Control'].must_equal 'no-cache'
   end
 
-  should "not set Cache-Control if it is already set" do
+  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'].should.equal 'public'
+    response[1]['Cache-Control'].must_equal 'public'
   end
 
-  should "not set Cache-Control if directive isn't present" do
+  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'].should.equal nil
+    response[1]['Cache-Control'].must_be_nil
   end
 
-  should "not change ETag if it is already set" do
+  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'].should.equal "\"abc\""
+    response[1]['ETag'].must_equal "\"abc\""
   end
 
-  should "not set ETag if body is empty" do
+  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'].should.be.nil
+    response[1]['ETag'].must_be_nil
   end
 
-  should "not set ETag if Last-Modified is set" do
+  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'].should.be.nil
+    response[1]['ETag'].must_be_nil
   end
 
-  should "not set ETag if a sendfile_body is given" do
+  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'].should.be.nil
+    response[1]['ETag'].must_be_nil
   end
 
-  should "not set ETag if a status is not 200 or 201" do
+  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'].should.be.nil
+    response[1]['ETag'].must_be_nil
   end
 
-  should "not set ETag if no-cache is given" do
+  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'].should.be.nil
+    response[1]['ETag'].must_be_nil
   end
 
-  should "close the original body" do
+  it "close the original body" do
     body = StringIO.new
     app = lambda { |env| [200, {}, body] }
     response = etag(app).call(request)
-    body.should.not.be.closed
+    body.wont_be :closed?
     response[2].close
-    body.should.be.closed
+    body.must_be :closed?
   end
 end