state_machines 0.0.2 → 0.1.0

data/test/unit/transition/transition_equality_test.rb

@@ -0,0 +1,52 @@
+require_relative '../../test_helper'
+
+class TransitionEqualityTest < 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_be_equal_with_same_properties
+    transition = StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling)
+    assert_equal transition, @transition
+  end
+
+  def test_should_not_be_equal_with_different_machines
+    machine = StateMachines::Machine.new(@klass, :status, namespace: :other)
+    machine.state :parked, :idling
+    machine.event :ignite
+    transition = StateMachines::Transition.new(@object, machine, :ignite, :parked, :idling)
+
+    refute_equal transition, @transition
+  end
+
+  def test_should_not_be_equal_with_different_objects
+    transition = StateMachines::Transition.new(@klass.new, @machine, :ignite, :parked, :idling)
+    refute_equal transition, @transition
+  end
+
+  def test_should_not_be_equal_with_different_event_names
+    @machine.event :park
+    transition = StateMachines::Transition.new(@object, @machine, :park, :parked, :idling)
+    refute_equal transition, @transition
+  end
+
+  def test_should_not_be_equal_with_different_from_state_names
+    @machine.state :first_gear
+    transition = StateMachines::Transition.new(@object, @machine, :ignite, :first_gear, :idling)
+    refute_equal transition, @transition
+  end
+
+  def test_should_not_be_equal_with_different_to_state_names
+    @machine.state :first_gear
+    transition = StateMachines::Transition.new(@object, @machine, :ignite, :idling, :first_gear)
+    refute_equal transition, @transition
+  end
+end

data/test/unit/transition/transition_loopback_test.rb

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

data/test/unit/transition/transition_test.rb

@@ -0,0 +1,96 @@
+require_relative '../../test_helper'
+
+class TransitionTest < 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_have_an_object
+    assert_equal @object, @transition.object
+  end
+
+  def test_should_have_a_machine
+    assert_equal @machine, @transition.machine
+  end
+
+  def test_should_have_an_event
+    assert_equal :ignite, @transition.event
+  end
+
+  def test_should_have_a_qualified_event
+    assert_equal :ignite, @transition.qualified_event
+  end
+
+  def test_should_have_a_human_event
+    assert_equal 'ignite', @transition.human_event
+  end
+
+  def test_should_have_a_from_value
+    assert_equal 'parked', @transition.from
+  end
+
+  def test_should_have_a_from_name
+    assert_equal :parked, @transition.from_name
+  end
+
+  def test_should_have_a_qualified_from_name
+    assert_equal :parked, @transition.qualified_from_name
+  end
+
+  def test_should_have_a_human_from_name
+    assert_equal 'parked', @transition.human_from_name
+  end
+
+  def test_should_have_a_to_value
+    assert_equal 'idling', @transition.to
+  end
+
+  def test_should_have_a_to_name
+    assert_equal :idling, @transition.to_name
+  end
+
+  def test_should_have_a_qualified_to_name
+    assert_equal :idling, @transition.qualified_to_name
+  end
+
+  def test_should_have_a_human_to_name
+    assert_equal 'idling', @transition.human_to_name
+  end
+
+  def test_should_have_an_attribute
+    assert_equal :state, @transition.attribute
+  end
+
+  def test_should_not_have_an_action
+    assert_nil @transition.action
+  end
+
+  def test_should_not_be_transient
+    assert_equal false, @transition.transient?
+  end
+
+  def test_should_generate_attributes
+    expected = { object: @object, attribute: :state, event: :ignite, from: 'parked', to: 'idling' }
+    assert_equal expected, @transition.attributes
+  end
+
+  def test_should_have_empty_args
+    assert_equal [], @transition.args
+  end
+
+  def test_should_not_have_a_result
+    assert_nil @transition.result
+  end
+
+  def test_should_use_pretty_inspect
+    assert_equal '#<StateMachines::Transition attribute=:state event=:ignite from="parked" from_name=:parked to="idling" to_name=:idling>', @transition.inspect
+  end
+end

data/test/unit/transition/transition_transient_test.rb

