rack 1.4.7 → 2.1.4

data/test/spec_response.rb

@@ -1,313 +0,0 @@
-require 'rack/response'
-require 'stringio'
-
-describe Rack::Response do
-  should "have sensible default values" do
-    response = Rack::Response.new
-    status, header, body = response.finish
-    status.should.equal 200
-    header.should.equal "Content-Type" => "text/html"
-    body.each { |part|
-      part.should.equal ""
-    }
-
-    response = Rack::Response.new
-    status, header, body = *response
-    status.should.equal 200
-    header.should.equal "Content-Type" => "text/html"
-    body.each { |part|
-      part.should.equal ""
-    }
-  end
-
-  it "can be written to" do
-    response = Rack::Response.new
-
-    _, _, body = response.finish do
-      response.write "foo"
-      response.write "bar"
-      response.write "baz"
-    end
-
-    parts = []
-    body.each { |part| parts << part }
-
-    parts.should.equal ["foo", "bar", "baz"]
-  end
-
-  it "can set and read headers" do
-    response = Rack::Response.new
-    response["Content-Type"].should.equal "text/html"
-    response["Content-Type"] = "text/plain"
-    response["Content-Type"].should.equal "text/plain"
-  end
-
-  it "can override the initial Content-Type with a different case" do
-    response = Rack::Response.new("", 200, "content-type" => "text/plain")
-    response["Content-Type"].should.equal "text/plain"
-  end
-
-  it "can set cookies" do
-    response = Rack::Response.new
-
-    response.set_cookie "foo", "bar"
-    response["Set-Cookie"].should.equal "foo=bar"
-    response.set_cookie "foo2", "bar2"
-    response["Set-Cookie"].should.equal ["foo=bar", "foo2=bar2"].join("\n")
-    response.set_cookie "foo3", "bar3"
-    response["Set-Cookie"].should.equal ["foo=bar", "foo2=bar2", "foo3=bar3"].join("\n")
-  end
-
-  it "can set cookies with the same name for multiple domains" do
-    response = Rack::Response.new
-    response.set_cookie "foo", {:value => "bar", :domain => "sample.example.com"}
-    response.set_cookie "foo", {:value => "bar", :domain => ".example.com"}
-    response["Set-Cookie"].should.equal ["foo=bar; domain=sample.example.com", "foo=bar; domain=.example.com"].join("\n")
-  end
-
-  it "formats the Cookie expiration date accordingly to RFC 2109" do
-    response = Rack::Response.new
-
-    response.set_cookie "foo", {:value => "bar", :expires => Time.now+10}
-    response["Set-Cookie"].should.match(
-      /expires=..., \d\d-...-\d\d\d\d \d\d:\d\d:\d\d .../)
-  end
-
-  it "can set secure cookies" do
-    response = Rack::Response.new
-    response.set_cookie "foo", {:value => "bar", :secure => true}
-    response["Set-Cookie"].should.equal "foo=bar; secure"
-  end
-
-  it "can set http only cookies" do
-    response = Rack::Response.new
-    response.set_cookie "foo", {:value => "bar", :httponly => true}
-    response["Set-Cookie"].should.equal "foo=bar; HttpOnly"
-  end
-
-  it "can delete cookies" do
-    response = Rack::Response.new
-    response.set_cookie "foo", "bar"
-    response.set_cookie "foo2", "bar2"
-    response.delete_cookie "foo"
-    response["Set-Cookie"].should.equal [
-      "foo2=bar2",
-      "foo=; expires=Thu, 01-Jan-1970 00:00:00 GMT"
-    ].join("\n")
-  end
-
-  it "can delete cookies with the same name from multiple domains" do
-    response = Rack::Response.new
-    response.set_cookie "foo", {:value => "bar", :domain => "sample.example.com"}
-    response.set_cookie "foo", {:value => "bar", :domain => ".example.com"}
-    response["Set-Cookie"].should.equal ["foo=bar; domain=sample.example.com", "foo=bar; domain=.example.com"].join("\n")
-    response.delete_cookie "foo", :domain => ".example.com"
-    response["Set-Cookie"].should.equal ["foo=bar; domain=sample.example.com", "foo=; domain=.example.com; expires=Thu, 01-Jan-1970 00:00:00 GMT"].join("\n")
-    response.delete_cookie "foo", :domain => "sample.example.com"
-    response["Set-Cookie"].should.equal ["foo=; domain=.example.com; expires=Thu, 01-Jan-1970 00:00:00 GMT",
-                                         "foo=; domain=sample.example.com; expires=Thu, 01-Jan-1970 00:00:00 GMT"].join("\n")
-  end
-
-  it "can delete cookies with the same name with different paths" do
-    response = Rack::Response.new
-    response.set_cookie "foo", {:value => "bar", :path => "/"}
-    response.set_cookie "foo", {:value => "bar", :path => "/path"}
-    response["Set-Cookie"].should.equal ["foo=bar; path=/",
-                                         "foo=bar; path=/path"].join("\n")
-
-    response.delete_cookie "foo", :path => "/path"
-    response["Set-Cookie"].should.equal ["foo=bar; path=/",
-                                         "foo=; path=/path; expires=Thu, 01-Jan-1970 00:00:00 GMT"].join("\n")
-  end
-
-  it "can do redirects" do
-    response = Rack::Response.new
-    response.redirect "/foo"
-    status, header, body = response.finish
-    status.should.equal 302
-    header["Location"].should.equal "/foo"
-
-    response = Rack::Response.new
-    response.redirect "/foo", 307
-    status, header, body = response.finish
-
-    status.should.equal 307
-  end
-
-  it "has a useful constructor" do
-    r = Rack::Response.new("foo")
-    status, header, body = r.finish
-    str = ""; body.each { |part| str << part }
-    str.should.equal "foo"
-
-    r = Rack::Response.new(["foo", "bar"])
-    status, header, body = r.finish
-    str = ""; body.each { |part| str << part }
-    str.should.equal "foobar"
-
-    object_with_each = Object.new
-    def object_with_each.each
-      yield "foo"
-      yield "bar"
-    end
-    r = Rack::Response.new(object_with_each)
-    r.write "foo"
-    status, header, body = r.finish
-    str = ""; body.each { |part| str << part }
-    str.should.equal "foobarfoo"
-
-    r = Rack::Response.new([], 500)
-    r.status.should.equal 500
-
-    r = Rack::Response.new([], "200 OK")
-    r.status.should.equal 200
-  end
-
-  it "has a constructor that can take a block" do
-    r = Rack::Response.new { |res|
-      res.status = 404
-      res.write "foo"
-    }
-    status, _, body = r.finish
-    str = ""; body.each { |part| str << part }
-    str.should.equal "foo"
-    status.should.equal 404
-  end
-
-  it "doesn't return invalid responses" do
-    r = Rack::Response.new(["foo", "bar"], 204)
-    _, header, body = r.finish
-    str = ""; body.each { |part| str << part }
-    str.should.be.empty
-    header["Content-Type"].should.equal nil
-    header['Content-Length'].should.equal nil
-
-    lambda {
-      Rack::Response.new(Object.new)
-    }.should.raise(TypeError).
-      message.should =~ /stringable or iterable required/
-  end
-
-  it "knows if it's empty" do
-    r = Rack::Response.new
-    r.should.be.empty
-    r.write "foo"
-    r.should.not.be.empty
-
-    r = Rack::Response.new
-    r.should.be.empty
-    r.finish
-    r.should.be.empty
-
-    r = Rack::Response.new
-    r.should.be.empty
-    r.finish { }
-    r.should.not.be.empty
-  end
-
-  should "provide access to the HTTP status" do
-    res = Rack::Response.new
-    res.status = 200
-    res.should.be.successful
-    res.should.be.ok
-
-    res.status = 400
-    res.should.not.be.successful
-    res.should.be.client_error
-    res.should.be.bad_request
-
-    res.status = 404
-    res.should.not.be.successful
-    res.should.be.client_error
-    res.should.be.not_found
-
-    res.status = 405
-    res.should.not.be.successful
-    res.should.be.client_error
-    res.should.be.method_not_allowed
-
-    res.status = 422
-    res.should.not.be.successful
-    res.should.be.client_error
-    res.should.be.unprocessable
-
-    res.status = 501
-    res.should.not.be.successful
-    res.should.be.server_error
-
-    res.status = 307
-    res.should.be.redirect
-  end
-
-  should "provide access to the HTTP headers" do
-    res = Rack::Response.new
-    res["Content-Type"] = "text/yaml"
-
-    res.should.include "Content-Type"
-    res.headers["Content-Type"].should.equal "text/yaml"
-    res["Content-Type"].should.equal "text/yaml"
-    res.content_type.should.equal "text/yaml"
-    res.content_length.should.be.nil
-    res.location.should.be.nil
-  end
-
-  it "does not add or change Content-Length when #finish()ing" do
-    res = Rack::Response.new
-    res.status = 200
-    res.finish
-    res.headers["Content-Length"].should.be.nil
-
-    res = Rack::Response.new
-    res.status = 200
-    res.headers["Content-Length"] = "10"
-    res.finish
-    res.headers["Content-Length"].should.equal "10"
-  end
-
-  it "updates Content-Length when body appended to using #write" do
-    res = Rack::Response.new
-    res.status = 200
-    res.headers["Content-Length"].should.be.nil
-    res.write "Hi"
-    res.headers["Content-Length"].should.equal "2"
-    res.write " there"
-    res.headers["Content-Length"].should.equal "8"
-  end
-
-  it "calls close on #body" do
-    res = Rack::Response.new
-    res.body = StringIO.new
-    res.close
-    res.body.should.be.closed
-  end
-
-  it "calls close on #body when 204, 205, or 304" do
-    res = Rack::Response.new
-    res.body = StringIO.new
-    res.finish
-    res.body.should.not.be.closed
-
-    res.status = 204
-    _, _, b = res.finish
-    res.body.should.be.closed
-    b.should.not == res.body
-
-    res.body = StringIO.new
-    res.status = 205
-    _, _, b = res.finish
-    res.body.should.be.closed
-    b.should.not == res.body
-
-    res.body = StringIO.new
-    res.status = 304
-    _, _, b = res.finish
-    res.body.should.be.closed
-    b.should.not == res.body
-  end
-
-  it "wraps the body from #to_ary to prevent infinite loops" do
-    res = Rack::Response.new
-    res.finish.last.should.not.respond_to?(:to_ary)
-    lambda { res.finish.last.to_ary }.should.raise(NoMethodError)
-  end
-end

