jets 1.4.11 → 1.5.0

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

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+class OldContentTypeController < ActionController::Base
+  # :ported:
+  def render_content_type_from_body
+    response.content_type = Mime[:rss]
+    render body: "hello world!"
+  end
+
+  # :ported:
+  def render_defaults
+    render body: "hello world!"
+  end
+
+  # :ported:
+  def render_content_type_from_render
+    render body: "hello world!", content_type: Mime[:rss]
+  end
+
+  # :ported:
+  def render_charset_from_body
+    response.charset = "utf-16"
+    render body: "hello world!"
+  end
+
+  # :ported:
+  def render_nil_charset_from_body
+    response.charset = nil
+    render body: "hello world!"
+  end
+
+  def render_default_for_erb
+  end
+
+  def render_default_for_builder
+  end
+
+  def render_change_for_builder
+    response.content_type = Mime[:html]
+    render action: "render_default_for_builder"
+  end
+
+  def render_default_content_types_for_respond_to
+    respond_to do |format|
+      format.html { render body: "hello world!" }
+      format.xml  { render action: "render_default_content_types_for_respond_to" }
+      format.js   { render body: "hello world!" }
+      format.rss  { render body: "hello world!", content_type: Mime[:xml] }
+    end
+  end
+end
+
+class ContentTypeTest < ActionController::TestCase
+  tests OldContentTypeController
+
+  def setup
+    super
+    # 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 = ActiveSupport::Logger.new(nil)
+  end
+
+  # :ported:
+  def test_render_defaults
+    get :render_defaults
+    assert_equal "utf-8", @response.charset
+    assert_equal Mime[:text], @response.content_type
+  end
+
+  def test_render_changed_charset_default
+    with_default_charset "utf-16" do
+      get :render_defaults
+      assert_equal "utf-16", @response.charset
+      assert_equal Mime[:text], @response.content_type
+    end
+  end
+
+  # :ported:
+  def test_content_type_from_body
+    get :render_content_type_from_body
+    assert_equal Mime[:rss], @response.content_type
+    assert_equal "utf-8", @response.charset
+  end
+
+  # :ported:
+  def test_content_type_from_render
+    get :render_content_type_from_render
+    assert_equal Mime[:rss], @response.content_type
+    assert_equal "utf-8", @response.charset
+  end
+
+  # :ported:
+  def test_charset_from_body
+    get :render_charset_from_body
+    assert_equal Mime[:text], @response.content_type
+    assert_equal "utf-16", @response.charset
+  end
+
+  # :ported:
+  def test_nil_charset_from_body
+    get :render_nil_charset_from_body
+    assert_equal Mime[:text], @response.content_type
+    assert_equal "utf-8", @response.charset, @response.headers.inspect
+  end
+
+  def test_nil_default_for_erb
+    with_default_charset nil do
+      get :render_default_for_erb
+      assert_equal Mime[:html], @response.content_type
+      assert_nil @response.charset, @response.headers.inspect
+    end
+  end
+
+  def test_default_for_erb
+    get :render_default_for_erb
+    assert_equal Mime[:html], @response.content_type
+    assert_equal "utf-8", @response.charset
+  end
+
+  def test_default_for_builder
+    get :render_default_for_builder
+    assert_equal Mime[:xml], @response.content_type
+    assert_equal "utf-8", @response.charset
+  end
+
+  def test_change_for_builder
+    get :render_change_for_builder
+    assert_equal Mime[:html], @response.content_type
+    assert_equal "utf-8", @response.charset
+  end
+
+  private
+
+    def with_default_charset(charset)
+      old_default_charset = ActionDispatch::Response.default_charset
+      ActionDispatch::Response.default_charset = charset
+      yield
+    ensure
+      ActionDispatch::Response.default_charset = old_default_charset
+    end
+end
+
+class AcceptBasedContentTypeTest < ActionController::TestCase
+  tests OldContentTypeController
+
+  def test_render_default_content_types_for_respond_to
+    @request.accept = Mime[:html].to_s
+    get :render_default_content_types_for_respond_to
+    assert_equal Mime[:html], @response.content_type
+
+    @request.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.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.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/default_url_options_with_before_action_test.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+class ControllerWithBeforeActionAndDefaultUrlOptions < ActionController::Base
+  before_action { I18n.locale = params[:locale] }
+  after_action { I18n.locale = "en" }
+
+  def target
+    render plain: "final response"
+  end
+
+  def redirect
+    redirect_to action: "target"
+  end
+
+  def default_url_options
+    { locale: "de" }
+  end
+end
+
+class ControllerWithBeforeActionAndDefaultUrlOptionsTest < ActionController::TestCase
+  # This test has its roots in issue #1872
+  test "should redirect with correct locale :de" do
+    get :redirect, params: { locale: "de" }
+    assert_redirected_to "/controller_with_before_action_and_default_url_options/target?locale=de"
+  end
+end

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

