rack 1.6.13 → 2.0.1

data/test/{spec_showstatus.rb → spec_show_status.rb}

@@ -1,4 +1,5 @@
-require 'rack/showstatus'
+require 'minitest/autorun'
+require 'rack/show_status'
 require 'rack/lint'
 require 'rack/mock'
 require 'rack/utils'
@@ -7,23 +8,23 @@ describe Rack::ShowStatus do
   def show_status(app)
     Rack::Lint.new Rack::ShowStatus.new(app)
   end
-  
-  should "provide a default status message" do
+
+  it "provide a default status message" do
     req = Rack::MockRequest.new(
       show_status(lambda{|env|
         [404, {"Content-Type" => "text/plain", "Content-Length" => "0"}, []]
     }))
 
     res = req.get("/", :lint => true)
-    res.should.be.not_found
-    res.should.be.not.empty
+    res.must_be :not_found?
+    res.wont_be_empty
 
-    res["Content-Type"].should.equal("text/html")
-    res.should =~ /404/
-    res.should =~ /Not Found/
+    res["Content-Type"].must_equal "text/html"
+    assert_match(res, /404/)
+    assert_match(res, /Not Found/)
   end
 
-  should "let the app provide additional information" do
+  it "let the app provide additional information" do
     req = Rack::MockRequest.new(
       show_status(
         lambda{|env|
@@ -32,16 +33,16 @@ describe Rack::ShowStatus do
     }))
 
     res = req.get("/", :lint => true)
-    res.should.be.not_found
-    res.should.be.not.empty
+    res.must_be :not_found?
+    res.wont_be_empty
 
-    res["Content-Type"].should.equal("text/html")
-    res.should =~ /404/
-    res.should =~ /Not Found/
-    res.should =~ /too meta/
+    res["Content-Type"].must_equal "text/html"
+    assert_match(res, /404/)
+    assert_match(res, /Not Found/)
+    assert_match(res, /too meta/)
   end
 
-  should "escape error" do
+  it "escape error" do
     detail = "<script>alert('hi \"')</script>"
     req = Rack::MockRequest.new(
       show_status(
@@ -51,15 +52,15 @@ describe Rack::ShowStatus do
     }))
 
     res = req.get("/", :lint => true)
-    res.should.be.not.empty
+    res.wont_be_empty
 
-    res["Content-Type"].should.equal("text/html")
-    res.should =~ /500/
-    res.should.not.include detail
-    res.body.should.include Rack::Utils.escape_html(detail)
+    res["Content-Type"].must_equal "text/html"
+    assert_match(res, /500/)
+    res.wont_include detail
+    res.body.must_include Rack::Utils.escape_html(detail)
   end
 
-  should "not replace existing messages" do
+  it "not replace existing messages" do
     req = Rack::MockRequest.new(
       show_status(
         lambda{|env|
@@ -67,22 +68,22 @@ describe Rack::ShowStatus do
     }))
 
     res = req.get("/", :lint => true)
-    res.should.be.not_found
+    res.must_be :not_found?
 
-    res.body.should == "foo!"
+    res.body.must_equal "foo!"
   end
 
-  should "pass on original headers" do
+  it "pass on original headers" do
     headers = {"WWW-Authenticate" => "Basic blah"}
 
     req = Rack::MockRequest.new(
       show_status(lambda{|env| [401, headers, []] }))
     res = req.get("/", :lint => true)
 
-    res["WWW-Authenticate"].should.equal("Basic blah")
+    res["WWW-Authenticate"].must_equal "Basic blah"
   end
 
-  should "replace existing messages if there is detail" do
+  it "replace existing messages if there is detail" do
     req = Rack::MockRequest.new(
       show_status(
         lambda{|env|
@@ -91,13 +92,13 @@ describe Rack::ShowStatus do
     }))
 
     res = req.get("/", :lint => true)
-    res.should.be.not_found
-    res.should.be.not.empty
-
-    res["Content-Type"].should.equal("text/html")
-    res["Content-Length"].should.not.equal("4")
-    res.should =~ /404/
-    res.should =~ /too meta/
-    res.body.should.not =~ /foo/
+    res.must_be :not_found?
+    res.wont_be_empty
+
+    res["Content-Type"].must_equal "text/html"
+    res["Content-Length"].wont_equal "4"
+    assert_match(res, /404/)
+    assert_match(res, /too meta/)
+    res.body.wont_match(/foo/)
   end
 end

