state_machines 0.5.0 → 0.10.0

data/test/unit/branch/branch_with_on_requirement_test.rb

@@ -1,45 +0,0 @@
-require_relative '../../test_helper'
-
-class BranchWithOnRequirementTest < StateMachinesTest
-  def setup
-    @object = Object.new
-    @branch = StateMachines::Branch.new(on: :ignite)
-  end
-
-  def test_should_use_a_whitelist_matcher
-    assert_instance_of StateMachines::WhitelistMatcher, @branch.event_requirement
-  end
-
-  def test_should_match_if_not_specified
-    assert @branch.matches?(@object, from: :parked)
-  end
-
-  def test_should_match_if_included
-    assert @branch.matches?(@object, on: :ignite)
-  end
-
-  def test_should_not_match_if_not_included
-    refute @branch.matches?(@object, on: :park)
-  end
-
-  def test_should_not_match_if_nil
-    refute @branch.matches?(@object, on: nil)
-  end
-
-  def test_should_ignore_to
-    assert @branch.matches?(@object, on: :ignite, to: :parked)
-  end
-
-  def test_should_ignore_from
-    assert @branch.matches?(@object, on: :ignite, from: :parked)
-  end
-
-  def test_should_not_be_included_in_known_states
-    assert_equal [], @branch.known_states
-  end
-
-  def test_should_include_requirement_in_match
-    match = @branch.match(@object, on: :ignite)
-    assert_equal @branch.event_requirement, match[:on]
-  end
-end

data/test/unit/branch/branch_with_to_matcher_requirement_test.rb

@@ -1,20 +0,0 @@
-require_relative '../../test_helper'
-
-class BranchWithToMatcherRequirementTest < StateMachinesTest
-  def setup
-    @object = Object.new
-    @branch = StateMachines::Branch.new(to: StateMachines::BlacklistMatcher.new([:idling, :parked]))
-  end
-
-  def test_should_match_if_included
-    assert @branch.matches?(@object, to: :first_gear)
-  end
-
-  def test_should_not_match_if_not_included
-    refute @branch.matches?(@object, to: :idling)
-  end
-
-  def test_include_values_in_known_states
-    assert_equal [:idling, :parked], @branch.known_states
-  end
-end

data/test/unit/branch/branch_with_to_requirement_test.rb

@@ -1,45 +0,0 @@
-require_relative '../../test_helper'
-
-class BranchWithToRequirementTest < StateMachinesTest
-  def setup
-    @object = Object.new
-    @branch = StateMachines::Branch.new(to: :idling)
-  end
-
-  def test_should_use_a_whitelist_matcher
-    assert_instance_of StateMachines::WhitelistMatcher, @branch.state_requirements.first[:to]
-  end
-
-  def test_should_match_if_not_specified
-    assert @branch.matches?(@object, from: :parked)
-  end
-
-  def test_should_match_if_included
-    assert @branch.matches?(@object, to: :idling)
-  end
-
-  def test_should_not_match_if_not_included
-    refute @branch.matches?(@object, to: :parked)
-  end
-
-  def test_should_not_match_if_nil
-    refute @branch.matches?(@object, to: nil)
-  end
-
-  def test_should_ignore_from
-    assert @branch.matches?(@object, to: :idling, from: :parked)
-  end
-
-  def test_should_ignore_on
-    assert @branch.matches?(@object, to: :idling, on: :ignite)
-  end
-
-  def test_should_be_included_in_known_states
-    assert_equal [:idling], @branch.known_states
-  end
-
-  def test_should_include_requirement_in_match
-    match = @branch.match(@object, to: :idling)
-    assert_equal @branch.state_requirements.first[:to], match[:to]
-  end
-end

data/test/unit/branch/branch_with_unless_conditional_test.rb

