state_machines 0.0.2 → 0.1.0

data/test/unit/transition/transition_with_before_callbacks_test.rb

@@ -0,0 +1,104 @@
+require_relative '../../test_helper'
+
+class TransitionWithBeforeCallbacksTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+
+    @machine = StateMachines::Machine.new(@klass)
+    @machine.state :parked, :idling
+    @machine.event :ignite
+
+    @object = @klass.new
+    @object.state = 'parked'
+    @transition = StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling)
+  end
+
+  def test_should_run_before_callbacks
+    @machine.before_transition { @run = true }
+    result = @transition.run_callbacks
+
+    assert_equal true, result
+    assert_equal true, @run
+  end
+
+  def test_should_only_run_those_that_match_transition_context
+    @count = 0
+    callback = lambda { @count += 1 }
+
+    @machine.before_transition from: :parked, to: :idling, on: :park, do: callback
+    @machine.before_transition from: :parked, to: :parked, on: :park, do: callback
+    @machine.before_transition from: :parked, to: :idling, on: :ignite, do: callback
+    @machine.before_transition from: :idling, to: :idling, on: :park, do: callback
+    @transition.run_callbacks
+
+    assert_equal 1, @count
+  end
+
+  def test_should_pass_transition_as_argument
+    @machine.before_transition { |*args| @args = args }
+    @transition.run_callbacks
+
+    assert_equal [@object, @transition], @args
+  end
+
+  def test_should_catch_halts
+    @machine.before_transition { throw :halt }
+
+    result = @transition.run_callbacks
+    assert_equal false, result
+  end
+
+  def test_should_not_catch_exceptions
+    @machine.before_transition { fail ArgumentError }
+    assert_raises(ArgumentError) { @transition.run_callbacks }
+  end
+
+  def test_should_not_be_able_to_run_twice
+    @count = 0
+    @machine.before_transition { @count += 1 }
+    @transition.run_callbacks
+    @transition.run_callbacks
+    assert_equal 1, @count
+  end
+
+  def test_should_be_able_to_run_again_after_halt
+    @count = 0
+    @machine.before_transition { @count += 1; throw :halt }
+    @transition.run_callbacks
+    @transition.run_callbacks
+    assert_equal 2, @count
+  end
+
+  def test_should_be_able_to_run_again_after_resetting
+    @count = 0
+    @machine.before_transition { @count += 1 }
+    @transition.run_callbacks
+    @transition.reset
+    @transition.run_callbacks
+    assert_equal 2, @count
+  end
+
+  def test_should_succeed_if_block_result_is_false
+    @machine.before_transition { @run = true }
+    assert_equal true, @transition.run_callbacks { { result: false } }
+    assert @run
+  end
+
+  def test_should_succeed_if_block_result_is_true
+    @machine.before_transition { @run = true }
+    assert_equal true, @transition.run_callbacks { { result: true } }
+    assert @run
+  end
+
+  def test_should_succeed_if_block_success_is_false
+    @machine.before_transition { @run = true }
+    assert_equal true, @transition.run_callbacks { { success: false } }
+    assert @run
+  end
+
+  def test_should_succeed_if_block_success_is_true
+    @machine.before_transition { @run = true }
+    assert_equal true, @transition.run_callbacks { { success: true } }
+    assert @run
+  end
+end

data/test/unit/transition/transition_with_custom_machine_attribute_test.rb

@@ -0,0 +1,28 @@
+require_relative '../../test_helper'
+
+class TransitionWithCustomMachineAttributeTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass, :state, attribute: :state_id)
+    @machine.state :off, value: 1
+    @machine.state :active, value: 2
+    @machine.event :activate
+
+    @object = @klass.new
+    @object.state_id = 1
+
+    @transition = StateMachines::Transition.new(@object, @machine, :activate, :off, :active)
+  end
+
+  def test_should_persist
+    @transition.persist
+    assert_equal 2, @object.state_id
+  end
+
+  def test_should_rollback
+    @object.state_id = 2
+    @transition.rollback
+
+    assert_equal 1, @object.state_id
+  end
+end