data/test/spec_static.rb

@@ -1,6 +1,9 @@
+require 'minitest/autorun'
 require 'rack/static'
 require 'rack/lint'
 require 'rack/mock'
+require 'zlib'
+require 'stringio'
 
 class DummyApp
   def call(env)
@@ -18,64 +21,101 @@ describe Rack::Static do
   OPTIONS = {:urls => ["/cgi"], :root => root}
   STATIC_OPTIONS = {:urls => [""], :root => "#{root}/static", :index => 'index.html'}
   HASH_OPTIONS = {:urls => {"/cgi/sekret" => 'cgi/test'}, :root => root}
+  HASH_ROOT_OPTIONS = {:urls => {"/" => "static/foo.html"}, :root => root}
+  GZIP_OPTIONS = {:urls => ["/cgi"], :root => root, :gzip=>true}
 
+  before do
   @request = Rack::MockRequest.new(static(DummyApp.new, OPTIONS))
   @static_request = Rack::MockRequest.new(static(DummyApp.new, STATIC_OPTIONS))
   @hash_request = Rack::MockRequest.new(static(DummyApp.new, HASH_OPTIONS))
+  @hash_root_request = Rack::MockRequest.new(static(DummyApp.new, HASH_ROOT_OPTIONS))
+  @gzip_request = Rack::MockRequest.new(static(DummyApp.new, GZIP_OPTIONS))
+  @header_request = Rack::MockRequest.new(static(DummyApp.new, HEADER_OPTIONS))
+  end
 
   it "serves files" do
     res = @request.get("/cgi/test")
-    res.should.be.ok
-    res.body.should =~ /ruby/
+    res.must_be :ok?
+    res.body.must_match(/ruby/)
   end
 
   it "404s if url root is known but it can't find the file" do
     res = @request.get("/cgi/foo")
-    res.should.be.not_found
+    res.must_be :not_found?
   end
 
   it "calls down the chain if url root is not known" do
     res = @request.get("/something/else")
-    res.should.be.ok
-    res.body.should == "Hello World"
+    res.must_be :ok?
+    res.body.must_equal "Hello World"
   end
 
   it "calls index file when requesting root in the given folder" do
     res = @static_request.get("/")
-    res.should.be.ok
-    res.body.should =~ /index!/
+    res.must_be :ok?
+    res.body.must_match(/index!/)
 
     res = @static_request.get("/other/")
-    res.should.be.not_found
+    res.must_be :not_found?
 
     res = @static_request.get("/another/")
-    res.should.be.ok
-    res.body.should =~ /another index!/
+    res.must_be :ok?
+    res.body.must_match(/another index!/)
   end
 
   it "doesn't call index file if :index option was omitted" do
     res = @request.get("/")
-    res.body.should == "Hello World"
+    res.body.must_equal "Hello World"
   end
 
   it "serves hidden files" do
     res = @hash_request.get("/cgi/sekret")
-    res.should.be.ok
-    res.body.should =~ /ruby/
+    res.must_be :ok?
+    res.body.must_match(/ruby/)
   end
 
   it "calls down the chain if the URI is not specified" do
     res = @hash_request.get("/something/else")
