rack 2.0.8 → 2.2.2

data/test/spec_rewindable_input.rb

@@ -1,128 +0,0 @@
-require 'minitest/autorun'
-require 'stringio'
-require 'rack/rewindable_input'
-
-module RewindableTest
-  extend Minitest::Spec::DSL
-
-  def setup
-    @rio = Rack::RewindableInput.new(@io)
-  end
-
-  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
-
-  it "be able to handle to read(nil)" do
-    @rio.read(nil).must_equal "hello world"
-  end
-
-  it "be able to handle to read(length)" do
-    @rio.read(1).must_equal "h"
-  end
-
-  it "be able to handle to read(length, buffer)" do
-    buffer = ""
-    result = @rio.read(1, buffer)
-    result.must_equal "h"
-    result.object_id.must_equal buffer.object_id
-  end
-
-  it "be able to handle to read(nil, buffer)" do
-    buffer = ""
-    result = @rio.read(nil, buffer)
-    result.must_equal "hello world"
-    result.object_id.must_equal buffer.object_id
-  end
-
-  it "rewind to the beginning when #rewind is called" do
-    @rio.read(1)
-    @rio.rewind
-    @rio.read.must_equal "hello world"
-  end
-
-  it "be able to handle gets" do
-    @rio.gets.must_equal "hello world"
-  end
-
-  it "be able to handle each" do
-    array = []
-    @rio.each do |data|
-      array << data
-    end
-    array.must_equal ["hello world"]
-  end
-
-  it "not buffer into a Tempfile if no data has been read yet" do
-    @rio.instance_variable_get(:@rewindable_io).must_be_nil
-  end
-
-  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.wont_be :nil?
-    @rio.read(1)
-    tempfile2 = @rio.instance_variable_get(:@rewindable_io)
-    tempfile2.path.must_equal tempfile.path
-  end
-
-  it "close the underlying tempfile upon calling #close" do
-    @rio.read(1)
-    tempfile = @rio.instance_variable_get(:@rewindable_io)
-    @rio.close
-    tempfile.must_be :closed?
-  end
-
-  it "be possible to call #close when no data has been buffered yet" do
-    @rio.close.must_be_nil
-  end
-
-  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
-    def setup
-      @io = StringIO.new("hello world")
-      super
-    end
-
-    include RewindableTest
-  end
-
-  describe "given an IO object that is not rewindable" do
-    def setup
-      @io = StringIO.new("hello world")
-      @io.instance_eval do
-        undef :rewind
-      end
-      super
-    end
-
-    include RewindableTest
-  end
-
-  describe "given an IO object whose rewind method raises Errno::ESPIPE" do
-    def setup
-      @io = StringIO.new("hello world")
-      def @io.rewind
-        raise Errno::ESPIPE, "You can't rewind this!"
-      end
-      super
-    end
-
-    include RewindableTest
-  end
-end

data/test/spec_runtime.rb

@@ -1,50 +0,0 @@
-require 'minitest/autorun'
-require 'rack/lint'
-require 'rack/mock'
-require 'rack/runtime'
-
-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'].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'].must_equal "foobar"
-  end
-
-  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'].must_match(/[\d\.]+/)
-  end
-
-  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")
-
-    # wrap many times to guarantee a measurable difference
-    100.times do |i|
-      runtime = Rack::Runtime.new(runtime, i.to_s)
-    end
-    runtime = Rack::Runtime.new(runtime, "All")
-
-    response = runtime.call(request)
-
-    response[1]['X-Runtime-App'].must_match(/[\d\.]+/)
-    response[1]['X-Runtime-All'].must_match(/[\d\.]+/)
-
-    Float(response[1]['X-Runtime-All']).must_be :>, Float(response[1]['X-Runtime-App'])
-  end
-end

data/test/spec_sendfile.rb

