state_machines 0.5.0 → 0.10.0

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

data/test/unit/transition/transition_with_perform_arguments_test.rb

@@ -1,35 +0,0 @@
-require_relative '../../test_helper'
-
-class TransitionWithPerformArgumentsTest < StateMachinesTest
-  def setup
-    @klass = Class.new do
-      attr_reader :saved
-
-      def save
-        @saved = true
-      end
-    end
-
-    @machine = StateMachines::Machine.new(@klass, action: :save)
-    @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_have_arguments
-    @transition.perform(1, 2)
-
-    assert_equal [1, 2], @transition.args
-    assert @object.saved
-  end
-
-  def test_should_not_include_run_action_in_arguments
-    @transition.perform(1, 2, false)
-
-    assert_equal [1, 2], @transition.args
-    refute @object.saved
-  end
-end

data/test/unit/transition/transition_with_transactions_test.rb

@@ -1,42 +0,0 @@
-require_relative '../../test_helper'
-
-class TransitionWithTransactionsTest < StateMachinesTest
-  def setup
-    @klass = Class.new do
-      class << self
-        attr_accessor :running_transaction
-      end
-
-      attr_accessor :result
-
-      def save
-        @result = self.class.running_transaction
-        true
-      end
-    end
-
-    @machine = StateMachines::Machine.new(@klass, action: :save)
-    @machine.state :parked, :idling
-    @machine.event :ignite
-
-    @object = @klass.new
-    @object.state = 'parked'
-    @transition = StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling)
-
-    class << @machine
-      def within_transaction(object)
-        owner_class.running_transaction = object
-        yield
-        owner_class.running_transaction = false
-      end
-    end
-  end
-
-  def test_should_run_blocks_within_transaction_for_object
-    @transition.within_transaction do
-      @result = @klass.running_transaction
-    end
-
-    assert_equal @object, @result
-  end
-end

data/test/unit/transition/transition_without_callbacks_test.rb

@@ -1,33 +0,0 @@
-require_relative '../../test_helper'
-
-class TransitionWithoutCallbacksTest < 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_succeed
-    assert_equal true, @transition.run_callbacks
-  end
-
-  def test_should_succeed_if_after_callbacks_skipped
-    assert_equal true, @transition.run_callbacks(after: false)
-  end
-
-  def test_should_call_block_if_provided
-    @transition.run_callbacks { @ran_block = true; {} }
-    assert @ran_block
-  end
-
-  def test_should_track_block_result
-    @transition.run_callbacks { { result: 1 } }
-    assert_equal 1, @transition.result
-  end
-end

data/test/unit/transition/transition_without_reading_state_test.rb

@@ -1,22 +0,0 @@
-require_relative '../../test_helper'
-
-class TransitionWithoutReadingStateTest < StateMachinesTest
-  def setup
-    @klass = Class.new
-    @machine = StateMachines::Machine.new(@klass)
-    @machine.state :parked, :idling
-    @machine.event :ignite
-
-    @object = @klass.new
-    @object.state = 'idling'
-    @transition = StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling, false)
-  end
-
-  def test_should_not_read_from_value_from_object
-    assert_equal 'parked', @transition.from
-  end
-
-  def test_should_have_to_value
-    assert_equal 'idling', @transition.to
-  end
-end