-    res.should.be.ok
-    res.body.should == "Hello World"
+    res.must_be :ok?
+    res.body.must_equal "Hello World"
+  end
+
+  it "allows the root URI to be configured via hash options" do
+    res = @hash_root_request.get("/")
+    res.must_be :ok?
+    res.body.must_match(/foo.html!/)
+  end
+
+  it "serves gzipped files if client accepts gzip encoding and gzip files are present" do
+    res = @gzip_request.get("/cgi/test", 'HTTP_ACCEPT_ENCODING'=>'deflate, gzip')
+    res.must_be :ok?
+    res.headers['Content-Encoding'].must_equal 'gzip'
+    res.headers['Content-Type'].must_equal 'text/plain'
+    Zlib::GzipReader.wrap(StringIO.new(res.body), &:read).must_match(/ruby/)
+  end
+
+  it "serves regular files if client accepts gzip encoding and gzip files are not present" do
+    res = @gzip_request.get("/cgi/rackup_stub.rb", 'HTTP_ACCEPT_ENCODING'=>'deflate, gzip')
+    res.must_be :ok?
+    res.headers['Content-Encoding'].must_equal nil
+    res.headers['Content-Type'].must_equal 'text/x-script.ruby'
+    res.body.must_match(/ruby/)
+  end
+
+  it "serves regular files if client does not accept gzip encoding" do
+    res = @gzip_request.get("/cgi/test")
+    res.must_be :ok?
+    res.headers['Content-Encoding'].must_equal nil
+    res.headers['Content-Type'].must_equal 'text/plain'
+    res.body.must_match(/ruby/)
   end
 
   it "supports serving fixed cache-control (legacy option)" do
     opts = OPTIONS.merge(:cache_control => 'public')
     request = Rack::MockRequest.new(static(DummyApp.new, opts))
     res = request.get("/cgi/test")
-    res.should.be.ok
-    res.headers['Cache-Control'].should == 'public'
+    res.must_be :ok?
+    res.headers['Cache-Control'].must_equal 'public'
   end
 
   HEADER_OPTIONS = {:urls => ["/cgi"], :root => root, :header_rules => [
@@ -86,47 +126,46 @@ describe Rack::Static do
     ['cgi/assets/javascripts', {'Cache-Control' => 'public, max-age=500'}],
     [/\.(css|erb)\z/, {'Cache-Control' => 'public, max-age=600'}]
   ]}
-  @header_request = Rack::MockRequest.new(static(DummyApp.new, HEADER_OPTIONS))
 
   it "supports header rule :all" do
     # Headers for all files via :all shortcut
     res = @header_request.get('/cgi/assets/index.html')
-    res.should.be.ok
-    res.headers['Cache-Control'].should == 'public, max-age=100'
+    res.must_be :ok?
+    res.headers['Cache-Control'].must_equal 'public, max-age=100'
   end
 
   it "supports header rule :fonts" do
     # Headers for web fonts via :fonts shortcut
     res = @header_request.get('/cgi/assets/fonts/font.eot')
-    res.should.be.ok
-    res.headers['Cache-Control'].should == 'public, max-age=200'
+    res.must_be :ok?
+    res.headers['Cache-Control'].must_equal 'public, max-age=200'
   end
 
   it "supports file extension header rules provided as an Array" do
     # Headers for file extensions via array
     res = @header_request.get('/cgi/assets/images/image.png')
-    res.should.be.ok
-    res.headers['Cache-Control'].should == 'public, max-age=300'
+    res.must_be :ok?
+    res.headers['Cache-Control'].must_equal 'public, max-age=300'
   end
 
   it "supports folder rules provided as a String" do
     # Headers for files in folder via string
     res = @header_request.get('/cgi/assets/folder/test.js')
-    res.should.be.ok
-    res.headers['Cache-Control'].should == 'public, max-age=400'
+    res.must_be :ok?
+    res.headers['Cache-Control'].must_equal 'public, max-age=400'
   end
 
   it "supports folder header rules provided as a String not starting with a slash" do
     res = @header_request.get('/cgi/assets/javascripts/app.js')
-    res.should.be.ok
-    res.headers['Cache-Control'].should == 'public, max-age=500'
+    res.must_be :ok?
+    res.headers['Cache-Control'].must_equal 'public, max-age=500'
   end
 
   it "supports flexible header rules provided as Regexp" do
     # Flexible Headers via Regexp
     res = @header_request.get('/cgi/assets/stylesheets/app.css')
-    res.should.be.ok
-    res.headers['Cache-Control'].should == 'public, max-age=600'
+    res.must_be :ok?
+    res.headers['Cache-Control'].must_equal 'public, max-age=600'
   end
 
   it "prioritizes header rules over fixed cache-control setting (legacy option)" do
@@ -138,8 +177,8 @@ describe Rack::Static do
 
     request = Rack::MockRequest.new(static(DummyApp.new, opts))
     res = request.get("/cgi/test")