@@ -1,27 +0,0 @@
-require_relative '../../test_helper'
-
-class BranchWithUnlessConditionalTest < StateMachinesTest
-  def setup
-    @object = Object.new
-  end
-
-  def test_should_have_an_unless_condition
-    branch = StateMachines::Branch.new(unless: lambda { true })
-    refute_nil branch.unless_condition
-  end
-
-  def test_should_match_if_false
-    branch = StateMachines::Branch.new(unless: lambda { false })
-    assert branch.matches?(@object)
-  end
-
-  def test_should_not_match_if_true
-    branch = StateMachines::Branch.new(unless: lambda { true })
-    refute branch.matches?(@object)
-  end
-
-  def test_should_be_nil_if_unmatched
-    branch = StateMachines::Branch.new(unless: lambda { true })
-    assert_nil branch.match(@object)
-  end
-end

data/test/unit/branch/branch_without_guards_test.rb

@@ -1,27 +0,0 @@
-require_relative '../../test_helper'
-
-class BranchWithoutGuardsTest < StateMachinesTest
-  def setup
-    @object = Object.new
-  end
-
-  def test_should_match_if_if_is_false
-    branch = StateMachines::Branch.new(if: lambda { false })
-    assert branch.matches?(@object, guard: false)
-  end
-
-  def test_should_match_if_if_is_true
-    branch = StateMachines::Branch.new(if: lambda { true })
-    assert branch.matches?(@object, guard: false)
-  end
-
-  def test_should_match_if_unless_is_false
-    branch = StateMachines::Branch.new(unless: lambda { false })
-    assert branch.matches?(@object, guard: false)
-  end
-
-  def test_should_match_if_unless_is_true
-    branch = StateMachines::Branch.new(unless: lambda { true })
-    assert branch.matches?(@object, guard: false)
-  end
-end

data/test/unit/callback/callback_by_default_test.rb

@@ -1,25 +0,0 @@
-require_relative '../../test_helper'
-
-class CallbackByDefaultTest < StateMachinesTest
-  def setup
-    @callback = StateMachines::Callback.new(:before) {}
-  end
-
-  def test_should_have_type
-    assert_equal :before, @callback.type
-  end
-
-  def test_should_not_have_a_terminator
-    assert_nil @callback.terminator
-  end
-
-  def test_should_have_a_branch_with_all_matcher_requirements
-    assert_equal StateMachines::AllMatcher.instance, @callback.branch.event_requirement
-    assert_equal StateMachines::AllMatcher.instance, @callback.branch.state_requirements.first[:from]
-    assert_equal StateMachines::AllMatcher.instance, @callback.branch.state_requirements.first[:to]
-  end
-
-  def test_should_not_have_any_known_states
-    assert_equal [], @callback.known_states
-  end
-end

data/test/unit/callback/callback_test.rb

@@ -1,53 +0,0 @@
-require_relative '../../test_helper'
-
-class CallbackTest < StateMachinesTest
-  def test_should_raise_exception_if_invalid_type_specified
-    exception = assert_raises(ArgumentError) { StateMachines::Callback.new(:invalid) {} }
-    assert_equal 'Type must be :before, :after, :around, or :failure', exception.message
-  end
-
-  def test_should_not_raise_exception_if_using_before_type
-    StateMachines::Callback.new(:before) {}
-  end
-
-  def test_should_not_raise_exception_if_using_after_type
-    StateMachines::Callback.new(:after) {}
-  end
-
-  def test_should_not_raise_exception_if_using_around_type
-    StateMachines::Callback.new(:around) {}
-  end
-
-  def test_should_not_raise_exception_if_using_failure_type
-    StateMachines::Callback.new(:failure) {}
-  end
-
-  def test_should_raise_exception_if_no_methods_specified
-    exception = assert_raises(ArgumentError) { StateMachines::Callback.new(:before) }
-    assert_equal 'Method(s) for callback must be specified', exception.message
-  end
-
-  def test_should_not_raise_exception_if_method_specified_in_do_option
-    StateMachines::Callback.new(:before, do: :run)
-  end
-
-  def test_should_not_raise_exception_if_method_specified_as_argument
-    StateMachines::Callback.new(:before, :run)
-  end
-
-  def test_should_not_raise_exception_if_method_specified_as_block
-    StateMachines::Callback.new(:before, :run) {}
-  end
-
-  def test_should_not_raise_exception_if_implicit_option_specified
-    StateMachines::Callback.new(:before, do: :run, invalid: :valid)
-  end
-
-  def test_should_not_bind_to_objects
-    refute StateMachines::Callback.bind_to_object
-  end
-
-  def test_should_not_have_a_terminator
-    assert_nil StateMachines::Callback.terminator
-  end
-end

