actionpack 1.12.5 → 1.13.0

data/test/controller/components_test.rb

@@ -46,7 +46,7 @@ end
 
 class CalleeController < ActionController::Base
   def being_called
-    render_text "#{@params["name"] || "Lady"} of the House, speaking"
+    render_text "#{params[:name] || "Lady"} of the House, speaking"
   end
   
   def blowing_up
@@ -126,4 +126,26 @@ class ComponentsTest < Test::Unit::TestCase
     
     assert_equal "Lady of the House, speaking", @response.body
   end
-end
+end
+
+module A
+  module B
+    module C
+      class NestedController < ActionController::Base
+        # Stub for uses_component_template_root
+        def self.caller
+          [ '/path/to/active_support/deprecation.rb:93:in `uses_component_template_root',
+            './test/fixtures/a/b/c/nested_controller.rb' ]
+        end
+      end
+    end
+  end
+end
+
+class UsesComponentTemplateRootTest < Test::Unit::TestCase
+  def test_uses_component_template_root
+    assert_deprecated 'uses_component_template_root' do
+      assert_equal './test/fixtures/', A::B::C::NestedController.uses_component_template_root
+    end
+  end
+end

data/test/controller/content_type_test.rb

@@ -0,0 +1,139 @@
+require File.dirname(__FILE__) + '/../abstract_unit'
+
+class ContentTypeController < ActionController::Base
+  def render_content_type_from_body
+    response.content_type = Mime::RSS
+    render :text => "hello world!"
+  end
+
+  def render_defaults
+    render :text => "hello world!"
+  end
+
+  def render_content_type_from_render
+    render :text => "hello world!", :content_type => Mime::RSS
+  end
+  
+  def render_charset_from_body
+    response.charset = "utf-16"
+    render :text => "hello world!"
+  end
+  
+  def render_default_for_rhtml
+  end
+
+  def render_default_for_rxml
+  end
+
+  def render_default_for_rjs
+  end
+
+  def render_change_for_rxml
+    response.content_type = Mime::HTML
+    render :action => "render_default_for_rxml"
+  end
+
+  def render_default_content_types_for_respond_to
+    respond_to do |format|
+      format.html { render :text   => "hello world!" }
+      format.xml  { render :action => "render_default_content_types_for_respond_to.rhtml" }
+      format.js   { render :text   => "hello world!" }
+      format.rss  { render :text   => "hello world!", :content_type => Mime::XML }
+    end
+  end
+
+  def rescue_action(e) raise end
+end
+
+ContentTypeController.template_root = File.dirname(__FILE__) + "/../fixtures/"
+
+class ContentTypeTest < Test::Unit::TestCase
+  def setup
+    @controller = ContentTypeController.new
+
+    # enable a logger so that (e.g.) the benchmarking stuff runs, so we can get
+    # a more accurate simulation of what happens in "real life".
+    @controller.logger = Logger.new(nil)
+
+    @request    = ActionController::TestRequest.new
+    @response   = ActionController::TestResponse.new
+  end
+
+  def test_render_defaults
+    get :render_defaults
+    assert_equal "utf-8", @response.charset
+    assert_equal Mime::HTML, @response.content_type
+  end
+
+  def test_render_changed_charset_default
+    ContentTypeController.default_charset = "utf-16"
+    get :render_defaults
+    assert_equal "utf-16", @response.charset    
+    assert_equal Mime::HTML, @response.content_type
+    ContentTypeController.default_charset = "utf-8"
+  end
+
+  def test_content_type_from_body
+    get :render_content_type_from_body
+    assert_equal "application/rss+xml", @response.content_type
+    assert_equal "utf-8", @response.charset    
+  end
+
+  def test_content_type_from_render
+    get :render_content_type_from_render
+    assert_equal "application/rss+xml", @response.content_type
+    assert_equal "utf-8", @response.charset    
+  end
+
+  def test_charset_from_body
+    get :render_charset_from_body
+    assert_equal "utf-16", @response.charset
+    assert_equal Mime::HTML, @response.content_type
+  end
+
+  def test_default_for_rhtml
+    get :render_default_for_rhtml
+    assert_equal Mime::HTML, @response.content_type
+    assert_equal "utf-8", @response.charset    
+  end
+
+  def test_default_for_rxml
+    get :render_default_for_rxml
+    assert_equal Mime::XML, @response.content_type
+    assert_equal "utf-8", @response.charset    
+  end
+
+  def test_default_for_rjs
+    xhr :post, :render_default_for_rjs
+    assert_equal Mime::JS, @response.content_type
+    assert_equal "utf-8", @response.charset    
+  end
+
+  def test_change_for_rxml
+    get :render_change_for_rxml
+    assert_equal Mime::HTML, @response.content_type
+    assert_equal "utf-8", @response.charset    
+  end
+  
+  def test_render_default_content_types_for_respond_to
+    @request.env["HTTP_ACCEPT"] = Mime::HTML.to_s
+    get :render_default_content_types_for_respond_to
+    assert_equal Mime::HTML, @response.content_type
+
+    @request.env["HTTP_ACCEPT"] = Mime::JS.to_s
+    get :render_default_content_types_for_respond_to
+    assert_equal Mime::JS, @response.content_type
+  end
+
+  def test_render_default_content_types_for_respond_to_with_template
+    @request.env["HTTP_ACCEPT"] = Mime::XML.to_s
+    get :render_default_content_types_for_respond_to
+    assert_equal Mime::XML, @response.content_type
+  end
+  
+  def test_render_default_content_types_for_respond_to_with_overwrite
+    @request.env["HTTP_ACCEPT"] = Mime::RSS.to_s
+    get :render_default_content_types_for_respond_to
+    assert_equal Mime::XML, @response.content_type
+  end
+end