-    res.should.be.ok
-    res.headers['Cache-Control'].should == 'public, max-age=42'
+    res.must_be :ok?
+    res.headers['Cache-Control'].must_equal 'public, max-age=42'
   end
 
 end

data/test/spec_tempfile_reaper.rb

@@ -1,3 +1,4 @@
+require 'minitest/autorun'
 require 'rack/tempfile_reaper'
 require 'rack/lint'
 require 'rack/mock'
@@ -23,33 +24,33 @@ describe Rack::TempfileReaper do
     Rack::Lint.new(Rack::TempfileReaper.new(app)).call(@env)
   end
 
-  should 'do nothing (i.e. not bomb out) without env[rack.tempfiles]' do
+  it 'do nothing (i.e. not bomb out) without env[rack.tempfiles]' do
     app = lambda { |_| [200, {}, ['Hello, World!']] }
     response = call(app)
     response[2].close
-    response[0].should.equal(200)
+    response[0].must_equal 200
   end
 
-  should 'close env[rack.tempfiles] when body is closed' do
+  it 'close env[rack.tempfiles] when body is closed' do
     tempfile1, tempfile2 = MockTempfile.new, MockTempfile.new
     @env['rack.tempfiles'] = [ tempfile1, tempfile2 ]
     app = lambda { |_| [200, {}, ['Hello, World!']] }
     call(app)[2].close
-    tempfile1.closed.should.equal true
-    tempfile2.closed.should.equal true
+    tempfile1.closed.must_equal true
+    tempfile2.closed.must_equal true
   end
 
-  should 'initialize env[rack.tempfiles] when not already present' do
+  it 'initialize env[rack.tempfiles] when not already present' do
     tempfile = MockTempfile.new
     app = lambda do |env|
       env['rack.tempfiles'] << tempfile
       [200, {}, ['Hello, World!']]
     end
     call(app)[2].close
-    tempfile.closed.should.equal true
+    tempfile.closed.must_equal true
   end
 
-  should 'append env[rack.tempfiles] when already present' do
+  it 'append env[rack.tempfiles] when already present' do
     tempfile1, tempfile2 = MockTempfile.new, MockTempfile.new
     @env['rack.tempfiles'] = [ tempfile1 ]
     app = lambda do |env|
@@ -57,7 +58,7 @@ describe Rack::TempfileReaper do
       [200, {}, ['Hello, World!']]
     end
     call(app)[2].close
-    tempfile1.closed.should.equal true
-    tempfile2.closed.should.equal true
+    tempfile1.closed.must_equal true
+    tempfile2.closed.must_equal true
   end
 end

data/test/spec_thin.rb

@@ -1,89 +1,94 @@
+require 'minitest/autorun'
 begin
 require 'rack/handler/thin'
 require File.expand_path('../testrequest', __FILE__)
 require 'timeout'
 
 describe Rack::Handler::Thin do
-  extend TestRequest::Helpers
+  include TestRequest::Helpers
 
-  @app = Rack::Lint.new(TestRequest.new)
-  @server = nil
-  Thin::Logging.silent = true
+  before do
+    @app = Rack::Lint.new(TestRequest.new)
+    @server = nil
+    Thin::Logging.silent = true
 
-  @thread = Thread.new do
-    Rack::Handler::Thin.run(@app, :Host => @host='127.0.0.1', :Port => @port=9204, :tag => "tag") do |server|
-      @server = server
+    @thread = Thread.new do
+      Rack::Handler::Thin.run(@app, :Host => @host='127.0.0.1', :Port => @port=9204, :tag => "tag") do |server|
+        @server = server
+      end
     end
+
+    Thread.pass until @server && @server.running?
+  end
+
+  after do
+    @server.stop!
+    @thread.join
   end
 
-  Thread.pass until @server && @server.running?
 
-  should "respond" do
+  it "respond" do
     GET("/")
-    response.should.not.be.nil
+    response.wont_be :nil?
   end
 
-  should "be a Thin" do
+  it "be a Thin" do
     GET("/")
