rack 1.6.13 → 2.0.9

data/test/spec_rewindable_input.rb

@@ -1,118 +1,128 @@
+require 'minitest/autorun'
 require 'stringio'
 require 'rack/rewindable_input'
 
-shared "a rewindable IO object" do
-  before do
+module RewindableTest
+  extend Minitest::Spec::DSL
+
+  def setup
     @rio = Rack::RewindableInput.new(@io)
   end
 
-  should "be able to handle to read()" do
-    @rio.read.should.equal "hello world"
+  class << self # HACK to get this running w/ as few changes as possible
+    alias_method :should, :it
+  end
+
+  it "be able to handle to read()" do
+    @rio.read.must_equal "hello world"
   end
 
-  should "be able to handle to read(nil)" do
-    @rio.read(nil).should.equal "hello world"
+  it "be able to handle to read(nil)" do
+    @rio.read(nil).must_equal "hello world"
   end
 
-  should "be able to handle to read(length)" do
-    @rio.read(1).should.equal "h"
+  it "be able to handle to read(length)" do
+    @rio.read(1).must_equal "h"
   end
 
-  should "be able to handle to read(length, buffer)" do
+  it "be able to handle to read(length, buffer)" do
     buffer = ""
     result = @rio.read(1, buffer)
-    result.should.equal "h"
-    result.object_id.should.equal buffer.object_id
+    result.must_equal "h"
+    result.object_id.must_equal buffer.object_id
   end
 
-  should "be able to handle to read(nil, buffer)" do
+  it "be able to handle to read(nil, buffer)" do
     buffer = ""
     result = @rio.read(nil, buffer)
-    result.should.equal "hello world"
-    result.object_id.should.equal buffer.object_id
+    result.must_equal "hello world"
+    result.object_id.must_equal buffer.object_id
   end
 
-  should "rewind to the beginning when #rewind is called" do
+  it "rewind to the beginning when #rewind is called" do
     @rio.read(1)
     @rio.rewind
-    @rio.read.should.equal "hello world"
+    @rio.read.must_equal "hello world"
   end
 
-  should "be able to handle gets" do
-    @rio.gets.should == "hello world"
+  it "be able to handle gets" do
+    @rio.gets.must_equal "hello world"
   end
 
-  should "be able to handle each" do
+  it "be able to handle each" do
     array = []
     @rio.each do |data|
       array << data
     end
-    array.should.equal(["hello world"])
+    array.must_equal ["hello world"]
   end
 
-  should "not buffer into a Tempfile if no data has been read yet" do
-    @rio.instance_variable_get(:@rewindable_io).should.be.nil
+  it "not buffer into a Tempfile if no data has been read yet" do
+    @rio.instance_variable_get(:@rewindable_io).must_be_nil
   end
 
-  should "buffer into a Tempfile when data has been consumed for the first time" do
+  it "buffer into a Tempfile when data has been consumed for the first time" do
     @rio.read(1)
     tempfile = @rio.instance_variable_get(:@rewindable_io)
-    tempfile.should.not.be.nil
+    tempfile.wont_be :nil?
     @rio.read(1)
     tempfile2 = @rio.instance_variable_get(:@rewindable_io)
-    tempfile2.path.should == tempfile.path
+    tempfile2.path.must_equal tempfile.path
   end
 
-  should "close the underlying tempfile upon calling #close" do
+  it "close the underlying tempfile upon calling #close" do
     @rio.read(1)
     tempfile = @rio.instance_variable_get(:@rewindable_io)
     @rio.close
-    tempfile.should.be.closed
+    tempfile.must_be :closed?
   end
 
-  should "be possible to call #close when no data has been buffered yet" do
-    lambda{ @rio.close }.should.not.raise
+  it "be possible to call #close when no data has been buffered yet" do
+    @rio.close.must_be_nil
   end
 
-  should "be possible to call #close multiple times" do
-    lambda{
-      @rio.close
-      @rio.close
-    }.should.not.raise
+  it "be possible to call #close multiple times" do
+    @rio.close.must_be_nil
+    @rio.close.must_be_nil
   end
 
+  after do
   @rio.close
   @rio = nil