data/test/unit/transition/transition_with_different_states_test.rb

@@ -0,0 +1,18 @@
+require_relative '../../test_helper'
+
+class TransitionWithDifferentStatesTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass)
+    @machine.state :parked, :idling
+    @machine.event :ignite
+
+    @object = @klass.new
+    @object.state = 'parked'
+    @transition = StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling)
+  end
+
+  def test_should_not_be_loopback
+    refute @transition.loopback?
+  end
+end

data/test/unit/transition/transition_with_dynamic_to_value_test.rb

@@ -0,0 +1,19 @@
+require_relative '../../test_helper'
+
+class TransitionWithDynamicToValueTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass)
+    @machine.state :parked
+    @machine.state :idling, value: lambda { 1 }
+    @machine.event :ignite
+
+    @object = @klass.new
+    @object.state = 'parked'
+    @transition = StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling)
+  end
+
+  def test_should_evaluate_to_value
+    assert_equal 1, @transition.to
+  end
+end

data/test/unit/transition/transition_with_failure_callbacks_test.rb

@@ -0,0 +1,84 @@
+require_relative '../../test_helper'
+
+class TransitionWithFailureCallbacksTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+
+    @machine = StateMachines::Machine.new(@klass)
+    @machine.state :parked, :idling
+    @machine.event :ignite
+
+    @object = @klass.new
+    @object.state = 'parked'
+    @transition = StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling)
+  end
+
+  def test_should_only_run_those_that_match_transition_context
+    @count = 0
+    callback = lambda { @count += 1 }
+
+    @machine.after_failure do: callback
+    @machine.after_failure on: :park, do: callback
+    @machine.after_failure on: :ignite, do: callback
+    @transition.run_callbacks { { success: false } }
+
+    assert_equal 2, @count
+  end
+
+  def test_should_run_if_not_successful
+    @machine.after_failure { |_object| @run = true }
+    @transition.run_callbacks { { success: false } }
+    assert @run
+  end
+
+  def test_should_not_run_if_successful
+    @run = false
+    @machine.after_failure { |_object| @run = true }
+    @transition.run_callbacks { { success: true } }
+    refute @run
+  end
+
+  def test_should_pass_transition_as_argument
+    @machine.after_failure { |*args| @args = args }
+
+    @transition.run_callbacks { { success: false } }
+    assert_equal [@object, @transition], @args
+  end
+
+  def test_should_catch_halts
+    @machine.after_failure { throw :halt }
+
+    result = @transition.run_callbacks { { success: false } }
+    assert_equal true, result
+  end
+
+  def test_should_not_catch_exceptions
+    @machine.after_failure  { fail ArgumentError }
+    assert_raises(ArgumentError) { @transition.run_callbacks { { success: false } } }
+  end
+
+  def test_should_not_be_able_to_run_twice
+    @count = 0
+    @machine.after_failure { @count += 1 }
+    @transition.run_callbacks { { success: false } }
+    @transition.run_callbacks { { success: false } }
+    assert_equal 1, @count
+  end
+
+  def test_should_not_be_able_to_run_twice_if_halted
+    @count = 0
+    @machine.after_failure { @count += 1; throw :halt }
+    @transition.run_callbacks { { success: false } }
+    @transition.run_callbacks { { success: false } }
+    assert_equal 1, @count
+  end
+
+  def test_should_be_able_to_run_again_after_resetting
+    @count = 0
+    @machine.after_failure { @count += 1 }
+    @transition.run_callbacks { { success: false } }
+    @transition.reset
+    @transition.run_callbacks { { success: false } }
+    assert_equal 2, @count
+  end
+end

data/test/unit/transition/transition_with_invalid_nodes_test.rb