data/test/spec_rewindable_input.rb

@@ -1,118 +0,0 @@
-require 'stringio'
-require 'rack/rewindable_input'
-
-shared "a rewindable IO object" do
-  before do
-    @rio = Rack::RewindableInput.new(@io)
-  end
-
-  should "be able to handle to read()" do
-    @rio.read.should.equal "hello world"
-  end
-
-  should "be able to handle to read(nil)" do
-    @rio.read(nil).should.equal "hello world"
-  end
-
-  should "be able to handle to read(length)" do
-    @rio.read(1).should.equal "h"
-  end
-
-  should "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
-  end
-
-  should "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
-  end
-
-  should "rewind to the beginning when #rewind is called" do
-    @rio.read(1)
-    @rio.rewind
-    @rio.read.should.equal "hello world"
-  end
-
-  should "be able to handle gets" do
-    @rio.gets.should == "hello world"
-  end
-
-  should "be able to handle each" do
-    array = []
-    @rio.each do |data|
-      array << data
-    end
-    array.should.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
-  end
-
-  should "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
-    @rio.read(1)
-    tempfile2 = @rio.instance_variable_get(:@rewindable_io)
-    tempfile2.path.should == tempfile.path
-  end
-
-  should "close the underlying tempfile upon calling #close" do
-    @rio.read(1)
-    tempfile = @rio.instance_variable_get(:@rewindable_io)
-    @rio.close
-    tempfile.should.be.closed
-  end
-
-  should "be possible to call #close when no data has been buffered yet" do
-    lambda{ @rio.close }.should.not.raise
-  end
-
-  should "be possible to call #close multiple times" do
-    lambda{
-      @rio.close
-      @rio.close
-    }.should.not.raise
-  end
-
-  @rio.close
-  @rio = nil
-end
-
-describe Rack::RewindableInput do
-  describe "given an IO object that is already rewindable" do
-    before do
-      @io = StringIO.new("hello world")
-    end
-
-    behaves_like "a rewindable IO object"
-  end
-
-  describe "given an IO object that is not rewindable" do
-    before do
-      @io = StringIO.new("hello world")
-      @io.instance_eval do
-        undef :rewind
-      end
-    end
-
-    behaves_like "a rewindable IO object"
-  end
-
-  describe "given an IO object whose rewind method raises Errno::ESPIPE" do
-    before do
-      @io = StringIO.new("hello world")
-      def @io.rewind
-        raise Errno::ESPIPE, "You can't rewind this!"
-      end
-    end
-
-    behaves_like "a rewindable IO object"
-  end
-end