+  end
 end
 
 describe Rack::RewindableInput do
   describe "given an IO object that is already rewindable" do
-    before do
+    def setup
       @io = StringIO.new("hello world")
+      super
     end
 
-    behaves_like "a rewindable IO object"
+    include RewindableTest
   end
 
   describe "given an IO object that is not rewindable" do
-    before do
+    def setup
       @io = StringIO.new("hello world")
       @io.instance_eval do
         undef :rewind
       end
+      super
     end
 
-    behaves_like "a rewindable IO object"
+    include RewindableTest
   end
 
   describe "given an IO object whose rewind method raises Errno::ESPIPE" do
-    before do
+    def setup
       @io = StringIO.new("hello world")
       def @io.rewind
         raise Errno::ESPIPE, "You can't rewind this!"
       end
+      super
     end
 
-    behaves_like "a rewindable IO object"
+    include RewindableTest
   end
 end

data/test/spec_runtime.rb

@@ -1,3 +1,4 @@
+require 'minitest/autorun'
 require 'rack/lint'
 require 'rack/mock'
 require 'rack/runtime'
@@ -6,30 +7,30 @@ describe Rack::Runtime do
   def runtime_app(app, *args)
     Rack::Lint.new Rack::Runtime.new(app, *args)
   end
-  
+
   def request
     Rack::MockRequest.env_for
   end
-  
+
   it "sets X-Runtime is none is set" do
     app = lambda { |env| [200, {'Content-Type' => 'text/plain'}, "Hello, World!"] }
     response = runtime_app(app).call(request)
-    response[1]['X-Runtime'].should =~ /[\d\.]+/
+    response[1]['X-Runtime'].must_match(/[\d\.]+/)
   end
 
   it "doesn't set the X-Runtime if it is already set" do
     app = lambda { |env| [200, {'Content-Type' => 'text/plain', "X-Runtime" => "foobar"}, "Hello, World!"] }
     response = runtime_app(app).call(request)
-    response[1]['X-Runtime'].should == "foobar"
+    response[1]['X-Runtime'].must_equal "foobar"
   end
 
-  should "allow a suffix to be set" do
+  it "allow a suffix to be set" do
     app = lambda { |env| [200, {'Content-Type' => 'text/plain'}, "Hello, World!"] }
     response = runtime_app(app, "Test").call(request)
-    response[1]['X-Runtime-Test'].should =~ /[\d\.]+/
+    response[1]['X-Runtime-Test'].must_match(/[\d\.]+/)
   end
 
-  should "allow multiple timers to be set" do
+  it "allow multiple timers to be set" do
     app = lambda { |env| sleep 0.1; [200, {'Content-Type' => 'text/plain'}, "Hello, World!"] }
     runtime = runtime_app(app, "App")
 
@@ -41,9 +42,9 @@ describe Rack::Runtime do
 
     response = runtime.call(request)
 
-    response[1]['X-Runtime-App'].should =~ /[\d\.]+/
-    response[1]['X-Runtime-All'].should =~ /[\d\.]+/
+    response[1]['X-Runtime-App'].must_match(/[\d\.]+/)
+    response[1]['X-Runtime-All'].must_match(/[\d\.]+/)
 
-    Float(response[1]['X-Runtime-All']).should > Float(response[1]['X-Runtime-App'])
+    Float(response[1]['X-Runtime-All']).must_be :>, Float(response[1]['X-Runtime-App'])
   end
 end

data/test/spec_sendfile.rb

@@ -1,15 +1,10 @@
+require 'minitest/autorun'
 require 'fileutils'
 require 'rack/lint'
 require 'rack/sendfile'
 require 'rack/mock'
 require 'tmpdir'
 
-describe Rack::File do
-  should "respond to #to_path" do
-    Rack::File.new(Dir.pwd).should.respond_to :to_path
-  end
-end
-
 describe Rack::Sendfile do
   def sendfile_body
     FileUtils.touch File.join(Dir.tmpdir,  "rack_sendfile")
@@ -40,27 +35,27 @@ describe Rack::Sendfile do
 
   it "does nothing when no X-Sendfile-Type header present" do
     request do |response|