@@ -1,125 +0,0 @@
-require 'minitest/autorun'
-require 'fileutils'
-require 'rack/lint'
-require 'rack/sendfile'
-require 'rack/mock'
-require 'tmpdir'
-
-describe Rack::Sendfile do
-  def sendfile_body
-    FileUtils.touch File.join(Dir.tmpdir,  "rack_sendfile")
-    res = ['Hello World']
-    def res.to_path ; File.join(Dir.tmpdir,  "rack_sendfile") ; end
-    res
-  end
-
-  def simple_app(body=sendfile_body)
-    lambda { |env| [200, {'Content-Type' => 'text/plain'}, body] }
-  end
-
-  def sendfile_app(body, mappings = [])
-    Rack::Lint.new Rack::Sendfile.new(simple_app(body), nil, mappings)
-  end
-
-  def request(headers={}, body=sendfile_body, mappings=[])
-    yield Rack::MockRequest.new(sendfile_app(body, mappings)).get('/', headers)
-  end
-
-  def open_file(path)
-    Class.new(File) do
-      unless method_defined?(:to_path)
-        alias :to_path :path
-      end
-    end.open(path, 'wb+')
-  end
-
-  it "does nothing when no X-Sendfile-Type header present" do
-    request do |response|
-      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.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.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
-
-  it "sets X-Accel-Redirect response header and discards body" do
-    headers = {
-      'HTTP_X_SENDFILE_TYPE' => 'X-Accel-Redirect',
-      'HTTP_X_ACCEL_MAPPING' => "#{Dir.tmpdir}/=/foo/bar/"
-    }
-    request headers do |response|
-      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.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.must_equal 'Not a file...'
-      response.headers.wont_include 'X-Sendfile'
-    end
-  end
-
-  it "sets X-Accel-Redirect response header and discards body when initialized with multiple mappings" do
-    begin
-      dir1 = Dir.mktmpdir
-      dir2 = Dir.mktmpdir
-
-      first_body = open_file(File.join(dir1, 'rack_sendfile'))
-      first_body.puts 'hello world'
-
-      second_body = open_file(File.join(dir2, 'rack_sendfile'))
-      second_body.puts 'goodbye world'
-
-      mappings = [
-        ["#{dir1}/", '/foo/bar/'],
-        ["#{dir2}/", '/wibble/']
-      ]
-
-      request({'HTTP_X_SENDFILE_TYPE' => 'X-Accel-Redirect'}, first_body, mappings) do |response|
-        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.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
-      FileUtils.remove_entry_secure dir2
-    end
-  end
-end

data/test/spec_server.rb

@@ -1,193 +0,0 @@
-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']] }
-  end
-
-  def with_stderr
-    old, $stderr = $stderr, StringIO.new
-    yield $stderr
-  ensure
-    $stderr = old
-  end
-
-  it "overrides :config if :app is passed in" do
-    server = Rack::Server.new(:app => "FOO")
-    server.app.must_equal "FOO"
-  end
-
-  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.must_equal Proc
-    Rack::MockRequest.new(server.app).get("/").body.to_s.must_equal 'success'
-  end
-
-  it "allow subclasses to override middleware" do
-    server = Class.new(Rack::Server).class_eval { def middleware; Hash.new [] end; self }
-    server.middleware['deployment'].wont_equal []
-    server.new(:app => 'foo').middleware['deployment'].must_equal []
-  end
-
-  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'].must_equal []
-    server.new(:app => 'foo').middleware['deployment'].must_equal []
-  end
-
-  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
-
-  it "always return an empty array for unknown environments" do
-    server = Rack::Server.new(:app => 'foo')
-    server.middleware['production'].must_equal []
-  end
-
-  it "not include Rack::Lint in deployment environment" do
-    server = Rack::Server.new(:app => 'foo')
-    server.middleware['deployment'].flatten.wont_include Rack::Lint
-  end
-
-  it "not include Rack::ShowExceptions in deployment environment" do
-    server = Rack::Server.new(:app => 'foo')
-    server.middleware['deployment'].flatten.wont_include Rack::ShowExceptions
-  end
-
-  it "include Rack::TempfileReaper in deployment environment" do
-    server = Rack::Server.new(:app => 'foo')
-    server.middleware['deployment'].flatten.must_include Rack::TempfileReaper
-  end
-
-  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).must_be_nil
-    ensure
-      ENV['REQUEST_METHOD'] = o
-    end
-  end
-
-  it "be quiet if said so" do
-    server = Rack::Server.new(:app => "FOO", :quiet => true)
-    Rack::Server.logging_middleware.call(server).must_be_nil
-  end
-
-  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].must_equal ::File.expand_path('testing.pid')
-  end
-
-  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.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.must_equal 'success'
-
-    Process.kill(:INT, $$)
-    t.join
-    open(pidfile.path) { |f| f.read.must_equal $$.to_s }
-  end
-
-  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).must_equal :running
-  end
-
-  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).must_equal :dead
-  end
-
-  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).must_equal :exited
-  end
-
-  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).must_equal :not_owned
-  end
-
-  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|
-      lambda { server.send(:write_pid) }.must_raise SystemExit
-      err.rewind
-      output = err.read
-      output.must_match(/already running/)
-      output.must_include pidfile
-    end
-  end
-
-  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|
-      lambda { server.start }.must_raise SystemExit
-      err.rewind
-      output = err.read
-      output.must_match(/already running/)
-      output.must_include pidfile
-    end
-  end
-
-end