state_machines 0.0.2 → 0.1.0

data/test/unit/transition_collection/attribute_transition_collection_with_callbacks_test.rb

@@ -0,0 +1,68 @@
+require_relative '../../test_helper'
+
+class AttributeTransitionCollectionWithCallbacksTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+
+    @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::AttributeTransitionCollection.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_not_have_events_during_before_callbacks
+    @state.before_transition { |object, _transition| @before_state_event = object.state_event }
+    @state.around_transition { |object, _transition, block| @around_state_event = object.state_event; block.call }
+    @transitions.perform
+
+    assert_nil @before_state_event
+    assert_nil @around_state_event
+  end
+
+  def test_should_not_have_events_during_action
+    @transitions.perform { @state_event = @object.state_event }
+
+    assert_nil @state_event
+  end
+
+  def test_should_not_have_events_during_after_callbacks
+    @state.after_transition { |object, _transition| @after_state_event = object.state_event }
+    @state.around_transition { |object, _transition, block| block.call; @around_state_event = object.state_event }
+    @transitions.perform
+
+    assert_nil @after_state_event
+    assert_nil @around_state_event
+  end
+
+  def test_should_not_have_event_transitions_during_before_callbacks
+    @state.before_transition { |object, _transition| @state_event_transition = object.send(:state_event_transition) }
+    @transitions.perform
+
+    assert_nil @state_event_transition
+  end
+
+  def test_should_not_have_event_transitions_during_action
+    @transitions.perform { @state_event_transition = @object.send(:state_event_transition) }
+
+    assert_nil @state_event_transition
+  end
+
+  def test_should_not_have_event_transitions_during_after_callbacks
+    @state.after_transition { |object, _transition| @after_state_event_transition = object.send(:state_event_transition) }
+    @state.around_transition { |object, _transition, block| block.call; @around_state_event_transition = object.send(:state_event_transition) }
+    @transitions.perform
+
+    assert_nil @after_state_event_transition
+    assert_nil @around_state_event_transition
+  end
+end

data/test/unit/transition_collection/attribute_transition_collection_with_event_transitions_test.rb

@@ -0,0 +1,41 @@
+require_relative '../../test_helper'
+
+class AttributeTransitionCollectionWithEventTransitionsTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+
+    @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
+    @object.send(:state_event_transition=, @state_transition = StateMachines::Transition.new(@object, @state, :ignite, :parked, :idling))
+    @object.send(:status_event_transition=, @status_transition = StateMachines::Transition.new(@object, @status, :shift_up, :first_gear, :second_gear))
+
+    @transitions = StateMachines::AttributeTransitionCollection.new([@state_transition, @status_transition])
+    @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_not_write_events
+    assert_nil @object.state_event
+    assert_nil @object.status_event
+  end
+
+  def test_should_clear_event_transitions
+    assert_nil @object.send(:state_event_transition)
+    assert_nil @object.send(:status_event_transition)
+  end
+end

data/test/unit/transition_collection/attribute_transition_collection_with_events_test.rb

@@ -0,0 +1,44 @@
+require_relative '../../test_helper'
+
+class AttributeTransitionCollectionWithEventsTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+
+    @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
+    @object.state_event = 'ignite'
+    @object.status_event = 'shift_up'
+
+    @transitions = StateMachines::AttributeTransitionCollection.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_clear_events
+    assert_nil @object.state_event
+    assert_nil @object.status_event
+  end
+
+  def test_should_not_write_event_transitions
+    assert_nil @object.send(:state_event_transition)
+    assert_nil @object.send(:status_event_transition)
+  end
+end

data/test/unit/transition_collection/attribute_transition_collection_with_skipped_after_callbacks_test.rb

