actionpack-rack-upgrade-2 2.3.15

data/test/controller/translation_test.rb

@@ -0,0 +1,26 @@
+require 'abstract_unit'
+
+# class TranslatingController < ActionController::Base
+# end
+
+class TranslationControllerTest < Test::Unit::TestCase
+  def setup
+    @controller = ActionController::Base.new
+  end
+  
+  def test_action_controller_base_responds_to_translate
+    assert @controller.respond_to?(:translate)
+  end
+  
+  def test_action_controller_base_responds_to_t
+    assert @controller.respond_to?(:t)
+  end
+  
+  def test_action_controller_base_responds_to_localize
+    assert @controller.respond_to?(:localize)
+  end
+  
+  def test_action_controller_base_responds_to_l
+    assert @controller.respond_to?(:l)
+  end
+end

data/test/controller/url_rewriter_test.rb

@@ -0,0 +1,395 @@
+require 'abstract_unit'
+
+ActionController::UrlRewriter
+
+class UrlRewriterTests < ActionController::TestCase
+  def setup
+    @request = ActionController::TestRequest.new
+    @params = {}
+    @rewriter = ActionController::UrlRewriter.new(@request, @params)
+  end
+
+  def test_port
+    assert_equal('http://test.host:1271/c/a/i',
+      @rewriter.rewrite(:controller => 'c', :action => 'a', :id => 'i', :port => 1271)
+    )
+  end
+
+  def test_protocol_with_and_without_separator
+    assert_equal('https://test.host/c/a/i',
+      @rewriter.rewrite(:protocol => 'https', :controller => 'c', :action => 'a', :id => 'i')
+    )
+
+    assert_equal('https://test.host/c/a/i',
+      @rewriter.rewrite(:protocol => 'https://', :controller => 'c', :action => 'a', :id => 'i')
+    )
+  end
+
+  def test_user_name_and_password
+    assert_equal(
+      'http://david:secret@test.host/c/a/i',
+      @rewriter.rewrite(:user => "david", :password => "secret", :controller => 'c', :action => 'a', :id => 'i')
+    )
+  end
+
+  def test_user_name_and_password_with_escape_codes
+    assert_equal(
+      'http://openid.aol.com%2Fnextangler:one+two%3F@test.host/c/a/i',
+      @rewriter.rewrite(:user => "openid.aol.com/nextangler", :password => "one two?", :controller => 'c', :action => 'a', :id => 'i')
+    )
+  end
+
+  def test_anchor
+    assert_equal(
+      'http://test.host/c/a/i#anchor',
+      @rewriter.rewrite(:controller => 'c', :action => 'a', :id => 'i', :anchor => 'anchor')
+    )
+  end
+
+  def test_anchor_should_call_to_param
+    assert_equal(
+      'http://test.host/c/a/i#anchor',
+      @rewriter.rewrite(:controller => 'c', :action => 'a', :id => 'i', :anchor => Struct.new(:to_param).new('anchor'))
+    )
+  end
+
+  def test_anchor_should_be_cgi_escaped
+    assert_equal(
+      'http://test.host/c/a/i#anc%2Fhor',
+      @rewriter.rewrite(:controller => 'c', :action => 'a', :id => 'i', :anchor => Struct.new(:to_param).new('anc/hor'))
+    )
+  end
+
+  def test_overwrite_params
+    @params[:controller] = 'hi'
+    @params[:action] = 'bye'
+    @params[:id] = '2'
+
+    assert_deprecated /overwrite_params/ do
+      assert_equal '/hi/hi/2', @rewriter.rewrite(:only_path => true, :overwrite_params => {:action => 'hi'})
+      u = @rewriter.rewrite(:only_path => false, :overwrite_params => {:action => 'hi'})
+      assert_match %r(/hi/hi/2$), u
+    end
+  end
+
+  def test_overwrite_removes_original
+    @params[:controller] = 'search'
+    @params[:action] = 'list'
+    @params[:list_page] = 1
+
+    assert_deprecated /overwrite_params/ do
+      assert_equal '/search/list?list_page=2', @rewriter.rewrite(:only_path => true, :overwrite_params => {"list_page" => 2})
+      u = @rewriter.rewrite(:only_path => false, :overwrite_params => {:list_page => 2})
+      assert_equal 'http://test.host/search/list?list_page=2', u
+    end
+  end
+
+  def test_to_str
+    @params[:controller] = 'hi'
+    @params[:action] = 'bye'
+    @request.parameters[:id] = '2'
+
+    assert_equal 'http://, test.host, /, hi, bye, {"id"=>"2"}', @rewriter.to_str
+  end
+
+  def test_trailing_slash
+    options = {:controller => 'foo', :action => 'bar', :id => '3', :only_path => true}
+    assert_equal '/foo/bar/3', @rewriter.rewrite(options)
+    assert_equal '/foo/bar/3?query=string', @rewriter.rewrite(options.merge({:query => 'string'}))
+    options.update({:trailing_slash => true})
+    assert_equal '/foo/bar/3/', @rewriter.rewrite(options)
+    options.update({:query => 'string'})
+    assert_equal '/foo/bar/3/?query=string', @rewriter.rewrite(options)
+  end
+end
+
+class UrlWriterTests < ActionController::TestCase
+  class W
+    include ActionController::UrlWriter
+  end
+
+  def teardown
+    W.default_url_options.clear
+  end
+
+  def add_host!
+    W.default_url_options[:host] = 'www.basecamphq.com'
+  end
+
+  def test_exception_is_thrown_without_host
+    assert_raise RuntimeError do
+      W.new.url_for :controller => 'c', :action => 'a', :id => 'i'
+    end
+  end
+
+  def test_anchor
+    assert_equal('/c/a#anchor',
+      W.new.url_for(:only_path => true, :controller => 'c', :action => 'a', :anchor => 'anchor')
+    )
+  end
+
+  def test_anchor_should_call_to_param
+    assert_equal('/c/a#anchor',
+      W.new.url_for(:only_path => true, :controller => 'c', :action => 'a', :anchor => Struct.new(:to_param).new('anchor'))
+    )
+  end
+
+  def test_anchor_should_escape_unsafe_pchar
+    assert_equal('/c/a#%23anchor',
+      W.new.url_for(:only_path => true, :controller => 'c', :action => 'a', :anchor => Struct.new(:to_param).new('#anchor'))
+    )
+  end
+
+  def test_anchor_should_not_escape_safe_pchar
+    assert_equal('/c/a#name=user&email=user@domain.com',
+      W.new.url_for(:only_path => true, :controller => 'c', :action => 'a', :anchor => Struct.new(:to_param).new('name=user&email=user@domain.com'))
+    )
+  end
+
+  def test_default_host
+    add_host!
+    assert_equal('http://www.basecamphq.com/c/a/i',
+      W.new.url_for(:controller => 'c', :action => 'a', :id => 'i')
+    )
+  end
+
+  def test_host_may_be_overridden
+    add_host!
+    assert_equal('http://37signals.basecamphq.com/c/a/i',
+      W.new.url_for(:host => '37signals.basecamphq.com', :controller => 'c', :action => 'a', :id => 'i')
+    )
+  end
+
+  def test_port
+    add_host!
+    assert_equal('http://www.basecamphq.com:3000/c/a/i',
+      W.new.url_for(:controller => 'c', :action => 'a', :id => 'i', :port => 3000)
+    )
+  end
+
+  def test_protocol
+    add_host!
+    assert_equal('https://www.basecamphq.com/c/a/i',
+      W.new.url_for(:controller => 'c', :action => 'a', :id => 'i', :protocol => 'https')
+    )
+  end
+
+  def test_protocol_with_and_without_separator
+    add_host!
+    assert_equal('https://www.basecamphq.com/c/a/i',
+      W.new.url_for(:controller => 'c', :action => 'a', :id => 'i', :protocol => 'https')
+    )
+    assert_equal('https://www.basecamphq.com/c/a/i',
+      W.new.url_for(:controller => 'c', :action => 'a', :id => 'i', :protocol => 'https://')
+    )
+  end
+
+  def test_trailing_slash
+    add_host!
+    options = {:controller => 'foo', :trailing_slash => true, :action => 'bar', :id => '33'}
+    assert_equal('http://www.basecamphq.com/foo/bar/33/', W.new.url_for(options) )
+  end
+
+  def test_trailing_slash_with_protocol
+    add_host!
+    options = { :trailing_slash => true,:protocol => 'https', :controller => 'foo', :action => 'bar', :id => '33'}
+    assert_equal('https://www.basecamphq.com/foo/bar/33/', W.new.url_for(options) )
+    assert_equal 'https://www.basecamphq.com/foo/bar/33/?query=string', W.new.url_for(options.merge({:query => 'string'}))
+  end
+
+  def test_trailing_slash_with_only_path
+    options = {:controller => 'foo', :trailing_slash => true}
+    assert_equal '/foo/', W.new.url_for(options.merge({:only_path => true}))
+    options.update({:action => 'bar', :id => '33'})
+    assert_equal '/foo/bar/33/', W.new.url_for(options.merge({:only_path => true}))
+    assert_equal '/foo/bar/33/?query=string', W.new.url_for(options.merge({:query => 'string',:only_path => true}))
+  end
+
+  def test_trailing_slash_with_anchor
+    options = {:trailing_slash => true, :controller => 'foo', :action => 'bar', :id => '33', :only_path => true, :anchor=> 'chapter7'}
+    assert_equal '/foo/bar/33/#chapter7', W.new.url_for(options)
+    assert_equal '/foo/bar/33/?query=string#chapter7', W.new.url_for(options.merge({:query => 'string'}))
+  end
+
+  def test_trailing_slash_with_params
+    url = W.new.url_for(:trailing_slash => true, :only_path => true, :controller => 'cont', :action => 'act', :p1 => 'cafe', :p2 => 'link')
+    params = extract_params(url)
+    assert_equal params[0], { :p1 => 'cafe' }.to_query
+    assert_equal params[1], { :p2 => 'link' }.to_query
+  end
+
+  def test_relative_url_root_is_respected
+    orig_relative_url_root = ActionController::Base.relative_url_root
+    ActionController::Base.relative_url_root = '/subdir'
+
+    add_host!
+    assert_equal('https://www.basecamphq.com/subdir/c/a/i',
+      W.new.url_for(:controller => 'c', :action => 'a', :id => 'i', :protocol => 'https')
+    )
+  ensure
+    ActionController::Base.relative_url_root = orig_relative_url_root
+  end
+
+  def test_named_routes
+    ActionController::Routing::Routes.draw do |map|
+      map.no_args '/this/is/verbose', :controller => 'home', :action => 'index'
+      map.home '/home/sweet/home/:user', :controller => 'home', :action => 'index'
+      map.connect ':controller/:action/:id'
+    end
+
+    # We need to create a new class in order to install the new named route.
+    kls = Class.new { include ActionController::UrlWriter }
+    controller = kls.new
+    assert controller.respond_to?(:home_url)
+    assert_equal 'http://www.basecamphq.com/home/sweet/home/again',
+      controller.send(:home_url, :host => 'www.basecamphq.com', :user => 'again')
+
+    assert_equal("/home/sweet/home/alabama", controller.send(:home_path, :user => 'alabama', :host => 'unused'))
+    assert_equal("http://www.basecamphq.com/home/sweet/home/alabama", controller.send(:home_url, :user => 'alabama', :host => 'www.basecamphq.com'))
+    assert_equal("http://www.basecamphq.com/this/is/verbose", controller.send(:no_args_url, :host=>'www.basecamphq.com'))
+  ensure
+    ActionController::Routing::Routes.load!
+  end
+
+  def test_relative_url_root_is_respected_for_named_routes
+    orig_relative_url_root = ActionController::Base.relative_url_root
+    ActionController::Base.relative_url_root = '/subdir'
+
+    ActionController::Routing::Routes.draw do |map|
+      map.home '/home/sweet/home/:user', :controller => 'home', :action => 'index'
+    end
+
+    kls = Class.new { include ActionController::UrlWriter }
+    controller = kls.new
+
+    assert_equal 'http://www.basecamphq.com/subdir/home/sweet/home/again',
+      controller.send(:home_url, :host => 'www.basecamphq.com', :user => 'again')
+  ensure
+    ActionController::Routing::Routes.load!
+    ActionController::Base.relative_url_root = orig_relative_url_root
+  end
+
+  def test_only_path
+    ActionController::Routing::Routes.draw do |map|
+      map.home '/home/sweet/home/:user', :controller => 'home', :action => 'index'
+      map.connect ':controller/:action/:id'
+    end
+
+    # We need to create a new class in order to install the new named route.
+    kls = Class.new { include ActionController::UrlWriter }
+    controller = kls.new
+    assert controller.respond_to?(:home_url)
+    assert_equal '/brave/new/world',
+      controller.send(:url_for, :controller => 'brave', :action => 'new', :id => 'world', :only_path => true)
+
+    assert_equal("/home/sweet/home/alabama", controller.send(:home_url, :user => 'alabama', :host => 'unused', :only_path => true))
+    assert_equal("/home/sweet/home/alabama", controller.send(:home_path, 'alabama'))
+  ensure
+    ActionController::Routing::Routes.load!
+  end
+
+  def test_one_parameter
+    assert_equal('/c/a?param=val',
+      W.new.url_for(:only_path => true, :controller => 'c', :action => 'a', :param => 'val')
+    )
+  end
+
+  def test_two_parameters
+    url = W.new.url_for(:only_path => true, :controller => 'c', :action => 'a', :p1 => 'X1', :p2 => 'Y2')
+    params = extract_params(url)
+    assert_equal params[0], { :p1 => 'X1' }.to_query
+    assert_equal params[1], { :p2 => 'Y2' }.to_query
+  end
+
+  def test_hash_parameter
+    url = W.new.url_for(:only_path => true, :controller => 'c', :action => 'a', :query => {:name => 'Bob', :category => 'prof'})
+    params = extract_params(url)
+    assert_equal params[0], { 'query[category]' => 'prof' }.to_query
+    assert_equal params[1], { 'query[name]'     => 'Bob'  }.to_query
+  end
+
+  def test_array_parameter
+    url = W.new.url_for(:only_path => true, :controller => 'c', :action => 'a', :query => ['Bob', 'prof'])
+    params = extract_params(url)
+    assert_equal params[0], { 'query[]' => 'Bob'  }.to_query
+    assert_equal params[1], { 'query[]' => 'prof' }.to_query
+  end
+
+  def test_hash_recursive_parameters
+    url = W.new.url_for(:only_path => true, :controller => 'c', :action => 'a', :query => {:person => {:name => 'Bob', :position => 'prof'}, :hobby => 'piercing'})
+    params = extract_params(url)
+    assert_equal params[0], { 'query[hobby]'            => 'piercing' }.to_query
+    assert_equal params[1], { 'query[person][name]'     => 'Bob'      }.to_query
+    assert_equal params[2], { 'query[person][position]' => 'prof'     }.to_query
+  end
+
+  def test_hash_recursive_and_array_parameters
+    url = W.new.url_for(:only_path => true, :controller => 'c', :action => 'a', :id => 101, :query => {:person => {:name => 'Bob', :position => ['prof', 'art director']}, :hobby => 'piercing'})
+    assert_match %r(^/c/a/101), url
+    params = extract_params(url)
+    assert_equal params[0], { 'query[hobby]'              => 'piercing'     }.to_query
+    assert_equal params[1], { 'query[person][name]'       => 'Bob'          }.to_query
+    assert_equal params[2], { 'query[person][position][]' => 'prof'         }.to_query
+    assert_equal params[3], { 'query[person][position][]' => 'art director' }.to_query
+  end
+
+  def test_path_generation_for_symbol_parameter_keys
+    assert_generates("/image", :controller=> :image)
+  end
+
+  def test_named_routes_with_nil_keys
+    ActionController::Routing::Routes.clear!
+    ActionController::Routing::Routes.draw do |map|
+      map.main '', :controller => 'posts', :format => nil
+      map.resources :posts
+      map.connect ':controller/:action/:id'
+    end
+    # We need to create a new class in order to install the new named route.
+    kls = Class.new { include ActionController::UrlWriter }
+    kls.default_url_options[:host] = 'www.basecamphq.com'
+
+    controller = kls.new
+    params = {:action => :index, :controller => :posts, :format => :xml}
+    assert_equal("http://www.basecamphq.com/posts.xml", controller.send(:url_for, params))
+    params[:format] = nil
+    assert_equal("http://www.basecamphq.com/", controller.send(:url_for, params))
+  ensure
+    ActionController::Routing::Routes.load!
+  end
+
+  def test_formatted_url_methods_are_deprecated
+    ActionController::Routing::Routes.draw do |map|
+      map.resources :posts
+    end
+    # We need to create a new class in order to install the new named route.
+    kls = Class.new { include ActionController::UrlWriter }
+    controller = kls.new
+    params = {:id => 1, :format => :xml}
+    assert_deprecated do
+      assert_equal("/posts/1.xml", controller.send(:formatted_post_path, params))    
+    end
+    assert_deprecated do
+      assert_equal("/posts/1.xml", controller.send(:formatted_post_path, 1, :xml))    
+    end
+  ensure
+    ActionController::Routing::Routes.load!
+  end
+
+  def test_multiple_includes_maintain_distinct_options
+    first_class = Class.new { include ActionController::UrlWriter }
+    second_class = Class.new { include ActionController::UrlWriter }
+
+    first_host, second_host = 'firsthost.com', 'secondhost.com'
+
+    first_class.default_url_options[:host] = first_host
+    second_class.default_url_options[:host] = second_host
+
+    assert_equal first_class.default_url_options[:host], first_host
+    assert_equal second_class.default_url_options[:host], second_host
+  end
+
+  private
+    def extract_params(url)
+      url.split('?', 2).last.split('&')
+    end
+end

