state_machines 0.0.2 → 0.1.0

data/test/unit/transition/transition_with_perform_arguments_test.rb

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

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

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

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

data/test/unit/transition/transition_without_running_action_test.rb

@@ -0,0 +1,47 @@
+require_relative '../../test_helper'
+
+class TransitionWithoutRunningActionTest < 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
+    @machine.after_transition { |_object| @run_after = true }
+
+    @object = @klass.new
+    @object.state = 'parked'
+    @transition = StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling)
+    @result = @transition.perform(false)
+  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_be_successful
+    assert_equal true, @result
+  end
+
+  def test_should_change_the_current_state
+    assert_equal 'idling', @object.state
+  end
+
+  def test_should_not_run_the_action
+    refute @object.saved
+  end
+
+  def test_should_run_after_callbacks
+    assert @run_after
+  end
+end

data/test/unit/transition_collection/attribute_transition_collection_by_default_test.rb

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

data/test/unit/transition_collection/attribute_transition_collection_marshalling_test.rb

@@ -0,0 +1,64 @@
+require_relative '../../test_helper'
+
+class AttributeTransitionCollectionMarshallingTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    self.class.const_set('Example', @klass)
+
+    @machine = StateMachines::Machine.new(@klass, initial: :parked, action: :save)
+    @machine.state :idling
+    @machine.event :ignite
+
+    @object = @klass.new
+    @object.state_event = 'ignite'
+  end
+
+  def test_should_marshal_during_before_callbacks
+    @machine.before_transition { |object, _transition| Marshal.dump(object) }
+    transitions(after: false).perform { true }
+    transitions.perform { true }
+  end
+
+  def test_should_marshal_during_action
+    transitions(after: false).perform do
+      Marshal.dump(@object)
+      true
+    end
+
+    transitions.perform do
+      Marshal.dump(@object)
+      true
+    end
+  end
+
+  def test_should_marshal_during_after_callbacks
+    @machine.after_transition { |object, _transition| Marshal.dump(object) }
+    transitions(after: false).perform { true }
+    transitions.perform { true }
+  end
+
+  if StateMachines::Transition.pause_supported?
+    def test_should_marshal_during_around_callbacks_before_yield
+      @machine.around_transition { |object, _transition, block| Marshal.dump(object); block.call }
+      transitions(after: false).perform { true }
+      transitions.perform { true }
+    end
+
+    def test_should_marshal_during_around_callbacks_after_yield
+      @machine.around_transition { |object, _transition, block| block.call; Marshal.dump(object) }
+      transitions(after: false).perform { true }
+      transitions.perform { true }
+    end
+  end
+
+  def teardown
+    self.class.send(:remove_const, 'Example')
+  end
+
+  private
+  def transitions(options = {})
+    StateMachines::AttributeTransitionCollection.new([
+      StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling)
+    ], options)
+  end
+end

data/test/unit/transition_collection/attribute_transition_collection_with_action_error_test.rb

@@ -0,0 +1,44 @@
+require_relative '../../test_helper'
+
+class AttributeTransitionCollectionWithActionErrorTest < 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)
+    ])
+
+    begin
+      ; @transitions.perform { fail ArgumentError }
+    rescue
+    end
+  end
+
+  def test_should_not_persist_states
+    assert_equal 'parked', @object.state
+    assert_equal 'first_gear', @object.status
+  end
+
+  def test_should_not_clear_events
+    assert_equal :ignite, @object.state_event
+    assert_equal :shift_up, @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_action_failed_test.rb

@@ -0,0 +1,44 @@
+require_relative '../../test_helper'
+
+class AttributeTransitionCollectionWithActionFailedTest < 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 { false }
+  end
+
+  def test_should_not_succeed
+    assert_equal false, @result
+  end
+
+  def test_should_not_persist_states
+    assert_equal 'parked', @object.state
+    assert_equal 'first_gear', @object.status
+  end
+
+  def test_should_not_clear_events
+    assert_equal :ignite, @object.state_event
+    assert_equal :shift_up, @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_after_callback_error_test.rb

@@ -0,0 +1,32 @@
+require_relative '../../test_helper'
+
+class AttributeTransitionCollectionWithBeforeCallbackErrorTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+
+    @machine = StateMachines::Machine.new(@klass, initial: :parked, action: :save)
+    @machine.state :idling
+    @machine.event :ignite
+
+    @machine.before_transition { fail ArgumentError }
+
+    @object = @klass.new
+    @object.state_event = 'ignite'
+
+    @transitions = StateMachines::AttributeTransitionCollection.new([
+      StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling)
+    ])
+    begin
+      ; @transitions.perform
+    rescue
+    end
+  end
+
+  def test_should_not_clear_event
+    assert_equal :ignite, @object.state_event
+  end
+
+  def test_should_not_write_event_transition
+    assert_nil @object.send(:state_event_transition)
+  end
+end

data/test/unit/transition_collection/attribute_transition_collection_with_after_callback_halt_test.rb

@@ -0,0 +1,33 @@
+require_relative '../../test_helper'
+
+class AttributeTransitionCollectionWithBeforeCallbackHaltTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+
+    @machine = StateMachines::Machine.new(@klass, initial: :parked, action: :save)
+    @machine.state :idling
+    @machine.event :ignite
+
+    @machine.before_transition { throw :halt }
+
+    @object = @klass.new
+    @object.state_event = 'ignite'
+
+    @transitions = StateMachines::AttributeTransitionCollection.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_clear_event
+    assert_equal :ignite, @object.state_event
+  end
+
+  def test_should_not_write_event_transition
+    assert_nil @object.send(:state_event_transition)
+  end
+end