@@ -0,0 +1,42 @@
+require_relative '../../test_helper'
+
+class AttributeTransitionCollectionWithSkippedAfterCallbacksTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+
+    @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
+    @object.state_event = 'ignite'
+    @object.status_event = 'shift_up'
+
+    @transitions = StateMachines::AttributeTransitionCollection.new([
+      @state_transition = StateMachines::Transition.new(@object, @state, :ignite, :parked, :idling),
+      @status_transition = StateMachines::Transition.new(@object, @status, :shift_up, :first_gear, :second_gear)
+    ], after: false)
+  end
+
+  def test_should_clear_events
+    @transitions.perform
+    assert_nil @object.state_event
+    assert_nil @object.status_event
+  end
+
+  def test_should_write_event_transitions_if_success
+    @transitions.perform { true }
+    assert_equal @state_transition, @object.send(:state_event_transition)
+    assert_equal @status_transition, @object.send(:status_event_transition)
+  end
+
+  def test_should_not_write_event_transitions_if_failed
+    @transitions.perform { false }
+    assert_nil @object.send(:state_event_transition)
+    assert_nil @object.send(:status_event_transition)
+  end
+end

data/test/unit/transition_collection/transition_collection_by_default_test.rb

@@ -0,0 +1,23 @@
+require_relative '../../test_helper'
+
+class TransitionCollectionByDefaultTest < StateMachinesTest
+  def setup
+    @transitions = StateMachines::TransitionCollection.new
+  end
+
+  def test_should_not_skip_actions
+    refute @transitions.skip_actions
+  end
+
+  def test_should_not_skip_after
+    refute @transitions.skip_after
+  end
+
+  def test_should_use_transaction
+    assert @transitions.use_transaction
+  end
+
+  def test_should_be_empty
+    assert @transitions.empty?
+  end
+end

data/test/unit/transition_collection/transition_collection_empty_with_block_test.rb

@@ -0,0 +1,23 @@
+require_relative '../../test_helper'
+
+class TransitionCollectionEmptyWithBlockTest < StateMachinesTest
+  def setup
+    @transitions = StateMachines::TransitionCollection.new
+  end
+
+  def test_should_raise_exception_if_perform_raises_exception
+    assert_raises(ArgumentError) { @transitions.perform { fail ArgumentError } }
+  end
+
+  def test_should_use_block_result_if_non_boolean
+    assert_equal 1, @transitions.perform { 1 }
+  end
+
+  def test_should_use_block_result_if_false
+    assert_equal false, @transitions.perform { false }
+  end
+
+  def test_should_use_block_reslut_if_nil
+    assert_equal nil, @transitions.perform { nil }
+  end
+end

data/test/unit/transition_collection/transition_collection_empty_without_block_test.rb

@@ -0,0 +1,12 @@
+require_relative '../../test_helper'
+
+class TransitionCollectionEmptyWithoutBlockTest < StateMachinesTest
+  def setup
+    @transitions = StateMachines::TransitionCollection.new
+    @result = @transitions.perform
+  end
+
+  def test_should_succeed
+    assert_equal true, @result
+  end
+end

data/test/unit/transition_collection/transition_collection_invalid_test.rb

@@ -0,0 +1,21 @@
+require_relative '../../test_helper'
+
+class TransitionCollectionInvalidTest < StateMachinesTest
+  def setup
+    @transitions = StateMachines::TransitionCollection.new([false])
+  end
+
+  def test_should_be_empty
+    assert @transitions.empty?
+  end
+
+  def test_should_not_succeed
+    assert_equal false, @transitions.perform
+  end
+
+  def test_should_not_run_perform_block
+    ran_block = false
+    @transitions.perform { ran_block = true }
+    refute ran_block
+  end
+end

data/test/unit/transition_collection/transition_collection_partial_invalid_test.rb

