RubyGems - aldebaran - Versions diffs - 1.0.1 - Mend

aldebaran 1.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (97) hide show

data/.gitignore +13 -0
data/.travis.yml +16 -0
data/.yardopts +4 -0
data/AUTHORS +4 -0
data/Gemfile +77 -0
data/KNOWN_ISSUES +5 -0
data/LICENSE +22 -0
data/README.rdoc +1900 -0
data/Rakefile +175 -0
data/aldebaran.gemspec +19 -0
data/lib/aldebaran.rb +7 -0
data/lib/aldebaran/base.rb +1600 -0
data/lib/aldebaran/images/404.png +0 -0
data/lib/aldebaran/images/500.png +0 -0
data/lib/aldebaran/main.rb +28 -0
data/lib/aldebaran/showexceptions.rb +340 -0
data/lib/aldebaran/version.rb +3 -0
data/test/aldebaran_test.rb +17 -0
data/test/base_test.rb +160 -0
data/test/builder_test.rb +95 -0
data/test/coffee_test.rb +92 -0
data/test/contest.rb +98 -0
data/test/creole_test.rb +65 -0
data/test/delegator_test.rb +162 -0
data/test/encoding_test.rb +20 -0
data/test/erb_test.rb +104 -0
data/test/extensions_test.rb +100 -0
data/test/filter_test.rb +397 -0
data/test/haml_test.rb +101 -0
data/test/helper.rb +115 -0
data/test/helpers_test.rb +1192 -0
data/test/less_test.rb +67 -0
data/test/liquid_test.rb +59 -0
data/test/mapped_error_test.rb +259 -0
data/test/markaby_test.rb +80 -0
data/test/markdown_test.rb +81 -0
data/test/middleware_test.rb +68 -0
data/test/nokogiri_test.rb +69 -0
data/test/public/favicon.ico +0 -0
data/test/radius_test.rb +59 -0
data/test/rdoc_test.rb +65 -0
data/test/readme_test.rb +136 -0
data/test/request_test.rb +45 -0
data/test/response_test.rb +61 -0
data/test/result_test.rb +98 -0
data/test/route_added_hook_test.rb +59 -0
data/test/routing_test.rb +1096 -0
data/test/sass_test.rb +115 -0
data/test/scss_test.rb +88 -0
data/test/server_test.rb +48 -0
data/test/settings_test.rb +493 -0
data/test/slim_test.rb +98 -0
data/test/static_test.rb +178 -0
data/test/streaming_test.rb +100 -0
data/test/templates_test.rb +298 -0
data/test/textile_test.rb +65 -0
data/test/views/a/in_a.str +1 -0
data/test/views/ascii.erb +2 -0
data/test/views/b/in_b.str +1 -0
data/test/views/calc.html.erb +1 -0
data/test/views/error.builder +3 -0
data/test/views/error.erb +3 -0
data/test/views/error.haml +3 -0
data/test/views/error.sass +2 -0
data/test/views/explicitly_nested.str +1 -0
data/test/views/foo/hello.test +1 -0
data/test/views/hello.builder +1 -0
data/test/views/hello.coffee +1 -0
data/test/views/hello.creole +1 -0
data/test/views/hello.erb +1 -0
data/test/views/hello.haml +1 -0
data/test/views/hello.less +5 -0
data/test/views/hello.liquid +1 -0
data/test/views/hello.mab +1 -0
data/test/views/hello.md +1 -0
data/test/views/hello.nokogiri +1 -0
data/test/views/hello.radius +1 -0
data/test/views/hello.rdoc +1 -0
data/test/views/hello.sass +2 -0
data/test/views/hello.scss +3 -0
data/test/views/hello.slim +1 -0
data/test/views/hello.str +1 -0
data/test/views/hello.test +1 -0
data/test/views/hello.textile +1 -0
data/test/views/layout2.builder +3 -0
data/test/views/layout2.erb +2 -0
data/test/views/layout2.haml +2 -0
data/test/views/layout2.liquid +2 -0
data/test/views/layout2.mab +2 -0
data/test/views/layout2.nokogiri +3 -0
data/test/views/layout2.radius +2 -0
data/test/views/layout2.slim +3 -0
data/test/views/layout2.str +2 -0
data/test/views/layout2.test +1 -0
data/test/views/nested.str +1 -0
data/test/views/utf8.erb +2 -0
metadata +231 -0

data/test/haml_test.rb ADDED

