vibes-bj 1.2.1

data/spec/rails_root/vendor/rails/actionpack/test/controller/cookie_test.rb

@@ -0,0 +1,146 @@
+require 'abstract_unit'
+
+class CookieTest < Test::Unit::TestCase
+  class TestController < ActionController::Base
+    def authenticate
+      cookies["user_name"] = "david"
+    end
+
+    def authenticate_for_fourteen_days
+      cookies["user_name"] = { "value" => "david", "expires" => Time.local(2005, 10, 10) }
+    end
+
+    def authenticate_for_fourteen_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 delete_cookie_with_path
+      cookies.delete("user_name", :path => '/beaten')
+      render :text => "hello world"
+    end
+
+    def authenticate_with_http_only
+      cookies["user_name"] = { :value => "david", :http_only => true }
+    end
+
+    def rescue_action(e) 
+      raise unless ActionView::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
+    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_fourteen_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_fourteen_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_with_http_only
+    get :authenticate_with_http_only
+    assert_equal [ CGI::Cookie::new("name" => "user_name", "value" => "david", "http_only" => true) ], @response.headers["cookie"]
+    assert_equal CGI::Cookie::new("name" => "user_name", "value" => "david", "path" => "/", "http_only" => true).to_s, @response.headers["cookie"][0].to_s
+  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"]
+    assert_equal CGI::Cookie::new("name" => "user_name", "value" => "", "expires" => Time.at(0)).value, []
+  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
+
+  def test_cookiejar_accessor_with_array_value
+    a = %w{1 2 3}
+    @request.cookies["pages"] = CGI::Cookie.new("name" => "pages", "value" => a, "expires" => Time.local(2025, 10, 10))
+    @controller.request = @request
+    jar = ActionController::CookieJar.new(@controller)
+    assert_equal a, jar["pages"]
+  end
+  
+  def test_delete_cookie_with_path
+    get :delete_cookie_with_path
+    assert_equal "/beaten", @response.headers["cookie"].first.path
+    assert_not_equal "/", @response.headers["cookie"].first.path
+  end
+
+  def test_cookie_to_s_simple_values
+    assert_equal 'myname=myvalue; path=', CGI::Cookie.new('myname', 'myvalue').to_s
+  end
+
+  def test_cookie_to_s_hash
+    cookie_str = CGI::Cookie.new(
+      'name' => 'myname',
+      'value' => 'myvalue',
+      'domain' => 'mydomain',
+      'path' => 'mypath',
+      'expires' => Time.utc(2007, 10, 20),
+      'secure' => true,
+      'http_only' => true).to_s
+    assert_equal 'myname=myvalue; domain=mydomain; path=mypath; expires=Sat, 20 Oct 2007 00:00:00 GMT; secure; HttpOnly', cookie_str
+  end
+
+  def test_cookie_to_s_hash_default_not_secure_not_http_only
+    cookie_str = CGI::Cookie.new(
+      'name' => 'myname',
+      'value' => 'myvalue',
+      'domain' => 'mydomain',
+      'path' => 'mypath',
+      'expires' => Time.utc(2007, 10, 20))
+    assert cookie_str !~ /secure/
+    assert cookie_str !~ /HttpOnly/
+  end
+
+  def test_cookies_should_not_be_split_on_ampersand_values
+    cookies = CGI::Cookie.parse('return_to=http://rubyonrails.org/search?term=api&scope=all&global=true')
+    assert_equal({"return_to" => ["http://rubyonrails.org/search?term=api&scope=all&global=true"]}, cookies)
+  end
+
+  def test_cookies_should_not_be_split_on_values_with_newlines
+    cookies = CGI::Cookie.new("name" => "val", "value" => "this\nis\na\ntest")
+    assert cookies.size == 1
+  end
+end

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