data/test/unit/callback/callback_with_application_bound_object_test.rb

@@ -1,23 +0,0 @@
-require_relative '../../test_helper'
-
-class CallbackWithApplicationBoundObjectTest < StateMachinesTest
-  def setup
-    @original_bind_to_object = StateMachines::Callback.bind_to_object
-    StateMachines::Callback.bind_to_object = true
-
-    context = nil
-    @callback = StateMachines::Callback.new(:before, do: lambda { |*_args| context = self })
-
-    @object = Object.new
-    @callback.call(@object)
-    @context = context
-  end
-
-  def test_should_call_method_within_the_context_of_the_object
-    assert_equal @object, @context
-  end
-
-  def teardown
-    StateMachines::Callback.bind_to_object = @original_bind_to_object
-  end
-end

data/test/unit/callback/callback_with_application_terminator_test.rb

@@ -1,24 +0,0 @@
-require_relative '../../test_helper'
-
-class CallbackWithApplicationTerminatorTest < StateMachinesTest
-  def setup
-    @original_terminator = StateMachines::Callback.terminator
-    StateMachines::Callback.terminator = lambda { |result| result == false }
-
-    @object = Object.new
-  end
-
-  def test_should_not_halt_if_terminator_does_not_match
-    callback = StateMachines::Callback.new(:before, do: lambda { true })
-    callback.call(@object)
-  end
-
-  def test_should_halt_if_terminator_matches
-    callback = StateMachines::Callback.new(:before, do: lambda { false })
-    assert_throws(:halt) { callback.call(@object) }
-  end
-
-  def teardown
-    StateMachines::Callback.terminator = @original_terminator
-  end
-end

data/test/unit/callback/callback_with_arguments_test.rb

@@ -1,14 +0,0 @@
-require_relative '../../test_helper'
-
-class CallbackWithArgumentsTest < StateMachinesTest
-  def setup
-    @callback = StateMachines::Callback.new(:before, do: lambda { |*args| @args = args })
-
-    @object = Object.new
-    @callback.call(@object, {}, 1, 2, 3)
-  end
-
-  def test_should_call_method_with_all_arguments
-    assert_equal [@object, 1, 2, 3], @args
-  end
-end

data/test/unit/callback/callback_with_around_type_and_arguments_test.rb

@@ -1,25 +0,0 @@
-require_relative '../../test_helper'
-
-class CallbackWithAroundTypeAndArgumentsTest < StateMachinesTest
-  def setup
-    @object = Object.new
-  end
-
-  def test_should_include_object_if_specified
-    callback = StateMachines::Callback.new(:around, lambda { |object, block| @args = [object]; block.call })
-    callback.call(@object)
-    assert_equal [@object], @args
-  end
-
-  def test_should_include_arguments_if_specified
-    callback = StateMachines::Callback.new(:around, lambda { |object, arg1, arg2, arg3, block| @args = [object, arg1, arg2, arg3]; block.call })
-    callback.call(@object, {}, 1, 2, 3)
-    assert_equal [@object, 1, 2, 3], @args
-  end
-
-  def test_should_include_arguments_if_splat_used
-    callback = StateMachines::Callback.new(:around, lambda { |*args| block = args.pop; @args = args; block.call })
-    callback.call(@object, {}, 1, 2, 3)
-    assert_equal [@object, 1, 2, 3], @args
-  end
-end

