eac-rack 1.1.1

data/test/spec_rack_response.rb

@@ -0,0 +1,221 @@
+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"]
+    response.set_cookie "foo3", "bar3"
+    response["Set-Cookie"].should.equal ["foo=bar", "foo2=bar2", "foo3=bar3"]
+  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"]
+  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

@@ -0,0 +1,118 @@
+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

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1,86 @@
+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