@@ -0,0 +1,45 @@
+require 'abstract_unit'
+
+class CustomHandler < ActionView::TemplateHandler
+  def initialize( view )
+    @view = view
+  end
+
+  def render( template )
+    [ template.source,
+      template.locals,
+      @view ]
+  end
+end
+
+class CustomHandlerTest < Test::Unit::TestCase
+  def setup
+    ActionView::Template.register_template_handler "foo", CustomHandler
+    ActionView::Template.register_template_handler :foo2, CustomHandler
+    @view = ActionView::Base.new
+  end
+
+  def test_custom_render
+    template = ActionView::InlineTemplate.new(@view, "hello <%= one %>", { :one => "two" }, "foo")
+
+    result = @view.render_template(template)
+    assert_equal(
+      [ "hello <%= one %>", { :one => "two" }, @view ],
+      result )
+  end
+
+  def test_custom_render2
+    template = ActionView::InlineTemplate.new(@view, "hello <%= one %>", { :one => "two" }, "foo2")
+    result = @view.render_template(template)
+    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
+    template = ActionView::InlineTemplate.new(@view, "hello <%= one %>", { :one => "two" }, "bar")
+    result = @view.render_template(template)
+    assert_equal "hello two", result
+  end
+end

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

@@ -0,0 +1,37 @@
+require 'abstract_unit'
+
+class DeprecatedBaseMethodsTest < Test::Unit::TestCase
+  class Target < ActionController::Base
+    
+    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_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/spec/rails_root/vendor/rails/actionpack/test/controller/dispatcher_test.rb

@@ -0,0 +1,105 @@
+require 'abstract_unit'
+
+uses_mocha 'dispatcher tests' do
+
+require 'action_controller/dispatcher'
+
+class DispatcherTest < Test::Unit::TestCase
+  Dispatcher = ActionController::Dispatcher
+
+  def setup
+    @output = StringIO.new
+    ENV['REQUEST_METHOD'] = 'GET'
+
+    # Clear callbacks as they are redefined by Dispatcher#define_dispatcher_callbacks
+    Dispatcher.instance_variable_set("@prepare_dispatch_callbacks", ActiveSupport::Callbacks::CallbackChain.new)
+    Dispatcher.instance_variable_set("@before_dispatch_callbacks", ActiveSupport::Callbacks::CallbackChain.new)
+    Dispatcher.instance_variable_set("@after_dispatch_callbacks", ActiveSupport::Callbacks::CallbackChain.new)
+
+    Dispatcher.stubs(:require_dependency)
+
+    @dispatcher = Dispatcher.new(@output)
+  end
+
+  def teardown
+    ENV.delete 'REQUEST_METHOD'
+  end
+
+  def test_clears_dependencies_after_dispatch_if_in_loading_mode
+    ActionController::Routing::Routes.expects(:reload).once
+    Dependencies.expects(:clear).once
+
+    dispatch(@output, false)
+  end
+
+  def test_leaves_dependencies_after_dispatch_if_not_in_loading_mode
+    ActionController::Routing::Routes.expects(:reload).never
+    Dependencies.expects(:clear).never
+
+    dispatch
+  end
+
+  # Stub out dispatch error logger
+  class << Dispatcher
+    def log_failsafe_exception(status, exception); end
+  end
+
+  def test_failsafe_response
+    CGI.expects(:new).raises('some multipart parsing failure')
+    Dispatcher.expects(:log_failsafe_exception)
+
+    assert_nothing_raised { dispatch }
+
+    assert_equal "Status: 400 Bad Request\r\nContent-Type: text/html\r\n\r\n<html><body><h1>400 Bad Request</h1></body></html>", @output.string
+  end
+
+  def test_prepare_callbacks
+    a = b = c = nil
+    Dispatcher.to_prepare { |*args| a = b = c = 1 }
+    Dispatcher.to_prepare { |*args| b = c = 2 }
+    Dispatcher.to_prepare { |*args| c = 3 }
+
+    # Ensure to_prepare callbacks are not run when defined
+    assert_nil a || b || c
+
+    # Run callbacks
+    @dispatcher.send :run_callbacks, :prepare_dispatch
+
+    assert_equal 1, a
+    assert_equal 2, b
+    assert_equal 3, c
+
+    # Make sure they are only run once
+    a = b = c = nil
+    @dispatcher.send :dispatch
+    assert_nil a || b || c
+  end
+
+  def test_to_prepare_with_identifier_replaces
+    a = b = nil
+    Dispatcher.to_prepare(:unique_id) { |*args| a = b = 1 }
+    Dispatcher.to_prepare(:unique_id) { |*args| a = 2 }
+
+    @dispatcher.send :run_callbacks, :prepare_dispatch
+    assert_equal 2, a
+    assert_equal nil, b
+  end
+
+  private
+    def dispatch(output = @output, cache_classes = true)
+      controller = mock
+      controller.stubs(:process).returns(controller)
+      controller.stubs(:out).with(output).returns('response')
+
+      ActionController::Routing::Routes.stubs(:recognize).returns(controller)
+
+      Dispatcher.define_dispatcher_callbacks(cache_classes)
+      Dispatcher.dispatch(nil, {}, output)
+    end
+
+    def assert_subclasses(howmany, klass, message = klass.subclasses.inspect)
+      assert_equal howmany, klass.subclasses.size, message
+    end
+end
+
+end