@@ -0,0 +1,20 @@
+require_relative '../../test_helper'
+
+class TransitionTransientTest < 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)
+    @transition.transient = true
+  end
+
+  def test_should_be_transient
+    assert @transition.transient?
+  end
+end

data/test/unit/transition/transition_with_action_test.rb

@@ -0,0 +1,27 @@
+require_relative '../../test_helper'
+
+class TransitionWithActionTest < StateMachinesTest
+  def setup
+    @klass = Class.new do
+      def save
+      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_an_action
+    assert_equal :save, @transition.action
+  end
+
+  def test_should_not_have_a_result
+    assert_nil @transition.result
+  end
+end

data/test/unit/transition/transition_with_after_callbacks_skipped_test.rb

@@ -0,0 +1,127 @@
+require_relative '../../test_helper'
+
+class TransitionWithAfterCallbacksSkippedTest < 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 }
+
+    assert_equal true, @transition.run_callbacks(after: false)
+    assert @run
+  end
+
+  def test_should_not_run_after_callbacks
+    @run = false
+    @machine.after_transition { @run = true }
+
+    assert_equal true, @transition.run_callbacks(after: false)
+    refute @run
+  end
+
+  if StateMachines::Transition.pause_supported?
+    def test_should_run_around_callbacks_before_yield
+      @machine.around_transition { |block| @run = true; block.call }
+
+      assert_equal true, @transition.run_callbacks(after: false)
+      assert @run
+    end
+
+    def test_should_not_run_around_callbacks_after_yield
+      @run = false
+      @machine.around_transition { |block| block.call; @run = true }
+
+      assert_equal true, @transition.run_callbacks(after: false)
+      refute @run
+    end
+
+    def test_should_continue_around_transition_execution_on_second_call
+      @callbacks = []
+      @machine.around_transition { |block| @callbacks << :before_around_1; block.call; @callbacks << :after_around_1 }
+      @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(after: false)
+      assert_equal [:before_around_1, :before_around_2], @callbacks
+
+      assert_equal true, @transition.run_callbacks
+      assert_equal [:before_around_1, :before_around_2, :after_around_2, :after_around_1, :after], @callbacks
+    end
+
+    def test_should_not_run_further_callbacks_if_halted_during_continue_around_transition
+      @callbacks = []
+      @machine.around_transition { |block| @callbacks << :before_around_1; block.call; @callbacks << :after_around_1 }
+      @machine.around_transition { |block| @callbacks << :before_around_2; block.call; @callbacks << :after_around_2; throw :halt }
+      @machine.after_transition { @callbacks << :after }
+
+      assert_equal true, @transition.run_callbacks(after: false)
+      assert_equal [:before_around_1, :before_around_2], @callbacks
+
+      assert_equal true, @transition.run_callbacks
+      assert_equal [:before_around_1, :before_around_2, :after_around_2], @callbacks
+    end
+
+    def test_should_not_be_able_to_continue_twice
+      @count = 0
+      @machine.around_transition { |block| block.call; @count += 1 }
+      @machine.after_transition { @count += 1 }
+
+      @transition.run_callbacks(after: false)
+
+      2.times do
+        assert_equal true, @transition.run_callbacks
+        assert_equal 2, @count
+      end
+    end
+
+    def test_should_not_be_able_to_continue_again_after_halted
+      @count = 0
+      @machine.around_transition { |block| block.call; @count += 1; throw :halt }
+      @machine.after_transition { @count += 1 }
+
+      @transition.run_callbacks(after: false)
+
+      2.times do
+        assert_equal true, @transition.run_callbacks
+        assert_equal 1, @count
+      end
+    end
+
+    def test_should_have_access_to_result_after_continued
+      @machine.around_transition { |block| @around_before_result = @transition.result; block.call; @around_after_result = @transition.result }
+      @machine.after_transition { @after_result = @transition.result }
+
+      @transition.run_callbacks(after: false)
+      @transition.run_callbacks { { result: 1 } }
+
+      assert_nil @around_before_result
+      assert_equal 1, @around_after_result
+      assert_equal 1, @after_result
+    end
+
+    def test_should_raise_exceptions_during_around_callbacks_after_yield_in_second_execution
+      @machine.around_transition { |block| block.call; fail ArgumentError }
+
+      @transition.run_callbacks(after: false)
+      assert_raises(ArgumentError) { @transition.run_callbacks }
+    end
+  else
+    def test_should_raise_exception_on_second_call
+      @callbacks = []
+      @machine.around_transition { |block| @callbacks << :before_around_1; block.call; @callbacks << :after_around_1 }
+      @machine.around_transition { |block| @callbacks << :before_around_2; block.call; @callbacks << :after_around_2 }
+      @machine.after_transition { @callbacks << :after }
+
+      assert_raises(ArgumentError) { @transition.run_callbacks(after: false) }
+    end
+  end
+end

