state_machines 0.5.0 → 0.10.0

data/test/unit/transition_collection/transition_collection_with_action_hook_with_different_actions_test.rb

@@ -1,48 +0,0 @@
-require_relative '../../test_helper'
-require_relative 'transition_collection_with_action_hook_base_test.rb'
-
-class TransitionCollectionWithActionHookWithDifferentActionsTest < TransitionCollectionWithActionHookBaseTest
-  def setup
-    super
-
-    @klass.class_eval do
-      def save_status
-        true
-      end
-    end
-
-    @machine = StateMachines::Machine.new(@klass, :status, initial: :first_gear, action: :save_status)
-    @machine.state :second_gear
-    @machine.event :shift_up
-
-    @result = StateMachines::TransitionCollection.new([@transition, StateMachines::Transition.new(@object, @machine, :shift_up, :first_gear, :second_gear)]).perform
-  end
-
-  def test_should_succeed
-    assert_equal true, @result
-  end
-
-  def test_should_run_action
-    assert @object.saved
-  end
-
-  def test_should_have_already_persisted_when_running_action
-    assert_equal 'idling', @object.state_on_save
-  end
-
-  def test_should_not_have_event_during_action
-    assert_nil @object.state_event_on_save
-  end
-
-  def test_should_not_write_event
-    assert_nil @object.state_event
-  end
-
-  def test_should_not_have_event_transition_during_save
-    assert_nil @object.state_event_transition_on_save
-  end
-
-  def test_should_not_write_event_attribute
-    assert_nil @object.send(:state_event_transition)
-  end
-end

data/test/unit/transition_collection/transition_collection_with_action_hook_with_nil_action_test.rb

@@ -1,42 +0,0 @@
-require_relative '../../test_helper'
-require_relative 'transition_collection_with_action_hook_base_test.rb'
-
-class TransitionCollectionWithActionHookWithNilActionTest < TransitionCollectionWithActionHookBaseTest
-  def setup
-    super
-
-    @machine = StateMachines::Machine.new(@klass, :status, initial: :first_gear)
-    @machine.state :second_gear
-    @machine.event :shift_up
-
-    @result = StateMachines::TransitionCollection.new([@transition, StateMachines::Transition.new(@object, @machine, :shift_up, :first_gear, :second_gear)]).perform
-  end
-
-  def test_should_succeed
-    assert_equal true, @result
-  end
-
-  def test_should_run_action
-    assert @object.saved
-  end
-
-  def test_should_have_already_persisted_when_running_action
-    assert_equal 'idling', @object.state_on_save
-  end
-
-  def test_should_not_have_event_during_action
-    assert_nil @object.state_event_on_save
-  end
-
-  def test_should_not_write_event
-    assert_nil @object.state_event
-  end
-
-  def test_should_not_have_event_transition_during_save
-    assert_nil @object.state_event_transition_on_save
-  end
-
-  def test_should_not_write_event_attribute
-    assert_nil @object.send(:state_event_transition)
-  end
-end

data/test/unit/transition_collection/transition_collection_with_after_callback_halt_test.rb

@@ -1,47 +0,0 @@
-require_relative '../../test_helper'
-
-class TransitionCollectionWithAfterCallbackHaltTest < StateMachinesTest
-  def setup
-    @klass = Class.new do
-      attr_reader :saved
-
-      def save
-        @saved = true
-      end
-    end
-    @before_count = 0
-    @after_count = 0
-
-    @machine = StateMachines::Machine.new(@klass, initial: :parked, action: :save)
-    @machine.state :idling
-    @machine.event :ignite
-
-    @machine.before_transition { @before_count += 1 }
-    @machine.after_transition { @after_count += 1; throw :halt }
-    @machine.after_transition { @after_count += 1 }
-    @machine.around_transition { |block| @before_count += 1; block.call; @after_count += 1 }
-
-    @object = @klass.new
-
-    @transitions = StateMachines::TransitionCollection.new([
-      StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling)
-    ])
-    @result = @transitions.perform
-  end
-
-  def test_should_succeed
-    assert_equal true, @result
-  end
-
-  def test_should_persist_state
-    assert_equal 'idling', @object.state
-  end
-
-  def test_should_run_before_callbacks
-    assert_equal 2, @before_count
-  end
-
-  def test_should_not_run_further_after_callbacks
-    assert_equal 2, @after_count
-  end
-end