data/test/controller/cookie_test.rb

@@ -4,77 +4,85 @@ class CookieTest < Test::Unit::TestCase
   class TestController < ActionController::Base
     def authenticate_with_deprecated_writer
       cookie "name" => "user_name", "value" => "david"
-      render_text "hello world"
     end
 
     def authenticate
       cookies["user_name"] = "david"
-      render_text "hello world"
     end
 
     def authenticate_for_fourten_days
       cookies["user_name"] = { "value" => "david", "expires" => Time.local(2005, 10, 10) }
-      render_text "hello world"
     end
 
     def authenticate_for_fourten_days_with_symbols
       cookies[:user_name] = { :value => "david", :expires => Time.local(2005, 10, 10) }
-      render_text "hello world"
     end
 
     def set_multiple_cookies
       cookies["user_name"] = { "value" => "david", "expires" => Time.local(2005, 10, 10) }
       cookies["login"]     = "XJ-122"
-      render_text "hello world"
     end
 
     def access_frozen_cookies
-      @cookies["will"] = "work"
-      render_text "hello world"
+      cookies["will"] = "work"
     end
 
-    def rescue_action(e) raise end
+    def logout
+      cookies.delete("user_name")
+    end
+
+    def rescue_action(e) 
+      raise unless ActionController::MissingTemplate # No templates here, and we don't care about the output 
+    end
   end
 
   def setup
     @request  = ActionController::TestRequest.new
     @response = ActionController::TestResponse.new
 
+    @controller = TestController.new
     @request.host = "www.nextangle.com"
   end
 
   def test_setting_cookie_with_deprecated_writer
-    @request.action = "authenticate_with_deprecated_writer"
-    assert_equal [ CGI::Cookie::new("name" => "user_name", "value" => "david") ], process_request.headers["cookie"]
+    get :authenticate_with_deprecated_writer
+    assert_equal [ CGI::Cookie::new("name" => "user_name", "value" => "david") ], @response.headers["cookie"]
   end
 
   def test_setting_cookie
-    @request.action = "authenticate"
-    assert_equal [ CGI::Cookie::new("name" => "user_name", "value" => "david") ], process_request.headers["cookie"]
+    get :authenticate
+    assert_equal [ CGI::Cookie::new("name" => "user_name", "value" => "david") ], @response.headers["cookie"]
   end
 
   def test_setting_cookie_for_fourteen_days
-    @request.action = "authenticate_for_fourten_days"
-    assert_equal [ CGI::Cookie::new("name" => "user_name", "value" => "david", "expires" => Time.local(2005, 10, 10)) ], process_request.headers["cookie"]
+    get :authenticate_for_fourten_days
+    assert_equal [ CGI::Cookie::new("name" => "user_name", "value" => "david", "expires" => Time.local(2005, 10, 10)) ], @response.headers["cookie"]
   end
 
   def test_setting_cookie_for_fourteen_days_with_symbols