@@ -0,0 +1,69 @@
+require_relative '../../test_helper'
+
+class TransitionCollectionPartialInvalidTest < StateMachinesTest
+  def setup
+    @klass = Class.new do
+      attr_accessor :ran_transaction
+    end
+
+    @callbacks = []
+
+    @machine = StateMachines::Machine.new(@klass, initial: :parked)
+    @machine.state :idling
+    @machine.event :ignite
+    @machine.before_transition { @callbacks << :before }
+    @machine.after_transition { @callbacks << :after }
+    @machine.around_transition { |block| @callbacks << :around_before; block.call; @callbacks << :around_after }
+
+    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),
+      false
+    ])
+  end
+
+  def test_should_not_store_invalid_values
+    assert_equal 1, @transitions.length
+  end
+
+  def test_should_not_succeed
+    assert_equal false, @transitions.perform
+  end
+
+  def test_should_not_start_transaction
+    refute @object.ran_transaction
+  end
+
+  def test_should_not_run_perform_block
+    ran_block = false
+    @transitions.perform { ran_block = true }
+    refute ran_block
+  end
+
+  def test_should_not_run_before_callbacks
+    refute @callbacks.include?(:before)
+  end
+
+  def test_should_not_persist_states
+    assert_equal 'parked', @object.state
+  end
+
+  def test_should_not_run_after_callbacks
+    refute @callbacks.include?(:after)
+  end
+
+  def test_should_not_run_around_callbacks_before_yield
+    refute @callbacks.include?(:around_before)
+  end
+
+  def test_should_not_run_around_callbacks_after_yield
+    refute @callbacks.include?(:around_after)
+  end
+end

data/test/unit/transition_collection/transition_collection_test.rb

@@ -0,0 +1,26 @@
+require_relative '../../test_helper'
+
+class TransitionCollectionTest < StateMachinesTest
+  def test_should_raise_exception_if_invalid_option_specified
+    exception = assert_raises(ArgumentError) { StateMachines::TransitionCollection.new([], invalid: true) }
+    assert_equal 'Unknown key: :invalid. Valid keys are: :actions, :after, :transaction', exception.message
+  end
+
+  def test_should_raise_exception_if_multiple_transitions_for_same_attribute_specified
+    @klass = Class.new
+
+    @machine = StateMachines::Machine.new(@klass, initial: :parked)
+    @machine.state :parked, :idling
+    @machine.event :ignite
+
+    @object = @klass.new
+
+    exception = assert_raises(ArgumentError) do
+      StateMachines::TransitionCollection.new([
+        StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling),
+        StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling)
+      ])
+    end
+    assert_equal 'Cannot perform multiple transitions in parallel for the same state machine attribute', exception.message
+  end
+end

data/test/unit/transition_collection/transition_collection_valid_test.rb

@@ -0,0 +1,57 @@
+require_relative '../../test_helper'
+
+class TransitionCollectionValidTest < StateMachinesTest
+  def setup
+    @klass = Class.new do
+      attr_reader :persisted
+
+      def initialize
+        @persisted = nil
+        super
+        @persisted = []
+      end
+
+      def state=(value)
+        @persisted << 'state' if @persisted
+        @state = value
+      end
+
+      def status=(value)
+        @persisted << 'status' if @persisted
+        @status = value
+      end
+    end
+
+    @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
+
+    @result = 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)
+    ]).perform
+  end
+
+  def test_should_succeed
+    assert_equal true, @result
+  end
+
+  def test_should_persist_each_state
+    assert_equal 'idling', @object.state
+    assert_equal 'second_gear', @object.status
+  end
+
+  def test_should_persist_in_order
+    assert_equal %w(state status), @object.persisted
+  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_action_error_test.rb

@@ -0,0 +1,66 @@
+require_relative '../../test_helper'
+
+class TransitionCollectionWithActionErrorTest < StateMachinesTest
+  def setup
+    @klass = Class.new do
+      def save
+        fail ArgumentError
+      end
+    end
+    @before_count = 0
+    @around_before_count = 0
+    @after_count = 0
+    @around_after_count = 0
+    @failure_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 }
+    @machine.around_transition { |block| @around_before_count += 1; block.call; @around_after_count += 1 }
+    @machine.after_failure { @failure_count += 1 }
+
+    @object = @klass.new
+
+    @transitions = StateMachines::TransitionCollection.new([
+      StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling)
+    ])
+
+    @raised = true
+    begin
+      @transitions.perform
+      @raised = false
+    rescue ArgumentError
+    end
+  end
+
+  def test_should_not_catch_exception
+    assert @raised
+  end
+
+  def test_should_not_persist_state
+    assert_equal 'parked', @object.state
+  end
+
+  def test_should_run_before_callbacks
+    assert_equal 1, @before_count
+  end
+
+  def test_should_run_around_callbacks_before_yield
+    assert_equal 1, @around_before_count
+  end
+
+  def test_should_not_run_after_callbacks
+    assert_equal 0, @after_count
+  end
+
+  def test_should_not_run_around_callbacks_after_yield
+    assert_equal 0, @around_after_count
+  end
+
+  def test_should_not_run_failure_callbacks
+    assert_equal 0, @failure_count
+  end
+end