data/spec/rails_root/vendor/rails/actionpack/test/controller/fake_controllers.rb

@@ -0,0 +1,33 @@
+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
+
+# For speed test
+class SpeedController < ActionController::Base;  end
+class SearchController        < SpeedController; end
+class VideosController        < SpeedController; end
+class VideoFileController     < SpeedController; end
+class VideoSharesController   < SpeedController; end
+class VideoAbusesController   < SpeedController; end
+class VideoUploadsController  < SpeedController; end
+class VideoVisitsController   < SpeedController; end
+class UsersController         < SpeedController; end
+class SettingsController      < SpeedController; end
+class ChannelsController      < SpeedController; end
+class ChannelVideosController < SpeedController; end
+class SessionsController      < SpeedController; end
+class LostPasswordsController < SpeedController; end
+class PagesController         < SpeedController; end
+
+ActionController::Routing::Routes.draw do |map|
+  map.route_one 'route_one', :controller => 'elsewhere', :action => 'flash_me'
+  map.connect ':controller/:action/:id'
+end

data/spec/rails_root/vendor/rails/actionpack/test/controller/fake_models.rb

@@ -0,0 +1,11 @@
+class Customer < Struct.new(:name, :id)
+  def to_param
+    id.to_s
+  end
+end
+
+class BadCustomer < Customer
+end
+
+class GoodCustomer < Customer
+end

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

