state_machines 0.0.2 → 0.1.0

data/test/unit/transition_collection/transition_collection_with_different_actions_test.rb

@@ -0,0 +1,189 @@
+require_relative '../../test_helper'
+
+class TransitionCollectionWithDifferentActionsTest < StateMachinesTest
+  def setup
+    @klass = Class.new do
+      attr_reader :actions
+
+      def save_state
+        (@actions ||= []) << :save_state
+        :save_state
+      end
+
+      def save_status
+        (@actions ||= []) << :save_status
+        :save_status
+      end
+    end
+
+    @state = StateMachines::Machine.new(@klass, initial: :parked, action: :save_state)
+    @state.state :idling
+    @state.event :ignite
+
+    @status = StateMachines::Machine.new(@klass, :status, initial: :first_gear, action: :save_status)
+    @status.state :second_gear
+    @status.event :shift_up
+
+    @object = @klass.new
+
+    @transitions = StateMachines::TransitionCollection.new([
+      @state_transition = StateMachines::Transition.new(@object, @state, :ignite, :parked, :idling),
+      @status_transition = StateMachines::Transition.new(@object, @status, :shift_up, :first_gear, :second_gear)
+    ])
+  end
+
+  def test_should_succeed
+    assert_equal true, @transitions.perform
+  end
+
+  def test_should_persist_states
+    @transitions.perform
+    assert_equal 'idling', @object.state
+    assert_equal 'second_gear', @object.status
+  end
+
+  def test_should_run_actions_in_order
+    @transitions.perform
+    assert_equal [:save_state, :save_status], @object.actions
+  end
+
+  def test_should_store_results_in_transitions
+    @transitions.perform
+    assert_equal :save_state, @state_transition.result
+    assert_equal :save_status, @status_transition.result
+  end
+
+  def test_should_not_halt_if_action_fails_for_first_transition
+    @klass.class_eval do
+      remove_method :save_state
+
+      def save_state
+        (@actions ||= []) << :save_state
+        false
+      end
+    end
+
+    assert_equal false, @transitions.perform
+    assert_equal [:save_state, :save_status], @object.actions
+  end
+
+  def test_should_halt_if_action_fails_for_second_transition
+    @klass.class_eval do
+      remove_method :save_status
+
+      def save_status
+        (@actions ||= []) << :save_status
+        false
+      end
+    end
+
+    assert_equal false, @transitions.perform
+    assert_equal [:save_state, :save_status], @object.actions
+  end
+
+  def test_should_rollback_if_action_errors_for_first_transition
+    @klass.class_eval do
+      remove_method :save_state
+
+      def save_state
+        fail ArgumentError
+      end
+    end
+
+    begin
+      ; @transitions.perform
+    rescue
+    end
+    assert_equal 'parked', @object.state
+    assert_equal 'first_gear', @object.status
+  end
+
+  def test_should_rollback_if_action_errors_for_second_transition
+    @klass.class_eval do
+      remove_method :save_status
+
+      def save_status
+        fail ArgumentError
+      end
+    end
+
+    begin
+      ; @transitions.perform
+    rescue
+    end
+    assert_equal 'parked', @object.state
+    assert_equal 'first_gear', @object.status
+  end
+
+  def test_should_not_run_after_callbacks_if_action_fails_for_first_transition
+    @klass.class_eval do
+      remove_method :save_state
+
+      def save_state
+        false
+      end
+    end
+
+    @callbacks = []
+    @state.after_transition { @callbacks << :state_after }
+    @state.around_transition { |block| block.call; @callbacks << :state_around }
+    @status.after_transition { @callbacks << :status_after }
+    @status.around_transition { |block| block.call; @callbacks << :status_around }
+
+    @transitions.perform
+    assert_equal [], @callbacks
+  end
+
+  def test_should_not_run_after_callbacks_if_action_fails_for_second_transition
+    @klass.class_eval do
+      remove_method :save_status
+
+      def save_status
+        false
+      end
+    end
+
+    @callbacks = []
+    @state.after_transition { @callbacks << :state_after }
+    @state.around_transition { |block| block.call; @callbacks << :state_around }
+    @status.after_transition { @callbacks << :status_after }
+    @status.around_transition { |block| block.call; @callbacks << :status_around }
+
+    @transitions.perform
+    assert_equal [], @callbacks
+  end
+
+  def test_should_run_after_failure_callbacks_if_action_fails_for_first_transition
+    @klass.class_eval do
+      remove_method :save_state
+
+      def save_state
+        false
+      end
+    end
+
+    @callbacks = []
+    @state.after_failure { @callbacks << :state_after }
+    @status.after_failure { @callbacks << :status_after }
+
+    @transitions.perform
+    assert_equal [:status_after, :state_after], @callbacks
+  end
+
+  def test_should_run_after_failure_callbacks_if_action_fails_for_second_transition
+    @klass.class_eval do
+      remove_method :save_status
+
+      def save_status
+        false
+      end
+    end
+
+    @callbacks = []
+    @state.after_failure { @callbacks << :state_after }
+    @status.after_failure { @callbacks << :status_after }
+
+    @transitions.perform
+    assert_equal [:status_after, :state_after], @callbacks
+  end
+end