data/test/unit/transition/transition_with_after_callbacks_test.rb

@@ -0,0 +1,93 @@
+require_relative '../../test_helper'
+
+class TransitionWithAfterCallbacksTest < 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_after_callbacks
+    @machine.after_transition { |_object| @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.after_transition from: :parked, to: :idling, on: :park, do: callback
+    @machine.after_transition from: :parked, to: :parked, on: :park, do: callback
+    @machine.after_transition from: :parked, to: :idling, on: :ignite, do: callback
+    @machine.after_transition from: :idling, to: :idling, on: :park, do: callback
+    @transition.run_callbacks
+
+    assert_equal 1, @count
+  end
+
+  def test_should_not_run_if_not_successful
+    @run = false
+    @machine.after_transition { |_object| @run = true }
+    @transition.run_callbacks { { success: false } }
+    refute @run
+  end
+
+  def test_should_run_if_successful
+    @machine.after_transition { |_object| @run = true }
+    @transition.run_callbacks { { success: true } }
+    assert @run
+  end
+
+  def test_should_pass_transition_as_argument
+    @machine.after_transition { |*args| @args = args }
+
+    @transition.run_callbacks
+    assert_equal [@object, @transition], @args
+  end
+
+  def test_should_catch_halts
+    @machine.after_transition { throw :halt }
+
+    result = @transition.run_callbacks
+    assert_equal true, result
+  end
+
+  def test_should_not_catch_exceptions
+    @machine.after_transition  { fail ArgumentError }
+    assert_raises(ArgumentError) { @transition.run_callbacks }
+  end
+
+  def test_should_not_be_able_to_run_twice
+    @count = 0
+    @machine.after_transition { @count += 1 }
+    @transition.run_callbacks
+    @transition.run_callbacks
+    assert_equal 1, @count
+  end
+
+  def test_should_not_be_able_to_run_twice_if_halted
+    @count = 0
+    @machine.after_transition { @count += 1; throw :halt }
+    @transition.run_callbacks
+    @transition.run_callbacks
+    assert_equal 1, @count
+  end
+
+  def test_should_be_able_to_run_again_after_resetting
+    @count = 0
+    @machine.after_transition { @count += 1 }
+    @transition.run_callbacks
+    @transition.reset
+    @transition.run_callbacks
+    assert_equal 2, @count
+  end
+end

data/test/unit/transition/transition_with_around_callbacks_test.rb

@@ -0,0 +1,141 @@
+require_relative '../../test_helper'
+
+class TransitionWithAroundCallbacksTest < 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_around_callbacks
+    @machine.around_transition { |_object, _transition, block| @run_before = true; block.call; @run_after = true }
+    result = @transition.run_callbacks
+
+    assert_equal true, result
+    assert_equal true, @run_before
+    assert_equal true, @run_after
+  end
+
+  def test_should_only_run_those_that_match_transition_context
+    @count = 0
+    callback = lambda { |_object, _transition, block| @count += 1; block.call }
+
+    @machine.around_transition from: :parked, to: :idling, on: :park, do: callback
+    @machine.around_transition from: :parked, to: :parked, on: :park, do: callback
+    @machine.around_transition from: :parked, to: :idling, on: :ignite, do: callback
+    @machine.around_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.around_transition { |*args| block = args.pop; @args = args; block.call }
+    @transition.run_callbacks
+
+    assert_equal [@object, @transition], @args
+  end
+
+  def test_should_run_block_between_callback
+    @callbacks = []
+    @machine.around_transition { |block| @callbacks << :before; block.call; @callbacks << :after }
+    @transition.run_callbacks { @callbacks << :within; { success: true } }
+
+    assert_equal [:before, :within, :after], @callbacks
+  end
+
+  def test_should_have_access_to_result_after_yield
+    @machine.around_transition { |block| @before_result = @transition.result; block.call; @after_result = @transition.result }
+    @transition.run_callbacks { { result: 1, success: true } }
+
+    assert_nil @before_result
+    assert_equal 1, @after_result
+  end
+
+  def test_should_catch_before_yield_halts
+    @machine.around_transition { throw :halt }
+
+    result = @transition.run_callbacks
+    assert_equal false, result
+  end
+
+  def test_should_catch_after_yield_halts
+    @machine.around_transition { |block| block.call; throw :halt }
+
+    result = @transition.run_callbacks
+    assert_equal true, result
+  end
+
+  def test_should_not_catch_before_yield
+    @machine.around_transition  { fail ArgumentError }
+    assert_raises(ArgumentError) { @transition.run_callbacks }
+  end
+
+  def test_should_not_catch_after_yield
+    @machine.around_transition { |block| block.call; fail ArgumentError }
+    assert_raises(ArgumentError) { @transition.run_callbacks }
+  end
+
+  def test_should_fail_if_not_yielded
+    @machine.around_transition {}
+
+    result = @transition.run_callbacks
+    assert_equal false, result
+  end
+
+  def test_should_not_be_able_to_run_twice
+    @before_count = 0
+    @after_count = 0
+    @machine.around_transition { |block| @before_count += 1; block.call; @after_count += 1 }
+    @transition.run_callbacks
+    @transition.run_callbacks
+    assert_equal 1, @before_count
+    assert_equal 1, @after_count
+  end
+
+  def test_should_be_able_to_run_again_after_resetting
+    @before_count = 0
+    @after_count = 0
+    @machine.around_transition { |block| @before_count += 1; block.call; @after_count += 1 }
+    @transition.run_callbacks
+    @transition.reset
+    @transition.run_callbacks
+    assert_equal 2, @before_count
+    assert_equal 2, @after_count
+  end
+
+  def test_should_succeed_if_block_result_is_false
+    @machine.around_transition { |block| @before_run = true; block.call; @after_run = true }
+    assert_equal true, @transition.run_callbacks { { success: true, result: false } }
+    assert @before_run
+    assert @after_run
+  end
+
+  def test_should_succeed_if_block_result_is_true
+    @machine.around_transition { |block| @before_run = true; block.call; @after_run = true }
+    assert_equal true, @transition.run_callbacks { { success: true, result: true } }
+    assert @before_run
+    assert @after_run
+  end
+
+  def test_should_only_run_before_if_block_success_is_false
+    @after_run = false
+    @machine.around_transition { |block| @before_run = true; block.call; @after_run = true }
+    assert_equal true, @transition.run_callbacks { { success: false } }
+    assert @before_run
+    refute @after_run
+  end
+
+  def test_should_succeed_if_block_success_is_false
+    @machine.around_transition { |block| @before_run = true; block.call; @after_run = true }
+    assert_equal true, @transition.run_callbacks { { success: true } }
+    assert @before_run
+    assert @after_run
+  end
+end

data/test/unit/transition/transition_with_before_callbacks_skipped_test.rb

@@ -0,0 +1,30 @@
+require_relative '../../test_helper'
+
+class TransitionWithBeforeCallbacksSkippedTest < 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_run_before_callbacks
+    @run = false
+    @machine.before_transition { @run = true }
+
+    assert_equal false, @transition.run_callbacks(before: false)
+    refute @run
+  end
+
+  def test_should_run_failure_callbacks
+    @machine.after_failure { @run = true }
+
+    assert_equal false, @transition.run_callbacks(before: false)
+    assert @run
+  end
+end