data/test/unit/transition_collection/transition_collection_with_before_callback_halt_test.rb

@@ -1,51 +0,0 @@
-require_relative '../../test_helper'
-
-class TransitionCollectionWithBeforeCallbackHaltTest < StateMachinesTest
-  def setup
-    @klass = Class.new do
-      attr_reader :saved
-
-      def save
-        @saved = true
-      end
-    end
-    @before_count = 0
-    @after_count = 0
-
-    @machine = StateMachines::Machine.new(@klass, initial: :parked, action: :save)
-    @machine.state :idling
-    @machine.event :ignite
-
-    @machine.before_transition { @before_count += 1; throw :halt }
-    @machine.before_transition { @before_count += 1 }
-    @machine.after_transition { @after_count += 1 }
-    @machine.around_transition { |block| @before_count += 1; block.call; @after_count += 1 }
-
-    @object = @klass.new
-
-    @transitions = StateMachines::TransitionCollection.new([
-      StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling)
-    ])
-    @result = @transitions.perform
-  end
-
-  def test_should_not_succeed
-    assert_equal false, @result
-  end
-
-  def test_should_not_persist_state
-    assert_equal 'parked', @object.state
-  end
-
-  def test_should_not_run_action
-    refute @object.saved
-  end
-
-  def test_should_not_run_further_before_callbacks
-    assert_equal 1, @before_count
-  end
-
-  def test_should_not_run_after_callbacks
-    assert_equal 0, @after_count
-  end
-end

data/test/unit/transition_collection/transition_collection_with_block_test.rb