data/test/unit/transition_collection/transition_collection_with_duplicate_actions_test.rb

@@ -0,0 +1,48 @@
+require_relative '../../test_helper'
+
+class TransitionCollectionWithDuplicateActionsTest < StateMachinesTest
+  def setup
+    @klass = Class.new do
+      attr_reader :actions
+
+      def save
+        (@actions ||= []) << :save
+        :save
+      end
+    end
+
+    @state = StateMachines::Machine.new(@klass, initial: :parked, action: :save)
+    @state.state :idling
+    @state.event :ignite
+
+    @status = StateMachines::Machine.new(@klass, :status, initial: :first_gear, action: :save)
+    @status.state :second_gear
+    @status.event :shift_up
+
+    @object = @klass.new
+
+    @transitions = StateMachines::TransitionCollection.new([
+      @state_transition = StateMachines::Transition.new(@object, @state, :ignite, :parked, :idling),
+      @status_transition = StateMachines::Transition.new(@object, @status, :shift_up, :first_gear, :second_gear)
+    ])
+    @result = @transitions.perform
+  end
+
+  def test_should_succeed
+    assert_equal :save, @result
+  end
+
+  def test_should_persist_states
+    assert_equal 'idling', @object.state
+    assert_equal 'second_gear', @object.status
+  end
+
+  def test_should_run_action_once
+    assert_equal [:save], @object.actions
+  end
+
+  def test_should_store_results_in_transitions
+    assert_equal :save, @state_transition.result
+    assert_equal :save, @status_transition.result
+  end
+end

data/test/unit/transition_collection/transition_collection_with_empty_actions_test.rb

@@ -0,0 +1,41 @@
+require_relative '../../test_helper'
+
+class TransitionCollectionWithEmptyActionsTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+
+    @state = StateMachines::Machine.new(@klass, initial: :parked)
+    @state.state :idling
+    @state.event :ignite
+
+    @status = StateMachines::Machine.new(@klass, :status, initial: :first_gear)
+    @status.state :second_gear
+    @status.event :shift_up
+
+    @object = @klass.new
+
+    @transitions = StateMachines::TransitionCollection.new([
+      @state_transition = StateMachines::Transition.new(@object, @state, :ignite, :parked, :idling),
+      @status_transition = StateMachines::Transition.new(@object, @status, :shift_up, :first_gear, :second_gear)
+    ])
+
+    @object.state = 'idling'
+    @object.status = 'second_gear'
+
+    @result = @transitions.perform
+  end
+
+  def test_should_succeed
+    assert_equal true, @result
+  end
+
+  def test_should_persist_states
+    assert_equal 'idling', @object.state
+    assert_equal 'second_gear', @object.status
+  end
+
+  def test_should_store_results_in_transitions
+    assert_nil @state_transition.result
+    assert_nil @status_transition.result
+  end
+end

data/test/unit/transition_collection/transition_collection_with_mixed_actions_test.rb

@@ -0,0 +1,41 @@
+require_relative '../../test_helper'
+
+class TransitionCollectionWithMixedActionsTest < StateMachinesTest
+  def setup
+    @klass = Class.new do
+      def save
+        true
+      end
+    end
+
+    @state = StateMachines::Machine.new(@klass, initial: :parked, action: :save)
+    @state.state :idling
+    @state.event :ignite
+
+    @status = StateMachines::Machine.new(@klass, :status, initial: :first_gear)
+    @status.state :second_gear
+    @status.event :shift_up
+
+    @object = @klass.new
+
+    @transitions = StateMachines::TransitionCollection.new([
+      @state_transition = StateMachines::Transition.new(@object, @state, :ignite, :parked, :idling),
+      @status_transition = StateMachines::Transition.new(@object, @status, :shift_up, :first_gear, :second_gear)
+    ])
+    @result = @transitions.perform
+  end
+
+  def test_should_succeed
+    assert_equal true, @result
+  end
+
+  def test_should_persist_states
+    assert_equal 'idling', @object.state
+    assert_equal 'second_gear', @object.status
+  end
+
+  def test_should_store_results_in_transitions
+    assert_equal true, @state_transition.result
+    assert_nil @status_transition.result
+  end
+end