data/test/unit/callback/callback_with_around_type_and_block_test.rb

@@ -1,44 +0,0 @@
-require_relative '../../test_helper'
-
-class CallbackWithAroundTypeAndBlockTest < StateMachinesTest
-  def setup
-    @object = Object.new
-    @callbacks = []
-  end
-
-  def test_should_evaluate_before_without_after
-    callback = StateMachines::Callback.new(:around, lambda { |*args| block = args.pop; @args = args; block.call })
-    assert callback.call(@object)
-    assert_equal [@object], @args
-  end
-
-  def test_should_evaluate_after_without_before
-    callback = StateMachines::Callback.new(:around, lambda { |*args| block = args.pop; block.call; @args = args })
-    assert callback.call(@object)
-    assert_equal [@object], @args
-  end
-
-  def test_should_halt_if_not_yielded
-    callback = StateMachines::Callback.new(:around, lambda { |_block| })
-    assert_throws(:halt) { callback.call(@object) }
-  end
-
-  def test_should_call_block_after_before
-    callback = StateMachines::Callback.new(:around, lambda { |block| @callbacks << :before; block.call })
-    assert callback.call(@object) { @callbacks << :block }
-    assert_equal [:before, :block], @callbacks
-  end
-
-  def test_should_call_block_before_after
-    @callbacks = []
-    callback = StateMachines::Callback.new(:around, lambda { |block| block.call; @callbacks << :after })
-    assert callback.call(@object) { @callbacks << :block }
-    assert_equal [:block, :after], @callbacks
-  end
-
-  def test_should_halt_if_block_halts
-    callback = StateMachines::Callback.new(:around, lambda { |block| block.call; @callbacks << :after })
-    assert_throws(:halt) { callback.call(@object) { throw :halt }  }
-    assert_equal [], @callbacks
-  end
-end

data/test/unit/callback/callback_with_around_type_and_bound_method_test.rb

@@ -1,23 +0,0 @@
-require_relative '../../test_helper'
-
-class CallbackWithAroundTypeAndBoundMethodTest < StateMachinesTest
-  def setup
-    @object = Object.new
-  end
-
-  def test_should_call_method_within_the_context_of_the_object
-    context = nil
-    callback = StateMachines::Callback.new(:around, do: lambda { |block| context = self; block.call }, bind_to_object: true)
-    callback.call(@object, {}, 1, 2, 3)
-
-    assert_equal @object, context
-  end
-
-  def test_should_include_arguments_if_specified
-    context = nil
-    callback = StateMachines::Callback.new(:around, do: lambda { |*args| block = args.pop; context = args; block.call }, bind_to_object: true)
-    callback.call(@object, {}, 1, 2, 3)
-
-    assert_equal [1, 2, 3], context
-  end
-end

data/test/unit/callback/callback_with_around_type_and_multiple_methods_test.rb