data/test/spec_runtime.rb

@@ -1,49 +0,0 @@
-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'].should =~ /[\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"
-  end
-
-  should "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\.]+/
-  end
-
-  should "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'].should =~ /[\d\.]+/
-    response[1]['X-Runtime-All'].should =~ /[\d\.]+/
-
-    Float(response[1]['X-Runtime-All']).should > Float(response[1]['X-Runtime-App'])
-  end
-end

data/test/spec_sendfile.rb

@@ -1,90 +0,0 @@
-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")
-    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=sendfile_body)
-    Rack::Lint.new Rack::Sendfile.new(simple_app(body))
-  end
-
-  @request = Rack::MockRequest.new(sendfile_app)
-
-  def request(headers={})
-    yield @request.get('/', headers)
-  end
-
-  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'
-    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")
-    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")
-    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.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'
-    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'
-    end
-  end
-
-  it 'does nothing when body does not respond to #to_path' do
-    @request = Rack::MockRequest.new(sendfile_app(['Not a file...']))
-    request 'HTTP_X_SENDFILE_TYPE' => 'X-Sendfile' do |response|
-      response.body.should.equal 'Not a file...'
-      response.headers.should.not.include 'X-Sendfile'
-    end
-  end
-end

data/test/spec_server.rb

@@ -1,121 +0,0 @@
-require 'rack'
-require 'rack/server'
-require 'tempfile'
-require 'socket'
-require 'open-uri'
-
-describe Rack::Server do
-
-  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.should == "FOO"
-  end
-
-  should "not include Rack::Lint in deployment or none environments" do
-    server = Rack::Server.new(:app => 'foo')
-    server.middleware['deployment'].flatten.should.not.include(Rack::Lint)
-    server.middleware['none'].flatten.should.not.include(Rack::Lint)
-  end
-
-  should "not include Rack::ShowExceptions in deployment or none environments" do
-    server = Rack::Server.new(:app => 'foo')
-    server.middleware['deployment'].flatten.should.not.include(Rack::ShowExceptions)
-    server.middleware['none'].flatten.should.not.include(Rack::ShowExceptions)
-  end
-
-  should "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)
-    ensure
-      ENV['REQUEST_METHOD'] = o
-    end
-  end
-
-  should "not force any middleware under the none configuration" do
-    server = Rack::Server.new(:app => 'foo')
-    server.middleware['none'].should.be.empty
-  end
-
-  should "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'))
-  end
-
-  should "run a server" do
-    pidfile = Tempfile.open('pidfile') { |f| break f }.path
-    FileUtils.rm pidfile
-    server = Rack::Server.new(
-      :app         => app,
-      :environment => 'none',
-      :pid         => pidfile,
-      :Port        => TCPServer.open('127.0.0.1', 0){|s| s.addr[1] },
-      :Host        => '127.0.0.1',
-      :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')
-
-    Process.kill(:INT, $$)
-    t.join
-    open(pidfile) { |f| f.read.should.eql $$.to_s }
-  end
-
-  should "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
-  end
-
-  should "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
-  end
-
-  should "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
-  end
-
-  should "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
-  end
-
-  should "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
-      err.rewind
-      output = err.read
-      output.should.match(/already running/)
-      output.should.include? pidfile
-    end
-  end
-
-end