-    status.should.equal 200
-    response["SERVER_SOFTWARE"].should =~ /thin/
-    response["HTTP_VERSION"].should.equal "HTTP/1.1"
-    response["SERVER_PROTOCOL"].should.equal "HTTP/1.1"
-    response["SERVER_PORT"].should.equal "9204"
-    response["SERVER_NAME"].should.equal "127.0.0.1"
+    status.must_equal 200
+    response["SERVER_SOFTWARE"].must_match(/thin/)
+    response["HTTP_VERSION"].must_equal "HTTP/1.1"
+    response["SERVER_PROTOCOL"].must_equal "HTTP/1.1"
+    response["SERVER_PORT"].must_equal "9204"
+    response["SERVER_NAME"].must_equal "127.0.0.1"
   end
 
-  should "have rack headers" do
+  it "have rack headers" do
     GET("/")
-    response["rack.version"].should.equal [1,0]
-    response["rack.multithread"].should.equal false
-    response["rack.multiprocess"].should.equal false
-    response["rack.run_once"].should.equal false
+    response["rack.version"].must_equal [1,0]
+    response["rack.multithread"].must_equal false
+    response["rack.multiprocess"].must_equal false
+    response["rack.run_once"].must_equal false
   end
 
-  should "have CGI headers on GET" do
+  it "have CGI headers on GET" do
     GET("/")
-    response["REQUEST_METHOD"].should.equal "GET"
-    response["REQUEST_PATH"].should.equal "/"
-    response["PATH_INFO"].should.be.equal "/"
-    response["QUERY_STRING"].should.equal ""
-    response["test.postdata"].should.equal ""
+    response["REQUEST_METHOD"].must_equal "GET"
+    response["REQUEST_PATH"].must_equal "/"
+    response["PATH_INFO"].must_equal "/"
+    response["QUERY_STRING"].must_equal ""
+    response["test.postdata"].must_equal ""
 
     GET("/test/foo?quux=1")
-    response["REQUEST_METHOD"].should.equal "GET"
-    response["REQUEST_PATH"].should.equal "/test/foo"
-    response["PATH_INFO"].should.equal "/test/foo"
-    response["QUERY_STRING"].should.equal "quux=1"
+    response["REQUEST_METHOD"].must_equal "GET"
+    response["REQUEST_PATH"].must_equal "/test/foo"
+    response["PATH_INFO"].must_equal "/test/foo"
+    response["QUERY_STRING"].must_equal "quux=1"
   end
 
-  should "have CGI headers on POST" do
+  it "have CGI headers on POST" do
     POST("/", {"rack-form-data" => "23"}, {'X-test-header' => '42'})
-    status.should.equal 200
-    response["REQUEST_METHOD"].should.equal "POST"
-    response["REQUEST_PATH"].should.equal "/"
-    response["QUERY_STRING"].should.equal ""
-    response["HTTP_X_TEST_HEADER"].should.equal "42"
-    response["test.postdata"].should.equal "rack-form-data=23"
+    status.must_equal 200
+    response["REQUEST_METHOD"].must_equal "POST"
+    response["REQUEST_PATH"].must_equal "/"
+    response["QUERY_STRING"].must_equal ""
+    response["HTTP_X_TEST_HEADER"].must_equal "42"
+    response["test.postdata"].must_equal "rack-form-data=23"
   end
 
-  should "support HTTP auth" do
+  it "support HTTP auth" do
     GET("/test", {:user => "ruth", :passwd => "secret"})
-    response["HTTP_AUTHORIZATION"].should.equal "Basic cnV0aDpzZWNyZXQ="
+    response["HTTP_AUTHORIZATION"].must_equal "Basic cnV0aDpzZWNyZXQ="
   end
 
-  should "set status" do
+  it "set status" do
     GET("/test?secret")
-    status.should.equal 403
-    response["rack.url_scheme"].should.equal "http"
+    status.must_equal 403
+    response["rack.url_scheme"].must_equal "http"
   end
 
-  should "set tag for server" do
-    @server.tag.should.equal 'tag'
+  it "set tag for server" do
+    @server.tag.must_equal 'tag'
   end
-
-  @server.stop!
-  @thread.kill
-
 end
 
 rescue LoadError