state_machines 0.4.0 → 0.6.0

data/test/unit/transition_collection/attribute_transition_collection_with_callbacks_test.rb

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

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

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

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

@@ -1,23 +0,0 @@
-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_transactions
-  end
-
-  def test_should_be_empty
-    assert @transitions.empty?
-  end
-end

data/test/unit/transition_collection/transition_collection_empty_with_block_test.rb

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

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

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

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

@@ -1,26 +0,0 @@
-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, :use_transactions', 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

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

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

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

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

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

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

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