@@ -1,46 +0,0 @@
-require_relative '../../test_helper'
-
-class TransitionCollectionWithBlockTest < StateMachinesTest
-  def setup
-    @klass = Class.new do
-      attr_reader :actions
-
-      def save
-        (@actions ||= []) << :save
-      end
-    end
-
-    @state = StateMachines::Machine.new(@klass, :state, 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 { 1 }
-  end
-
-  def test_should_succeed
-    assert_equal 1, @result
-  end
-
-  def test_should_persist_states
-    assert_equal 'idling', @object.state
-    assert_equal 'second_gear', @object.status
-  end
-
-  def test_should_not_run_machine_actions
-    assert_nil @object.actions
-  end
-
-  def test_should_use_result_as_transition_result
-    assert_equal 1, @state_transition.result
-    assert_equal 1, @status_transition.result
-  end
-end

data/test/unit/transition_collection/transition_collection_with_callbacks_test.rb

@@ -1,135 +0,0 @@
-require_relative '../../test_helper'
-
-class TransitionCollectionWithCallbacksTest < StateMachinesTest
-  def setup
-    @klass = Class.new do
-      attr_reader :saved
-
-      def save
-        @saved = true
-      end
-    end
-
-    @before_callbacks = []
-    @after_callbacks = []
-
-    @state = StateMachines::Machine.new(@klass, initial: :parked, action: :save)
-    @state.state :idling
-    @state.event :ignite
-    @state.before_transition { @before_callbacks << :state_before }
-    @state.after_transition { @after_callbacks << :state_after }
-    @state.around_transition { |block| @before_callbacks << :state_around; block.call; @after_callbacks << :state_around }
-
-    @status = StateMachines::Machine.new(@klass, :status, initial: :first_gear, action: :save)
-    @status.state :second_gear
-    @status.event :shift_up
-    @status.before_transition { @before_callbacks << :status_before }
-    @status.after_transition { @after_callbacks << :status_after }
-    @status.around_transition { |block| @before_callbacks << :status_around; block.call; @after_callbacks << :status_around }
-
-    @object = @klass.new
-    @transitions = StateMachines::TransitionCollection.new([
-      StateMachines::Transition.new(@object, @state, :ignite, :parked, :idling),
-      StateMachines::Transition.new(@object, @status, :shift_up, :first_gear, :second_gear)
-    ])
-  end
-
-  def test_should_run_before_callbacks_in_order
-    @transitions.perform
-    assert_equal [:state_before, :state_around, :status_before, :status_around], @before_callbacks
-  end
-
-  def test_should_halt_if_before_callback_halted_for_first_transition
-    @state.before_transition { throw :halt }
-
-    assert_equal false, @transitions.perform
-    assert_equal [:state_before, :state_around], @before_callbacks
-  end
-
-  def test_should_halt_if_before_callback_halted_for_second_transition
-    @status.before_transition { throw :halt }
-
-    assert_equal false, @transitions.perform
-    assert_equal [:state_before, :state_around, :status_before, :status_around], @before_callbacks
-  end
-
-  def test_should_halt_if_around_callback_halted_before_yield_for_first_transition
-    @state.around_transition { throw :halt }
-
-    assert_equal false, @transitions.perform
-    assert_equal [:state_before, :state_around], @before_callbacks
-  end
-
-  def test_should_halt_if_around_callback_halted_before_yield_for_second_transition
-    @status.around_transition { throw :halt }
-
-    assert_equal false, @transitions.perform
-    assert_equal [:state_before, :state_around, :status_before, :status_around], @before_callbacks
-  end
-
-  def test_should_run_after_callbacks_in_reverse_order
-    @transitions.perform
-    assert_equal [:status_around, :status_after, :state_around, :state_after], @after_callbacks
-  end
-
-  def test_should_not_halt_if_after_callback_halted_for_first_transition
-    @state.after_transition { throw :halt }
-
-    assert_equal true, @transitions.perform
-    assert_equal [:status_around, :status_after, :state_around, :state_after], @after_callbacks
-  end
-
-  def test_should_not_halt_if_around_callback_halted_for_second_transition
-    @status.around_transition { |block| block.call; throw :halt }
-
-    assert_equal true, @transitions.perform
-    assert_equal [:state_around, :state_after], @after_callbacks
-  end
-
-  def test_should_run_before_callbacks_before_persisting_the_state
-    @state.before_transition { |object| @before_state = object.state }
-    @state.around_transition { |object, _transition, block| @around_state = object.state; block.call }
-    @transitions.perform
-
-    assert_equal 'parked', @before_state
-    assert_equal 'parked', @around_state
-  end
-
-  def test_should_persist_state_before_running_action
-    @klass.class_eval do
-      attr_reader :saved_on_persist
-
-      def state=(value)
-        @state = value
-        @saved_on_persist = saved
-      end
-    end
-
-    @transitions.perform
-    refute @object.saved_on_persist
-  end
-
-  def test_should_persist_state_before_running_action_block
-    @klass.class_eval do
-      attr_writer :saved
-      attr_reader :saved_on_persist
-
-      def state=(value)
-        @state = value
-        @saved_on_persist = saved
-      end
-    end
-
-    @transitions.perform { @object.saved = true }
-    refute @object.saved_on_persist
-  end
-
-  def test_should_run_after_callbacks_after_running_the_action
-    @state.after_transition { |object| @after_saved = object.saved }
-    @state.around_transition { |object, _transition, block| block.call; @around_saved = object.saved }
-    @transitions.perform
-
-    assert @after_saved
-    assert @around_saved
-  end
-end

data/test/unit/transition_collection/transition_collection_with_different_actions_test.rb

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

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

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

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