@@ -0,0 +1,1050 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+class ActionController::Base
+  class << self
+    %w(append_around_action prepend_after_action prepend_around_action prepend_before_action skip_after_action skip_before_action).each do |pending|
+      define_method(pending) do |*args|
+        $stderr.puts "#{pending} unimplemented: #{args.inspect}"
+      end unless method_defined?(pending)
+    end
+
+    def before_actions
+      filters = _process_action_callbacks.select { |c| c.kind == :before }
+      filters.map!(&:raw_filter)
+    end
+  end
+end
+
+class FilterTest < ActionController::TestCase
+  class TestController < ActionController::Base
+    before_action :ensure_login
+    after_action  :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_action ||= []
+        @ran_after_action << "clean_up"
+      end
+  end
+
+  class ChangingTheRequirementsController < TestController
+    before_action :ensure_login, except: [:go_wild]
+
+    def go_wild
+      render plain: "gobble"
+    end
+  end
+
+  class TestMultipleFiltersController < ActionController::Base
+    before_action :try_1
+    before_action :try_2
+    before_action :try_3
+
+    (1..3).each do |i|
+      define_method "fail_#{i}" do
+        render plain: i.to_s
+      end
+    end
+
+    private
+      (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_action :before_action_rendering
+    after_action :unreached_after_action
+
+    def show
+      @ran_action = true
+      render inline: "ran action"
+    end
+
+    private
+      def before_action_rendering
+        @ran_filter ||= []
+        @ran_filter << "before_action_rendering"
+        render inline: "something else"
+      end
+
+      def unreached_after_action
+        @ran_filter << "unreached_after_action_after_render"
+      end
+  end
+
+  class RenderingForPrependAfterActionController < RenderingController
+    prepend_after_action :unreached_prepend_after_action
+
+    private
+      def unreached_prepend_after_action
+        @ran_filter << "unreached_preprend_after_action_after_render"
+      end
+  end
+
+  class BeforeActionRedirectionController < ActionController::Base
+    before_action :before_action_redirects
+    after_action :unreached_after_action
+
+    def show
+      @ran_action = true
+      render inline: "ran show action"
+    end
+
+    def target_of_redirection
+      @ran_target_of_redirection = true
+      render inline: "ran target_of_redirection action"
+    end
+
+    private
+      def before_action_redirects
+        @ran_filter ||= []
+        @ran_filter << "before_action_redirects"
+        redirect_to(action: "target_of_redirection")
+      end
+
+      def unreached_after_action
+        @ran_filter << "unreached_after_action_after_redirection"
+      end
+  end
+
+  class BeforeActionRedirectionForPrependAfterActionController < BeforeActionRedirectionController
+    prepend_after_action :unreached_prepend_after_action_after_redirection
+
+    private
+      def unreached_prepend_after_action_after_redirection
+        @ran_filter << "unreached_prepend_after_action_after_redirection"
+      end
+  end
+
+  class ConditionalFilterController < ActionController::Base
+    def show
+      render inline: "ran action"
+    end
+
+    def another_action
+      render inline: "ran action"
+    end
+
+    def show_without_action
+      render inline: "ran action without action"
+    end
+
+    private
+      def ensure_login
+        @ran_filter ||= []
+        @ran_filter << "ensure_login"
+      end
+
+      def clean_up_tmp
+        @ran_filter ||= []
+        @ran_filter << "clean_up_tmp"
+      end
+  end
+
+  class ConditionalCollectionFilterController < ConditionalFilterController
+    before_action :ensure_login, except: [ :show_without_action, :another_action ]
+  end
+
+  class OnlyConditionSymController < ConditionalFilterController
+    before_action :ensure_login, only: :show
+  end
+
+  class ExceptConditionSymController < ConditionalFilterController
+    before_action :ensure_login, except: :show_without_action
+  end
+
+  class BeforeAndAfterConditionController < ConditionalFilterController
+    before_action :ensure_login, only: :show
+    after_action  :clean_up_tmp, only: :show
+  end
+
+  class OnlyConditionProcController < ConditionalFilterController
+    before_action(only: :show) { |c| c.instance_variable_set(:"@ran_proc_action", true) }
+  end
+
+  class ExceptConditionProcController < ConditionalFilterController
+    before_action(except: :show_without_action) { |c| c.instance_variable_set(:"@ran_proc_action", true) }
+  end
+
+  class ConditionalClassFilter
+    def self.before(controller) controller.instance_variable_set(:"@ran_class_action", true) end
+  end
+
+  class OnlyConditionClassController < ConditionalFilterController
+    before_action ConditionalClassFilter, only: :show
+  end
+
+  class ExceptConditionClassController < ConditionalFilterController
+    before_action ConditionalClassFilter, except: :show_without_action
+  end
+
+  class AnomolousYetValidConditionController < ConditionalFilterController
+    before_action(ConditionalClassFilter, :ensure_login, Proc.new { |c| c.instance_variable_set(:"@ran_proc_action1", true) }, except: :show_without_action) { |c| c.instance_variable_set(:"@ran_proc_action2", true) }
+  end
+
+  class OnlyConditionalOptionsFilter < ConditionalFilterController
+    before_action :ensure_login, only: :index, if: Proc.new { |c| c.instance_variable_set(:"@ran_conditional_index_proc", true) }
+  end
+
+  class ConditionalOptionsFilter < ConditionalFilterController
+    before_action :ensure_login, if: Proc.new { |c| true }
+    before_action :clean_up_tmp, if: Proc.new { |c| false }
+  end
+
+  class ConditionalOptionsSkipFilter < ConditionalFilterController
+    before_action :ensure_login
+    before_action :clean_up_tmp
+
+    skip_before_action :ensure_login, if: -> { false }
+    skip_before_action :clean_up_tmp, if: -> { true }
+  end
+
+  class SkipFilterUsingOnlyAndIf < ConditionalFilterController
+    before_action :clean_up_tmp
+    before_action :ensure_login
+
+    skip_before_action :ensure_login, only: :login, if: -> { false }
+    skip_before_action :clean_up_tmp, only: :login, if: -> { true }
+
+    def login
+      render plain: "ok"
+    end
+  end
+
+  class SkipFilterUsingIfAndExcept < ConditionalFilterController
+    before_action :clean_up_tmp
+    before_action :ensure_login
+
+    skip_before_action :ensure_login, if: -> { false }, except: :login
+    skip_before_action :clean_up_tmp, if: -> { true }, except: :login
+
+    def login
+      render plain: "ok"
+    end
+  end
+
+  class ClassController < ConditionalFilterController
+    before_action ConditionalClassFilter
+  end
+
+  class PrependingController < TestController
+    prepend_before_action :wonderful_life
+    # skip_before_action :fire_flash
+
+    private
+      def wonderful_life
+        @ran_filter ||= []
+        @ran_filter << "wonderful_life"
+      end
+  end
+
+  class SkippingAndLimitedController < TestController
+    skip_before_action :ensure_login
+    before_action :ensure_login, only: :index
+
+    def index
+      render plain: "ok"
+    end
+
+    def public
+      render plain: "ok"
+    end
+  end
+
+  class SkippingAndReorderingController < TestController
+    skip_before_action :ensure_login
+    before_action :find_record
+    before_action :ensure_login
+
+    def index
+      render plain: "ok"
+    end
+
+    private
+      def find_record
+        @ran_filter ||= []
+        @ran_filter << "find_record"
+      end
+  end
+
+  class ConditionalSkippingController < TestController
+    skip_before_action :ensure_login, only: [ :login ]
+    skip_after_action  :clean_up,     only: [ :login ]
+
+    before_action :find_user, only: [ :change_password ]
+
+    def login
+      render inline: "ran action"
+    end
+
+    def change_password
+      render inline: "ran action"
+    end
+
+    private
+      def find_user
+        @ran_filter ||= []
+        @ran_filter << "find_user"
+      end
+  end
+
+  class ConditionalParentOfConditionalSkippingController < ConditionalFilterController
+    before_action :conditional_in_parent_before, only: [:show, :another_action]
+    after_action  :conditional_in_parent_after, only: [:show, :another_action]
+
+    private
+
+      def conditional_in_parent_before
+        @ran_filter ||= []
+        @ran_filter << "conditional_in_parent_before"
+      end
+
+      def conditional_in_parent_after
+        @ran_filter ||= []
+        @ran_filter << "conditional_in_parent_after"
+      end
+  end
+
+  class ChildOfConditionalParentController < ConditionalParentOfConditionalSkippingController
+    skip_before_action :conditional_in_parent_before, only: :another_action
+    skip_after_action  :conditional_in_parent_after, only: :another_action
+  end
+
+  class AnotherChildOfConditionalParentController < ConditionalParentOfConditionalSkippingController
+    skip_before_action :conditional_in_parent_before, only: :show
+  end
+
+  class ProcController < PrependingController
+    before_action(proc { |c| c.instance_variable_set(:"@ran_proc_action", true) })
+  end
+
+  class ImplicitProcController < PrependingController
+    before_action { |c| c.instance_variable_set(:"@ran_proc_action", true) }
+  end
+
+  class AuditFilter
+    def self.before(controller)
+      controller.instance_variable_set(:"@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.instance_variable_set(:"@before_ran", true)
+    end
+
+    def after(controller)
+      controller.instance_variable_set(:"@execution_log", @execution_log + " and after")
+      controller.instance_variable_set(:"@after_ran", true)
+      controller.class.execution_log << " after aroundfilter " if controller.respond_to? :execution_log
+    end
+
+    def around(controller)
+      before(controller)
+      yield
+      after(controller)
+    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
+
+    def around(controller)
+      before(controller)
+      yield
+      after(controller)
+    end
+  end
+
+  class AuditController < ActionController::Base
+    before_action(AuditFilter)
+
+    def show
+      render plain: "hello"
+    end
+  end
+
+  class AroundFilterController < PrependingController
+    around_action AroundFilter.new
+  end
+
+  class BeforeAfterClassFilterController < PrependingController
+    begin
+      filter = AroundFilter.new
+      before_action filter
+      after_action filter
+    end
+  end
+
+  class MixedFilterController < PrependingController
+    cattr_accessor :execution_log
+
+    def initialize
+      @@execution_log = ""
+      super()
+    end
+
+    before_action { |c| c.class.execution_log << " before procfilter "  }
+    prepend_around_action AroundFilter.new
+
+    after_action  { |c| c.class.execution_log << " after procfilter " }
+    append_around_action AppendedAroundFilter.new
+  end
+
+  class MixedSpecializationController < ActionController::Base
+    class OutOfOrder < StandardError; end
+
+    before_action :first
+    before_action :second, only: :foo
+
+    def foo
+      render plain: "foo"
+    end
+
+    def bar
+      render plain: "bar"
+    end
+
+    private
+      def first
+        @first = true
+      end
+
+      def second
+        raise OutOfOrder unless @first
+      end
+  end
+
+  class DynamicDispatchController < ActionController::Base
+    before_action :choose
+
+    %w(foo bar baz).each do |action|
+      define_method(action) { render plain: action }
+    end
+
+    private
+      def choose
+        self.action_name = params[:choose]
+      end
+  end
+
+  class PrependingBeforeAndAfterController < ActionController::Base
+    prepend_before_action :before_all
+    prepend_after_action :after_all
+    before_action :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 plain: "hello"
+    end
+  end
+
+  class ErrorToRescue < Exception; end
+
+  class RescuingAroundFilterWithBlock
+    def around(controller)
+      yield
+    rescue ErrorToRescue => ex
+      controller.__send__ :render, plain: "I rescued this: #{ex.inspect}"
+    end
+  end
+
+  class RescuedController < ActionController::Base
+    around_action RescuingAroundFilterWithBlock.new
+
+    def show
+      raise ErrorToRescue.new("Something made the bad noise.")
+    end
+  end
+
+  class NonYieldingAroundFilterController < ActionController::Base
+    before_action :filter_one
+    around_action :non_yielding_action
+    before_action :action_two
+    after_action :action_three
+
+    def index
+      render inline: "index"
+    end
+
+    private
+
+      def filter_one
+        @filters ||= []
+        @filters << "filter_one"
+      end
+
+      def action_two
+        @filters << "action_two"
+      end
+
+      def non_yielding_action
+        @filters << "it didn't yield"
+      end
+
+      def action_three
+        @filters << "action_three"
+      end
+  end
+
+  class ImplicitActionsController < ActionController::Base
+    before_action :find_only, only: :edit
+    before_action :find_except, except: :edit
+
+    private
+
+      def find_only
+        @only = "Only"
+      end
+
+      def find_except
+        @except = "Except"
+      end
+  end
+
+  def test_non_yielding_around_actions_do_not_raise
+    controller = NonYieldingAroundFilterController.new
+    assert_nothing_raised do
+      test_process(controller, "index")
+    end
+  end
+
+  def test_after_actions_are_not_run_if_around_action_does_not_yield
+    controller = NonYieldingAroundFilterController.new
+    test_process(controller, "index")
+    assert_equal ["filter_one", "it didn't yield"], controller.instance_variable_get(:@filters)
+  end
+
+  def test_added_action_to_inheritance_graph
+    assert_equal [ :ensure_login ], TestController.before_actions
+  end
+
+  def test_base_class_in_isolation
+    assert_equal [ ], ActionController::Base.before_actions
+  end
+
+  def test_prepending_action
+    assert_equal [ :wonderful_life, :ensure_login ], PrependingController.before_actions
+  end
+
+  def test_running_actions
+    test_process(PrependingController)
+    assert_equal %w( wonderful_life ensure_login ),
+      @controller.instance_variable_get(:@ran_filter)
+  end
+
+  def test_running_actions_with_proc
+    test_process(ProcController)
+    assert @controller.instance_variable_get(:@ran_proc_action)
+  end
+
+  def test_running_actions_with_implicit_proc
+    test_process(ImplicitProcController)
+    assert @controller.instance_variable_get(:@ran_proc_action)
+  end
+
+  def test_running_actions_with_class
+    test_process(AuditController)
+    assert @controller.instance_variable_get(:@was_audited)
+  end
+
+  def test_running_anomalous_yet_valid_condition_actions
+    test_process(AnomolousYetValidConditionController)
+    assert_equal %w( ensure_login ), @controller.instance_variable_get(:@ran_filter)
+    assert @controller.instance_variable_get(:@ran_class_action)
+    assert @controller.instance_variable_get(:@ran_proc_action1)
+    assert @controller.instance_variable_get(:@ran_proc_action2)
+
+    test_process(AnomolousYetValidConditionController, "show_without_action")
+    assert_not @controller.instance_variable_defined?(:@ran_filter)
+    assert_not @controller.instance_variable_defined?(:@ran_class_action)
+    assert_not @controller.instance_variable_defined?(:@ran_proc_action1)
+    assert_not @controller.instance_variable_defined?(:@ran_proc_action2)
+  end
+
+  def test_running_conditional_options
+    test_process(ConditionalOptionsFilter)
+    assert_equal %w( ensure_login ), @controller.instance_variable_get(:@ran_filter)
+  end
+
+  def test_running_conditional_skip_options
+    test_process(ConditionalOptionsSkipFilter)
+    assert_equal %w( ensure_login ), @controller.instance_variable_get(:@ran_filter)
+  end
+
+  def test_if_is_ignored_when_used_with_only
+    test_process(SkipFilterUsingOnlyAndIf, "login")
+    assert_not @controller.instance_variable_defined?(:@ran_filter)
+  end
+
+  def test_except_is_ignored_when_used_with_if
+    test_process(SkipFilterUsingIfAndExcept, "login")
+    assert_equal %w(ensure_login), @controller.instance_variable_get(:@ran_filter)
+  end
+
+  def test_skipping_class_actions
+    test_process(ClassController)
+    assert_equal true, @controller.instance_variable_get(:@ran_class_action)
+
+    skipping_class_controller = Class.new(ClassController) do
+      skip_before_action ConditionalClassFilter
+    end
+
+    test_process(skipping_class_controller)
+    assert_not @controller.instance_variable_defined?(:@ran_class_action)
+  end
+
+  def test_running_collection_condition_actions
+    test_process(ConditionalCollectionFilterController)
+    assert_equal %w( ensure_login ), @controller.instance_variable_get(:@ran_filter)
+    test_process(ConditionalCollectionFilterController, "show_without_action")
+    assert_not @controller.instance_variable_defined?(:@ran_filter)
+    test_process(ConditionalCollectionFilterController, "another_action")
+    assert_not @controller.instance_variable_defined?(:@ran_filter)
+  end
+
+  def test_running_only_condition_actions
+    test_process(OnlyConditionSymController)
+    assert_equal %w( ensure_login ), @controller.instance_variable_get(:@ran_filter)
+    test_process(OnlyConditionSymController, "show_without_action")
+    assert_not @controller.instance_variable_defined?(:@ran_filter)
+
+    test_process(OnlyConditionProcController)
+    assert @controller.instance_variable_get(:@ran_proc_action)
+    test_process(OnlyConditionProcController, "show_without_action")
+    assert_not @controller.instance_variable_defined?(:@ran_proc_action)
+
+    test_process(OnlyConditionClassController)
+    assert @controller.instance_variable_get(:@ran_class_action)
+    test_process(OnlyConditionClassController, "show_without_action")
+    assert_not @controller.instance_variable_defined?(:@ran_class_action)
+  end
+
+  def test_running_except_condition_actions
+    test_process(ExceptConditionSymController)
+    assert_equal %w( ensure_login ), @controller.instance_variable_get(:@ran_filter)
+    test_process(ExceptConditionSymController, "show_without_action")
+    assert_not @controller.instance_variable_defined?(:@ran_filter)
+
+    test_process(ExceptConditionProcController)
+    assert @controller.instance_variable_get(:@ran_proc_action)
+    test_process(ExceptConditionProcController, "show_without_action")
+    assert_not @controller.instance_variable_defined?(:@ran_proc_action)
+
+    test_process(ExceptConditionClassController)
+    assert @controller.instance_variable_get(:@ran_class_action)
+    test_process(ExceptConditionClassController, "show_without_action")
+    assert_not @controller.instance_variable_defined?(:@ran_class_action)
+  end
+
+  def test_running_only_condition_and_conditional_options
+    test_process(OnlyConditionalOptionsFilter, "show")
+    assert_not @controller.instance_variable_defined?(:@ran_conditional_index_proc)
+  end
+
+  def test_running_before_and_after_condition_actions
+    test_process(BeforeAndAfterConditionController)
+    assert_equal %w( ensure_login clean_up_tmp), @controller.instance_variable_get(:@ran_filter)
+    test_process(BeforeAndAfterConditionController, "show_without_action")
+    assert_not @controller.instance_variable_defined?(:@ran_filter)
+  end
+
+  def test_around_action
+    test_process(AroundFilterController)
+    assert @controller.instance_variable_get(:@before_ran)
+    assert @controller.instance_variable_get(:@after_ran)
+  end
+
+  def test_before_after_class_action
+    test_process(BeforeAfterClassFilterController)
+    assert @controller.instance_variable_get(:@before_ran)
+    assert @controller.instance_variable_get(:@after_ran)
+  end
+
+  def test_having_properties_in_around_action
+    test_process(AroundFilterController)
+    assert_equal "before and after", @controller.instance_variable_get(:@execution_log)
+  end
+
+  def test_prepending_and_appending_around_action
+    test_process(MixedFilterController)
+    assert_equal " before aroundfilter  before procfilter  before appended aroundfilter " \
+                 " after appended aroundfilter  after procfilter  after aroundfilter ",
+                 MixedFilterController.execution_log
+  end
+
+  def test_rendering_breaks_actioning_chain
+    response = test_process(RenderingController)
+    assert_equal "something else", response.body
+    assert_not @controller.instance_variable_defined?(:@ran_action)
+  end
+
+  def test_before_action_rendering_breaks_actioning_chain_for_after_action
+    test_process(RenderingController)
+    assert_equal %w( before_action_rendering ), @controller.instance_variable_get(:@ran_filter)
+    assert_not @controller.instance_variable_defined?(:@ran_action)
+  end
+
+  def test_before_action_redirects_breaks_actioning_chain_for_after_action
+    test_process(BeforeActionRedirectionController)
+    assert_response :redirect
+    assert_equal "http://test.host/filter_test/before_action_redirection/target_of_redirection", redirect_to_url
+    assert_equal %w( before_action_redirects ), @controller.instance_variable_get(:@ran_filter)
+  end
+
+  def test_before_action_rendering_breaks_actioning_chain_for_preprend_after_action
+    test_process(RenderingForPrependAfterActionController)
+    assert_equal %w( before_action_rendering ), @controller.instance_variable_get(:@ran_filter)
+    assert_not @controller.instance_variable_defined?(:@ran_action)
+  end
+
+  def test_before_action_redirects_breaks_actioning_chain_for_preprend_after_action
+    test_process(BeforeActionRedirectionForPrependAfterActionController)
+    assert_response :redirect
+    assert_equal "http://test.host/filter_test/before_action_redirection_for_prepend_after_action/target_of_redirection", redirect_to_url
+    assert_equal %w( before_action_redirects ), @controller.instance_variable_get(:@ran_filter)
+  end
+
+  def test_actions_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.query_parameters[:choose] = action
+      response = DynamicDispatchController.action(action).call(@request.env).last
+      assert_equal action, response.body
+    end
+  end
+
+  def test_running_prepended_before_and_after_action
+    test_process(PrependingBeforeAndAfterController)
+    assert_equal %w( before_all between_before_all_and_after_all after_all ), @controller.instance_variable_get(:@ran_filter)
+  end
+
+  def test_skipping_and_limiting_controller
+    test_process(SkippingAndLimitedController, "index")
+    assert_equal %w( ensure_login ), @controller.instance_variable_get(:@ran_filter)
+    test_process(SkippingAndLimitedController, "public")
+    assert_not @controller.instance_variable_defined?(:@ran_filter)
+  end
+
+  def test_skipping_and_reordering_controller
+    test_process(SkippingAndReorderingController, "index")
+    assert_equal %w( find_record ensure_login ), @controller.instance_variable_get(:@ran_filter)
+  end
+
+  def test_conditional_skipping_of_actions
+    test_process(ConditionalSkippingController, "login")
+    assert_not @controller.instance_variable_defined?(:@ran_filter)
+    test_process(ConditionalSkippingController, "change_password")
+    assert_equal %w( ensure_login find_user ), @controller.instance_variable_get(:@ran_filter)
+
+    test_process(ConditionalSkippingController, "login")
+    assert !@controller.instance_variable_defined?("@ran_after_action")
+    test_process(ConditionalSkippingController, "change_password")
+    assert_equal %w( clean_up ), @controller.instance_variable_get("@ran_after_action")
+  end
+
+  def test_conditional_skipping_of_actions_when_parent_action_is_also_conditional
+    test_process(ChildOfConditionalParentController)
+    assert_equal %w( conditional_in_parent_before conditional_in_parent_after ), @controller.instance_variable_get(:@ran_filter)
+    test_process(ChildOfConditionalParentController, "another_action")
+    assert_not @controller.instance_variable_defined?(:@ran_filter)
+  end
+
+  def test_condition_skipping_of_actions_when_siblings_also_have_conditions
+    test_process(ChildOfConditionalParentController)
+    assert_equal %w( conditional_in_parent_before conditional_in_parent_after ), @controller.instance_variable_get(:@ran_filter)
+    test_process(AnotherChildOfConditionalParentController)
+    assert_equal %w( conditional_in_parent_after ), @controller.instance_variable_get(:@ran_filter)
+    test_process(ChildOfConditionalParentController)
+    assert_equal %w( conditional_in_parent_before conditional_in_parent_after ), @controller.instance_variable_get(:@ran_filter)
+  end
+
+  def test_changing_the_requirements
+    test_process(ChangingTheRequirementsController, "go_wild")
+    assert_not @controller.instance_variable_defined?(:@ran_filter)
+  end
+
+  def test_a_rescuing_around_action
+    response = nil
+    assert_nothing_raised do
+      response = test_process(RescuedController)
+    end
+
+    assert_predicate response, :successful?
+    assert_equal("I rescued this: #<FilterTest::ErrorToRescue: Something made the bad noise.>", response.body)
+  end
+
+  def test_actions_obey_only_and_except_for_implicit_actions
+    test_process(ImplicitActionsController, "show")
+    assert_equal "Except", @controller.instance_variable_get(:@except)
+    assert_not @controller.instance_variable_defined?(:@only)
+    assert_equal "show", response.body
+
+    test_process(ImplicitActionsController, "edit")
+    assert_equal "Only", @controller.instance_variable_get(:@only)
+    assert_not @controller.instance_variable_defined?(:@except)
+    assert_equal "edit", response.body
+  end
+
+  private
+    def test_process(controller, action = "show")
+      @controller = controller.is_a?(Class) ? controller.new : controller
+
+      process(action)
+    end
+end
+
+class PostsController < ActionController::Base
+  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_action).map { |action| "def #{action}; default_action end" }.join("\n")
+
+  private
+    def default_action
+      render inline: "#{action_name} called"
+    end
+end
+
+class ControllerWithSymbolAsFilter < PostsController
+  around_action :raise_before, only: :raises_before
+  around_action :raise_after, only: :raises_after
+  around_action :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...
+      wtf = 1 + 1
+
+      yield
+
+      # Do stuff...
+      wtf += 1
+    end
+end
+
+class ControllerWithFilterClass < PostsController
+  class YieldingFilter < DefaultFilter
+    def self.around(controller)
+      yield
+      raise After
+    end
+  end
+
+  around_action YieldingFilter, only: :raises_after
+end
+
+class ControllerWithFilterInstance < PostsController
+  class YieldingFilter < DefaultFilter
+    def around(controller)
+      yield
+      raise After
+    end
+  end
+
+  around_action YieldingFilter.new, only: :raises_after
+end
+
+class ControllerWithProcFilter < PostsController
+  around_action(only: :no_raise) do |c, b|
+    c.instance_variable_set(:"@before", true)
+    b.call
+    c.instance_variable_set(:"@after", true)
+  end
+end
+
+class ControllerWithNestedFilters < ControllerWithSymbolAsFilter
+  around_action :raise_before, :raise_after, :without_exception, only: :raises_both
+end
+
+class ControllerWithAllTypesOfFilters < PostsController
+  before_action :before
+  around_action :around
+  after_action :after
+  around_action :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_around_action :around_again
+  skip_after_action :after
+end
+
+class YieldingAroundFiltersTest < ActionController::TestCase
+  include PostsController::AroundExceptions
+
+  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_action") }
+  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_proc
+    test_process(ControllerWithProcFilter, "no_raise")
+    assert @controller.instance_variable_get(:@before)
+    assert @controller.instance_variable_get(:@after)
+  end
+
+  def test_nested_actions
+    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_action_order_with_all_action_types
+    test_process(ControllerWithAllTypesOfFilters, "no_raise")
+    assert_equal "before around (before yield) around_again (before yield) around_again (after yield) after around (after yield)", @controller.instance_variable_get(:@ran_filter).join(" ")
+  end
+
+  def test_action_order_with_skip_action_method
+    test_process(ControllerWithTwoLessFilters, "no_raise")
+    assert_equal "before around (before yield) around (after yield)", @controller.instance_variable_get(:@ran_filter).join(" ")
+  end
+
+  def test_first_action_in_multiple_before_action_chain_halts
+    controller = ::FilterTest::TestMultipleFiltersController.new
+    response = test_process(controller, "fail_1")
+    assert_equal "", response.body
+    assert_equal 1, controller.instance_variable_get(:@try)
+  end
+
+  def test_second_action_in_multiple_before_action_chain_halts
+    controller = ::FilterTest::TestMultipleFiltersController.new
+    response = test_process(controller, "fail_2")
+    assert_equal "", response.body
+    assert_equal 2, controller.instance_variable_get(:@try)
+  end
+
+  def test_last_action_in_multiple_before_action_chain_halts
+    controller = ::FilterTest::TestMultipleFiltersController.new
+    response = test_process(controller, "fail_3")
+    assert_equal "", response.body
+    assert_equal 3, controller.instance_variable_get(:@try)
+  end
+
+  private
+    def test_process(controller, action = "show")
+      @controller = controller.is_a?(Class) ? controller.new : controller
+      process(action)
+    end
+end