@@ -0,0 +1,49 @@
+require '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'=>nil},{'foo'=>nil},[]],
+    [{'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.send!(: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.send!(:filter_parameters, before_filter)
+    end
+  end
+
+  def test_filter_parameters_is_protected
+    FilterParamController.filter_parameter_logging(:foo)
+    assert !FilterParamController.action_methods.include?('filter_parameters')
+    assert_raise(NoMethodError) { @controller.filter_parameters([{'password' => '[FILTERED]'}]) }
+  end
+end

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

@@ -0,0 +1,881 @@
+require 'abstract_unit'
+
+# FIXME: crashes Ruby 1.9
+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
+        if action_name == "fail_#{i}"
+          head(404)
+        end
+      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 ConditionalOptionsFilter < ConditionalFilterController
+    before_filter :ensure_login, :if => Proc.new { |c| true }
+    before_filter :clean_up_tmp, :if => Proc.new { |c| false }
+  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 SkippingAndLimitedController < TestController
+    skip_before_filter :ensure_login
+    before_filter :ensure_login, :only => :index
+
+    def index
+      render :text => 'ok'
+    end
+    
+    def public
+    end
+  end
+  
+  class SkippingAndReorderingController < TestController
+    skip_before_filter :ensure_login
+    before_filter :find_record
+    before_filter :ensure_login
+
+    private
+      def find_record
+        @ran_filter ||= []
+        @ran_filter << "find_record"
+      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
+
+  class ErrorToRescue < Exception; end
+
+  class RescuingAroundFilterWithBlock
+    def filter(controller)
+      begin
+        yield
+      rescue ErrorToRescue => ex
+        controller.send! :render, :text => "I rescued this: #{ex.inspect}"
+      end
+    end
+  end
+
+  class RescuedController < ActionController::Base
+    around_filter RescuingAroundFilterWithBlock.new
+
+    def show
+      raise ErrorToRescue.new("Something made the bad noise.")
+    end
+
+  private
+    def rescue_action(exception)
+      raise exception
+    end
+  end
+
+  class NonYieldingAroundFilterController < ActionController::Base
+
+    before_filter :filter_one
+    around_filter :non_yielding_filter
+    before_filter :filter_two
+    after_filter :filter_three
+
+    def index
+      render :inline => "index"
+    end
+
+    #make sure the controller complains
+    def rescue_action(e); raise e; end
+
+    private
+
+      def filter_one
+        @filters  ||= []
+        @filters  << "filter_one"
+      end
+
+      def filter_two
+        @filters  << "filter_two"
+      end
+
+      def non_yielding_filter
+        @filters  << "zomg it didn't yield"
+        @filter_return_value
+      end
+
+      def filter_three
+        @filters  << "filter_three"
+      end
+
+  end
+
+  def test_non_yielding_around_filters_not_returning_false_do_not_raise
+    controller = NonYieldingAroundFilterController.new
+    controller.instance_variable_set "@filter_return_value", true
+    assert_nothing_raised do
+      test_process(controller, "index")
+    end
+  end
+
+  def test_non_yielding_around_filters_returning_false_do_not_raise
+    controller = NonYieldingAroundFilterController.new
+    controller.instance_variable_set "@filter_return_value", false
+    assert_nothing_raised do
+      test_process(controller, "index")
+    end
+  end
+
+  def test_after_filters_are_not_run_if_around_filter_returns_false
+    controller = NonYieldingAroundFilterController.new
+    controller.instance_variable_set "@filter_return_value", false
+    test_process(controller, "index")
+    assert_equal ["filter_one", "zomg it didn't yield"], controller.assigns['filters']
+  end
+
+  def test_after_filters_are_not_run_if_around_filter_does_not_yield
+    controller = NonYieldingAroundFilterController.new
+    controller.instance_variable_set "@filter_return_value", true
+    test_process(controller, "index")
+    assert_equal ["filter_one", "zomg it didn't yield"], controller.assigns['filters']
+  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_conditional_options
+    response = test_process(ConditionalOptionsFilter)
+    assert_equal %w( ensure_login ), response.template.assigns["ran_filter"]
+  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_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_skipping_and_limiting_controller
+    assert_equal %w( ensure_login ), test_process(SkippingAndLimitedController, "index").template.assigns["ran_filter"]
+    assert_nil test_process(SkippingAndLimitedController, "public").template.assigns["ran_filter"]
+  end
+
+  def test_skipping_and_reordering_controller
+    assert_equal %w( find_record ensure_login ), test_process(SkippingAndReorderingController, "index").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
+
+  def test_a_rescuing_around_filter
+    response = nil
+    assert_nothing_raised do
+      response = test_process(RescuedController)
+    end
+
+    assert response.success?
+    assert_equal("I rescued this: #<FilterTest::ErrorToRescue: Something made the bad noise.>", response.body)
+  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 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 6, ControllerWithNestedFilters.filter_chain.size
+    assert_equal 4, ControllerWithAllTypesOfFilters.filter_chain.size
+  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