@@ -0,0 +1,101 @@
+require File.expand_path('../helper', __FILE__)
+begin
+require 'haml'
+class HAMLTest < Test::Unit::TestCase
+  def haml_app(&block)
+    mock_app {
+      set :views, File.dirname(__FILE__) + '/views'
+      get '/', &block
+    }
+    get '/'
+  end
+  it 'renders inline HAML strings' do
+    haml_app { haml '%h1 Hiya' }
+    assert ok?
+    assert_equal "<h1>Hiya</h1>\n", body
+  end
+  it 'renders .haml files in views path' do
+    haml_app { haml :hello }
+    assert ok?
+    assert_equal "<h1>Hello From Haml</h1>\n", body
+  end
+  it "renders with inline layouts" do
+    mock_app {
+      layout { %q(%h1= 'THIS. IS. ' + yield.upcase) }
+      get('/') { haml '%em Sparta' }
+    }
+    get '/'
+    assert ok?
+    assert_equal "<h1>THIS. IS. <EM>SPARTA</EM></h1>\n", body
+  end
+  it "renders with file layouts" do
+    haml_app {
+      haml 'Hello World', :layout => :layout2
+    }
+    assert ok?
+    assert_equal "<h1>HAML Layout!</h1>\n<p>Hello World</p>\n", body
+  end
+  it "raises error if template not found" do
+    mock_app {
+      get('/') { haml :no_such_template }
+    }
+    assert_raise(Errno::ENOENT) { get('/') }
+  end
+  it "passes HAML options to the Haml engine" do
+    mock_app {
+      get '/' do
+        haml "!!!\n%h1 Hello World", :format => :html5
+      end
+    }
+    get '/'
+    assert ok?
+    assert_equal "<!DOCTYPE html>\n<h1>Hello World</h1>\n", body
+  end
+  it "passes default HAML options to the Haml engine" do
+    mock_app {
+      set :haml, {:format => :html5}
+      get '/' do
+        haml "!!!\n%h1 Hello World"
+      end
+    }
+    get '/'
+    assert ok?
+    assert_equal "<!DOCTYPE html>\n<h1>Hello World</h1>\n", body
+  end
+  it "merges the default HAML options with the overrides and passes them to the Haml engine" do
+    mock_app {
+      set :haml, {:format => :html5, :attr_wrapper => '"'} # default HAML attr are <tag attr='single-quoted'>
+      get '/' do
+        haml "!!!\n%h1{:class => :header} Hello World"
+      end
+      get '/html4' do
+        haml "!!!\n%h1{:class => 'header'} Hello World", :format => :html4
+      end
+    }
+    get '/'
+    assert ok?
+    assert_equal "<!DOCTYPE html>\n<h1 class=\"header\">Hello World</h1>\n", body
+    get '/html4'
+    assert ok?
+    assert_match(/^<!DOCTYPE html PUBLIC (.*) HTML 4.01/, body)
+  end
+  it "is possible to pass locals" do
+    haml_app { haml "= foo", :locals => { :foo => 'bar' }}
+    assert_equal "bar\n", body
+  end
+end
+rescue LoadError
+  warn "#{$!.to_s}: skipping haml tests"
+end

data/test/helper.rb ADDED

