rack 1.1.6 → 1.6.9

data/test/spec_rack_response.rb

@@ -1,221 +0,0 @@
-require 'test/spec'
-require 'set'
-
-require 'rack/response'
-
-context "Rack::Response" do
-  specify "has 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
-
-  specify "can be written to" do
-    response = Rack::Response.new
-
-    status, header, 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
-
-  specify "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
-
-  specify "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
-
-  specify "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
-
-  specify "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
-
-  specify "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
-
-  specify "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
-
-  specify "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
-
-  specify "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"
-
-    r = Rack::Response.new(["foo", "bar"].to_set)
-    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
-
-  specify "has a constructor that can take a block" do
-    r = Rack::Response.new { |res|
-      res.status = 404
-      res.write "foo"
-    }
-    status, header, body = r.finish
-    str = ""; body.each { |part| str << part }
-    str.should.equal "foo"
-    status.should.equal 404
-  end
- 
-  specify "doesn't return invalid responses" do
-    r = Rack::Response.new(["foo", "bar"], 204)
-    status, header, body = r.finish
-    str = ""; body.each { |part| str << part }
-    str.should.be.empty
-    header["Content-Type"].should.equal nil
-
-    lambda {
-      Rack::Response.new(Object.new)
-    }.should.raise(TypeError).
-      message.should =~ /stringable or iterable required/
-  end
-
-  specify "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
-
-  specify "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 = 404
-    res.should.not.be.successful
-    res.should.be.client_error
-    res.should.be.not_found
-
-    res.status = 501
-    res.should.not.be.successful
-    res.should.be.server_error
-
-    res.status = 307
-    res.should.be.redirect
-  end
-
-  specify "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
-
-  specify "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
-
-  specify "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
-
-end

data/test/spec_rack_rewindable_input.rb

@@ -1,118 +0,0 @@
-require 'test/spec'
-require 'stringio'
-require 'rack/rewindable_input'
-
-shared_context "a rewindable IO object" do
-  setup do
-    @rio = Rack::RewindableInput.new(@io)
-  end
-  
-  teardown do
-    @rio.close
-  end
-  
-  specify "should be able to handle to read()" do
-    @rio.read.should.equal "hello world"
-  end
-  
-  specify "should be able to handle to read(nil)" do
-    @rio.read(nil).should.equal "hello world"
-  end
-  
-  specify "should be able to handle to read(length)" do
-    @rio.read(1).should.equal "h"
-  end
-  
-  specify "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
-  
-  specify "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
-  
-  specify "should rewind to the beginning when #rewind is called" do
-    @rio.read(1)
-    @rio.rewind
-    @rio.read.should.equal "hello world"
-  end
-  
-  specify "should be able to handle gets" do
-    @rio.gets.should == "hello world"
-  end
-  
-  specify "should be able to handle each" do
-    array = []
-    @rio.each do |data|
-      array << data
-    end
-    array.should.equal(["hello world"])
-  end
-  
-  specify "should not buffer into a Tempfile if no data has been read yet" do
-    @rio.instance_variable_get(:@rewindable_io).should.be.nil
-  end
-  
-  specify "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.should.equal tempfile
-  end
-  
-  specify "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
-  
-  specify "should be possibel to call #close when no data has been buffered yet" do
-    @rio.close
-  end
-  
-  specify "should be possible to call #close multiple times" do
-    @rio.close
-    @rio.close
-  end
-end
-
-context "Rack::RewindableInput" do
-  context "given an IO object that is already rewindable" do
-    setup do
-      @io = StringIO.new("hello world")
-    end
-    
-    it_should_behave_like "a rewindable IO object"
-  end
-  
-  context "given an IO object that is not rewindable" do
-    setup do
-      @io = StringIO.new("hello world")
-      @io.instance_eval do
-        undef :rewind
-      end
-    end
-    
-    it_should_behave_like "a rewindable IO object"
-  end
-  
-  context "given an IO object whose rewind method raises Errno::ESPIPE" do
-    setup do
-      @io = StringIO.new("hello world")
-      def @io.rewind
-        raise Errno::ESPIPE, "You can't rewind this!"
-      end
-    end
-    
-    it_should_behave_like "a rewindable IO object"
-  end
-end

data/test/spec_rack_runtime.rb

@@ -1,35 +0,0 @@
-require 'test/spec'
-require 'rack/mock'
-require 'rack/runtime'
-
-context "Rack::Runtime" do
-  specify "sets X-Runtime is none is set" do
-    app = lambda { |env| [200, {'Content-Type' => 'text/plain'}, "Hello, World!"] }
-    response = Rack::Runtime.new(app).call({})
-    response[1]['X-Runtime'].should =~ /[\d\.]+/
-  end
-
-  specify "does not set the X-Runtime if it is already set" do
-    app = lambda { |env| [200, {'Content-Type' => 'text/plain', "X-Runtime" => "foobar"}, "Hello, World!"] }
-    response = Rack::Runtime.new(app).call({})
-    response[1]['X-Runtime'].should == "foobar"
-  end
-
-  specify "should allow a suffix to be set" do
-    app = lambda { |env| [200, {'Content-Type' => 'text/plain'}, "Hello, World!"] }
-    response = Rack::Runtime.new(app, "Test").call({})
-    response[1]['X-Runtime-Test'].should =~ /[\d\.]+/
-  end
-
-  specify "should allow multiple timers to be set" do
-    app = lambda { |env| [200, {'Content-Type' => 'text/plain'}, "Hello, World!"] }
-    runtime1 = Rack::Runtime.new(app, "App")
-    runtime2 = Rack::Runtime.new(runtime1, "All")
-    response = runtime2.call({})
-
-    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_rack_sendfile.rb

