498 lines
13 KiB
Ruby
498 lines
13 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
require "abstract_unit"
|
|
|
|
module AbstractController
|
|
module Testing
|
|
class ControllerWithCallbacks < AbstractController::Base
|
|
include AbstractController::Callbacks
|
|
end
|
|
|
|
class Callback1 < ControllerWithCallbacks
|
|
set_callback :process_action, :before, :first
|
|
|
|
def first
|
|
@text = "Hello world"
|
|
end
|
|
|
|
def index
|
|
self.response_body = @text
|
|
end
|
|
end
|
|
|
|
class TestCallbacks1 < ActiveSupport::TestCase
|
|
test "basic callbacks work" do
|
|
controller = Callback1.new
|
|
controller.process(:index)
|
|
assert_equal "Hello world", controller.response_body
|
|
end
|
|
end
|
|
|
|
class Callback2 < ControllerWithCallbacks
|
|
before_action :first
|
|
after_action :second
|
|
around_action :aroundz
|
|
|
|
def first
|
|
@text = "Hello world"
|
|
end
|
|
|
|
def second
|
|
@second = "Goodbye"
|
|
end
|
|
|
|
def aroundz
|
|
@aroundz = "FIRST"
|
|
yield
|
|
@aroundz += "SECOND"
|
|
end
|
|
|
|
def index
|
|
@text ||= nil
|
|
self.response_body = @text.to_s
|
|
end
|
|
end
|
|
|
|
class Callback2Overwrite < Callback2
|
|
before_action :first, except: :index
|
|
end
|
|
|
|
class TestCallbacks2 < ActiveSupport::TestCase
|
|
def setup
|
|
@controller = Callback2.new
|
|
end
|
|
|
|
test "before_action works" do
|
|
@controller.process(:index)
|
|
assert_equal "Hello world", @controller.response_body
|
|
end
|
|
|
|
test "after_action works" do
|
|
@controller.process(:index)
|
|
assert_equal "Goodbye", @controller.instance_variable_get("@second")
|
|
end
|
|
|
|
test "around_action works" do
|
|
@controller.process(:index)
|
|
assert_equal "FIRSTSECOND", @controller.instance_variable_get("@aroundz")
|
|
end
|
|
|
|
test "before_action with overwritten condition" do
|
|
@controller = Callback2Overwrite.new
|
|
@controller.process(:index)
|
|
assert_equal "", @controller.response_body
|
|
end
|
|
end
|
|
|
|
class Callback3 < ControllerWithCallbacks
|
|
before_action do |c|
|
|
c.instance_variable_set("@text", "Hello world")
|
|
end
|
|
|
|
after_action do |c|
|
|
c.instance_variable_set("@second", "Goodbye")
|
|
end
|
|
|
|
def index
|
|
self.response_body = @text
|
|
end
|
|
end
|
|
|
|
class TestCallbacks3 < ActiveSupport::TestCase
|
|
def setup
|
|
@controller = Callback3.new
|
|
end
|
|
|
|
test "before_action works with procs" do
|
|
@controller.process(:index)
|
|
assert_equal "Hello world", @controller.response_body
|
|
end
|
|
|
|
test "after_action works with procs" do
|
|
@controller.process(:index)
|
|
assert_equal "Goodbye", @controller.instance_variable_get("@second")
|
|
end
|
|
end
|
|
|
|
class CallbacksWithConditions < ControllerWithCallbacks
|
|
before_action :list, only: :index
|
|
before_action :authenticate, except: :index
|
|
|
|
def index
|
|
self.response_body = @list.join(", ")
|
|
end
|
|
|
|
def sekrit_data
|
|
self.response_body = (@list + [@authenticated]).join(", ")
|
|
end
|
|
|
|
private
|
|
def list
|
|
@list = ["Hello", "World"]
|
|
end
|
|
|
|
def authenticate
|
|
@list ||= []
|
|
@authenticated = "true"
|
|
end
|
|
end
|
|
|
|
class TestCallbacksWithConditions < ActiveSupport::TestCase
|
|
def setup
|
|
@controller = CallbacksWithConditions.new
|
|
end
|
|
|
|
test "when :only is specified, a before action is triggered on that action" do
|
|
@controller.process(:index)
|
|
assert_equal "Hello, World", @controller.response_body
|
|
end
|
|
|
|
test "when :only is specified, a before action is not triggered on other actions" do
|
|
@controller.process(:sekrit_data)
|
|
assert_equal "true", @controller.response_body
|
|
end
|
|
|
|
test "when :except is specified, an after action is not triggered on that action" do
|
|
@controller.process(:index)
|
|
assert_not @controller.instance_variable_defined?("@authenticated")
|
|
end
|
|
end
|
|
|
|
class CallbacksWithReusedConditions < ControllerWithCallbacks
|
|
options = { only: :index }
|
|
before_action :list, options
|
|
before_action :authenticate, options
|
|
|
|
def index
|
|
self.response_body = @list.join(", ")
|
|
end
|
|
|
|
def public_data
|
|
@authenticated = "false"
|
|
self.response_body = @authenticated
|
|
end
|
|
|
|
private
|
|
def list
|
|
@list = ["Hello", "World"]
|
|
end
|
|
|
|
def authenticate
|
|
@list ||= []
|
|
@authenticated = "true"
|
|
end
|
|
end
|
|
|
|
class TestCallbacksWithReusedConditions < ActiveSupport::TestCase
|
|
def setup
|
|
@controller = CallbacksWithReusedConditions.new
|
|
end
|
|
|
|
test "when :only is specified, both actions triggered on that action" do
|
|
@controller.process(:index)
|
|
assert_equal "Hello, World", @controller.response_body
|
|
assert_equal "true", @controller.instance_variable_get("@authenticated")
|
|
end
|
|
|
|
test "when :only is specified, both actions are not triggered on other actions" do
|
|
@controller.process(:public_data)
|
|
assert_equal "false", @controller.response_body
|
|
end
|
|
end
|
|
|
|
class CallbacksWithArrayConditions < ControllerWithCallbacks
|
|
before_action :list, only: [:index, :listy]
|
|
before_action :authenticate, except: [:index, :listy]
|
|
|
|
def index
|
|
self.response_body = @list.join(", ")
|
|
end
|
|
|
|
def sekrit_data
|
|
self.response_body = (@list + [@authenticated]).join(", ")
|
|
end
|
|
|
|
private
|
|
def list
|
|
@list = ["Hello", "World"]
|
|
end
|
|
|
|
def authenticate
|
|
@list = []
|
|
@authenticated = "true"
|
|
end
|
|
end
|
|
|
|
class TestCallbacksWithArrayConditions < ActiveSupport::TestCase
|
|
def setup
|
|
@controller = CallbacksWithArrayConditions.new
|
|
end
|
|
|
|
test "when :only is specified with an array, a before action is triggered on that action" do
|
|
@controller.process(:index)
|
|
assert_equal "Hello, World", @controller.response_body
|
|
end
|
|
|
|
test "when :only is specified with an array, a before action is not triggered on other actions" do
|
|
@controller.process(:sekrit_data)
|
|
assert_equal "true", @controller.response_body
|
|
end
|
|
|
|
test "when :except is specified with an array, an after action is not triggered on that action" do
|
|
@controller.process(:index)
|
|
assert_not @controller.instance_variable_defined?("@authenticated")
|
|
end
|
|
end
|
|
|
|
class ChangedConditions < Callback2
|
|
before_action :first, only: :index
|
|
|
|
def not_index
|
|
@text ||= nil
|
|
self.response_body = @text.to_s
|
|
end
|
|
end
|
|
|
|
class TestCallbacksWithChangedConditions < ActiveSupport::TestCase
|
|
def setup
|
|
@controller = ChangedConditions.new
|
|
end
|
|
|
|
test "when a callback is modified in a child with :only, it works for the :only action" do
|
|
@controller.process(:index)
|
|
assert_equal "Hello world", @controller.response_body
|
|
end
|
|
|
|
test "when a callback is modified in a child with :only, it does not work for other actions" do
|
|
@controller.process(:not_index)
|
|
assert_equal "", @controller.response_body
|
|
end
|
|
end
|
|
|
|
class SetsResponseBody < ControllerWithCallbacks
|
|
before_action :set_body
|
|
|
|
def index
|
|
self.response_body = "Fail"
|
|
end
|
|
|
|
def set_body
|
|
self.response_body = "Success"
|
|
end
|
|
end
|
|
|
|
class TestHalting < ActiveSupport::TestCase
|
|
test "when a callback sets the response body, the action should not be invoked" do
|
|
controller = SetsResponseBody.new
|
|
controller.process(:index)
|
|
assert_equal "Success", controller.response_body
|
|
end
|
|
end
|
|
|
|
class CallbacksWithArgs < ControllerWithCallbacks
|
|
set_callback :process_action, :before, :first
|
|
|
|
def first
|
|
@text = "Hello world"
|
|
end
|
|
|
|
def index(text)
|
|
self.response_body = @text + text
|
|
end
|
|
end
|
|
|
|
class TestCallbacksWithArgs < ActiveSupport::TestCase
|
|
test "callbacks still work when invoking process with multiple arguments" do
|
|
controller = CallbacksWithArgs.new
|
|
controller.process(:index, " Howdy!")
|
|
assert_equal "Hello world Howdy!", controller.response_body
|
|
end
|
|
end
|
|
|
|
class TestCallbacksWithMissingConditions < ActiveSupport::TestCase
|
|
class CallbacksWithMissingOnly < ControllerWithCallbacks
|
|
before_action :callback, only: :showw
|
|
|
|
def index
|
|
end
|
|
|
|
def show
|
|
end
|
|
|
|
private
|
|
def callback
|
|
end
|
|
end
|
|
|
|
test "callbacks raise exception when their 'only' condition is a missing action" do
|
|
with_raise_on_missing_callback_actions do
|
|
controller = CallbacksWithMissingOnly.new
|
|
assert_raises(AbstractController::ActionNotFound) do
|
|
controller.process(:index)
|
|
end
|
|
end
|
|
end
|
|
|
|
class CallbacksWithMissingOnlyInArray < ControllerWithCallbacks
|
|
before_action :callback, only: [:index, :showw]
|
|
|
|
def index
|
|
end
|
|
|
|
def show
|
|
end
|
|
|
|
private
|
|
def callback
|
|
end
|
|
end
|
|
|
|
test "callbacks raise exception when their 'only' array condition contains a missing action" do
|
|
with_raise_on_missing_callback_actions do
|
|
controller = CallbacksWithMissingOnlyInArray.new
|
|
assert_raises(AbstractController::ActionNotFound) do
|
|
controller.process(:index)
|
|
end
|
|
end
|
|
end
|
|
|
|
class CallbacksWithMissingExcept < ControllerWithCallbacks
|
|
before_action :callback, except: :showw
|
|
|
|
def index
|
|
end
|
|
|
|
def show
|
|
end
|
|
|
|
private
|
|
def callback
|
|
end
|
|
end
|
|
|
|
test "callbacks raise exception when their 'except' condition is a missing action" do
|
|
with_raise_on_missing_callback_actions do
|
|
controller = CallbacksWithMissingExcept.new
|
|
assert_raises(AbstractController::ActionNotFound) do
|
|
controller.process(:index)
|
|
end
|
|
end
|
|
end
|
|
|
|
class CallbacksWithMissingExceptInArray < ControllerWithCallbacks
|
|
before_action :callback, except: [:index, :showw]
|
|
|
|
def index
|
|
end
|
|
|
|
def show
|
|
end
|
|
|
|
private
|
|
def callback
|
|
end
|
|
end
|
|
|
|
test "callbacks raise exception when their 'except' array condition contains a missing action" do
|
|
with_raise_on_missing_callback_actions do
|
|
controller = CallbacksWithMissingExceptInArray.new
|
|
assert_raises(AbstractController::ActionNotFound) do
|
|
controller.process(:index)
|
|
end
|
|
end
|
|
end
|
|
|
|
class MultipleCallbacksWithMissingOnly < ControllerWithCallbacks
|
|
before_action :callback1, :callback2, ->() { }, only: :showw
|
|
|
|
def index
|
|
end
|
|
|
|
def show
|
|
end
|
|
|
|
private
|
|
def callback1
|
|
end
|
|
|
|
def callback2
|
|
end
|
|
end
|
|
|
|
test "raised exception message includes the names of callback actions and missing conditional action" do
|
|
with_raise_on_missing_callback_actions do
|
|
controller = MultipleCallbacksWithMissingOnly.new
|
|
error = assert_raises(AbstractController::ActionNotFound) do
|
|
controller.process(:index)
|
|
end
|
|
|
|
assert_includes error.message, ":callback1"
|
|
assert_includes error.message, ":callback2"
|
|
assert_includes error.message, "#<Proc:"
|
|
assert_includes error.message, "only"
|
|
assert_includes error.message, "showw"
|
|
end
|
|
end
|
|
|
|
class BlockCallbackWithMissingOnly < ControllerWithCallbacks
|
|
before_action only: :showw do
|
|
# Callback body
|
|
end
|
|
|
|
def index
|
|
end
|
|
|
|
def show
|
|
end
|
|
end
|
|
|
|
test "raised exception message includes a block callback" do
|
|
with_raise_on_missing_callback_actions do
|
|
controller = BlockCallbackWithMissingOnly.new
|
|
error = assert_raises(AbstractController::ActionNotFound) do
|
|
controller.process(:index)
|
|
end
|
|
|
|
assert_includes error.message, "#<Proc:"
|
|
end
|
|
end
|
|
|
|
class CallbacksWithBothOnlyAndExcept < ControllerWithCallbacks
|
|
before_action :callback, only: [:index, :show], except: :showw
|
|
|
|
def index
|
|
end
|
|
|
|
def show
|
|
end
|
|
|
|
private
|
|
def callback
|
|
end
|
|
end
|
|
|
|
test "callbacks with both :only and :except options raise an exception with the correct message" do
|
|
with_raise_on_missing_callback_actions do
|
|
controller = CallbacksWithBothOnlyAndExcept.new
|
|
error = assert_raises(AbstractController::ActionNotFound) do
|
|
controller.process(:index)
|
|
end
|
|
|
|
assert_includes error.message, ":callback"
|
|
assert_includes error.message, "except"
|
|
assert_includes error.message, "showw"
|
|
end
|
|
end
|
|
|
|
private
|
|
def with_raise_on_missing_callback_actions
|
|
old_raise_on_missing_callback_actions = ControllerWithCallbacks.raise_on_missing_callback_actions
|
|
ControllerWithCallbacks.raise_on_missing_callback_actions = true
|
|
yield
|
|
ensure
|
|
ControllerWithCallbacks.raise_on_missing_callback_actions = old_raise_on_missing_callback_actions
|
|
end
|
|
end
|
|
end
|
|
end
|