state_machines 0.0.2 → 0.1.0

data/test/unit/branch/branch_with_multiple_to_requirements_test.rb

@@ -0,0 +1,20 @@
+require_relative '../../test_helper'
+
+class BranchWithMultipleToRequirementsTest < StateMachinesTest
+  def setup
+    @object = Object.new
+    @branch = StateMachines::Branch.new(to: [:idling, :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: :first_gear)
+  end
+
+  def test_should_be_included_in_known_states
+    assert_equal [:idling, :parked], @branch.known_states
+  end
+end

data/test/unit/branch/branch_with_multiple_unless_conditionals_test.rb

@@ -0,0 +1,20 @@
+require_relative '../../test_helper'
+
+class BranchWithMultipleUnlessConditionalsTest < StateMachinesTest
+  def setup
+    @object = Object.new
+  end
+
+  def test_should_match_if_all_are_false
+    branch = StateMachines::Branch.new(unless: [lambda { false }, lambda { false }])
+    assert branch.match(@object)
+  end
+
+  def test_should_not_match_if_any_are_true
+    branch = StateMachines::Branch.new(unless: [lambda { true }, lambda { false }])
+    refute branch.match(@object)
+
+    branch = StateMachines::Branch.new(unless: [lambda { false }, lambda { true }])
+    refute branch.match(@object)
+  end
+end

data/test/unit/branch/branch_with_nil_requirements_test.rb

@@ -0,0 +1,28 @@
+require_relative '../../test_helper'
+
+class BranchWithNilRequirementsTest < StateMachinesTest
+  def setup
+    @object = Object.new
+    @branch = StateMachines::Branch.new(from: nil, to: nil)
+  end
+
+  def test_should_match_empty_query
+    assert @branch.matches?(@object)
+  end
+
+  def test_should_match_if_all_requirements_match
+    assert @branch.matches?(@object, from: nil, to: nil)
+  end
+
+  def test_should_not_match_if_from_not_included
+    refute @branch.matches?(@object, from: :parked)
+  end
+
+  def test_should_not_match_if_to_not_included
+    refute @branch.matches?(@object, to: :idling)
+  end
+
+  def test_should_include_all_known_states
+    assert_equal [nil], @branch.known_states
+  end
+end

data/test/unit/branch/branch_with_no_requirements_test.rb

@@ -0,0 +1,36 @@
+require_relative '../../test_helper'
+
+class BranchWithNoRequirementsTest < StateMachinesTest
+  def setup
+    @object = Object.new
+    @branch = StateMachines::Branch.new
+  end
+
+  def test_should_use_all_matcher_for_event_requirement
+    assert_equal StateMachines::AllMatcher.instance, @branch.event_requirement
+  end
+
+  def test_should_use_all_matcher_for_from_state_requirement
+    assert_equal StateMachines::AllMatcher.instance, @branch.state_requirements.first[:from]
+  end
+
+  def test_should_use_all_matcher_for_to_state_requirement
+    assert_equal StateMachines::AllMatcher.instance, @branch.state_requirements.first[:to]
+  end
+
+  def test_should_match_empty_query
+    assert @branch.matches?(@object, {})
+  end
+
+  def test_should_match_non_empty_query
+    assert @branch.matches?(@object, to: :idling, from: :parked, on: :ignite)
+  end
+
+  def test_should_include_all_requirements_in_match
+    match = @branch.match(@object, {})
+
+    assert_equal @branch.state_requirements.first[:from], match[:from]
+    assert_equal @branch.state_requirements.first[:to], match[:to]
+    assert_equal @branch.event_requirement, match[:on]
+  end
+end

data/test/unit/branch/branch_with_on_matcher_requirement_test.rb

@@ -0,0 +1,16 @@
+require_relative '../../test_helper'
+
+class BranchWithOnMatcherRequirementTest < StateMachinesTest
+  def setup
+    @object = Object.new
+    @branch = StateMachines::Branch.new(on: StateMachines::BlacklistMatcher.new([:ignite, :park]))
+  end
+
+  def test_should_match_if_included
+    assert @branch.matches?(@object, on: :shift_up)
+  end
+
+  def test_should_not_match_if_not_included
+    refute @branch.matches?(@object, on: :ignite)
+  end
+end

data/test/unit/branch/branch_with_on_requirement_test.rb

@@ -0,0 +1,45 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,45 @@
+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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,53 @@
+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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,44 @@
+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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,93 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,20 @@
+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