-    @request.action = "authenticate_for_fourten_days"
-    assert_equal [ CGI::Cookie::new("name" => "user_name", "value" => "david", "expires" => Time.local(2005, 10, 10)) ], process_request.headers["cookie"]
+    get :authenticate_for_fourten_days
+    assert_equal [ CGI::Cookie::new("name" => "user_name", "value" => "david", "expires" => Time.local(2005, 10, 10)) ], @response.headers["cookie"]
   end
 
   def test_multiple_cookies
-    @request.action = "set_multiple_cookies"
-    assert_equal 2, process_request.headers["cookie"].size
+    get :set_multiple_cookies
+    assert_equal 2, @response.cookies.size
   end
 
   def test_setting_test_cookie
-    @request.action = "access_frozen_cookies"
-    assert_nothing_raised { process_request }
+    assert_nothing_raised { get :access_frozen_cookies }
+  end
+  
+  def test_expiring_cookie
+    get :logout
+    assert_equal [ CGI::Cookie::new("name" => "user_name", "value" => "", "expires" => Time.at(0)) ], @response.headers["cookie"]
+  end  
+  
+  def test_cookiejar_accessor
+    @request.cookies["user_name"] = CGI::Cookie.new("name" => "user_name", "value" => "david", "expires" => Time.local(2025, 10, 10))
+    @controller.request = @request
+    jar = ActionController::CookieJar.new(@controller)
+    assert_equal "david", jar["user_name"]
+    assert_equal nil, jar["something_else"]
   end
-
-  private
-    def process_request
-      TestController.process(@request, @response)
-    end
 end

data/test/controller/deprecated_instance_variables_test.rb