-      response.should.be.ok
-      response.body.should.equal 'Hello World'
-      response.headers.should.not.include 'X-Sendfile'
+      response.must_be :ok?
+      response.body.must_equal 'Hello World'
+      response.headers.wont_include 'X-Sendfile'
     end
   end
 
   it "sets X-Sendfile response header and discards body" do
     request 'HTTP_X_SENDFILE_TYPE' => 'X-Sendfile' do |response|
-      response.should.be.ok
-      response.body.should.be.empty
-      response.headers['Content-Length'].should.equal '0'
-      response.headers['X-Sendfile'].should.equal File.join(Dir.tmpdir,  "rack_sendfile")
+      response.must_be :ok?
+      response.body.must_be :empty?
+      response.headers['Content-Length'].must_equal '0'
+      response.headers['X-Sendfile'].must_equal File.join(Dir.tmpdir,  "rack_sendfile")
     end
   end
 
   it "sets X-Lighttpd-Send-File response header and discards body" do
     request 'HTTP_X_SENDFILE_TYPE' => 'X-Lighttpd-Send-File' do |response|
-      response.should.be.ok
-      response.body.should.be.empty
-      response.headers['Content-Length'].should.equal '0'
-      response.headers['X-Lighttpd-Send-File'].should.equal File.join(Dir.tmpdir,  "rack_sendfile")
+      response.must_be :ok?
+      response.body.must_be :empty?
+      response.headers['Content-Length'].must_equal '0'
+      response.headers['X-Lighttpd-Send-File'].must_equal File.join(Dir.tmpdir,  "rack_sendfile")
     end
   end
 
@@ -70,26 +65,26 @@ describe Rack::Sendfile do
       'HTTP_X_ACCEL_MAPPING' => "#{Dir.tmpdir}/=/foo/bar/"
     }
     request headers do |response|
-      response.should.be.ok
-      response.body.should.be.empty
-      response.headers['Content-Length'].should.equal '0'
-      response.headers['X-Accel-Redirect'].should.equal '/foo/bar/rack_sendfile'
+      response.must_be :ok?
+      response.body.must_be :empty?
+      response.headers['Content-Length'].must_equal '0'
+      response.headers['X-Accel-Redirect'].must_equal '/foo/bar/rack_sendfile'
     end
   end
 
   it 'writes to rack.error when no X-Accel-Mapping is specified' do
     request 'HTTP_X_SENDFILE_TYPE' => 'X-Accel-Redirect' do |response|
-      response.should.be.ok
-      response.body.should.equal 'Hello World'
-      response.headers.should.not.include 'X-Accel-Redirect'
-      response.errors.should.include 'X-Accel-Mapping'
+      response.must_be :ok?
+      response.body.must_equal 'Hello World'
+      response.headers.wont_include 'X-Accel-Redirect'
+      response.errors.must_include 'X-Accel-Mapping'
     end
   end
 
   it 'does nothing when body does not respond to #to_path' do
     request({'HTTP_X_SENDFILE_TYPE' => 'X-Sendfile'}, ['Not a file...']) do |response|
-      response.body.should.equal 'Not a file...'
-      response.headers.should.not.include 'X-Sendfile'
+      response.body.must_equal 'Not a file...'
+      response.headers.wont_include 'X-Sendfile'
     end
   end
 
@@ -110,17 +105,17 @@ describe Rack::Sendfile do
       ]
 
       request({'HTTP_X_SENDFILE_TYPE' => 'X-Accel-Redirect'}, first_body, mappings) do |response|
-        response.should.be.ok
-        response.body.should.be.empty
-        response.headers['Content-Length'].should.equal '0'
-        response.headers['X-Accel-Redirect'].should.equal '/foo/bar/rack_sendfile'
+        response.must_be :ok?
+        response.body.must_be :empty?
+        response.headers['Content-Length'].must_equal '0'
+        response.headers['X-Accel-Redirect'].must_equal '/foo/bar/rack_sendfile'
       end
 
       request({'HTTP_X_SENDFILE_TYPE' => 'X-Accel-Redirect'}, second_body, mappings) do |response|