@@ -0,0 +1,29 @@
+require_relative '../../test_helper'
+
+class TransitionWithInvalidNodesTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass)
+    @machine.state :parked, :idling
+    @machine.event :ignite
+
+    @object = @klass.new
+    @object.state = 'parked'
+  end
+
+  def test_should_raise_exception_without_event
+    assert_raises(IndexError) { StateMachines::Transition.new(@object, @machine, nil, :parked, :idling) }
+  end
+
+  def test_should_raise_exception_with_invalid_event
+    assert_raises(IndexError) { StateMachines::Transition.new(@object, @machine, :invalid, :parked, :idling) }
+  end
+
+  def test_should_raise_exception_with_invalid_from_state
+    assert_raises(IndexError) { StateMachines::Transition.new(@object, @machine, :ignite, :invalid, :idling) }
+  end
+
+  def test_should_raise_exception_with_invalid_to_state
+    assert_raises(IndexError) { StateMachines::Transition.new(@object, @machine, :ignite, :parked, :invalid) }
+  end
+end

data/test/unit/transition/transition_with_mixed_callbacks_test.rb

@@ -0,0 +1,105 @@
+require_relative '../../test_helper'
+
+class TransitionWithMixedCallbacksTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+
+    @machine = StateMachines::Machine.new(@klass)
+    @machine.state :parked, :idling
+    @machine.event :ignite
+
+    @object = @klass.new
+    @object.state = 'parked'
+    @transition = StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling)
+  end
+
+  def test_should_before_and_around_callbacks_in_order_defined
+    @callbacks = []
+    @machine.before_transition { @callbacks << :before_1 }
+    @machine.around_transition { |block| @callbacks << :around; block.call }
+    @machine.before_transition { @callbacks << :before_2 }
+
+    assert_equal true, @transition.run_callbacks
+    assert_equal [:before_1, :around, :before_2], @callbacks
+  end
+
+  def test_should_run_around_callbacks_before_after_callbacks
+    @callbacks = []
+    @machine.after_transition { @callbacks << :after_1 }
+    @machine.around_transition { |block| block.call; @callbacks << :after_2 }
+    @machine.after_transition { @callbacks << :after_3 }
+
+    assert_equal true, @transition.run_callbacks
+    assert_equal [:after_2, :after_1, :after_3], @callbacks
+  end
+
+  def test_should_have_access_to_result_for_both_after_and_around_callbacks
+    @machine.after_transition { @after_result = @transition.result }
+    @machine.around_transition { |block| block.call; @around_result = @transition.result }
+
+    @transition.run_callbacks { { result: 1, success: true } }
+    assert_equal 1, @after_result
+    assert_equal 1, @around_result
+  end
+
+  def test_should_not_run_further_callbacks_if_before_callback_halts
+    @callbacks = []
+    @machine.before_transition { @callbacks << :before_1 }
+    @machine.around_transition { |block| @callbacks << :before_around_1; block.call; @callbacks << :after_around_1 }
+    @machine.before_transition { @callbacks << :before_2; throw :halt }
+    @machine.around_transition { |block| @callbacks << :before_around_2; block.call; @callbacks << :after_around_2 }
+    @machine.after_transition { @callbacks << :after }
+
+    assert_equal false, @transition.run_callbacks
+    assert_equal [:before_1, :before_around_1, :before_2], @callbacks
+  end
+
+  def test_should_not_run_further_callbacks_if_before_yield_halts
+    @callbacks = []
+    @machine.before_transition { @callbacks << :before_1 }
+    @machine.around_transition { |_block| @callbacks << :before_around_1; throw :halt }
+    @machine.before_transition { @callbacks << :before_2; throw :halt }
+    @machine.around_transition { |block| @callbacks << :before_around_2; block.call; @callbacks << :after_around_2 }
+    @machine.after_transition { @callbacks << :after }
+
+    assert_equal false, @transition.run_callbacks
+    assert_equal [:before_1, :before_around_1], @callbacks
+  end
+
+  def test_should_not_run_further_callbacks_if_around_callback_fails_to_yield
+    @callbacks = []
+    @machine.before_transition { @callbacks << :before_1 }
+    @machine.around_transition { |_block| @callbacks << :before_around_1 }
+    @machine.before_transition { @callbacks << :before_2; throw :halt }
+    @machine.around_transition { |block| @callbacks << :before_around_2; block.call; @callbacks << :after_around_2 }
+    @machine.after_transition { @callbacks << :after }
+
+    assert_equal false, @transition.run_callbacks
+    assert_equal [:before_1, :before_around_1], @callbacks
+  end
+
+  def test_should_not_run_further_callbacks_if_after_yield_halts
+    @callbacks = []
+    @machine.before_transition { @callbacks << :before_1 }
+    @machine.around_transition { |block| @callbacks << :before_around_1; block.call; @callbacks << :after_around_1; throw :halt }
+    @machine.before_transition { @callbacks << :before_2 }
+    @machine.around_transition { |block| @callbacks << :before_around_2; block.call; @callbacks << :after_around_2 }
+    @machine.after_transition { @callbacks << :after }
+
+    assert_equal true, @transition.run_callbacks
+    assert_equal [:before_1, :before_around_1, :before_2, :before_around_2, :after_around_2, :after_around_1], @callbacks
+  end
+
+  def test_should_not_run_further_callbacks_if_after_callback_halts
+    @callbacks = []
+    @machine.before_transition { @callbacks << :before_1 }
+    @machine.around_transition { |block| @callbacks << :before_around_1; block.call; @callbacks << :after_around_1 }
+    @machine.before_transition { @callbacks << :before_2 }
+    @machine.around_transition { |block| @callbacks << :before_around_2; block.call; @callbacks << :after_around_2 }
+    @machine.after_transition { @callbacks << :after_1; throw :halt }
+    @machine.after_transition { @callbacks << :after_2 }
+
+    assert_equal true, @transition.run_callbacks
+    assert_equal [:before_1, :before_around_1, :before_2, :before_around_2, :after_around_2, :after_around_1, :after_1], @callbacks
+  end
+end