data/test/unit/transition_collection/attribute_transition_collection_with_around_after_yield_callback_error_test.rb

@@ -0,0 +1,32 @@
+require_relative '../../test_helper'
+
+class AttributeTransitionCollectionWithAroundAfterYieldCallbackErrorTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+
+    @machine = StateMachines::Machine.new(@klass, initial: :parked, action: :save)
+    @machine.state :idling
+    @machine.event :ignite
+
+    @machine.before_transition { fail ArgumentError }
+
+    @object = @klass.new
+    @object.state_event = 'ignite'
+
+    @transitions = StateMachines::AttributeTransitionCollection.new([
+      StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling)
+    ])
+    begin
+      ; @transitions.perform
+    rescue
+    end
+  end
+
+  def test_should_not_clear_event
+    assert_equal :ignite, @object.state_event
+  end
+
+  def test_should_not_write_event_transition
+    assert_nil @object.send(:state_event_transition)
+  end
+end

data/test/unit/transition_collection/attribute_transition_collection_with_around_callback_after_yield_error_test.rb

@@ -0,0 +1,32 @@
+require_relative '../../test_helper'
+
+class AttributeTransitionCollectionWithAroundCallbackAfterYieldErrorTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+
+    @machine = StateMachines::Machine.new(@klass, initial: :parked, action: :save)
+    @machine.state :idling
+    @machine.event :ignite
+
+    @machine.around_transition { |block| block.call; fail ArgumentError }
+
+    @object = @klass.new
+    @object.state_event = 'ignite'
+
+    @transitions = StateMachines::AttributeTransitionCollection.new([
+      StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling)
+    ])
+    begin
+      ; @transitions.perform
+    rescue
+    end
+  end
+
+  def test_should_clear_event
+    assert_nil @object.state_event
+  end
+
+  def test_should_not_write_event_transition
+    assert_nil @object.send(:state_event_transition)
+  end
+end

data/test/unit/transition_collection/attribute_transition_collection_with_around_callback_after_yield_halt_test.rb

@@ -0,0 +1,33 @@
+require_relative '../../test_helper'
+
+class AttributeTransitionCollectionWithAroundCallbackAfterYieldHaltTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+
+    @machine = StateMachines::Machine.new(@klass, initial: :parked, action: :save)
+    @machine.state :idling
+    @machine.event :ignite
+
+    @machine.around_transition { |block| block.call; throw :halt }
+
+    @object = @klass.new
+    @object.state_event = 'ignite'
+
+    @transitions = StateMachines::AttributeTransitionCollection.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_clear_event
+    assert_nil @object.state_event
+  end
+
+  def test_should_not_write_event_transition
+    assert_nil @object.send(:state_event_transition)
+  end
+end

data/test/unit/transition_collection/attribute_transition_collection_with_around_callback_before_yield_halt_test.rb

@@ -0,0 +1,33 @@
+require_relative '../../test_helper'
+
+class AttributeTransitionCollectionWithAroundCallbackBeforeYieldHaltTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+
+    @machine = StateMachines::Machine.new(@klass, initial: :parked, action: :save)
+    @machine.state :idling
+    @machine.event :ignite
+
+    @machine.around_transition { throw :halt }
+
+    @object = @klass.new
+    @object.state_event = 'ignite'
+
+    @transitions = StateMachines::AttributeTransitionCollection.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_clear_event
+    assert_equal :ignite, @object.state_event
+  end
+
+  def test_should_not_write_event_transition
+    assert_nil @object.send(:state_event_transition)
+  end
+end

data/test/unit/transition_collection/attribute_transition_collection_with_before_callback_error_test.rb

@@ -0,0 +1,32 @@
+require_relative '../../test_helper'
+
+class AttributeTransitionCollectionWithAfterCallbackErrorTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+
+    @machine = StateMachines::Machine.new(@klass, initial: :parked, action: :save)
+    @machine.state :idling
+    @machine.event :ignite
+
+    @machine.after_transition { fail ArgumentError }
+
+    @object = @klass.new
+    @object.state_event = 'ignite'
+
+    @transitions = StateMachines::AttributeTransitionCollection.new([
+      StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling)
+    ])
+    begin
+      ; @transitions.perform
+    rescue
+    end
+  end
+
+  def test_should_clear_event
+    assert_nil @object.state_event
+  end
+
+  def test_should_not_write_event_transition
+    assert_nil @object.send(:state_event_transition)
+  end
+end

data/test/unit/transition_collection/attribute_transition_collection_with_before_callback_halt_test.rb

@@ -0,0 +1,33 @@
+require_relative '../../test_helper'
+
+class AttributeTransitionCollectionWithAfterCallbackHaltTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+
+    @machine = StateMachines::Machine.new(@klass, initial: :parked, action: :save)
+    @machine.state :idling
+    @machine.event :ignite
+
+    @machine.after_transition { throw :halt }
+
+    @object = @klass.new
+    @object.state_event = 'ignite'
+
+    @transitions = StateMachines::AttributeTransitionCollection.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_clear_event
+    assert_nil @object.state_event
+  end
+
+  def test_should_not_write_event_transition
+    assert_nil @object.send(:state_event_transition)
+  end
+end