data/test/controller/verification_test.rb

@@ -0,0 +1,270 @@
+require 'abstract_unit'
+
+class VerificationTest < ActionController::TestCase
+  class TestController < ActionController::Base
+    verify :only => :guarded_one, :params => "one",
+           :add_flash => { :error => 'unguarded' },
+           :redirect_to => { :action => "unguarded" }
+
+    verify :only => :guarded_two, :params => %w( one two ),
+           :redirect_to => { :action => "unguarded" }
+
+    verify :only => :guarded_with_flash, :params => "one",
+           :add_flash => { :notice => "prereqs failed" },
+           :redirect_to => { :action => "unguarded" }
+
+    verify :only => :guarded_in_session, :session => "one",
+           :redirect_to => { :action => "unguarded" }
+
+    verify :only => [:multi_one, :multi_two], :session => %w( one two ),
+           :redirect_to => { :action => "unguarded" }
+
+    verify :only => :guarded_by_method, :method => :post,
+           :redirect_to => { :action => "unguarded" }
+
+    verify :only => :guarded_by_xhr, :xhr => true,
+           :redirect_to => { :action => "unguarded" }
+
+    verify :only => :guarded_by_not_xhr, :xhr => false,
+           :redirect_to => { :action => "unguarded" }
+
+    before_filter :unconditional_redirect, :only => :two_redirects
+    verify :only => :two_redirects, :method => :post,
+           :redirect_to => { :action => "unguarded" }
+
+    verify :only => :must_be_post, :method => :post, :render => { :status => 405, :text => "Must be post" }, :add_headers => { "Allow" => "POST" }
+
+    verify :only => :guarded_one_for_named_route_test, :params => "one",
+           :redirect_to => :foo_url
+
+    verify :only => :no_default_action, :params => "santa"
+
+    verify :only => :guarded_with_back, :method => :post,
+           :redirect_to => :back
+
+    def guarded_one
+      render :text => "#{params[:one]}"
+    end
+
+    def guarded_one_for_named_route_test
+      render :text => "#{params[:one]}"
+    end
+
+    def guarded_with_flash
+      render :text => "#{params[:one]}"
+    end
+
+    def guarded_two
+      render :text => "#{params[:one]}:#{params[:two]}"
+    end
+
+    def guarded_in_session
+      render :text => "#{session["one"]}"
+    end
+
+    def multi_one
+      render :text => "#{session["one"]}:#{session["two"]}"
+    end
+
+    def multi_two
+      render :text => "#{session["two"]}:#{session["one"]}"
+    end
+
+    def guarded_by_method
+      render :text => "#{request.method}"
+    end
+
+    def guarded_by_xhr
+      render :text => "#{request.xhr?}"
+    end
+
+    def guarded_by_not_xhr
+      render :text => "#{request.xhr?}"
+    end
+
+    def unguarded
+      render :text => "#{params[:one]}"
+    end
+
+    def two_redirects
+      render :nothing => true
+    end
+
+    def must_be_post
+      render :text => "Was a post!"
+    end
+
+    def guarded_with_back
+      render :text => "#{params[:one]}"
+    end
+
+    def no_default_action
+      # Will never run
+    end
+
+    protected
+      def rescue_action(e) raise end
+
+      def unconditional_redirect
+        redirect_to :action => "unguarded"
+      end
+  end
+
+  def setup
+    @controller = TestController.new
+    @request    = ActionController::TestRequest.new
+    @response   = ActionController::TestResponse.new
+    ActionController::Routing::Routes.add_named_route :foo, '/foo', :controller => 'test', :action => 'foo'
+  end
+
+  def test_using_symbol_back_with_no_referrer
+    assert_raise(ActionController::RedirectBackError) { get :guarded_with_back }
+  end
+
+  def test_using_symbol_back_redirects_to_referrer
+    @request.env["HTTP_REFERER"] = "/foo"
+    get :guarded_with_back
+    assert_redirected_to '/foo'
+  end
+
+  def test_no_deprecation_warning_for_named_route
+    assert_not_deprecated do
+      get :guarded_one_for_named_route_test, :two => "not one"
+      assert_redirected_to '/foo'
+    end
+  end
+
+  def test_guarded_one_with_prereqs
+    get :guarded_one, :one => "here"
+    assert_equal "here", @response.body
+  end
+
+  def test_guarded_one_without_prereqs
+    get :guarded_one
+    assert_redirected_to :action => "unguarded"
+    assert_equal 'unguarded', flash[:error]
+  end
+
+  def test_guarded_with_flash_with_prereqs
+    get :guarded_with_flash, :one => "here"
+    assert_equal "here", @response.body
+    assert flash.empty?
+  end
+
+  def test_guarded_with_flash_without_prereqs
+    get :guarded_with_flash
+    assert_redirected_to :action => "unguarded"
+    assert_equal "prereqs failed", flash[:notice]
+  end
+
+  def test_guarded_two_with_prereqs
+    get :guarded_two, :one => "here", :two => "there"
+    assert_equal "here:there", @response.body
+  end
+
+  def test_guarded_two_without_prereqs_one
+    get :guarded_two, :two => "there"
+    assert_redirected_to :action => "unguarded"
+  end
+
+  def test_guarded_two_without_prereqs_two
+    get :guarded_two, :one => "here"
+    assert_redirected_to :action => "unguarded"
+  end
+
+  def test_guarded_two_without_prereqs_both
+    get :guarded_two
+    assert_redirected_to :action => "unguarded"
+  end
+
+  def test_unguarded_with_params
+    get :unguarded, :one => "here"
+    assert_equal "here", @response.body
+  end
+
+  def test_unguarded_without_params
+    get :unguarded
+    assert_equal "", @response.body
+  end
+
+  def test_guarded_in_session_with_prereqs
+    get :guarded_in_session, {}, "one" => "here"
+    assert_equal "here", @response.body
+  end
+
+  def test_guarded_in_session_without_prereqs
+    get :guarded_in_session
+    assert_redirected_to :action => "unguarded"
+  end
+
+  def test_multi_one_with_prereqs
+    get :multi_one, {}, "one" => "here", "two" => "there"
+    assert_equal "here:there", @response.body
+  end
+
+  def test_multi_one_without_prereqs
+    get :multi_one
+    assert_redirected_to :action => "unguarded"
+  end
+
+  def test_multi_two_with_prereqs
+    get :multi_two, {}, "one" => "here", "two" => "there"
+    assert_equal "there:here", @response.body
+  end
+
+  def test_multi_two_without_prereqs
+    get :multi_two
+    assert_redirected_to :action => "unguarded"
+  end
+
+  def test_guarded_by_method_with_prereqs
+    post :guarded_by_method
+    assert_equal "post", @response.body
+  end
+
+  def test_guarded_by_method_without_prereqs
+    get :guarded_by_method
+    assert_redirected_to :action => "unguarded"
+  end
+
+  def test_guarded_by_xhr_with_prereqs
+    xhr :post, :guarded_by_xhr
+    assert_equal "true", @response.body
+  end
+
+  def test_guarded_by_xhr_without_prereqs
+    get :guarded_by_xhr
+    assert_redirected_to :action => "unguarded"
+  end
+
+  def test_guarded_by_not_xhr_with_prereqs
+    get :guarded_by_not_xhr
+    assert_equal "false", @response.body
+  end
+
+  def test_guarded_by_not_xhr_without_prereqs
+    xhr :post, :guarded_by_not_xhr
+    assert_redirected_to :action => "unguarded"
+  end
+
+  def test_guarded_post_and_calls_render_succeeds
+    post :must_be_post
+    assert_equal "Was a post!", @response.body
+  end
+
+  def test_default_failure_should_be_a_bad_request
+    post :no_default_action
+    assert_response :bad_request
+  end
+
+  def test_guarded_post_and_calls_render_fails_and_sets_allow_header
+    get :must_be_post
+    assert_response 405
+    assert_equal "Must be post", @response.body
+    assert_equal "POST", @response.headers["Allow"]
+  end
+
+  def test_second_redirect
+    assert_nothing_raised { get :two_redirects }
+  end
+end