data/test/unit/transition/transition_with_multiple_after_callbacks_test.rb

@@ -0,0 +1,40 @@
+require_relative '../../test_helper'
+
+class TransitionWithMultipleAfterCallbacksTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+
+    @machine = StateMachines::Machine.new(@klass)
+    @machine.state :parked, :idling
+    @machine.event :ignite
+
+    @object = @klass.new
+    @object.state = 'parked'
+    @transition = StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling)
+  end
+
+  def test_should_run_in_the_order_they_were_defined
+    @callbacks = []
+    @machine.after_transition { @callbacks << 1 }
+    @machine.after_transition { @callbacks << 2 }
+    @transition.run_callbacks
+
+    assert_equal [1, 2], @callbacks
+  end
+
+  def test_should_not_run_further_callbacks_if_halted
+    @callbacks = []
+    @machine.after_transition { @callbacks << 1; throw :halt }
+    @machine.after_transition { @callbacks << 2 }
+
+    assert_equal true, @transition.run_callbacks
+    assert_equal [1], @callbacks
+  end
+
+  def test_should_fail_if_any_callback_halted
+    @machine.after_transition { true }
+    @machine.after_transition { throw :halt }
+
+    assert_equal true, @transition.run_callbacks
+  end
+end

data/test/unit/transition/transition_with_multiple_around_callbacks_test.rb