@@ -1,93 +0,0 @@
-require_relative '../../test_helper'
-
-class CallbackWithAroundTypeAndMultipleMethodsTest < StateMachinesTest
-  def setup
-    @callback = StateMachines::Callback.new(:around, :run_1, :run_2)
-
-    class << @object = Object.new
-      attr_accessor :before_callbacks
-      attr_accessor :after_callbacks
-
-      def run_1
-        (@before_callbacks ||= []) << :run_1
-        yield
-        (@after_callbacks ||= []) << :run_1
-      end
-
-      def run_2
-        (@before_callbacks ||= []) << :run_2
-        yield
-        (@after_callbacks ||= []) << :run_2
-      end
-    end
-  end
-
-  def test_should_succeed
-    assert @callback.call(@object)
-  end
-
-  def test_should_evaluate_before_callbacks_in_order
-    @callback.call(@object)
-    assert_equal [:run_1, :run_2], @object.before_callbacks
-  end
-
-  def test_should_evaluate_after_callbacks_in_reverse_order
-    @callback.call(@object)
-    assert_equal [:run_2, :run_1], @object.after_callbacks
-  end
-
-  def test_should_call_block_after_before_callbacks
-    @callback.call(@object) { (@object.before_callbacks ||= []) << :block }
-    assert_equal [:run_1, :run_2, :block], @object.before_callbacks
-  end
-
-  def test_should_call_block_before_after_callbacks
-    @callback.call(@object) { (@object.after_callbacks ||= []) << :block }
-    assert_equal [:block, :run_2, :run_1], @object.after_callbacks
-  end
-
-  def test_should_halt_if_first_doesnt_yield
-    class << @object
-      remove_method :run_1
-      def run_1
-        (@before_callbacks ||= []) << :run_1
-      end
-    end
-
-    catch(:halt) do
-      @callback.call(@object) { (@object.before_callbacks ||= []) << :block }
-    end
-
-    assert_equal [:run_1], @object.before_callbacks
-    assert_nil @object.after_callbacks
-  end
-
-  def test_should_halt_if_last_doesnt_yield
-    class << @object
-      remove_method :run_2
-      def run_2
-        (@before_callbacks ||= []) << :run_2
-      end
-    end
-
-    catch(:halt) { @callback.call(@object) }
-    assert_equal [:run_1, :run_2], @object.before_callbacks
-    assert_nil @object.after_callbacks
-  end
-
-  def test_should_not_evaluate_further_methods_if_after_halts
-    class << @object
-      remove_method :run_2
-      def run_2
-        (@before_callbacks ||= []) << :run_2
-        yield
-        (@after_callbacks ||= []) << :run_2
-        throw :halt
-      end
-    end
-
-    catch(:halt) { @callback.call(@object) }
-    assert_equal [:run_1, :run_2], @object.before_callbacks
-    assert_equal [:run_2], @object.after_callbacks
-  end
-end

data/test/unit/callback/callback_with_around_type_and_terminator_test.rb

@@ -1,17 +0,0 @@
-require_relative '../../test_helper'
-
-class CallbackWithAroundTypeAndTerminatorTest < StateMachinesTest
-  def setup
-    @object = Object.new
-  end
-
-  def test_should_not_halt_if_terminator_does_not_match
-    callback = StateMachines::Callback.new(:around, do: lambda { |block| block.call(false); false }, terminator: lambda { |result| result == true })
-    callback.call(@object)
-  end
-
-  def test_should_not_halt_if_terminator_matches
-    callback = StateMachines::Callback.new(:around, do: lambda { |block| block.call(false); false }, terminator: lambda { |result| result == false })
-    callback.call(@object)
-  end
-end

data/test/unit/callback/callback_with_block_test.rb

@@ -1,20 +0,0 @@
-require_relative '../../test_helper'
-
-class CallbackWithBlockTest < StateMachinesTest
-  def setup
-    @callback = StateMachines::Callback.new(:before) do |*args|
-      @args = args
-    end
-
-    @object = Object.new
-    @result = @callback.call(@object)
-  end
-
-  def test_should_be_successful
-    assert @result
-  end
-
-  def test_should_call_with_empty_context
-    assert_equal [@object], @args
-  end
-end

data/test/unit/callback/callback_with_bound_method_and_arguments_test.rb

@@ -1,28 +0,0 @@
-require_relative '../../test_helper'
-
-class CallbackWithBoundMethodAndArgumentsTest < StateMachinesTest
-  def setup
-    @object = Object.new
-  end
-
-  def test_should_include_single_argument_if_specified
-    context = nil
-    callback = StateMachines::Callback.new(:before, do: lambda { |arg1| context = [arg1] }, bind_to_object: true)
-    callback.call(@object, {}, 1)
-    assert_equal [1], context
-  end
-
-  def test_should_include_multiple_arguments_if_specified
-    context = nil
-    callback = StateMachines::Callback.new(:before, do: lambda { |arg1, arg2, arg3| context = [arg1, arg2, arg3] }, bind_to_object: true)
-    callback.call(@object, {}, 1, 2, 3)
-    assert_equal [1, 2, 3], context
-  end
-
-  def test_should_include_arguments_if_splat_used
-    context = nil
-    callback = StateMachines::Callback.new(:before, do: lambda { |*args| context = args }, bind_to_object: true)
-    callback.call(@object, {}, 1, 2, 3)
-    assert_equal [1, 2, 3], context
-  end
-end