data/test/unit/transition_collection/transition_collection_with_skipped_actions_and_block_test.rb

@@ -0,0 +1,34 @@
+require_relative '../../test_helper'
+
+class TransitionCollectionWithSkippedActionsAndBlockTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+
+    @machine = StateMachines::Machine.new(@klass, initial: :parked, action: :save_state)
+    @machine.state :idling
+    @machine.event :ignite
+
+    @object = @klass.new
+
+    @transitions = StateMachines::TransitionCollection.new([
+      @state_transition = StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling)
+    ], actions: false)
+    @result = @transitions.perform { @ran_block = true; 1 }
+  end
+
+  def test_should_succeed
+    assert_equal 1, @result
+  end
+
+  def test_should_persist_states
+    assert_equal 'idling', @object.state
+  end
+
+  def test_should_run_block
+    assert @ran_block
+  end
+
+  def test_should_store_results_in_transitions
+    assert_equal 1, @state_transition.result
+  end
+end

data/test/unit/transition_collection/transition_collection_with_skipped_actions_test.rb

@@ -0,0 +1,69 @@
+require_relative '../../test_helper'
+
+class TransitionCollectionWithSkippedActionsTest < StateMachinesTest
+  def setup
+    @klass = Class.new do
+      attr_reader :actions
+
+      def save_state
+        (@actions ||= []) << :save_state
+        :save_state
+      end
+
+      def save_status
+        (@actions ||= []) << :save_status
+        :save_status
+      end
+    end
+
+    @callbacks = []
+
+    @state = StateMachines::Machine.new(@klass, initial: :parked, action: :save_state)
+    @state.state :idling
+    @state.event :ignite
+    @state.before_transition { @callbacks << :state_before }
+    @state.after_transition { @callbacks << :state_after }
+    @state.around_transition { |block| @callbacks << :state_around_before; block.call; @callbacks << :state_around_after }
+
+    @status = StateMachines::Machine.new(@klass, :status, initial: :first_gear, action: :save_status)
+    @status.state :second_gear
+    @status.event :shift_up
+    @status.before_transition { @callbacks << :status_before }
+    @status.after_transition { @callbacks << :status_after }
+    @status.around_transition { |block| @callbacks << :status_around_before; block.call; @callbacks << :status_around_after }
+
+    @object = @klass.new
+
+    @transitions = StateMachines::TransitionCollection.new([
+      @state_transition = StateMachines::Transition.new(@object, @state, :ignite, :parked, :idling),
+      @status_transition = StateMachines::Transition.new(@object, @status, :shift_up, :first_gear, :second_gear)
+    ], actions: false)
+    @result = @transitions.perform
+  end
+
+  def test_should_skip_actions
+    assert_equal true, @transitions.skip_actions
+  end
+
+  def test_should_succeed
+    assert_equal true, @result
+  end
+
+  def test_should_persist_states
+    assert_equal 'idling', @object.state
+    assert_equal 'second_gear', @object.status
+  end
+
+  def test_should_not_run_actions
+    assert_nil @object.actions
+  end
+
+  def test_should_store_results_in_transitions
+    assert_nil @state_transition.result
+    assert_nil @status_transition.result
+  end
+
+  def test_should_run_all_callbacks
+    assert_equal [:state_before, :state_around_before, :status_before, :status_around_before, :status_around_after, :status_after, :state_around_after, :state_after], @callbacks
+  end
+end

data/test/unit/transition_collection/transition_collection_with_skipped_after_callbacks_and_around_callbacks_test.rb

@@ -0,0 +1,53 @@
+require_relative '../../test_helper'
+
+class TransitionCollectionWithSkippedAfterCallbacksAndAroundCallbacksTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+
+    @callbacks = []
+
+    @machine = StateMachines::Machine.new(@klass, initial: :parked)
+    @machine.state :idling
+    @machine.event :ignite
+    @machine.around_transition { |block| @callbacks << :around_before; block.call; @callbacks << :around_after }
+
+    @object = @klass.new
+
+    @transitions = StateMachines::TransitionCollection.new([
+      @transition = StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling)
+    ], after: false)
+    @result = @transitions.perform
+  end
+
+  def test_should_raise_exception
+    skip('Not supported') if StateMachines::Transition.pause_supported?
+    assert_raises(ArgumentError) { @transitions.perform }
+  end
+
+  def test_should_succeed
+    skip unless StateMachines::Transition.pause_supported?
+
+    assert_equal true, @result
+  end
+
+  def test_should_not_run_around_callbacks_after_yield
+    skip unless StateMachines::Transition.pause_supported?
+
+    refute @callbacks.include?(:around_after)
+  end
+
+  def test_should_run_around_callbacks_after_yield_on_subsequent_perform
+    skip unless StateMachines::Transition.pause_supported?
+
+    StateMachines::TransitionCollection.new([@transition]).perform
+    assert @callbacks.include?(:around_after)
+  end
+
+  def test_should_not_rerun_around_callbacks_before_yield_on_subsequent_perform
+    skip unless StateMachines::Transition.pause_supported?
+
+    @callbacks = []
+    StateMachines::TransitionCollection.new([@transition]).perform
+    refute @callbacks.include?(:around_before)
+  end
+end