@@ -0,0 +1,114 @@
+require_relative '../../test_helper'
+
+class TransitionWithMultipleAroundCallbacksTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+
+    @machine = StateMachines::Machine.new(@klass)
+    @machine.state :parked, :idling
+    @machine.event :ignite
+
+    @object = @klass.new
+    @object.state = 'parked'
+    @transition = StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling)
+  end
+
+  def test_should_before_yield_in_the_order_they_were_defined
+    @callbacks = []
+    @machine.around_transition { |block| @callbacks << 1; block.call }
+    @machine.around_transition { |block| @callbacks << 2; block.call }
+    @transition.run_callbacks
+
+    assert_equal [1, 2], @callbacks
+  end
+
+  def test_should_before_yield_multiple_methods_in_the_order_they_were_defined
+    @callbacks = []
+    @machine.around_transition(lambda { |block| @callbacks << 1; block.call }, lambda { |block| @callbacks << 2; block.call })
+    @machine.around_transition(lambda { |block| @callbacks << 3; block.call }, lambda { |block| @callbacks << 4; block.call })
+    @transition.run_callbacks
+
+    assert_equal [1, 2, 3, 4], @callbacks
+  end
+
+  def test_should_after_yield_in_the_reverse_order_they_were_defined
+    @callbacks = []
+    @machine.around_transition { |block| block.call; @callbacks << 1 }
+    @machine.around_transition { |block| block.call; @callbacks << 2 }
+    @transition.run_callbacks
+
+    assert_equal [2, 1], @callbacks
+  end
+
+  def test_should_after_yield_multiple_methods_in_the_reverse_order_they_were_defined
+    @callbacks = []
+    @machine.around_transition(lambda { |block| block.call; @callbacks << 1 }) { |block| block.call; @callbacks << 2 }
+    @machine.around_transition(lambda { |block| block.call; @callbacks << 3 }) { |block| block.call; @callbacks << 4 }
+    @transition.run_callbacks
+
+    assert_equal [4, 3, 2, 1], @callbacks
+  end
+
+  def test_should_run_block_between_callback
+    @callbacks = []
+    @machine.around_transition { |block| @callbacks << :before_1; block.call; @callbacks << :after_1 }
+    @machine.around_transition { |block| @callbacks << :before_2; block.call; @callbacks << :after_2 }
+    @transition.run_callbacks { @callbacks << :within; { success: true } }
+
+    assert_equal [:before_1, :before_2, :within, :after_2, :after_1], @callbacks
+  end
+
+  def test_should_have_access_to_result_after_yield
+    @machine.around_transition { |block| @before_result_1 = @transition.result; block.call; @after_result_1 = @transition.result }
+    @machine.around_transition { |block| @before_result_2 = @transition.result; block.call; @after_result_2 = @transition.result }
+    @transition.run_callbacks { { result: 1, success: true } }
+
+    assert_nil @before_result_1
+    assert_nil @before_result_2
+    assert_equal 1, @after_result_1
+    assert_equal 1, @after_result_2
+  end
+
+  def test_should_fail_if_any_before_yield_halted
+    @machine.around_transition { |block| block.call }
+    @machine.around_transition { throw :halt }
+
+    assert_equal false, @transition.run_callbacks
+  end
+
+  def test_should_not_continue_around_callbacks_if_before_yield_halted
+    @callbacks = []
+    @machine.around_transition { @callbacks << 1; throw :halt }
+    @machine.around_transition { |block| @callbacks << 2; block.call; @callbacks << 3 }
+
+    assert_equal false, @transition.run_callbacks
+    assert_equal [1], @callbacks
+  end
+
+  def test_should_not_continue_around_callbacks_if_later_before_yield_halted
+    @callbacks = []
+    @machine.around_transition { |block| block.call; @callbacks << 1 }
+    @machine.around_transition { throw :halt }
+
+    @transition.run_callbacks
+    assert_equal [], @callbacks
+  end
+
+  def test_should_not_run_further_callbacks_if_after_yield_halted
+    @callbacks = []
+    @machine.around_transition { |block| block.call; @callbacks << 1 }
+    @machine.around_transition { |block| block.call; throw :halt }
+
+    assert_equal true, @transition.run_callbacks
+    assert_equal [], @callbacks
+  end
+
+  def test_should_fail_if_any_fail_to_yield
+    @callbacks = []
+    @machine.around_transition { @callbacks << 1 }
+    @machine.around_transition { |block| @callbacks << 2; block.call; @callbacks << 3 }
+
+    assert_equal false, @transition.run_callbacks
+    assert_equal [1], @callbacks
+  end
+end