@@ -0,0 +1,48 @@
+require File.dirname(__FILE__) + '/../abstract_unit'
+
+class DeprecatedControllerInstanceVariablesTest < Test::Unit::TestCase
+  class Target < ActionController::Base
+    def initialize(run = nil)
+      instance_eval(run) if run
+      super()
+    end
+
+    def noop
+      render :nothing => true
+    end
+
+    ActionController::Base::DEPRECATED_INSTANCE_VARIABLES.each do |var|
+      class_eval "def old_#{var}; render :text => @#{var}.to_s end"
+      class_eval "def new_#{var}; render :text => #{var}.to_s end"
+      class_eval "def internal_#{var}; render :text => @_#{var}.to_s end"
+    end
+
+    def rescue_action(e) raise e end
+  end
+
+  def setup
+    @request    = ActionController::TestRequest.new
+    @response   = ActionController::TestResponse.new
+    @controller = Target.new
+  end
+
+  ActionController::Base::DEPRECATED_INSTANCE_VARIABLES.each do |var|
+    class_eval <<-end_eval, __FILE__, __LINE__
+      def test_old_#{var}_is_deprecated
+        assert_deprecated('@#{var}') { get :old_#{var} }
+      end
+      def test_new_#{var}_isnt_deprecated
+        assert_not_deprecated { get :new_#{var} }
+      end
+      def test_internal_#{var}_isnt_deprecated
+        assert_not_deprecated { get :internal_#{var} }
+      end
+      def test_#{var}_raises_if_already_set
+        assert_raise(RuntimeError) do
+          @controller = Target.new '@#{var} = Object.new'
+          get :noop
+        end
+      end
+    end_eval
+  end
+end

data/test/controller/deprecation/deprecated_base_methods_test.rb

@@ -0,0 +1,60 @@
+require File.dirname(__FILE__) + '/../../abstract_unit'
+
+class DeprecatedBaseMethodsTest < Test::Unit::TestCase
+  class Target < ActionController::Base
+    def deprecated_symbol_parameter_to_url_for
+      redirect_to(url_for(:home_url, "superstars"))
+    end
+    
+    def deprecated_render_parameters
+      render "fun/games/hello_world"
+    end
+    
+    def home_url(greeting)
+      "http://example.com/#{greeting}"
+    end
+
+    def raises_name_error
+      this_method_doesnt_exist
+    end
+
+    def rescue_action(e) raise e end
+  end
+
+  Target.template_root = File.dirname(__FILE__) + "/../../fixtures"
+
+  def setup
+    @request    = ActionController::TestRequest.new
+    @response   = ActionController::TestResponse.new
+    @controller = Target.new
+  end
+
+  def test_deprecated_symbol_parameter_to_url_for
+    assert_deprecated("url_for(:home_url)") do
+      get :deprecated_symbol_parameter_to_url_for
+    end
+
+    assert_redirected_to "http://example.com/superstars"
+  end
+  
+  def test_deprecated_render_parameters
+    assert_deprecated("render('fun/games/hello_world')") do
+      get :deprecated_render_parameters
+    end
+
+    assert_equal "Living in a nested world", @response.body
+  end
+
+  def test_log_error_silences_deprecation_warnings
+    get :raises_name_error
+  rescue => e
+    assert_not_deprecated { @controller.send :log_error, e }
+  end
+
+  def test_assertion_failed_error_silences_deprecation_warnings
+    get :raises_name_error
+  rescue => e
+    error = Test::Unit::Error.new('testing ur doodz', e)
+    assert_not_deprecated { error.message }
+  end
+end

data/test/controller/fake_controllers.rb

@@ -6,7 +6,6 @@ class NotAController
 end
 module Admin
   class << self; alias_method :const_available?, :const_defined?; end
-  SomeConstant = 10
   class UserController < Class.new(ActionController::Base); end
   class NewsFeedController < Class.new(ActionController::Base); end
 end

data/test/controller/filters_test.rb

@@ -21,6 +21,34 @@ class FilterTest < Test::Unit::TestCase
       end
   end
 
+  class ChangingTheRequirementsController < TestController
+    before_filter :ensure_login, :except => [:go_wild]
+
+    def go_wild
+      render :text => "gobble"
+    end
+  end
+
+  class TestMultipleFiltersController < ActionController::Base
+    before_filter :try_1
+    before_filter :try_2
+    before_filter :try_3
+
+    (1..3).each do |i|
+      define_method "fail_#{i}" do
+        render :text => i.to_s
+      end
+    end
+
+    protected
+    (1..3).each do |i|
+      define_method "try_#{i}" do
+        instance_variable_set :@try, i
+        action_name != "fail_#{i}"
+      end
+    end
+  end
+
   class RenderingController < ActionController::Base
     before_filter :render_something_else
 
@@ -134,7 +162,7 @@ class FilterTest < Test::Unit::TestCase
         @ran_filter << "find_user"
       end
   end
-  
+
   class ConditionalParentOfConditionalSkippingController < ConditionalFilterController
     before_filter :conditional_in_parent, :only => [:show, :another_action]
     after_filter  :conditional_in_parent, :only => [:show, :another_action]
@@ -152,6 +180,10 @@ class FilterTest < Test::Unit::TestCase
     skip_after_filter  :conditional_in_parent, :only => :another_action
   end
 
+  class AnotherChildOfConditionalParentController < ConditionalParentOfConditionalSkippingController
+    skip_before_filter :conditional_in_parent, :only => :show
+  end
+
   class ProcController < PrependingController
     before_filter(proc { |c| c.assigns["ran_proc_filter"] = true })
   end
@@ -198,15 +230,6 @@ class FilterTest < Test::Unit::TestCase
     end
   end
 
-  class BadFilterController < ActionController::Base
-    before_filter 2
-    
-    def show() "show" end
-    
-    protected
-      def rescue_action(e) raise(e) end
-  end
-
   class AroundFilterController < PrependingController
     around_filter AroundFilter.new
   end
@@ -336,19 +359,20 @@ class FilterTest < Test::Unit::TestCase
     assert_equal %w( ensure_login clean_up_tmp), test_process(BeforeAndAfterConditionController).template.assigns["ran_filter"]
     assert_equal nil, test_process(BeforeAndAfterConditionController, "show_without_filter").template.assigns["ran_filter"]
   end
-  
+
   def test_bad_filter
-    assert_raises(ActionController::ActionControllerError) { 
-      test_process(BadFilterController)
-    }
+    bad_filter_controller = Class.new(ActionController::Base)
+    assert_raises(ActionController::ActionControllerError) do
+      bad_filter_controller.before_filter 2
+    end
   end
-  
+
   def test_around_filter
     controller = test_process(AroundFilterController)
     assert controller.template.assigns["before_ran"]
     assert controller.template.assigns["after_ran"]
   end
- 
+
   def test_having_properties_in_around_filter
     controller = test_process(AroundFilterController)
     assert_equal "before and after", controller.template.assigns["execution_log"]
@@ -401,6 +425,16 @@ class FilterTest < Test::Unit::TestCase
     assert_nil test_process(ChildOfConditionalParentController, 'another_action').template.assigns['ran_filter']
   end
 
+  def test_condition_skipping_of_filters_when_siblings_also_have_conditions
+    assert_equal %w( conditional_in_parent conditional_in_parent ), test_process(ChildOfConditionalParentController).template.assigns['ran_filter'], "1"
+    assert_equal nil, test_process(AnotherChildOfConditionalParentController).template.assigns['ran_filter']
+    assert_equal %w( conditional_in_parent conditional_in_parent ), test_process(ChildOfConditionalParentController).template.assigns['ran_filter']
+  end
+
+  def test_changing_the_requirements
+    assert_equal nil, test_process(ChangingTheRequirementsController, "go_wild").template.assigns['ran_filter']
+  end
+
   private
     def test_process(controller, action = "show")
       request = ActionController::TestRequest.new
@@ -408,3 +442,254 @@ class FilterTest < Test::Unit::TestCase
       controller.process(request, ActionController::TestResponse.new)
     end
 end
+
+
+
+class PostsController < ActionController::Base
+  def rescue_action(e); raise e; end
+
+  module AroundExceptions
+    class Error < StandardError ; end
+    class Before < Error ; end
+    class After < Error ; end
+  end
+  include AroundExceptions
+
+  class DefaultFilter
+    include AroundExceptions
+  end
+
+  module_eval %w(raises_before raises_after raises_both no_raise no_filter).map { |action| "def #{action}; default_action end" }.join("\n")
+
+  private
+    def default_action
+      render :inline => "#{action_name} called"
+    end
+end
+
+class ControllerWithSymbolAsFilter < PostsController
+  around_filter :raise_before, :only => :raises_before
+  around_filter :raise_after, :only => :raises_after
+  around_filter :without_exception, :only => :no_raise
+
+  private
+    def raise_before
+      raise Before
+      yield
+    end
+
+    def raise_after
+      yield
+      raise After
+    end
+
+    def without_exception
+      # Do stuff...
+      1 + 1
+
+      yield
+
+      # Do stuff...
+      1 + 1
+    end
+end
+
+class ControllerWithFilterClass < PostsController
+  class YieldingFilter < DefaultFilter
+    def self.filter(controller)
+      yield
+      raise After
+    end
+  end
+
+  around_filter YieldingFilter, :only => :raises_after
+end
+
+class ControllerWithFilterInstance < PostsController
+  class YieldingFilter < DefaultFilter
+    def filter(controller)
+      yield
+      raise After
+    end
+  end
+
+  around_filter YieldingFilter.new, :only => :raises_after
+end
+
+class ControllerWithFilterMethod < PostsController
+  class YieldingFilter < DefaultFilter
+    def filter(controller)
+      yield
+      raise After
+    end
+  end
+
+  around_filter YieldingFilter.new.method(:filter), :only => :raises_after
+end
+
+class ControllerWithProcFilter < PostsController
+  around_filter(:only => :no_raise) do |c,b|
+    c.assigns['before'] = true
+    b.call
+    c.assigns['after'] = true
+  end
+end
+
+class ControllerWithWrongFilterType < PostsController
+  around_filter lambda { yield }, :only => :no_raise
+end
+
+class ControllerWithNestedFilters < ControllerWithSymbolAsFilter
+  around_filter :raise_before, :raise_after, :without_exception, :only => :raises_both
+end
+
+class ControllerWithAllTypesOfFilters < PostsController
+  before_filter :before
+  around_filter :around
+  after_filter :after
+  around_filter :around_again
+
+  private
+  def before
+    @ran_filter ||= []
+    @ran_filter << 'before'
+  end
+
+  def around
+    @ran_filter << 'around (before yield)'
+    yield
+    @ran_filter << 'around (after yield)'
+  end
+
+  def after
+    @ran_filter << 'after'
+  end
+
+  def around_again
+    @ran_filter << 'around_again (before yield)'
+    yield
+    @ran_filter << 'around_again (after yield)'
+  end
+end
+
+class ControllerWithTwoLessFilters < ControllerWithAllTypesOfFilters
+  skip_filter :around_again
+  skip_filter :after
+end
+
+class YieldingAroundFiltersTest < Test::Unit::TestCase
+  include PostsController::AroundExceptions
+
+  def test_filters_registering
+    assert_equal 1, ControllerWithFilterMethod.filter_chain.size
+    assert_equal 1, ControllerWithFilterClass.filter_chain.size
+    assert_equal 1, ControllerWithFilterInstance.filter_chain.size
+    assert_equal 3, ControllerWithSymbolAsFilter.filter_chain.size
+    assert_equal 1, ControllerWithWrongFilterType.filter_chain.size
+    assert_equal 6, ControllerWithNestedFilters.filter_chain.size
+    assert_equal 4, ControllerWithAllTypesOfFilters.filter_chain.size
+  end
+
+  def test_wrong_filter_type
+    assert_raise(ActionController::ActionControllerError) do
+      test_process(ControllerWithWrongFilterType,'no_raise')
+    end
+  end
+
+  def test_base
+    controller = PostsController
+    assert_nothing_raised { test_process(controller,'no_raise') }
+    assert_nothing_raised { test_process(controller,'raises_before') }
+    assert_nothing_raised { test_process(controller,'raises_after') }
+    assert_nothing_raised { test_process(controller,'no_filter') }
+  end
+
+  def test_with_symbol
+    controller = ControllerWithSymbolAsFilter
+    assert_nothing_raised { test_process(controller,'no_raise') }
+    assert_raise(Before) { test_process(controller,'raises_before') }
+    assert_raise(After) { test_process(controller,'raises_after') }
+    assert_nothing_raised { test_process(controller,'no_raise') }
+  end
+
+  def test_with_class
+    controller = ControllerWithFilterClass
+    assert_nothing_raised { test_process(controller,'no_raise') }
+    assert_raise(After) { test_process(controller,'raises_after') }
+  end
+
+  def test_with_instance
+    controller = ControllerWithFilterInstance
+    assert_nothing_raised { test_process(controller,'no_raise') }
+    assert_raise(After) { test_process(controller,'raises_after') }
+  end
+
+  def test_with_method
+    controller = ControllerWithFilterMethod
+    assert_nothing_raised { test_process(controller,'no_raise') }
+    assert_raise(After) { test_process(controller,'raises_after') }
+  end
+
+  def test_with_proc
+    controller = test_process(ControllerWithProcFilter,'no_raise')
+    assert controller.template.assigns['before']
+    assert controller.template.assigns['after']
+  end
+
+  def test_nested_filters
+    controller = ControllerWithNestedFilters
+    assert_nothing_raised do
+      begin
+        test_process(controller,'raises_both')
+      rescue Before, After
+      end
+    end
+    assert_raise Before do
+      begin
+        test_process(controller,'raises_both')
+      rescue After
+      end
+    end
+  end
+
+  def test_filter_order_with_all_filter_types
+    controller = test_process(ControllerWithAllTypesOfFilters,'no_raise')
+    assert_equal 'before around (before yield) around_again (before yield) around_again (after yield) around (after yield) after',controller.template.assigns['ran_filter'].join(' ')
+  end
+
+  def test_filter_order_with_skip_filter_method
+    controller = test_process(ControllerWithTwoLessFilters,'no_raise')
+    assert_equal 'before around (before yield) around (after yield)',controller.template.assigns['ran_filter'].join(' ')
+  end
+
+  def test_first_filter_in_multiple_before_filter_chain_halts
+    controller = ::FilterTest::TestMultipleFiltersController.new
+    response = test_process(controller, 'fail_1')
+    assert_equal '', response.body
+    assert_equal 1, controller.instance_variable_get(:@try)
+    assert controller.instance_variable_get(:@before_filter_chain_aborted)
+  end
+
+  def test_second_filter_in_multiple_before_filter_chain_halts
+    controller = ::FilterTest::TestMultipleFiltersController.new
+    response = test_process(controller, 'fail_2')
+    assert_equal '', response.body
+    assert_equal 2, controller.instance_variable_get(:@try)
+    assert controller.instance_variable_get(:@before_filter_chain_aborted)
+  end
+
+  def test_last_filter_in_multiple_before_filter_chain_halts
+    controller = ::FilterTest::TestMultipleFiltersController.new
+    response = test_process(controller, 'fail_3')
+    assert_equal '', response.body
+    assert_equal 3, controller.instance_variable_get(:@try)
+    assert controller.instance_variable_get(:@before_filter_chain_aborted)
+  end
+
+  protected
+    def test_process(controller, action = "show")
+      request = ActionController::TestRequest.new
+      request.action = action
+      controller.process(request, ActionController::TestResponse.new)
+    end
+end