-        response.should.be.ok
-        response.body.should.be.empty
-        response.headers['Content-Length'].should.equal '0'
-        response.headers['X-Accel-Redirect'].should.equal '/wibble/rack_sendfile'
+        response.must_be :ok?
+        response.body.must_be :empty?
+        response.headers['Content-Length'].must_equal '0'
+        response.headers['X-Accel-Redirect'].must_equal '/wibble/rack_sendfile'
       end
     ensure
       FileUtils.remove_entry_secure dir1

data/test/spec_server.rb

@@ -1,10 +1,18 @@
+require 'minitest/autorun'
 require 'rack'
 require 'rack/server'
 require 'tempfile'
 require 'socket'
 require 'open-uri'
 
+module Minitest::Spec::DSL
+  alias :should :it
+end
+
 describe Rack::Server do
+  SPEC_ARGV = []
+
+  before { SPEC_ARGV[0..-1] = [] }
 
   def app
     lambda { |env| [200, {'Content-Type' => 'text/plain'}, ['success']] }
@@ -19,148 +27,166 @@ describe Rack::Server do
 
   it "overrides :config if :app is passed in" do
     server = Rack::Server.new(:app => "FOO")
-    server.app.should.equal "FOO"
+    server.app.must_equal "FOO"
   end
 
-  should "prefer to use :builder when it is passed in" do
+  it "prefer to use :builder when it is passed in" do
     server = Rack::Server.new(:builder => "run lambda { |env| [200, {'Content-Type' => 'text/plain'}, ['success']] }")
-    server.app.class.should.equal Proc
-    Rack::MockRequest.new(server.app).get("/").body.to_s.should.equal 'success'
+    server.app.class.must_equal Proc
+    Rack::MockRequest.new(server.app).get("/").body.to_s.must_equal 'success'
   end
 
-  should "allow subclasses to override middleware" do
+  it "allow subclasses to override middleware" do
     server = Class.new(Rack::Server).class_eval { def middleware; Hash.new [] end; self }
-    server.middleware['deployment'].should.not.equal []
-    server.new(:app => 'foo').middleware['deployment'].should.equal []
+    server.middleware['deployment'].wont_equal []
+    server.new(:app => 'foo').middleware['deployment'].must_equal []
   end
 
-  should "allow subclasses to override default middleware" do
+  it "allow subclasses to override default middleware" do
     server = Class.new(Rack::Server).instance_eval { def default_middleware_by_environment; Hash.new [] end; self }
-    server.middleware['deployment'].should.equal []
-    server.new(:app => 'foo').middleware['deployment'].should.equal []
+    server.middleware['deployment'].must_equal []
+    server.new(:app => 'foo').middleware['deployment'].must_equal []
   end
 
-  should "only provide default middleware for development and deployment environments" do
-    Rack::Server.default_middleware_by_environment.keys.sort.should.equal %w(deployment development)
+  it "only provide default middleware for development and deployment environments" do
+    Rack::Server.default_middleware_by_environment.keys.sort.must_equal %w(deployment development)
   end
 
-  should "always return an empty array for unknown environments" do
+  it "always return an empty array for unknown environments" do
     server = Rack::Server.new(:app => 'foo')
-    server.middleware['production'].should.equal []
+    server.middleware['production'].must_equal []
   end
 
-  should "not include Rack::Lint in deployment environment" do
+  it "not include Rack::Lint in deployment environment" do
     server = Rack::Server.new(:app => 'foo')
-    server.middleware['deployment'].flatten.should.not.include(Rack::Lint)
+    server.middleware['deployment'].flatten.wont_include Rack::Lint
   end
 
-  should "not include Rack::ShowExceptions in deployment environment" do
+  it "not include Rack::ShowExceptions in deployment environment" do
     server = Rack::Server.new(:app => 'foo')
-    server.middleware['deployment'].flatten.should.not.include(Rack::ShowExceptions)
+    server.middleware['deployment'].flatten.wont_include Rack::ShowExceptions
   end
 
-  should "include Rack::TempfileReaper in deployment environment" do
+  it "include Rack::TempfileReaper in deployment environment" do
     server = Rack::Server.new(:app => 'foo')