data/test/unit/transition/transition_with_multiple_before_callbacks_test.rb

@@ -0,0 +1,40 @@
+require_relative '../../test_helper'
+
+class TransitionWithMultipleBeforeCallbacksTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+
+    @machine = StateMachines::Machine.new(@klass)
+    @machine.state :parked, :idling
+    @machine.event :ignite
+
+    @object = @klass.new
+    @object.state = 'parked'
+    @transition = StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling)
+  end
+
+  def test_should_run_in_the_order_they_were_defined
+    @callbacks = []
+    @machine.before_transition { @callbacks << 1 }
+    @machine.before_transition { @callbacks << 2 }
+    @transition.run_callbacks
+
+    assert_equal [1, 2], @callbacks
+  end
+
+  def test_should_not_run_further_callbacks_if_halted
+    @callbacks = []
+    @machine.before_transition { @callbacks << 1; throw :halt }
+    @machine.before_transition { @callbacks << 2 }
+
+    assert_equal false, @transition.run_callbacks
+    assert_equal [1], @callbacks
+  end
+
+  def test_should_fail_if_any_callback_halted
+    @machine.before_transition { true }
+    @machine.before_transition { throw :halt }
+
+    assert_equal false, @transition.run_callbacks
+  end
+end

data/test/unit/transition/transition_with_multiple_failure_callbacks_test.rb

@@ -0,0 +1,40 @@
+require_relative '../../test_helper'
+
+class TransitionWithMultipleFailureCallbacksTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+
+    @machine = StateMachines::Machine.new(@klass)
+    @machine.state :parked, :idling
+    @machine.event :ignite
+
+    @object = @klass.new
+    @object.state = 'parked'
+    @transition = StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling)
+  end
+
+  def test_should_run_in_the_order_they_were_defined
+    @callbacks = []
+    @machine.after_failure { @callbacks << 1 }
+    @machine.after_failure { @callbacks << 2 }
+    @transition.run_callbacks { { success: false } }
+
+    assert_equal [1, 2], @callbacks
+  end
+
+  def test_should_not_run_further_callbacks_if_halted
+    @callbacks = []
+    @machine.after_failure { @callbacks << 1; throw :halt }
+    @machine.after_failure { @callbacks << 2 }
+
+    assert_equal true, @transition.run_callbacks { { success: false } }
+    assert_equal [1], @callbacks
+  end
+
+  def test_should_fail_if_any_callback_halted
+    @machine.after_failure { true }
+    @machine.after_failure { throw :halt }
+
+    assert_equal true, @transition.run_callbacks { { success: false } }
+  end
+end

data/test/unit/transition/transition_with_namespace_test.rb

@@ -0,0 +1,47 @@
+require_relative '../../test_helper'
+
+class TransitionWithNamespaceTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass, namespace: 'alarm')
+    @machine.state :off, :active
+    @machine.event :activate
+
+    @object = @klass.new
+    @object.state = 'off'
+
+    @transition = StateMachines::Transition.new(@object, @machine, :activate, :off, :active)
+  end
+
+  def test_should_have_an_event
+    assert_equal :activate, @transition.event
+  end
+
+  def test_should_have_a_qualified_event
+    assert_equal :activate_alarm, @transition.qualified_event
+  end
+
+  def test_should_have_a_from_name
+    assert_equal :off, @transition.from_name
+  end
+
+  def test_should_have_a_qualified_from_name
+    assert_equal :alarm_off, @transition.qualified_from_name
+  end
+
+  def test_should_have_a_human_from_name
+    assert_equal 'off', @transition.human_from_name
+  end
+
+  def test_should_have_a_to_name
+    assert_equal :active, @transition.to_name
+  end
+
+  def test_should_have_a_qualified_to_name
+    assert_equal :alarm_active, @transition.qualified_to_name
+  end
+
+  def test_should_have_a_human_to_name
+    assert_equal 'active', @transition.human_to_name
+  end
+end