backlog 0.9.1 → 0.10.0

data/vendor/rails/actionpack/test/controller/content_type_test.rb

@@ -1,139 +0,0 @@
-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.view_paths = [ 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/vendor/rails/actionpack/test/controller/cookie_test.rb

@@ -1,88 +0,0 @@
-require File.dirname(__FILE__) + '/../abstract_unit'
-
-class CookieTest < Test::Unit::TestCase
-  class TestController < ActionController::Base
-    def authenticate_with_deprecated_writer
-      cookie "name" => "user_name", "value" => "david"
-    end
-
-    def authenticate
-      cookies["user_name"] = "david"
-    end
-
-    def authenticate_for_fourten_days
-      cookies["user_name"] = { "value" => "david", "expires" => Time.local(2005, 10, 10) }
-    end
-
-    def authenticate_for_fourten_days_with_symbols
-      cookies[:user_name] = { :value => "david", :expires => Time.local(2005, 10, 10) }
-    end
-
-    def set_multiple_cookies
-      cookies["user_name"] = { "value" => "david", "expires" => Time.local(2005, 10, 10) }
-      cookies["login"]     = "XJ-122"
-    end
-
-    def access_frozen_cookies
-      cookies["will"] = "work"
-    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
-    get :authenticate_with_deprecated_writer
-    assert_equal [ CGI::Cookie::new("name" => "user_name", "value" => "david") ], @response.headers["cookie"]
-  end
-
-  def test_setting_cookie
-    get :authenticate
-    assert_equal [ CGI::Cookie::new("name" => "user_name", "value" => "david") ], @response.headers["cookie"]
-  end
-
-  def test_setting_cookie_for_fourteen_days
-    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
-    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
-    get :set_multiple_cookies
-    assert_equal 2, @response.cookies.size
-  end
-
-  def test_setting_test_cookie
-    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
-end

data/vendor/rails/actionpack/test/controller/custom_handler_test.rb

@@ -1,41 +0,0 @@
-require File.dirname(__FILE__) + '/../abstract_unit'
-
-class CustomHandler
-  def initialize( view )
-    @view = view
-  end
-
-  def render( template, local_assigns )
-    [ template,
-      local_assigns,
-      @view ]
-  end
-end
-
-class CustomHandlerTest < Test::Unit::TestCase
-  def setup
-    ActionView::Base.register_template_handler "foo", CustomHandler
-    ActionView::Base.register_template_handler :foo2, CustomHandler
-    @view = ActionView::Base.new
-  end
-
-  def test_custom_render
-    result = @view.render_template( "foo", "hello <%= one %>", nil, :one => "two" )
-    assert_equal(
-      [ "hello <%= one %>", { :one => "two" }, @view ],
-      result )
-  end
-
-  def test_custom_render2
-    result = @view.render_template( "foo2", "hello <%= one %>", nil, :one => "two" )
-    assert_equal(
-      [ "hello <%= one %>", { :one => "two" }, @view ],
-      result )
-  end
-
-  def test_unhandled_extension
-    # uses the ERb handler by default if the extension isn't recognized
-    result = @view.render_template( "bar", "hello <%= one %>", nil, :one => "two" )
-    assert_equal "hello two", result
-  end
-end

data/vendor/rails/actionpack/test/controller/deprecation/deprecated_base_methods_test.rb

@@ -1,48 +0,0 @@
-require File.dirname(__FILE__) + '/../../abstract_unit'
-
-class DeprecatedBaseMethodsTest < Test::Unit::TestCase
-  class Target < ActionController::Base
-    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.view_paths = [ File.dirname(__FILE__) + "/../../fixtures" ]
-
-  def setup
-    @request    = ActionController::TestRequest.new
-    @response   = ActionController::TestResponse.new
-    @controller = Target.new
-  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/vendor/rails/actionpack/test/controller/fake_controllers.rb

@@ -1,16 +0,0 @@
-class << Object; alias_method :const_available?, :const_defined?; end
-  
-class ContentController < Class.new(ActionController::Base)
-end
-class NotAController
-end
-module Admin
-  class << self; alias_method :const_available?, :const_defined?; end
-  class UserController < Class.new(ActionController::Base); end
-  class NewsFeedController < Class.new(ActionController::Base); end
-end
-
-ActionController::Routing::Routes.draw do |map|
-  map.route_one 'route_one', :controller => 'elsewhere', :action => 'flash_me'
-  map.connect ':controller/:action/:id'
-end

data/vendor/rails/actionpack/test/controller/filter_params_test.rb

@@ -1,42 +0,0 @@
-require File.dirname(__FILE__) + '/../abstract_unit'
-
-class FilterParamController < ActionController::Base
-end
-
-class FilterParamTest < Test::Unit::TestCase
-  def setup
-    @controller = FilterParamController.new
-  end
-  
-  def test_filter_parameters
-    assert FilterParamController.respond_to?(:filter_parameter_logging)
-    assert !@controller.respond_to?(:filter_parameters)
-    
-    FilterParamController.filter_parameter_logging
-    assert @controller.respond_to?(:filter_parameters)
-    
-    test_hashes = [[{},{},[]],
-    [{'foo'=>'bar'},{'foo'=>'bar'},[]],
-    [{'foo'=>'bar'},{'foo'=>'bar'},%w'food'],
-    [{'foo'=>'bar'},{'foo'=>'[FILTERED]'},%w'foo'],
-    [{'foo'=>'bar', 'bar'=>'foo'},{'foo'=>'[FILTERED]', 'bar'=>'foo'},%w'foo baz'],
-    [{'foo'=>'bar', 'baz'=>'foo'},{'foo'=>'[FILTERED]', 'baz'=>'[FILTERED]'},%w'foo baz'],
-    [{'bar'=>{'foo'=>'bar','bar'=>'foo'}},{'bar'=>{'foo'=>'[FILTERED]','bar'=>'foo'}},%w'fo'],
-    [{'foo'=>{'foo'=>'bar','bar'=>'foo'}},{'foo'=>'[FILTERED]'},%w'f banana']]
-    
-    test_hashes.each do |before_filter, after_filter, filter_words|
-      FilterParamController.filter_parameter_logging(*filter_words)
-      assert_equal after_filter, @controller.filter_parameters(before_filter)
-      
-      filter_words.push('blah')
-      FilterParamController.filter_parameter_logging(*filter_words) do |key, value|
-        value.reverse! if key =~ /bargain/
-      end
-
-      before_filter['barg'] = {'bargain'=>'gain', 'blah'=>'bar', 'bar'=>{'bargain'=>{'blah'=>'foo'}}}
-      after_filter['barg'] = {'bargain'=>'niag', 'blah'=>'[FILTERED]', 'bar'=>{'bargain'=>{'blah'=>'[FILTERED]'}}}
-
-      assert_equal after_filter, @controller.filter_parameters(before_filter)
-    end
-  end
-end

data/vendor/rails/actionpack/test/controller/filters_test.rb

@@ -1,752 +0,0 @@
-require File.dirname(__FILE__) + '/../abstract_unit'
-
-class FilterTest < Test::Unit::TestCase
-  class TestController < ActionController::Base
-    before_filter :ensure_login
-    after_filter  :clean_up
-
-    def show
-      render :inline => "ran action"
-    end
-
-    private
-      def ensure_login
-        @ran_filter ||= []
-        @ran_filter << "ensure_login"
-      end
-
-      def clean_up
-        @ran_after_filter ||= []
-        @ran_after_filter << "clean_up"
-      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
-
-    def show
-      @ran_action = true
-      render :inline => "ran action"
-    end
-
-    private
-      def render_something_else
-        render :inline => "something else"
-      end
-  end
-
-  class ConditionalFilterController < ActionController::Base
-    def show
-      render :inline => "ran action"
-    end
-
-    def another_action
-      render :inline => "ran action"
-    end
-
-    def show_without_filter
-      render :inline => "ran action without filter"
-    end
-
-    private
-      def ensure_login
-        @ran_filter ||= []
-        @ran_filter << "ensure_login"
-      end
-
-      def clean_up_tmp
-        @ran_filter ||= []
-        @ran_filter << "clean_up_tmp"
-      end
-
-      def rescue_action(e) raise(e) end
-  end
-
-  class ConditionalCollectionFilterController < ConditionalFilterController
-    before_filter :ensure_login, :except => [ :show_without_filter, :another_action ]
-  end
-
-  class OnlyConditionSymController < ConditionalFilterController
-    before_filter :ensure_login, :only => :show
-  end
-
-  class ExceptConditionSymController < ConditionalFilterController
-    before_filter :ensure_login, :except => :show_without_filter
-  end
-
-  class BeforeAndAfterConditionController < ConditionalFilterController
-    before_filter :ensure_login, :only => :show
-    after_filter  :clean_up_tmp, :only => :show
-  end
-
-  class OnlyConditionProcController < ConditionalFilterController
-    before_filter(:only => :show) {|c| c.assigns["ran_proc_filter"] = true }
-  end
-
-  class ExceptConditionProcController < ConditionalFilterController
-    before_filter(:except => :show_without_filter) {|c| c.assigns["ran_proc_filter"] = true }
-  end
-
-  class ConditionalClassFilter
-    def self.filter(controller) controller.assigns["ran_class_filter"] = true end
-  end
-
-  class OnlyConditionClassController < ConditionalFilterController
-    before_filter ConditionalClassFilter, :only => :show
-  end
-
-  class ExceptConditionClassController < ConditionalFilterController
-    before_filter ConditionalClassFilter, :except => :show_without_filter
-  end
-
-  class AnomolousYetValidConditionController < ConditionalFilterController
-    before_filter(ConditionalClassFilter, :ensure_login, Proc.new {|c| c.assigns["ran_proc_filter1"] = true }, :except => :show_without_filter) { |c| c.assigns["ran_proc_filter2"] = true}
-  end
-
-  class EmptyFilterChainController < TestController
-    self.filter_chain.clear
-    def show
-      @action_executed = true
-      render :text => "yawp!"
-    end
-  end
-
-  class PrependingController < TestController
-    prepend_before_filter :wonderful_life
-    # skip_before_filter :fire_flash
-
-    private
-      def wonderful_life
-        @ran_filter ||= []
-        @ran_filter << "wonderful_life"
-      end
-  end
-
-  class ConditionalSkippingController < TestController
-    skip_before_filter :ensure_login, :only => [ :login ]
-    skip_after_filter  :clean_up,     :only => [ :login ]
-
-    before_filter :find_user, :only => [ :change_password ]
-
-    def login
-      render :inline => "ran action"
-    end
-
-    def change_password
-      render :inline => "ran action"
-    end
-
-    protected
-      def find_user
-        @ran_filter ||= []
-        @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]
-
-    private
-
-      def conditional_in_parent
-        @ran_filter ||= []
-        @ran_filter << 'conditional_in_parent'
-      end
-  end
-
-  class ChildOfConditionalParentController < ConditionalParentOfConditionalSkippingController
-    skip_before_filter :conditional_in_parent, :only => :another_action
-    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
-
-  class ImplicitProcController < PrependingController
-    before_filter { |c| c.assigns["ran_proc_filter"] = true }
-  end
-
-  class AuditFilter
-    def self.filter(controller)
-      controller.assigns["was_audited"] = true
-    end
-  end
-
-  class AroundFilter
-    def before(controller)
-      @execution_log = "before"
-      controller.class.execution_log << " before aroundfilter " if controller.respond_to? :execution_log
-      controller.assigns["before_ran"] = true
-    end
-
-    def after(controller)
-      controller.assigns["execution_log"] = @execution_log + " and after"
-      controller.assigns["after_ran"] = true
-      controller.class.execution_log << " after aroundfilter " if controller.respond_to? :execution_log
-    end
-  end
-
-  class AppendedAroundFilter
-    def before(controller)
-      controller.class.execution_log << " before appended aroundfilter "
-    end
-
-    def after(controller)
-      controller.class.execution_log << " after appended aroundfilter "
-    end
-  end
-
-  class AuditController < ActionController::Base
-    before_filter(AuditFilter)
-
-    def show
-      render_text "hello"
-    end
-  end
-
-  class AroundFilterController < PrependingController
-    around_filter AroundFilter.new
-  end
-
-  class BeforeAfterClassFilterController < PrependingController
-    begin
-      filter = AroundFilter.new
-      before_filter filter
-      after_filter filter
-    end
-  end
-
-  class MixedFilterController < PrependingController
-    cattr_accessor :execution_log
-
-    def initialize
-      @@execution_log = ""
-    end
-
-    before_filter { |c| c.class.execution_log << " before procfilter "  }
-    prepend_around_filter AroundFilter.new
-
-    after_filter  { |c| c.class.execution_log << " after procfilter " }
-    append_around_filter AppendedAroundFilter.new
-  end
-
-  class MixedSpecializationController < ActionController::Base
-    class OutOfOrder < StandardError; end
-
-    before_filter :first
-    before_filter :second, :only => :foo
-
-    def foo
-      render_text 'foo'
-    end
-
-    def bar
-      render_text 'bar'
-    end
-
-    protected
-      def first
-        @first = true
-      end
-
-      def second
-        raise OutOfOrder unless @first
-      end
-  end
-
-  class DynamicDispatchController < ActionController::Base
-    before_filter :choose
-
-    %w(foo bar baz).each do |action|
-      define_method(action) { render :text => action }
-    end
-
-    private
-      def choose
-        self.action_name = params[:choose]
-      end
-  end
-
-  class PrependingBeforeAndAfterController < ActionController::Base
-    prepend_before_filter :before_all
-    prepend_after_filter :after_all
-    before_filter :between_before_all_and_after_all
-
-    def before_all
-      @ran_filter ||= []
-      @ran_filter << 'before_all'
-    end
-
-    def after_all
-      @ran_filter ||= []
-      @ran_filter << 'after_all'
-    end
-
-    def between_before_all_and_after_all
-      @ran_filter ||= []
-      @ran_filter << 'between_before_all_and_after_all'
-    end
-    def show
-      render :text => 'hello'
-    end
-  end
-
-  def test_empty_filter_chain
-    assert_equal 0, EmptyFilterChainController.filter_chain.size
-    assert test_process(EmptyFilterChainController).template.assigns['action_executed']
-  end
-
-  def test_added_filter_to_inheritance_graph
-    assert_equal [ :ensure_login ], TestController.before_filters
-  end
-
-  def test_base_class_in_isolation
-    assert_equal [ ], ActionController::Base.before_filters
-  end
-
-  def test_prepending_filter
-    assert_equal [ :wonderful_life, :ensure_login ], PrependingController.before_filters
-  end
-
-  def test_running_filters
-    assert_equal %w( wonderful_life ensure_login ), test_process(PrependingController).template.assigns["ran_filter"]
-  end
-
-  def test_running_filters_with_proc
-    assert test_process(ProcController).template.assigns["ran_proc_filter"]
-  end
-
-  def test_running_filters_with_implicit_proc
-    assert test_process(ImplicitProcController).template.assigns["ran_proc_filter"]
-  end
-
-  def test_running_filters_with_class
-    assert test_process(AuditController).template.assigns["was_audited"]
-  end
-
-  def test_running_anomolous_yet_valid_condition_filters
-    response = test_process(AnomolousYetValidConditionController)
-    assert_equal %w( ensure_login ), response.template.assigns["ran_filter"]
-    assert response.template.assigns["ran_class_filter"]
-    assert response.template.assigns["ran_proc_filter1"]
-    assert response.template.assigns["ran_proc_filter2"]
-
-    response = test_process(AnomolousYetValidConditionController, "show_without_filter")
-    assert_equal nil, response.template.assigns["ran_filter"]
-    assert !response.template.assigns["ran_class_filter"]
-    assert !response.template.assigns["ran_proc_filter1"]
-    assert !response.template.assigns["ran_proc_filter2"]
-  end
-
-  def test_running_collection_condition_filters
-    assert_equal %w( ensure_login ), test_process(ConditionalCollectionFilterController).template.assigns["ran_filter"]
-    assert_equal nil, test_process(ConditionalCollectionFilterController, "show_without_filter").template.assigns["ran_filter"]
-    assert_equal nil, test_process(ConditionalCollectionFilterController, "another_action").template.assigns["ran_filter"]
-  end
-
-  def test_running_only_condition_filters
-    assert_equal %w( ensure_login ), test_process(OnlyConditionSymController).template.assigns["ran_filter"]
-    assert_equal nil, test_process(OnlyConditionSymController, "show_without_filter").template.assigns["ran_filter"]
-
-    assert test_process(OnlyConditionProcController).template.assigns["ran_proc_filter"]
-    assert !test_process(OnlyConditionProcController, "show_without_filter").template.assigns["ran_proc_filter"]
-
-    assert test_process(OnlyConditionClassController).template.assigns["ran_class_filter"]
-    assert !test_process(OnlyConditionClassController, "show_without_filter").template.assigns["ran_class_filter"]
-  end
-
-  def test_running_except_condition_filters
-    assert_equal %w( ensure_login ), test_process(ExceptConditionSymController).template.assigns["ran_filter"]
-    assert_equal nil, test_process(ExceptConditionSymController, "show_without_filter").template.assigns["ran_filter"]
-
-    assert test_process(ExceptConditionProcController).template.assigns["ran_proc_filter"]
-    assert !test_process(ExceptConditionProcController, "show_without_filter").template.assigns["ran_proc_filter"]
-
-    assert test_process(ExceptConditionClassController).template.assigns["ran_class_filter"]
-    assert !test_process(ExceptConditionClassController, "show_without_filter").template.assigns["ran_class_filter"]
-  end
-
-  def test_running_before_and_after_condition_filters
-    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
-    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_before_after_class_filter
-    controller = test_process(BeforeAfterClassFilterController)
-    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"]
-  end
-
-  def test_prepending_and_appending_around_filter
-    controller = test_process(MixedFilterController)
-    assert_equal " before aroundfilter  before procfilter  before appended aroundfilter " +
-                 " after appended aroundfilter  after aroundfilter  after procfilter ",
-                 MixedFilterController.execution_log
-  end
-
-  def test_rendering_breaks_filtering_chain
-    response = test_process(RenderingController)
-    assert_equal "something else", response.body
-    assert !response.template.assigns["ran_action"]
-  end
-
-  def test_filters_with_mixed_specialization_run_in_order
-    assert_nothing_raised do
-      response = test_process(MixedSpecializationController, 'bar')
-      assert_equal 'bar', response.body
-    end
-
-    assert_nothing_raised do
-      response = test_process(MixedSpecializationController, 'foo')
-      assert_equal 'foo', response.body
-    end
-  end
-
-  def test_dynamic_dispatch
-    %w(foo bar baz).each do |action|
-      request = ActionController::TestRequest.new
-      request.query_parameters[:choose] = action
-      response = DynamicDispatchController.process(request, ActionController::TestResponse.new)
-      assert_equal action, response.body
-    end
-  end
-
-  def test_running_prepended_before_and_after_filter
-    assert_equal 3, PrependingBeforeAndAfterController.filter_chain.length
-    response = test_process(PrependingBeforeAndAfterController)
-    assert_equal %w( before_all between_before_all_and_after_all after_all ), response.template.assigns["ran_filter"]
-  end
-
-  def test_conditional_skipping_of_filters
-    assert_nil test_process(ConditionalSkippingController, "login").template.assigns["ran_filter"]
-    assert_equal %w( ensure_login find_user ), test_process(ConditionalSkippingController, "change_password").template.assigns["ran_filter"]
-
-    assert_nil test_process(ConditionalSkippingController, "login").template.controller.instance_variable_get("@ran_after_filter")
-    assert_equal %w( clean_up ), test_process(ConditionalSkippingController, "change_password").template.controller.instance_variable_get("@ran_after_filter")
-  end
-
-  def test_conditional_skipping_of_filters_when_parent_filter_is_also_conditional
-    assert_equal %w( conditional_in_parent conditional_in_parent ), test_process(ChildOfConditionalParentController).template.assigns['ran_filter']
-    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
-      request.action = action
-      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