rack 1.1.6 → 1.2.0

data/{test/spec_rack_response.rb → spec/spec_response.rb}

@@ -1,10 +1,8 @@
-require 'test/spec'
 require 'set'
-
 require 'rack/response'
 
-context "Rack::Response" do
-  specify "has sensible default values" do
+describe Rack::Response do
+  should "have sensible default values" do
     response = Rack::Response.new
     status, header, body = response.finish
     status.should.equal 200
@@ -22,7 +20,7 @@ context "Rack::Response" do
     }
   end
 
-  specify "can be written to" do
+  it "can be written to" do
     response = Rack::Response.new
 
     status, header, body = response.finish do
@@ -30,23 +28,23 @@ context "Rack::Response" do
       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
+  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
 
-  specify "can set cookies" do
+  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"
@@ -55,36 +53,57 @@ context "Rack::Response" do
     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
+  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
 
-  specify "can set secure cookies" do
+  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
 
-  specify "can set http only cookies" do
+  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
 
-  specify "can delete cookies" do
+  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")
+    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
 
-  specify "can do redirects" do
+  it "can do redirects" do
     response = Rack::Response.new
     response.redirect "/foo"
     status, header, body = response.finish
@@ -99,7 +118,7 @@ context "Rack::Response" do
     status.should.equal 307
   end
 
-  specify "has a useful constructor" do
+  it "has a useful constructor" do
     r = Rack::Response.new("foo")
     status, header, body = r.finish
     str = ""; body.each { |part| str << part }
@@ -123,7 +142,7 @@ context "Rack::Response" do
     r.status.should.equal 200
   end
 
-  specify "has a constructor that can take a block" do
+  it "has a constructor that can take a block" do
     r = Rack::Response.new { |res|
       res.status = 404
       res.write "foo"
@@ -133,8 +152,8 @@ context "Rack::Response" do
     str.should.equal "foo"
     status.should.equal 404
   end
- 
-  specify "doesn't return invalid responses" do
+
+  it "doesn't return invalid responses" do
     r = Rack::Response.new(["foo", "bar"], 204)
     status, header, body = r.finish
     str = ""; body.each { |part| str << part }
@@ -147,7 +166,7 @@ context "Rack::Response" do
       message.should =~ /stringable or iterable required/
   end
 
-  specify "knows if it's empty" do
+  it "knows if it's empty" do
     r = Rack::Response.new
     r.should.be.empty
     r.write "foo"
@@ -164,7 +183,7 @@ context "Rack::Response" do
     r.should.not.be.empty
   end
 
-  specify "should provide access to the HTTP status" do
+  should "provide access to the HTTP status" do
     res = Rack::Response.new
     res.status = 200
     res.should.be.successful
@@ -183,7 +202,7 @@ context "Rack::Response" do
     res.should.be.redirect
   end
 
-  specify "should provide access to the HTTP headers" do
+  should "provide access to the HTTP headers" do
     res = Rack::Response.new
     res["Content-Type"] = "text/yaml"
 
@@ -195,7 +214,7 @@ context "Rack::Response" do
     res.location.should.be.nil
   end
 
-  specify "does not add or change Content-Length when #finish()ing" do
+  it "does not add or change Content-Length when #finish()ing" do
     res = Rack::Response.new
     res.status = 200
     res.finish
@@ -208,7 +227,7 @@ context "Rack::Response" do
     res.headers["Content-Length"].should.equal "10"
   end
 
-  specify "updates Content-Length when body appended to using #write" do
+  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

data/spec/spec_rewindable_input.rb

@@ -0,0 +1,118 @@
+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_rack_runtime.rb → spec/spec_runtime.rb}

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

data/{test/spec_rack_sendfile.rb → spec/spec_sendfile.rb}

@@ -1,14 +1,13 @@
-require 'test/spec'
-require 'rack/mock'
 require 'rack/sendfile'
+require 'rack/mock'
 
-context "Rack::File" do
-  specify "should respond to #to_path" do
+describe Rack::File do
+  should "respond to #to_path" do
     Rack::File.new(Dir.pwd).should.respond_to :to_path
   end
 end
 
-context "Rack::Sendfile" do
+describe Rack::Sendfile do
   def sendfile_body
     res = ['Hello World']
     def res.to_path ; "/tmp/hello.txt" ; end
@@ -23,15 +22,13 @@ context "Rack::Sendfile" do
     Rack::Sendfile.new(simple_app(body))
   end
 
-  setup do
-    @request = Rack::MockRequest.new(sendfile_app)
-  end
+  @request = Rack::MockRequest.new(sendfile_app)
 
   def request(headers={})
     yield @request.get('/', headers)
   end
 
-  specify "does nothing when no X-Sendfile-Type header present" 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'
@@ -39,7 +36,7 @@ context "Rack::Sendfile" do
     end
   end
 
-  specify "sets X-Sendfile response header and discards body" do
+  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
@@ -47,7 +44,7 @@ context "Rack::Sendfile" do
     end
   end
 
-  specify "sets X-Lighttpd-Send-File response header and discards body" do
+  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
@@ -55,7 +52,7 @@ context "Rack::Sendfile" do
     end
   end
 
-  specify "sets X-Accel-Redirect response header and discards body" do
+  it "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/'
@@ -67,7 +64,7 @@ context "Rack::Sendfile" do
     end
   end
 
-  specify 'writes to rack.error when no X-Accel-Mapping is specified' do
+  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'
@@ -76,7 +73,7 @@ context "Rack::Sendfile" do
     end
   end
 
-  specify 'does nothing when body does not respond to #to_path' do
+  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...'

data/{test/spec_rack_session_cookie.rb → spec/spec_session_cookie.rb}

@@ -1,42 +1,20 @@
-require 'test/spec'
-
 require 'rack/session/cookie'
 require 'rack/mock'
-require 'rack/response'
 
-context "Rack::Session::Cookie" do
-  incrementor = lambda { |env|
+describe Rack::Session::Cookie do
+  incrementor = lambda do |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
+  it "creates a new cookie" do
     res = Rack::MockRequest.new(Rack::Session::Cookie.new(incrementor)).get("/")
-    res["Set-Cookie"].should.match("rack.session=")
+    res["Set-Cookie"].should.include("rack.session=")
     res.body.should.equal '{"counter"=>1}'
   end
 
-  specify "loads from a cookie" do
+  it "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)).
@@ -48,25 +26,25 @@ context "Rack::Session::Cookie" do
     res.body.should.equal '{"counter"=>3}'
   end
 
-  specify "survives broken cookies" do
+  it "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|
+  bigcookie = lambda do |env|
     env["rack.session"]["cookie"] = "big" * 3000
     Rack::Response.new(env["rack.session"].inspect).to_a
-  }
+  end
 
-  specify "barks on too big cookies" do
-    lambda {
+  it "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
+  it "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')).
@@ -77,15 +55,15 @@ context "Rack::Session::Cookie" do
       get("/", "HTTP_COOKIE" => cookie)
     res.body.should.equal '{"counter"=>3}'
   end
-  
-  specify "ignores tampered with session cookies" do
+
+  it "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