data/test/unit/transition_collection/transition_collection_with_skipped_after_callbacks_test.rb

@@ -0,0 +1,34 @@
+require_relative '../../test_helper'
+
+class TransitionCollectionWithSkippedAfterCallbacksTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+
+    @callbacks = []
+
+    @machine = StateMachines::Machine.new(@klass, initial: :parked)
+    @machine.state :idling
+    @machine.event :ignite
+    @machine.after_transition { @callbacks << :after }
+
+    @object = @klass.new
+
+    @transitions = StateMachines::TransitionCollection.new([
+      @transition = StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling)
+    ], after: false)
+    @result = @transitions.perform
+  end
+
+  def test_should_succeed
+    assert_equal true, @result
+  end
+
+  def test_should_not_run_after_callbacks
+    refute @callbacks.include?(:after)
+  end
+
+  def test_should_run_after_callbacks_on_subsequent_perform
+    StateMachines::TransitionCollection.new([@transition]).perform
+    assert @callbacks.include?(:after)
+  end
+end

data/test/unit/transition_collection/transition_collection_with_transactions_test.rb

@@ -0,0 +1,65 @@
+require_relative '../../test_helper'
+
+class TransitionCollectionWithTransactionsTest < StateMachinesTest
+  def setup
+    @klass = Class.new do
+      attr_accessor :running_transaction, :cancelled_transaction
+    end
+
+    @machine = StateMachines::Machine.new(@klass, initial: :parked)
+    @machine.state :idling
+    @machine.event :ignite
+
+    class << @machine
+      def within_transaction(object)
+        object.running_transaction = true
+        object.cancelled_transaction = yield == false
+        object.running_transaction = false
+      end
+    end
+
+    @object = @klass.new
+    @transitions = StateMachines::TransitionCollection.new([
+      StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling)
+    ], transaction: true)
+  end
+
+  def test_should_run_before_callbacks_within_transaction
+    @machine.before_transition { |object| @in_transaction = object.running_transaction }
+    @transitions.perform
+
+    assert @in_transaction
+  end
+
+  def test_should_run_action_within_transaction
+    @transitions.perform { @in_transaction = @object.running_transaction }
+
+    assert @in_transaction
+  end
+
+  def test_should_run_after_callbacks_within_transaction
+    @machine.after_transition { |object| @in_transaction = object.running_transaction }
+    @transitions.perform
+
+    assert @in_transaction
+  end
+
+  def test_should_cancel_the_transaction_on_before_halt
+    @machine.before_transition { throw :halt }
+
+    @transitions.perform
+    assert @object.cancelled_transaction
+  end
+
+  def test_should_cancel_the_transaction_on_action_failure
+    @transitions.perform { false }
+    assert @object.cancelled_transaction
+  end
+
+  def test_should_not_cancel_the_transaction_on_after_halt
+    @machine.after_transition { throw :halt }
+
+    @transitions.perform
+    refute @object.cancelled_transaction
+  end
+end

data/test/unit/transition_collection/transition_collection_without_transactions_test.rb

@@ -0,0 +1,29 @@
+require_relative '../../test_helper'
+
+class TransitionCollectionWithoutTransactionsTest < StateMachinesTest
+  def setup
+    @klass = Class.new do
+      attr_accessor :ran_transaction
+    end
+
+    @machine = StateMachines::Machine.new(@klass, initial: :parked)
+    @machine.state :idling
+    @machine.event :ignite
+
+    class << @machine
+      def within_transaction(object)
+        object.ran_transaction = true
+      end
+    end
+
+    @object = @klass.new
+    @transitions = StateMachines::TransitionCollection.new([
+      StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling)
+    ], transaction: false)
+    @transitions.perform
+  end
+
+  def test_should_not_run_within_transaction
+    refute @object.ran_transaction
+  end
+end