@@ -1,86 +0,0 @@
-require 'test/spec'
-require 'rack/mock'
-require 'rack/sendfile'
-
-context "Rack::File" do
-  specify "should respond to #to_path" do
-    Rack::File.new(Dir.pwd).should.respond_to :to_path
-  end
-end
-
-context "Rack::Sendfile" do
-  def sendfile_body
-    res = ['Hello World']
-    def res.to_path ; "/tmp/hello.txt" ; 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::Sendfile.new(simple_app(body))
-  end
-
-  setup do
-    @request = Rack::MockRequest.new(sendfile_app)
-  end
-
-  def request(headers={})
-    yield @request.get('/', headers)
-  end
-
-  specify "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
-
-  specify "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['X-Sendfile'].should.equal '/tmp/hello.txt'
-    end
-  end
-
-  specify "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['X-Lighttpd-Send-File'].should.equal '/tmp/hello.txt'
-    end
-  end
-
-  specify "sets X-Accel-Redirect response header and discards body" do
-    headers = {
-      'HTTP_X_SENDFILE_TYPE' => 'X-Accel-Redirect',
-      'HTTP_X_ACCEL_MAPPING' => '/tmp/=/foo/bar/'
-    }
-    request headers do |response|
-      response.should.be.ok
-      response.body.should.be.empty
-      response.headers['X-Accel-Redirect'].should.equal '/foo/bar/hello.txt'
-    end
-  end
-
-  specify '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
-
-  specify '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_rack_session_cookie.rb

@@ -1,92 +0,0 @@
-require 'test/spec'
-
-require 'rack/session/cookie'
-require 'rack/mock'
-require 'rack/response'
-
-context "Rack::Session::Cookie" do
-  incrementor = lambda { |env|
-    env["rack.session"]["counter"] ||= 0
-    env["rack.session"]["counter"] += 1
-    Rack::Response.new(env["rack.session"].inspect).to_a
-  }
-
-  before do
-    @warnings = warnings = []
-    Rack::Session::Cookie.class_eval do
-      define_method(:warn) { |m| warnings << m }
-    end
-  end
-
-  after do
-    Rack::Session::Cookie.class_eval { remove_method :warn }
-  end
-
-  specify "warns if no secret is given" do
-    cookie = Rack::Session::Cookie.new(incrementor)
-    @warnings.first.should =~ /no secret/i
-    @warnings.clear
-    cookie = Rack::Session::Cookie.new(incrementor, :secret => 'abc')
-    @warnings.should.be.empty?
-  end
-
-  specify "creates a new cookie" do
-    res = Rack::MockRequest.new(Rack::Session::Cookie.new(incrementor)).get("/")
-    res["Set-Cookie"].should.match("rack.session=")
-    res.body.should.equal '{"counter"=>1}'
-  end
-
-  specify "loads from a cookie" do
-    res = Rack::MockRequest.new(Rack::Session::Cookie.new(incrementor)).get("/")
-    cookie = res["Set-Cookie"]
-    res = Rack::MockRequest.new(Rack::Session::Cookie.new(incrementor)).
-      get("/", "HTTP_COOKIE" => cookie)
-    res.body.should.equal '{"counter"=>2}'
-    cookie = res["Set-Cookie"]
-    res = Rack::MockRequest.new(Rack::Session::Cookie.new(incrementor)).
-      get("/", "HTTP_COOKIE" => cookie)
-    res.body.should.equal '{"counter"=>3}'
-  end
-
-  specify "survives broken cookies" do
-    res = Rack::MockRequest.new(Rack::Session::Cookie.new(incrementor)).
-      get("/", "HTTP_COOKIE" => "rack.session=blarghfasel")
-    res.body.should.equal '{"counter"=>1}'
-  end
-
-  bigcookie = lambda { |env|
-    env["rack.session"]["cookie"] = "big" * 3000
-    Rack::Response.new(env["rack.session"].inspect).to_a
-  }
-
-  specify "barks on too big cookies" do
-    lambda {
-      Rack::MockRequest.new(Rack::Session::Cookie.new(bigcookie)).
-        get("/", :fatal => true)
-    }.should.raise(Rack::MockRequest::FatalWarning)
-  end
-
-  specify "loads from a cookie wih integrity hash" do
-    res = Rack::MockRequest.new(Rack::Session::Cookie.new(incrementor, :secret => 'test')).get("/")
-    cookie = res["Set-Cookie"]
-    res = Rack::MockRequest.new(Rack::Session::Cookie.new(incrementor, :secret => 'test')).
-      get("/", "HTTP_COOKIE" => cookie)
-    res.body.should.equal '{"counter"=>2}'
-    cookie = res["Set-Cookie"]
-    res = Rack::MockRequest.new(Rack::Session::Cookie.new(incrementor, :secret => 'test')).
-      get("/", "HTTP_COOKIE" => cookie)
-    res.body.should.equal '{"counter"=>3}'
-  end
-  
-  specify "ignores tampered with session cookies" do
-    app = Rack::Session::Cookie.new(incrementor, :secret => 'test')
-    response1 = Rack::MockRequest.new(app).get("/")
-    _, digest = response1["Set-Cookie"].split("--")
-    tampered_with_cookie = "hackerman-was-here" + "--" + digest
-    response2 = Rack::MockRequest.new(app).get("/", "HTTP_COOKIE" =>
-                                               tampered_with_cookie)
-    
-    # The tampered-with cookie is ignored, so we get back an identical Set-Cookie
-    response2["Set-Cookie"].should.equal(response1["Set-Cookie"])
-  end
-end