data/test/unit/transition_collection/transition_collection_with_action_failed_test.rb

@@ -0,0 +1,60 @@
+require_relative '../../test_helper'
+
+class TransitionCollectionWithActionFailedTest < StateMachinesTest
+  def setup
+    @klass = Class.new do
+      def save
+        false
+      end
+    end
+    @before_count = 0
+    @around_before_count = 0
+    @after_count = 0
+    @around_after_count = 0
+    @failure_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 }
+    @machine.around_transition { |block| @around_before_count += 1; block.call; @around_after_count += 1 }
+    @machine.after_failure { @failure_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_run_before_callbacks
+    assert_equal 1, @before_count
+  end
+
+  def test_should_run_around_callbacks_before_yield
+    assert_equal 1, @around_before_count
+  end
+
+  def test_should_not_run_after_callbacks
+    assert_equal 0, @after_count
+  end
+
+  def test_should_not_run_around_callbacks
+    assert_equal 0, @around_after_count
+  end
+
+  def test_should_run_failure_callbacks
+    assert_equal 1, @failure_count
+  end
+end

data/test/unit/transition_collection/transition_collection_with_action_hook_and_block_test.rb

@@ -0,0 +1,17 @@
+require_relative '../../test_helper'
+require_relative 'transition_collection_with_action_hook_base_test'
+
+class TransitionCollectionWithActionHookAndBlockTest < TransitionCollectionWithActionHookBaseTest
+  def setup
+    super
+    @result = StateMachines::TransitionCollection.new([@transition]).perform { true }
+  end
+
+  def test_should_succeed
+    assert_equal true, @result
+  end
+
+  def test_should_not_run_action
+    refute @object.saved
+  end
+end

data/test/unit/transition_collection/transition_collection_with_action_hook_and_skipped_action_test.rb

@@ -0,0 +1,17 @@
+require_relative '../../test_helper'
+require_relative 'transition_collection_with_action_hook_base_test.rb'
+
+class TransitionCollectionWithActionHookAndSkippedActionTest < TransitionCollectionWithActionHookBaseTest
+  def setup
+    super
+    @result = StateMachines::TransitionCollection.new([@transition], actions: false).perform
+  end
+
+  def test_should_succeed
+    assert_equal true, @result
+  end
+
+  def test_should_not_run_action
+    refute @object.saved
+  end
+end

data/test/unit/transition_collection/transition_collection_with_action_hook_and_skipped_after_callbacks_test.rb

@@ -0,0 +1,37 @@
+require_relative '../../test_helper'
+require_relative 'transition_collection_with_action_hook_base_test.rb'
+
+class TransitionCollectionWithActionHookAndSkippedAfterCallbacksTest < TransitionCollectionWithActionHookBaseTest
+  def setup
+    super
+    @result = StateMachines::TransitionCollection.new([@transition], after: false).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_base_test.rb

@@ -0,0 +1,34 @@
+require_relative '../../test_helper'
+
+class TransitionCollectionWithActionHookBaseTest < StateMachinesTest
+  def setup
+    @superclass = Class.new do
+      def save
+        true
+      end
+    end
+
+    @klass = Class.new(@superclass) do
+      attr_reader :saved, :state_on_save, :state_event_on_save, :state_event_transition_on_save
+
+      def save
+        @saved = true
+        @state_on_save = state
+        @state_event_on_save = state_event
+        @state_event_transition_on_save = state_event_transition
+        super
+      end
+    end
+
+    @machine = StateMachines::Machine.new(@klass, initial: :parked, action: :save)
+    @machine.state :idling
+    @machine.event :ignite
+
+    @object = @klass.new
+
+    @transition = StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling)
+  end
+
+  def default_test
+  end
+end