data/test/unit/callback/callback_with_bound_method_test.rb

@@ -1,35 +0,0 @@
-require_relative '../../test_helper'
-
-class CallbackWithBoundMethodTest < StateMachinesTest
-  def setup
-    @object = Object.new
-  end
-
-  def test_should_call_method_within_the_context_of_the_object_for_block_methods
-    context = nil
-    callback = StateMachines::Callback.new(:before, do: lambda { |*args| context = [self] + args }, bind_to_object: true)
-    callback.call(@object, {}, 1, 2, 3)
-
-    assert_equal [@object, 1, 2, 3], context
-  end
-
-  def test_should_ignore_option_for_symbolic_methods
-    class << @object
-      attr_reader :context
-
-      def after_ignite(*args)
-        @context = args
-      end
-    end
-
-    callback = StateMachines::Callback.new(:before, do: :after_ignite, bind_to_object: true)
-    callback.call(@object)
-
-    assert_equal [], @object.context
-  end
-
-  def test_should_ignore_option_for_string_methods
-    callback = StateMachines::Callback.new(:before, do: '[1, 2, 3]', bind_to_object: true)
-    assert callback.call(@object)
-  end
-end

data/test/unit/callback/callback_with_do_method_test.rb

@@ -1,18 +0,0 @@
-require_relative '../../test_helper'
-
-class CallbackWithDoMethodTest < StateMachinesTest
-  def setup
-    @callback = StateMachines::Callback.new(:before, do: lambda { |*args| @args = args })
-
-    @object = Object.new
-    @result = @callback.call(@object)
-  end
-
-  def test_should_be_successful
-    assert @result
-  end
-
-  def test_should_call_with_empty_context
-    assert_equal [@object], @args
-  end
-end

data/test/unit/callback/callback_with_explicit_requirements_test.rb

@@ -1,32 +0,0 @@
-require_relative '../../test_helper'
-
-class CallbackWithExplicitRequirementsTest < StateMachinesTest
-  def setup
-    @object = Object.new
-    @callback = StateMachines::Callback.new(:before, from: :parked, to: :idling, on: :ignite, do: lambda {})
-  end
-
-  def test_should_call_with_empty_context
-    assert @callback.call(@object, {})
-  end
-
-  def test_should_not_call_if_from_not_included
-    refute @callback.call(@object, from: :idling)
-  end
-
-  def test_should_not_call_if_to_not_included
-    refute @callback.call(@object, to: :parked)
-  end
-
-  def test_should_not_call_if_on_not_included
-    refute @callback.call(@object, on: :park)
-  end
-
-  def test_should_call_if_all_requirements_met
-    assert @callback.call(@object, from: :parked, to: :idling, on: :ignite)
-  end
-
-  def test_should_include_in_known_states
-    assert_equal [:parked, :idling], @callback.known_states
-  end
-end

data/test/unit/callback/callback_with_if_condition_test.rb

@@ -1,17 +0,0 @@
-require_relative '../../test_helper'
-
-class CallbackWithIfConditionTest < StateMachinesTest
-  def setup
-    @object = Object.new
-  end
-
-  def test_should_call_if_true
-    callback = StateMachines::Callback.new(:before, if: lambda { true }, do: lambda {})
-    assert callback.call(@object)
-  end
-
-  def test_should_not_call_if_false
-    callback = StateMachines::Callback.new(:before, if: lambda { false }, do: lambda {})
-    refute callback.call(@object)
-  end
-end