@@ -0,0 +1,115 @@
+ENV['RACK_ENV'] = 'test'
+Encoding.default_external = "UTF-8" if defined? Encoding
+RUBY_ENGINE = 'ruby' unless defined? RUBY_ENGINE
+begin
+  require 'rack'
+rescue LoadError
+  require 'rubygems'
+  require 'rack'
+end
+testdir = File.dirname(__FILE__)
+$LOAD_PATH.unshift testdir unless $LOAD_PATH.include?(testdir)
+libdir = File.dirname(File.dirname(__FILE__)) + '/lib'
+$LOAD_PATH.unshift libdir unless $LOAD_PATH.include?(libdir)
+require 'contest'
+require 'rack/test'
+require 'aldebaran/base'
+class aldebaran::Base
+  # Allow assertions in request context
+  include Test::Unit::Assertions
+end
+class Rack::Builder
+  def include?(middleware)
+    @ins.any? { |m| p m ; middleware === m }
+  end
+end
+aldebaran::Base.set :environment, :test
+class Test::Unit::TestCase
+  include Rack::Test::Methods
+  class << self
+    alias_method :it, :test
+    alias_method :section, :context
+  end
+  def self.example(desc = nil, &block)
+    @example_count = 0 unless instance_variable_defined? :@example_count
+    @example_count += 1
+    it(desc || "Example #{@example_count}", &block)
+  end
+  alias_method :response, :last_response
+  setup do
+    aldebaran::Base.set :environment, :test
+  end
+  # Sets up a aldebaran::Base subclass defined with the block
+  # given. Used in setup or individual spec methods to establish
+  # the application.
+  def mock_app(base=aldebaran::Base, &block)
+    @app = aldebaran.new(base, &block)
+  end
+  def app
+    Rack::Lint.new(@app)
+  end
+  def body
+    response.body.to_s
+  end
+  def assert_body(value)
+    assert_equal value.lstrip.gsub(/\s*\n\s*/, ""), body.lstrip.gsub(/\s*\n\s*/, "")
+  end
+  def assert_like(a,b)
+    pattern = /id=['"][^"']*["']|\s+/
+    assert_equal a.strip.gsub(pattern, ""), b.strip.gsub(pattern, "")
+  end
+  def assert_include(str, substr)
+    assert str.include?(substr), "expected #{str.inspect} to include #{substr.inspect}"
+  end
+  def options(uri, params = {}, env = {}, &block)
+    request(uri, env.merge(:method => "OPTIONS", :params => params), &block)
+  end
+  def patch(uri, params = {}, env = {}, &block)
+    request(uri, env.merge(:method => "PATCH", :params => params), &block)
+  end
+  # Delegate other missing methods to response.
+  def method_missing(name, *args, &block)
+    if response && response.respond_to?(name)
+      response.send(name, *args, &block)
+    else
+      super
+    end
+  rescue Rack::Test::Error
+    super
+  end
+  # Also check response since we delegate there.
+  def respond_to?(symbol, include_private=false)
+    super || (response && response.respond_to?(symbol, include_private))
+  end
+  # Do not output warnings for the duration of the block.
+  def silence_warnings
+    $VERBOSE, v = nil, $VERBOSE
+    yield
+  ensure
+    $VERBOSE = v
+  end
+end

data/test/helpers_test.rb ADDED

@@ -0,0 +1,1192 @@
+require File.expand_path('../helper', __FILE__)
+require 'date'
+class HelpersTest < Test::Unit::TestCase
+  def test_default
+    assert true
+  end
+  def status_app(code, &block)
+    code += 2 if [204, 205, 304].include? code
+    block ||= proc { }
+    mock_app do
+      get '/' do
+        status code
+        instance_eval(&block).inspect
+      end
+    end
+    get '/'
+  end
+  describe 'status' do
+    it 'sets the response status code' do
+      status_app 207
+      assert_equal 207, response.status
+    end
+  end
+  describe 'not_found?' do
+    it 'is true for status == 404' do
+      status_app(404) { not_found? }
+      assert_body 'true'
+    end
+    it 'is false for status > 404' do
+      status_app(405) { not_found? }
+      assert_body 'false'
+    end
+    it 'is false for status < 404' do
+      status_app(403) { not_found? }
+      assert_body 'false'
+    end
+  end
+  describe 'informational?' do
+    it 'is true for 1xx status' do
+      status_app(100 + rand(100)) { informational? }
+      assert_body 'true'
+    end
+    it 'is false for status > 199' do
+      status_app(200 + rand(400)) { informational? }
+      assert_body 'false'
+    end
+  end
+  describe 'success?' do
+    it 'is true for 2xx status' do
+      status_app(200 + rand(100)) { success? }
+      assert_body 'true'
+    end
+    it 'is false for status < 200' do
+      status_app(100 + rand(100)) { success? }
+      assert_body 'false'
+    end
+    it 'is false for status > 299' do
+      status_app(300 + rand(300)) { success? }
+      assert_body 'false'
+    end
+  end
+  describe 'redirect?' do
+    it 'is true for 3xx status' do
+      status_app(300 + rand(100)) { redirect? }
+      assert_body 'true'
+    end
+    it 'is false for status < 300' do
+      status_app(200 + rand(100)) { redirect? }
+      assert_body 'false'
+    end
+    it 'is false for status > 399' do
+      status_app(400 + rand(200)) { redirect? }
+      assert_body 'false'
+    end
+  end
+  describe 'client_error?' do
+    it 'is true for 4xx status' do
+      status_app(400 + rand(100)) { client_error? }
+      assert_body 'true'
+    end
+    it 'is false for status < 400' do
+      status_app(200 + rand(200)) { client_error? }
+      assert_body 'false'
+    end
+    it 'is false for status > 499' do
+      status_app(500 + rand(100)) { client_error? }
+      assert_body 'false'
+    end
+  end
+  describe 'server_error?' do
+    it 'is true for 5xx status' do
+      status_app(500 + rand(100)) { server_error? }
+      assert_body 'true'
+    end
+    it 'is false for status < 500' do
+      status_app(200 + rand(300)) { server_error? }
+      assert_body 'false'
+    end
+  end
+  describe 'body' do
+    it 'takes a block for defered body generation' do
+      mock_app {
+        get '/' do
+          body { 'Hello World' }
+        end
+      }
+      get '/'
+      assert_equal 'Hello World', body
+    end
+    it 'takes a String, Array, or other object responding to #each' do
+      mock_app {
+        get '/' do
+          body 'Hello World'
+        end
+      }
+      get '/'
+      assert_equal 'Hello World', body
+    end
+  end
+  describe 'redirect' do
+    it 'uses a 302 when only a path is given' do
+      mock_app {
+        get '/' do
+          redirect '/foo'
+          fail 'redirect should halt'
+        end
+      }
+      get '/'
+      assert_equal 302, status
+      assert_equal '', body
+      assert_equal 'http://example.org/foo', response['Location']
+    end
+    it 'uses the code given when specified' do
+      mock_app {
+        get '/' do
+          redirect '/foo', 301
+          fail 'redirect should halt'
+        end
+      }
+      get '/'
+      assert_equal 301, status
+      assert_equal '', body
+      assert_equal 'http://example.org/foo', response['Location']
+    end
+    it 'redirects back to request.referer when passed back' do
+      mock_app {
+        get '/try_redirect' do
+          redirect back
+        end
+      }
+      request = Rack::MockRequest.new(@app)
+      response = request.get('/try_redirect', 'HTTP_REFERER' => '/foo')
+      assert_equal 302, response.status
+      assert_equal 'http://example.org/foo', response['Location']
+    end
+    it 'redirects using a non-standard HTTP port' do
+      mock_app {
+        get '/' do
+          redirect '/foo'
+        end
+      }
+      request = Rack::MockRequest.new(@app)
+      response = request.get('/', 'SERVER_PORT' => '81')
+      assert_equal 'http://example.org:81/foo', response['Location']
+    end
+    it 'redirects using a non-standard HTTPS port' do
+      mock_app {
+        get '/' do
+          redirect '/foo'
+        end
+      }
+      request = Rack::MockRequest.new(@app)
+      response = request.get('/', 'SERVER_PORT' => '444')
+      assert_equal 'http://example.org:444/foo', response['Location']
+    end
+    it 'uses 303 for post requests if request is HTTP 1.1' do
+      mock_app { post('/') { redirect '/'} }
+      post '/', {}, 'HTTP_VERSION' => 'HTTP/1.1'
+      assert_equal 303, status
+      assert_equal '', body
+      assert_equal 'http://example.org/', response['Location']
+    end
+    it 'uses 302 for post requests if request is HTTP 1.0' do
+      mock_app { post('/') { redirect '/'} }
+      post '/', {}, 'HTTP_VERSION' => 'HTTP/1.0'
+      assert_equal 302, status
+      assert_equal '', body
+      assert_equal 'http://example.org/', response['Location']
+    end
+    it 'works behind a reverse proxy' do
+      mock_app do
+        get '/' do
+          redirect '/foo'
+        end
+      end
+      request = Rack::MockRequest.new(@app)
+      response = request.get('/', 'HTTP_X_FORWARDED_HOST' => 'example.com', 'SERVER_PORT' => '8080')
+      assert_equal 'http://example.com/foo', response['Location']
+    end
+    it 'accepts absolute URIs' do
+      mock_app do
+        get '/' do
+          redirect 'http://google.com'
+          fail 'redirect should halt'
+        end
+      end
+      get '/'
+      assert_equal 302, status
+      assert_equal '', body
+      assert_equal 'http://google.com', response['Location']
+    end
+    it 'accepts absolute URIs with a different schema' do
+      mock_app do
+        get '/' do
+          redirect 'mailto:jsmith@example.com'
+          fail 'redirect should halt'
+        end
+      end
+      get '/'
+      assert_equal 302, status
+      assert_equal '', body
+      assert_equal 'mailto:jsmith@example.com', response['Location']
+    end
+  end
+  describe 'error' do
+    it 'sets a status code and halts' do
+      mock_app {
+        get '/' do
+          error 501
+          fail 'error should halt'
+        end
+      }
+      get '/'
+      assert_equal 501, status
+      assert_equal '', body
+    end
+    it 'takes an optional body' do
+      mock_app {
+        get '/' do
+          error 501, 'FAIL'
+          fail 'error should halt'
+        end
+      }
+      get '/'
+      assert_equal 501, status
+      assert_equal 'FAIL', body
+    end
+    it 'uses a 500 status code when first argument is a body' do
+      mock_app {
+        get '/' do
+          error 'FAIL'
+          fail 'error should halt'
+        end
+      }
+      get '/'
+      assert_equal 500, status
+      assert_equal 'FAIL', body
+    end
+  end
+  describe 'not_found' do
+    it 'halts with a 404 status' do
+      mock_app {
+        get '/' do
+          not_found
+          fail 'not_found should halt'
+        end
+      }
+      get '/'
+      assert_equal 404, status
+      assert_equal '', body
+    end
+    it 'does not set a X-Cascade header' do
+      mock_app {
+        get '/' do
+          not_found
+          fail 'not_found should halt'
+        end
+      }
+      get '/'
+      assert_equal 404, status
+      assert_equal nil, response.headers['X-Cascade']
+    end
+  end
+  describe 'headers' do
+    it 'sets headers on the response object when given a Hash' do
+      mock_app {
+        get '/' do
+          headers 'X-Foo' => 'bar', 'X-Baz' => 'bling'
+          'kthx'
+        end
+      }
+      get '/'
+      assert ok?
+      assert_equal 'bar', response['X-Foo']
+      assert_equal 'bling', response['X-Baz']
+      assert_equal 'kthx', body
+    end
+    it 'returns the response headers hash when no hash provided' do
+      mock_app {
+        get '/' do
+          headers['X-Foo'] = 'bar'
+          'kthx'
+        end
+      }
+      get '/'
+      assert ok?
+      assert_equal 'bar', response['X-Foo']
+    end
+  end
+  describe 'session' do
+    it 'uses the existing rack.session' do
+      mock_app {
+        get '/' do
+          session[:foo]
+        end
+      }
+      get '/', {}, { 'rack.session' => { :foo => 'bar' } }
+      assert_equal 'bar', body
+    end
+    it 'creates a new session when none provided' do
+      mock_app {
+        enable :sessions
+        get '/' do
+          assert session.empty?
+          session[:foo] = 'bar'
+          redirect '/hi'
+        end
+        get '/hi' do
+          "hi #{session[:foo]}"
+        end
+      }
+      get '/'
+      follow_redirect!
+      assert_equal 'hi bar', body
+    end
+    it 'inserts session middleware' do
+      mock_app do
+        enable :sessions
+        get '/' do
+          assert env['rack.session']
+          assert env['rack.session.options']
+          'ok'
+        end
+      end
+      get '/'
+      assert_body 'ok'
+    end
+    it 'sets a default session secret' do
+      mock_app do
+        enable :sessions
+        get '/' do
+          secret = env['rack.session.options'][:secret]
+          assert secret
+          assert_equal secret, settings.session_secret
+          'ok'
+        end
+      end
+      get '/'
+      assert_body 'ok'
+    end
+    it 'allows disabling session secret' do
+      mock_app do
+        enable :sessions
+        disable :session_secret
+        get '/' do
+          assert !env['rack.session.options'].include?(:session_secret)
+          'ok'
+        end
+      end
+      get '/'
+      assert_body 'ok'
+    end
+    it 'accepts an options hash' do
+      mock_app do
+        set :sessions, :foo => :bar
+        get '/' do
+          assert_equal env['rack.session.options'][:foo], :bar
+          'ok'
+        end
+      end
+      get '/'
+      assert_body 'ok'
+    end
+  end
+  describe 'mime_type' do
+    include aldebaran::Helpers
+    it "looks up mime types in Rack's MIME registry" do
+      Rack::Mime::MIME_TYPES['.foo'] = 'application/foo'
+      assert_equal 'application/foo', mime_type('foo')
+      assert_equal 'application/foo', mime_type('.foo')
+      assert_equal 'application/foo', mime_type(:foo)
+    end
+    it 'returns nil when given nil' do
+      assert mime_type(nil).nil?
+    end
+    it 'returns nil when media type not registered' do
+      assert mime_type(:bizzle).nil?
+    end
+    it 'returns the argument when given a media type string' do
+      assert_equal 'text/plain', mime_type('text/plain')
+    end
+  end
+  test 'Base.mime_type registers mime type' do
+    mock_app {
+      mime_type :foo, 'application/foo'
+      get '/' do
+        "foo is #{mime_type(:foo)}"
+      end
+    }
+    get '/'
+    assert_equal 'foo is application/foo', body
+  end
+  describe 'content_type' do
+    it 'sets the Content-Type header' do
+      mock_app {
+        get '/' do
+          content_type 'text/plain'
+          'Hello World'
+        end
+      }
+      get '/'
+      assert_equal 'text/plain;charset=utf-8', response['Content-Type']
+      assert_equal 'Hello World', body
+    end
+    it 'takes media type parameters (like charset=)' do
+      mock_app {
+        get '/' do
+          content_type 'text/html', :charset => 'latin1'
+          "<h1>Hello, World</h1>"
+        end
+      }
+      get '/'
+      assert ok?
+      assert_equal 'text/html;charset=latin1', response['Content-Type']
+      assert_equal "<h1>Hello, World</h1>", body
+    end
+    it "looks up symbols in Rack's mime types dictionary" do
+      Rack::Mime::MIME_TYPES['.foo'] = 'application/foo'
+      mock_app {
+        get '/foo.xml' do
+          content_type :foo
+          "I AM FOO"
+        end
+      }
+      get '/foo.xml'
+      assert ok?
+      assert_equal 'application/foo', response['Content-Type']
+      assert_equal 'I AM FOO', body
+    end
+    it 'fails when no mime type is registered for the argument provided' do
+      mock_app {
+        get '/foo.xml' do
+          content_type :bizzle
+          "I AM FOO"
+        end
+      }
+      assert_raise(RuntimeError) { get '/foo.xml' }
+    end
+    it 'only sets default charset for specific mime types' do
+      tests_ran = false
+      mock_app do
+        mime_type :foo, 'text/foo'
+        mime_type :bar, 'application/bar'
+        mime_type :baz, 'application/baz'
+        add_charset << mime_type(:baz)
+        get '/' do
+          assert_equal content_type(:txt),    'text/plain;charset=utf-8'
+          assert_equal content_type(:css),    'text/css;charset=utf-8'
+          assert_equal content_type(:html),   'text/html;charset=utf-8'
+          assert_equal content_type(:foo),    'text/foo;charset=utf-8'
+          assert_equal content_type(:xml),    'application/xml;charset=utf-8'
+          assert_equal content_type(:xhtml),  'application/xhtml+xml;charset=utf-8'
+          assert_equal content_type(:js),     'application/javascript;charset=utf-8'
+          assert_equal content_type(:json),   'application/json;charset=utf-8'
+          assert_equal content_type(:bar),    'application/bar'
+          assert_equal content_type(:png),    'image/png'
+          assert_equal content_type(:baz),    'application/baz;charset=utf-8'
+          tests_ran = true
+          "done"
+        end
+      end
+      get '/'
+      assert tests_ran
+    end
+    it 'handles already present params' do
+      mock_app do
+        get '/' do
+          content_type 'foo/bar;level=1', :charset => 'utf-8'
+          'ok'
+        end
+      end
+      get '/'
+      assert_equal 'foo/bar;level=1, charset=utf-8', response['Content-Type']
+    end
+    it 'does not add charset if present' do
+      mock_app do
+        get '/' do
+          content_type 'text/plain;charset=utf-16'
+          'ok'
+        end
+      end
+      get '/'
+      assert_equal 'text/plain;charset=utf-16', response['Content-Type']
+    end
+  end
+  describe 'attachment' do
+    def attachment_app(filename=nil)
+      mock_app {
+        get '/attachment' do
+          attachment filename
+          response.write("<aldebaran></aldebaran>")
+        end
+      }
+    end
+    it 'sets the Content-Type response header' do
+      attachment_app('test.xml')
+      get '/attachment'
+      assert_equal 'application/xml;charset=utf-8', response['Content-Type']
+      assert_equal '<aldebaran></aldebaran>', body
+    end
+    it 'sets the Content-Type response header without extname' do
+      attachment_app('test')
+      get '/attachment'
+      assert_equal 'text/html;charset=utf-8', response['Content-Type']
+      assert_equal '<aldebaran></aldebaran>', body
+    end
+    it 'sets the Content-Type response header without extname' do
+      mock_app do
+        get '/attachment' do
+          content_type :atom
+          attachment 'test.xml'
+          response.write("<aldebaran></aldebaran>")
+        end
+      end
+      get '/attachment'
+      assert_equal 'application/atom+xml', response['Content-Type']
+      assert_equal '<aldebaran></aldebaran>', body
+    end
+  end
+  describe 'send_file' do
+    setup do
+      @file = File.dirname(__FILE__) + '/file.txt'
+      File.open(@file, 'wb') { |io| io.write('Hello World') }
+    end
+    def teardown
+      File.unlink @file
+      @file = nil
+    end
+    def send_file_app(opts={})
+      path = @file
+      mock_app {
+        get '/file.txt' do
+          send_file path, opts
+        end
+      }
+    end
+    it "sends the contents of the file" do
+      send_file_app
+      get '/file.txt'
+      assert ok?
+      assert_equal 'Hello World', body
+    end
+    it 'sets the Content-Type response header if a mime-type can be located' do
+      send_file_app
+      get '/file.txt'
+      assert_equal 'text/plain;charset=utf-8', response['Content-Type']
+    end
+    it 'sets the Content-Type response header if type option is set to a file extesion' do
+      send_file_app :type => 'html'
+      get '/file.txt'
+      assert_equal 'text/html;charset=utf-8', response['Content-Type']
+    end
+    it 'sets the Content-Type response header if type option is set to a mime type' do
+      send_file_app :type => 'application/octet-stream'
+      get '/file.txt'
+      assert_equal 'application/octet-stream', response['Content-Type']
+    end
+    it 'sets the Content-Length response header' do
+      send_file_app
+      get '/file.txt'
+      assert_equal 'Hello World'.length.to_s, response['Content-Length']
+    end
+    it 'sets the Last-Modified response header' do
+      send_file_app
+      get '/file.txt'
+      assert_equal File.mtime(@file).httpdate, response['Last-Modified']
+    end
+    it 'allows passing in a differen Last-Modified response header with :last_modified' do
+      time = Time.now
+      send_file_app :last_modified => time
+      get '/file.txt'
+      assert_equal time.httpdate, response['Last-Modified']
+    end
+    it "returns a 404 when not found" do
+      mock_app {
+        get '/' do
+          send_file 'this-file-does-not-exist.txt'
+        end
+      }
+      get '/'
+      assert not_found?
+    end
+    it "does not set the Content-Disposition header by default" do
+      send_file_app
+      get '/file.txt'
+      assert_nil response['Content-Disposition']
+    end
+    it "sets the Content-Disposition header when :disposition set to 'attachment'" do
+      send_file_app :disposition => 'attachment'
+      get '/file.txt'
+      assert_equal 'attachment; filename="file.txt"', response['Content-Disposition']
+    end
+    it "sets the Content-Disposition header when :disposition set to 'inline'" do
+      send_file_app :disposition => 'inline'
+      get '/file.txt'
+      assert_equal 'inline', response['Content-Disposition']
+    end
+    it "sets the Content-Disposition header when :filename provided" do
+      send_file_app :filename => 'foo.txt'
+      get '/file.txt'
+      assert_equal 'attachment; filename="foo.txt"', response['Content-Disposition']
+    end
+    it "is able to send files with unkown mime type" do
+      @file = File.dirname(__FILE__) + '/file.foobar'
+      File.open(@file, 'wb') { |io| io.write('Hello World') }
+      send_file_app
+      get '/file.txt'
+      assert_equal 'application/octet-stream', response['Content-Type']
+    end
+    it "does not override Content-Type if already set and no explicit type is given" do
+      path = @file
+      mock_app do
+        get '/' do
+          content_type :png
+          send_file path
+        end
+      end
+      get '/'
+      assert_equal 'image/png', response['Content-Type']
+    end
+    it "does override Content-Type even if already set, if explicit type is given" do
+      path = @file
+      mock_app do
+        get '/' do
+          content_type :png
+          send_file path, :type => :gif
+        end
+      end
+      get '/'
+      assert_equal 'image/gif', response['Content-Type']
+    end
+  end
+  describe 'cache_control' do
+    setup do
+      mock_app do
+        get '/foo' do
+          cache_control :public, :no_cache, :max_age => 60.0
+          'Hello World'
+        end
+        get '/bar' do
+          cache_control :public, :no_cache
+          'Hello World'
+        end
+      end
+    end
+    it 'sets the Cache-Control header' do
+      get '/foo'
+      assert_equal ['public', 'no-cache', 'max-age=60'], response['Cache-Control'].split(', ')
+    end
+    it 'last argument does not have to be a hash' do
+      get '/bar'
+      assert_equal ['public', 'no-cache'], response['Cache-Control'].split(', ')
+    end
+  end
+  describe 'expires' do
+    setup do
+      mock_app do
+        get '/foo' do
+          expires 60, :public, :no_cache
+          'Hello World'
+        end
+        get '/bar' do
+          expires Time.now
+        end
+        get '/baz' do
+          expires Time.at(0)
+        end
+        get '/blah' do
+          obj = Object.new
+          def obj.method_missing(*a, &b) 60.send(*a, &b) end
+          def obj.is_a?(thing) 60.is_a?(thing) end
+          expires obj, :public, :no_cache
+          'Hello World'
+        end
+        get '/boom' do
+          expires '9999'
+        end
+      end
+    end
+    it 'sets the Cache-Control header' do
+      get '/foo'
+      assert_equal ['public', 'no-cache', 'max-age=60'], response['Cache-Control'].split(', ')
+    end
+    it 'sets the Expires header' do
+      get '/foo'
+      assert_not_nil response['Expires']
+    end
+    it 'allows passing time objects' do
+      get '/bar'
+      assert_not_nil response['Expires']
+    end
+    it 'allows passing time objects' do
+      get '/baz'
+      assert_equal 'Thu, 01 Jan 1970 00:00:00 GMT', response['Expires']
+    end
+    it 'accepts values pretending to be a Numeric (like ActiveSupport::Duration)' do
+      get '/blah'
+      assert_equal ['public', 'no-cache', 'max-age=60'], response['Cache-Control'].split(', ')
+    end
+    it 'fails when Time.parse raises an ArgumentError' do
+      assert_raise(ArgumentError) { get '/boom' }
+    end
+  end
+  describe 'last_modified' do
+    it 'ignores nil' do
+      mock_app do
+        get '/' do last_modified nil; 200; end
+      end
+      get '/'
+      assert ! response['Last-Modified']
+    end
+    [Time.now, DateTime.now, Date.today, Time.now.to_i,
+      Struct.new(:to_time).new(Time.now) ].each do |last_modified_time|
+      describe "with #{last_modified_time.class.name}" do
+        setup do
+          mock_app do
+            get '/' do
+              last_modified last_modified_time
+              'Boo!'
+            end
+          end
+          wrapper = Object.new.extend aldebaran::Helpers
+          @last_modified_time = wrapper.time_for last_modified_time
+        end
+        # fixes strange missing test error when running complete test suite.
+        it("does not complain about missing tests") { }
+        context "when there's no If-Modified-Since header" do
+          it 'sets the Last-Modified header to a valid RFC 2616 date value' do
+            get '/'
+            assert_equal @last_modified_time.httpdate, response['Last-Modified']
+          end
+          it 'conditional GET misses and returns a body' do
+            get '/'
+            assert_equal 200, status
+            assert_equal 'Boo!', body
+          end
+        end
+        context "when there's an invalid If-Modified-Since header" do
+          it 'sets the Last-Modified header to a valid RFC 2616 date value' do
+            get '/', {}, { 'HTTP_IF_MODIFIED_SINCE' => 'a really weird date' }
+            assert_equal @last_modified_time.httpdate, response['Last-Modified']
+          end
+          it 'conditional GET misses and returns a body' do
+            get '/', {}, { 'HTTP_IF_MODIFIED_SINCE' => 'a really weird date' }
+            assert_equal 200, status
+            assert_equal 'Boo!', body
+          end
+        end
+        context "when the resource has been modified since the If-Modified-Since header date" do
+          it 'sets the Last-Modified header to a valid RFC 2616 date value' do
+            get '/', {}, { 'HTTP_IF_MODIFIED_SINCE' => (@last_modified_time - 1).httpdate }
+            assert_equal @last_modified_time.httpdate, response['Last-Modified']
+          end
+          it 'conditional GET misses and returns a body' do
+            get '/', {}, { 'HTTP_IF_MODIFIED_SINCE' => (@last_modified_time - 1).httpdate }
+            assert_equal 200, status
+            assert_equal 'Boo!', body
+          end
+          it 'does not rely on string comparison' do
+            mock_app do
+              get '/compare' do
+                last_modified "Mon, 18 Oct 2010 20:57:11 GMT"
+                "foo"
+              end
+            end
+            get '/compare', {}, { 'HTTP_IF_MODIFIED_SINCE' => 'Sun, 26 Sep 2010 23:43:52 GMT' }
+            assert_equal 200, status
+            assert_equal 'foo', body
+            get '/compare', {}, { 'HTTP_IF_MODIFIED_SINCE' => 'Sun, 26 Sep 2030 23:43:52 GMT' }
+            assert_equal 304, status
+            assert_equal '', body
+          end
+        end
+        context "when the resource has been modified on the exact If-Modified-Since header date" do
+          it 'sets the Last-Modified header to a valid RFC 2616 date value' do
+            get '/', {}, { 'HTTP_IF_MODIFIED_SINCE' => @last_modified_time.httpdate }
+            assert_equal @last_modified_time.httpdate, response['Last-Modified']
+          end
+          it 'conditional GET matches and halts' do
+            get '/', {}, { 'HTTP_IF_MODIFIED_SINCE' => @last_modified_time.httpdate }
+            assert_equal 304, status
+            assert_equal '', body
+          end
+        end
+        context "when the resource hasn't been modified since the If-Modified-Since header date" do
+          it 'sets the Last-Modified header to a valid RFC 2616 date value' do
+            get '/', {}, { 'HTTP_IF_MODIFIED_SINCE' => (@last_modified_time + 1).httpdate }
+            assert_equal @last_modified_time.httpdate, response['Last-Modified']
+          end
+          it 'conditional GET matches and halts' do
+            get '/', {}, { 'HTTP_IF_MODIFIED_SINCE' => (@last_modified_time + 1).httpdate }
+            assert_equal 304, status
+            assert_equal '', body
+          end
+        end
+      end
+    end
+  end
+  describe 'etag' do
+    setup do
+      mock_app {
+        get '/' do
+          body { 'Hello World' }
+          etag 'FOO'
+          'Boo!'
+        end
+        post '/' do
+          etag 'FOO'
+          'Matches!'
+        end
+      }
+    end
+    it 'sets the ETag header' do
+      get '/'
+      assert_equal '"FOO"', response['ETag']
+    end
+    it 'returns a body when conditional get misses' do
+      get '/'
+      assert_equal 200, status
+      assert_equal 'Boo!', body
+    end
+    it 'returns a body when posting with no If-None-Match header' do
+      post '/'
+      assert_equal 200, status
+      assert_equal 'Matches!', body
+    end
+    it 'returns a body when conditional post matches' do
+      post '/', {}, { 'HTTP_IF_NONE_MATCH' => '"FOO"' }
+      assert_equal 200, status
+      assert_equal 'Matches!', body
+    end
+    it 'halts with 412 when conditional post misses' do
+      post '/', {}, { 'HTTP_IF_NONE_MATCH' => '"BAR"' }
+      assert_equal 412, status
+      assert_equal '', body
+    end
+    it 'halts when a conditional GET matches' do
+      get '/', {}, { 'HTTP_IF_NONE_MATCH' => '"FOO"' }
+      assert_equal 304, status
+      assert_equal '', body
+    end
+    it 'should handle multiple ETag values in If-None-Match header' do
+      get '/', {}, { 'HTTP_IF_NONE_MATCH' => '"BAR", *' }
+      assert_equal 304, status
+      assert_equal '', body
+    end
+    it 'uses a weak etag with the :weak option' do
+      mock_app {
+        get '/' do
+          etag 'FOO', :weak
+          "that's weak, dude."
+        end
+      }
+      get '/'
+      assert_equal 'W/"FOO"', response['ETag']
+    end
+    it 'raises an ArgumentError for an invalid strength' do
+      mock_app do
+        get '/' do
+          etag 'FOO', :w00t
+          "that's weak, dude."
+        end
+      end
+      assert_raise(ArgumentError) { get '/' }
+    end
+  end
+  describe 'back' do
+    it "makes redirecting back pretty" do
+      mock_app {
+        get '/foo' do
+          redirect back
+        end
+      }
+      get '/foo', {}, 'HTTP_REFERER' => 'http://github.com'
+      assert redirect?
+      assert_equal "http://github.com", response.location
+    end
+  end
+  describe 'uri' do
+    it 'generates absolute urls' do
+      mock_app { get('/') { uri }}
+      get '/'
+      assert_equal 'http://example.org/', body
+    end
+    it 'includes path_info' do
+      mock_app { get('/:name') { uri }}
+      get '/foo'
+      assert_equal 'http://example.org/foo', body
+    end
+    it 'allows passing an alternative to path_info' do
+      mock_app { get('/:name') { uri '/bar' }}
+      get '/foo'
+      assert_equal 'http://example.org/bar', body
+    end
+    it 'includes script_name' do
+      mock_app { get('/:name') { uri '/bar' }}
+      get '/foo', {}, { "SCRIPT_NAME" => '/foo' }
+      assert_equal 'http://example.org/foo/bar', body
+    end
+    it 'handles absolute URIs' do
+      mock_app { get('/') { uri 'http://google.com' }}
+      get '/'
+      assert_equal 'http://google.com', body
+    end
+    it 'handles different protocols' do
+      mock_app { get('/') { uri 'mailto:jsmith@example.com' }}
+      get '/'
+      assert_equal 'mailto:jsmith@example.com', body
+    end
+    it 'is aliased to #url' do
+      mock_app { get('/') { url }}
+      get '/'
+      assert_equal 'http://example.org/', body
+    end
+    it 'is aliased to #to' do
+      mock_app { get('/') { to }}
+      get '/'
+      assert_equal 'http://example.org/', body
+    end
+  end
+  describe 'logger' do
+    it 'logging works when logging is enabled' do
+      mock_app do
+        enable :logging
+        get '/' do
+          logger.info "Program started"
+          logger.warn "Nothing to do!"
+        end
+      end
+      io = StringIO.new
+      get '/', {}, 'rack.errors' => io
+      assert io.string.include?("INFO -- : Program started")
+      assert io.string.include?("WARN -- : Nothing to do")
+    end
+    it 'logging works when logging is disable, but no output is produced' do
+      mock_app do
+        disable :logging
+        get '/' do
+          logger.info "Program started"
+          logger.warn "Nothing to do!"
+        end
+      end
+      io = StringIO.new
+      get '/', {}, 'rack.errors' => io
+      assert !io.string.include?("INFO -- : Program started")
+      assert !io.string.include?("WARN -- : Nothing to do")
+    end
+  end
+  module ::HelperOne; def one; '1'; end; end
+  module ::HelperTwo; def two; '2'; end; end
+  describe 'Adding new helpers' do
+    it 'takes a list of modules to mix into the app' do
+      mock_app {
+        helpers ::HelperOne, ::HelperTwo
+        get '/one' do
+          one
+        end
+        get '/two' do
+          two
+        end
+      }
+      get '/one'
+      assert_equal '1', body
+      get '/two'
+      assert_equal '2', body
+    end
+    it 'takes a block to mix into the app' do
+      mock_app {
+        helpers do
+          def foo
+            'foo'
+          end
+        end
+        get '/' do
+          foo
+        end
+      }
+      get '/'
+      assert_equal 'foo', body
+    end
+    it 'evaluates the block in class context so that methods can be aliased' do
+      mock_app {
+        helpers do
+          alias_method :h, :escape_html
+        end
+        get '/' do
+          h('42 < 43')
+        end
+      }
+      get '/'
+      assert ok?
+      assert_equal '42 &lt; 43', body
+    end
+  end
+end