-    server.middleware['deployment'].flatten.should.include(Rack::TempfileReaper)
+    server.middleware['deployment'].flatten.must_include Rack::TempfileReaper
   end
 
-  should "support CGI" do
+  it "support CGI" do
     begin
       o, ENV["REQUEST_METHOD"] = ENV["REQUEST_METHOD"], 'foo'
       server = Rack::Server.new(:app => 'foo')
       server.server.name =~ /CGI/
-      Rack::Server.logging_middleware.call(server).should.eql(nil)
+      Rack::Server.logging_middleware.call(server).must_be_nil
     ensure
       ENV['REQUEST_METHOD'] = o
     end
   end
 
-  should "be quiet if said so" do
+  it "be quiet if said so" do
     server = Rack::Server.new(:app => "FOO", :quiet => true)
-    Rack::Server.logging_middleware.call(server).should.eql(nil)
+    Rack::Server.logging_middleware.call(server).must_be_nil
   end
 
-  should "use a full path to the pidfile" do
+  it "use a full path to the pidfile" do
     # avoids issues with daemonize chdir
     opts = Rack::Server.new.send(:parse_options, %w[--pid testing.pid])
-    opts[:pid].should.eql(::File.expand_path('testing.pid'))
+    opts[:pid].must_equal ::File.expand_path('testing.pid')
   end
 
-  should "run a server" do
-    pidfile = Tempfile.open('pidfile') { |f| break f }.path
-    FileUtils.rm pidfile
+  it "get options from ARGV" do
+    SPEC_ARGV[0..-1] = ['--debug', '-sthin', '--env', 'production']
+    server = Rack::Server.new
+    server.options[:debug].must_equal true
+    server.options[:server].must_equal 'thin'
+    server.options[:environment].must_equal 'production'
+  end
+
+  it "only override non-passed options from parsed .ru file" do
+    builder_file = File.join(File.dirname(__FILE__), 'builder', 'options.ru')
+    SPEC_ARGV[0..-1] = ['--debug', '-sthin', '--env', 'production', builder_file]
+    server = Rack::Server.new
+    server.app # force .ru file to be parsed
+
+    server.options[:debug].must_equal true
+    server.options[:server].must_equal 'thin'
+    server.options[:environment].must_equal 'production'
+    server.options[:Port].must_equal '2929'
+  end
+
+  it "run a server" do
+    pidfile = Tempfile.open('pidfile') { |f| break f }
+    FileUtils.rm pidfile.path
     server = Rack::Server.new(
       :app         => app,
       :environment => 'none',
-      :pid         => pidfile,
+      :pid         => pidfile.path,
       :Port        => TCPServer.open('127.0.0.1', 0){|s| s.addr[1] },
       :Host        => '127.0.0.1',
+      :Logger      => WEBrick::Log.new(nil, WEBrick::BasicLog::WARN),
+      :AccessLog   => [],
       :daemonize   => false,
       :server      => 'webrick'
     )
     t = Thread.new { server.start { |s| Thread.current[:server] = s } }
     t.join(0.01) until t[:server] && t[:server].status != :Stop
     body = open("http://127.0.0.1:#{server.options[:Port]}/") { |f| f.read }
-    body.should.eql('success')
+    body.must_equal 'success'
 
     Process.kill(:INT, $$)
     t.join
-    open(pidfile) { |f| f.read.should.eql $$.to_s }
+    open(pidfile.path) { |f| f.read.must_equal $$.to_s }
   end
 
-  should "check pid file presence and running process" do
+  it "check pid file presence and running process" do
     pidfile = Tempfile.open('pidfile') { |f| f.write($$); break f }.path
     server = Rack::Server.new(:pid => pidfile)
-    server.send(:pidfile_process_status).should.eql :running
+    server.send(:pidfile_process_status).must_equal :running
   end
 
-  should "check pid file presence and dead process" do
+  it "check pid file presence and dead process" do
     dead_pid = `echo $$`.to_i
     pidfile = Tempfile.open('pidfile') { |f| f.write(dead_pid); break f }.path
     server = Rack::Server.new(:pid => pidfile)
-    server.send(:pidfile_process_status).should.eql :dead
+    server.send(:pidfile_process_status).must_equal :dead
   end
 
