state_machines 0.4.0 → 0.6.0

data/test/unit/transition/transition_with_before_callbacks_test.rb

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

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

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

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

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

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

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

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

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

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

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

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