data/test/spec_rack_showexceptions.rb

@@ -1,21 +0,0 @@
-require 'test/spec'
-
-require 'rack/showexceptions'
-require 'rack/mock'
-
-context "Rack::ShowExceptions" do
-  specify "catches exceptions" do
-    res = nil
-    req = Rack::MockRequest.new(Rack::ShowExceptions.new(lambda { |env|
-                                                           raise RuntimeError
-                                                         }))
-    lambda {
-      res = req.get("/")
-    }.should.not.raise
-    res.should.be.a.server_error
-    res.status.should.equal 500
-
-    res.should =~ /RuntimeError/
-    res.should =~ /ShowExceptions/
-  end
-end

data/test/spec_rack_showstatus.rb

@@ -1,72 +0,0 @@
-require 'test/spec'
-
-require 'rack/showstatus'
-require 'rack/mock'
-
-context "Rack::ShowStatus" do
-  specify "should provide a default status message" do
-    req = Rack::MockRequest.new(Rack::ShowStatus.new(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["Content-Type"].should.equal("text/html")
-    res.should =~ /404/
-    res.should =~ /Not Found/
-  end
-
-  specify "should let the app provide additional information" do
-    req = Rack::MockRequest.new(Rack::ShowStatus.new(lambda { |env|
-                                                       env["rack.showstatus.detail"] = "gone too meta."
-                                                       [404, {"Content-Type" => "text/plain", "Content-Length" => "0"}, []]
-                                                     }))
-
-    res = req.get("/", :lint => true)
-    res.should.be.not_found
-    res.should.be.not.empty
-
-    res["Content-Type"].should.equal("text/html")
-    res.should =~ /404/
-    res.should =~ /Not Found/
-    res.should =~ /too meta/
-  end
-
-  specify "should not replace existing messages" do
-    req = Rack::MockRequest.new(Rack::ShowStatus.new(lambda { |env|
-                                                       [404, {"Content-Type" => "text/plain", "Content-Length" => "4"}, ["foo!"]]
-                                                     }))
-    res = req.get("/", :lint => true)
-    res.should.be.not_found
-
-    res.body.should == "foo!"
-  end
-
-  specify "should pass on original headers" do
-    headers = {"WWW-Authenticate" => "Basic blah"}
-
-    req = Rack::MockRequest.new(Rack::ShowStatus.new(lambda { |env| [401, headers, []] }))
-    res = req.get("/", :lint => true)
-
-    res["WWW-Authenticate"].should.equal("Basic blah")
-  end
-
-  specify "should replace existing messages if there is detail" do
-    req = Rack::MockRequest.new(Rack::ShowStatus.new(lambda { |env|
-                                                       env["rack.showstatus.detail"] = "gone too meta."
-                                                       [404, {"Content-Type" => "text/plain", "Content-Length" => "4"}, ["foo!"]]
-                                                     }))
-
-    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/
-  end
-end

data/test/spec_rack_static.rb

@@ -1,37 +0,0 @@
-require 'test/spec'
-
-require 'rack/static'
-require 'rack/mock'
-
-class DummyApp
-  def call(env)
-    [200, {}, ["Hello World"]]
-  end
-end
-
-context "Rack::Static" do
-  root = File.expand_path(File.dirname(__FILE__))
-  OPTIONS = {:urls => ["/cgi"], :root => root}
-
-  setup do
-    @request = Rack::MockRequest.new(Rack::Static.new(DummyApp.new, OPTIONS))
-  end
-
-  specify "serves files" do
-    res = @request.get("/cgi/test")
-    res.should.be.ok
-    res.body.should =~ /ruby/
-  end
-
-  specify "404s if url root is known but it can't find the file" do
-    res = @request.get("/cgi/foo")
-    res.should.be.not_found
-  end
-
-  specify "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"
-  end
-
-end