-  should "check pid file presence and exited process" do
+  it "check pid file presence and exited process" do
     pidfile = Tempfile.open('pidfile') { |f| break f }.path
     ::File.delete(pidfile)
     server = Rack::Server.new(:pid => pidfile)
-    server.send(:pidfile_process_status).should.eql :exited
+    server.send(:pidfile_process_status).must_equal :exited
   end
 
-  should "check pid file presence and not owned process" do
+  it "check pid file presence and not owned process" do
     pidfile = Tempfile.open('pidfile') { |f| f.write(1); break f }.path
     server = Rack::Server.new(:pid => pidfile)
-    server.send(:pidfile_process_status).should.eql :not_owned
+    server.send(:pidfile_process_status).must_equal :not_owned
   end
 
-  should "not write pid file when it is created after check" do
+  it "not write pid file when it is created after check" do
     pidfile = Tempfile.open('pidfile') { |f| break f }.path
     ::File.delete(pidfile)
     server = Rack::Server.new(:pid => pidfile)
     ::File.open(pidfile, 'w') { |f| f.write(1) }
     with_stderr do |err|
-      should.raise(SystemExit) do
-        server.send(:write_pid)
-      end
+      lambda { server.send(:write_pid) }.must_raise SystemExit
       err.rewind
       output = err.read
-      output.should.match(/already running/)
-      output.should.include? pidfile
+      output.must_match(/already running/)
+      output.must_include pidfile
     end
   end
 
-  should "inform the user about existing pidfiles with running processes" do
+  it "inform the user about existing pidfiles with running processes" do
     pidfile = Tempfile.open('pidfile') { |f| f.write(1); break f }.path
     server = Rack::Server.new(:pid => pidfile)
     with_stderr do |err|
-      should.raise(SystemExit) do
-        server.start
-      end
+      lambda { server.start }.must_raise SystemExit
       err.rewind
       output = err.read
-      output.should.match(/already running/)
-      output.should.include? pidfile
+      output.must_match(/already running/)
+      output.must_include pidfile
     end
   end
 

data/test/spec_session_abstract_id.rb

@@ -1,53 +1,31 @@
+require 'minitest/autorun'
 ### WARNING: there be hax in this file.
 
 require 'rack/session/abstract/id'
 
 describe Rack::Session::Abstract::ID do
-  id = Rack::Session::Abstract::ID
+  attr_reader :id
 
-  def silence_warning
-    o, $VERBOSE = $VERBOSE, nil
-    yield
-  ensure
-    $VERBOSE = o
+  def setup
+    super
+    @id = Rack::Session::Abstract::ID
   end
 
-  def reload_id
-    $".delete $".find { |part| part =~ %r{session/abstract/id.rb} }
-    silence_warning { require 'rack/session/abstract/id' }
-  end
-
-  should "use securerandom when available" do
-    begin
-      fake = false
-      silence_warning do
-        ::SecureRandom = fake = true unless defined?(SecureRandom)
-      end
-      reload_id
-      id::DEFAULT_OPTIONS[:secure_random].should.eql(fake || SecureRandom)
-    ensure
-      Object.send(:remove_const, :SecureRandom) if fake
-    end
-  end
+  it "use securerandom" do
+    assert_equal ::SecureRandom, id::DEFAULT_OPTIONS[:secure_random]
 
-  should "not use securerandom when unavailable" do
-    begin
-      sr = Object.send(:remove_const, :SecureRandom) if defined?(SecureRandom)
-      reload_id
-      id::DEFAULT_OPTIONS[:secure_random].should.eql false
-    ensure
-      ::SecureRandom = sr if defined?(sr)
-    end
+    id = @id.new nil
+    assert_equal ::SecureRandom, id.sid_secure
   end
 
-  should "allow to use another securerandom provider" do
+  it "allow to use another securerandom provider" do
     secure_random = Class.new do
       def hex(*args)
         'fake_hex'
       end
     end
     id = Rack::Session::Abstract::ID.new nil, :secure_random => secure_random.new
-    id.send(:generate_sid).should.equal 'fake_hex'
+    id.send(:generate_sid).must_equal 'fake_hex'
   end
 
 end