state_machines 0.5.0 → 0.10.0

data/test/unit/transition/transition_test.rb

@@ -1,96 +0,0 @@
-require_relative '../../test_helper'
-
-class TransitionTest < 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_have_an_object
-    assert_equal @object, @transition.object
-  end
-
-  def test_should_have_a_machine
-    assert_equal @machine, @transition.machine
-  end
-
-  def test_should_have_an_event
-    assert_equal :ignite, @transition.event
-  end
-
-  def test_should_have_a_qualified_event
-    assert_equal :ignite, @transition.qualified_event
-  end
-
-  def test_should_have_a_human_event
-    assert_equal 'ignite', @transition.human_event
-  end
-
-  def test_should_have_a_from_value
-    assert_equal 'parked', @transition.from
-  end
-
-  def test_should_have_a_from_name
-    assert_equal :parked, @transition.from_name
-  end
-
-  def test_should_have_a_qualified_from_name
-    assert_equal :parked, @transition.qualified_from_name
-  end
-
-  def test_should_have_a_human_from_name
-    assert_equal 'parked', @transition.human_from_name
-  end
-
-  def test_should_have_a_to_value
-    assert_equal 'idling', @transition.to
-  end
-
-  def test_should_have_a_to_name
-    assert_equal :idling, @transition.to_name
-  end
-
-  def test_should_have_a_qualified_to_name
-    assert_equal :idling, @transition.qualified_to_name
-  end
-
-  def test_should_have_a_human_to_name
-    assert_equal 'idling', @transition.human_to_name
-  end
-
-  def test_should_have_an_attribute
-    assert_equal :state, @transition.attribute
-  end
-
-  def test_should_not_have_an_action
-    assert_nil @transition.action
-  end
-
-  def test_should_not_be_transient
-    assert_equal false, @transition.transient?
-  end
-
-  def test_should_generate_attributes
-    expected = { object: @object, attribute: :state, event: :ignite, from: 'parked', to: 'idling' }
-    assert_equal expected, @transition.attributes
-  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_use_pretty_inspect
-    assert_equal '#<StateMachines::Transition attribute=:state event=:ignite from="parked" from_name=:parked to="idling" to_name=:idling>', @transition.inspect
-  end
-end

data/test/unit/transition/transition_transient_test.rb

@@ -1,20 +0,0 @@
-require_relative '../../test_helper'
-
-class TransitionTransientTest < 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)
-    @transition.transient = true
-  end
-
-  def test_should_be_transient
-    assert @transition.transient?
-  end
-end

data/test/unit/transition/transition_with_action_test.rb

@@ -1,27 +0,0 @@
-require_relative '../../test_helper'
-
-class TransitionWithActionTest < StateMachinesTest
-  def setup
-    @klass = Class.new do
-      def save
-      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_an_action
-    assert_equal :save, @transition.action
-  end
-
-  def test_should_not_have_a_result
-    assert_nil @transition.result
-  end
-end

data/test/unit/transition/transition_with_after_callbacks_skipped_test.rb

@@ -1,127 +0,0 @@
-require_relative '../../test_helper'
-
-class TransitionWithAfterCallbacksSkippedTest < 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_run_before_callbacks
-    @machine.before_transition { @run = true }
-
-    assert_equal true, @transition.run_callbacks(after: false)
-    assert @run
-  end
-
-  def test_should_not_run_after_callbacks
-    @run = false
-    @machine.after_transition { @run = true }
-
-    assert_equal true, @transition.run_callbacks(after: false)
-    refute @run
-  end
-
-  if StateMachines::Transition.pause_supported?
-    def test_should_run_around_callbacks_before_yield
-      @machine.around_transition { |block| @run = true; block.call }
-
-      assert_equal true, @transition.run_callbacks(after: false)
-      assert @run
-    end
-
-    def test_should_not_run_around_callbacks_after_yield
-      @run = false
-      @machine.around_transition { |block| block.call; @run = true }
-
-      assert_equal true, @transition.run_callbacks(after: false)
-      refute @run
-    end
-
-    def test_should_continue_around_transition_execution_on_second_call
-      @callbacks = []
-      @machine.around_transition { |block| @callbacks << :before_around_1; block.call; @callbacks << :after_around_1 }
-      @machine.around_transition { |block| @callbacks << :before_around_2; block.call; @callbacks << :after_around_2 }
-      @machine.after_transition { @callbacks << :after }
-
-      assert_equal true, @transition.run_callbacks(after: false)
-      assert_equal [:before_around_1, :before_around_2], @callbacks
-
-      assert_equal true, @transition.run_callbacks
-      assert_equal [:before_around_1, :before_around_2, :after_around_2, :after_around_1, :after], @callbacks
-    end
-
-    def test_should_not_run_further_callbacks_if_halted_during_continue_around_transition
-      @callbacks = []
-      @machine.around_transition { |block| @callbacks << :before_around_1; block.call; @callbacks << :after_around_1 }
-      @machine.around_transition { |block| @callbacks << :before_around_2; block.call; @callbacks << :after_around_2; throw :halt }
-      @machine.after_transition { @callbacks << :after }
-
-      assert_equal true, @transition.run_callbacks(after: false)
-      assert_equal [:before_around_1, :before_around_2], @callbacks
-
-      assert_equal true, @transition.run_callbacks
-      assert_equal [:before_around_1, :before_around_2, :after_around_2], @callbacks
-    end
-
-    def test_should_not_be_able_to_continue_twice
-      @count = 0
-      @machine.around_transition { |block| block.call; @count += 1 }
-      @machine.after_transition { @count += 1 }
-
-      @transition.run_callbacks(after: false)
-
-      2.times do
-        assert_equal true, @transition.run_callbacks
-        assert_equal 2, @count
-      end
-    end
-
-    def test_should_not_be_able_to_continue_again_after_halted
-      @count = 0
-      @machine.around_transition { |block| block.call; @count += 1; throw :halt }
-      @machine.after_transition { @count += 1 }
-
-      @transition.run_callbacks(after: false)
-
-      2.times do
-        assert_equal true, @transition.run_callbacks
-        assert_equal 1, @count
-      end
-    end
-
-    def test_should_have_access_to_result_after_continued
-      @machine.around_transition { |block| @around_before_result = @transition.result; block.call; @around_after_result = @transition.result }
-      @machine.after_transition { @after_result = @transition.result }
-
-      @transition.run_callbacks(after: false)
-      @transition.run_callbacks { { result: 1 } }
-
-      assert_nil @around_before_result
-      assert_equal 1, @around_after_result
-      assert_equal 1, @after_result
-    end
-
-    def test_should_raise_exceptions_during_around_callbacks_after_yield_in_second_execution
-      @machine.around_transition { |block| block.call; fail ArgumentError }
-
-      @transition.run_callbacks(after: false)
-      assert_raises(ArgumentError) { @transition.run_callbacks }
-    end
-  else
-    def test_should_raise_exception_on_second_call
-      @callbacks = []
-      @machine.around_transition { |block| @callbacks << :before_around_1; block.call; @callbacks << :after_around_1 }
-      @machine.around_transition { |block| @callbacks << :before_around_2; block.call; @callbacks << :after_around_2 }
-      @machine.after_transition { @callbacks << :after }
-
-      assert_raises(ArgumentError) { @transition.run_callbacks(after: false) }
-    end
-  end
-end

data/test/unit/transition/transition_with_after_callbacks_test.rb

@@ -1,93 +0,0 @@
-require_relative '../../test_helper'
-
-class TransitionWithAfterCallbacksTest < 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_run_after_callbacks
-    @machine.after_transition { |_object| @run = true }
-    result = @transition.run_callbacks
-
-    assert_equal true, result
-    assert_equal true, @run
-  end
-
-  def test_should_only_run_those_that_match_transition_context
-    @count = 0
-    callback = lambda { @count += 1 }
-
-    @machine.after_transition from: :parked, to: :idling, on: :park, do: callback
-    @machine.after_transition from: :parked, to: :parked, on: :park, do: callback
-    @machine.after_transition from: :parked, to: :idling, on: :ignite, do: callback
-    @machine.after_transition from: :idling, to: :idling, on: :park, do: callback
-    @transition.run_callbacks
-
-    assert_equal 1, @count
-  end
-
-  def test_should_not_run_if_not_successful
-    @run = false
-    @machine.after_transition { |_object| @run = true }
-    @transition.run_callbacks { { success: false } }
-    refute @run
-  end
-
-  def test_should_run_if_successful
-    @machine.after_transition { |_object| @run = true }
-    @transition.run_callbacks { { success: true } }
-    assert @run
-  end
-
-  def test_should_pass_transition_as_argument
-    @machine.after_transition { |*args| @args = args }
-
-    @transition.run_callbacks
-    assert_equal [@object, @transition], @args
-  end
-
-  def test_should_catch_halts
-    @machine.after_transition { throw :halt }
-
-    result = @transition.run_callbacks
-    assert_equal true, result
-  end
-
-  def test_should_not_catch_exceptions
-    @machine.after_transition  { fail ArgumentError }
-    assert_raises(ArgumentError) { @transition.run_callbacks }
-  end
-
-  def test_should_not_be_able_to_run_twice
-    @count = 0
-    @machine.after_transition { @count += 1 }
-    @transition.run_callbacks
-    @transition.run_callbacks
-    assert_equal 1, @count
-  end
-
-  def test_should_not_be_able_to_run_twice_if_halted
-    @count = 0
-    @machine.after_transition { @count += 1; throw :halt }
-    @transition.run_callbacks
-    @transition.run_callbacks
-    assert_equal 1, @count
-  end
-
-  def test_should_be_able_to_run_again_after_resetting
-    @count = 0
-    @machine.after_transition { @count += 1 }
-    @transition.run_callbacks
-    @transition.reset
-    @transition.run_callbacks
-    assert_equal 2, @count
-  end
-end

data/test/unit/transition/transition_with_around_callbacks_test.rb

@@ -1,141 +0,0 @@
-require_relative '../../test_helper'
-
-class TransitionWithAroundCallbacksTest < 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_run_around_callbacks
-    @machine.around_transition { |_object, _transition, block| @run_before = true; block.call; @run_after = true }
-    result = @transition.run_callbacks
-
-    assert_equal true, result
-    assert_equal true, @run_before
-    assert_equal true, @run_after
-  end
-
-  def test_should_only_run_those_that_match_transition_context
-    @count = 0
-    callback = lambda { |_object, _transition, block| @count += 1; block.call }
-
-    @machine.around_transition from: :parked, to: :idling, on: :park, do: callback
-    @machine.around_transition from: :parked, to: :parked, on: :park, do: callback
-    @machine.around_transition from: :parked, to: :idling, on: :ignite, do: callback
-    @machine.around_transition from: :idling, to: :idling, on: :park, do: callback
-    @transition.run_callbacks
-
-    assert_equal 1, @count
-  end
-
-  def test_should_pass_transition_as_argument
-    @machine.around_transition { |*args| block = args.pop; @args = args; block.call }
-    @transition.run_callbacks
-
-    assert_equal [@object, @transition], @args
-  end
-
-  def test_should_run_block_between_callback
-    @callbacks = []
-    @machine.around_transition { |block| @callbacks << :before; block.call; @callbacks << :after }
-    @transition.run_callbacks { @callbacks << :within; { success: true } }
-
-    assert_equal [:before, :within, :after], @callbacks
-  end
-
-  def test_should_have_access_to_result_after_yield
-    @machine.around_transition { |block| @before_result = @transition.result; block.call; @after_result = @transition.result }
-    @transition.run_callbacks { { result: 1, success: true } }
-
-    assert_nil @before_result
-    assert_equal 1, @after_result
-  end
-
-  def test_should_catch_before_yield_halts
-    @machine.around_transition { throw :halt }
-
-    result = @transition.run_callbacks
-    assert_equal false, result
-  end
-
-  def test_should_catch_after_yield_halts
-    @machine.around_transition { |block| block.call; throw :halt }
-
-    result = @transition.run_callbacks
-    assert_equal true, result
-  end
-
-  def test_should_not_catch_before_yield
-    @machine.around_transition  { fail ArgumentError }
-    assert_raises(ArgumentError) { @transition.run_callbacks }
-  end
-
-  def test_should_not_catch_after_yield
-    @machine.around_transition { |block| block.call; fail ArgumentError }
-    assert_raises(ArgumentError) { @transition.run_callbacks }
-  end
-
-  def test_should_fail_if_not_yielded
-    @machine.around_transition {}
-
-    result = @transition.run_callbacks
-    assert_equal false, result
-  end
-
-  def test_should_not_be_able_to_run_twice
-    @before_count = 0
-    @after_count = 0
-    @machine.around_transition { |block| @before_count += 1; block.call; @after_count += 1 }
-    @transition.run_callbacks
-    @transition.run_callbacks
-    assert_equal 1, @before_count
-    assert_equal 1, @after_count
-  end
-
-  def test_should_be_able_to_run_again_after_resetting
-    @before_count = 0
-    @after_count = 0
-    @machine.around_transition { |block| @before_count += 1; block.call; @after_count += 1 }
-    @transition.run_callbacks
-    @transition.reset
-    @transition.run_callbacks
-    assert_equal 2, @before_count
-    assert_equal 2, @after_count
-  end
-
-  def test_should_succeed_if_block_result_is_false
-    @machine.around_transition { |block| @before_run = true; block.call; @after_run = true }
-    assert_equal true, @transition.run_callbacks { { success: true, result: false } }
-    assert @before_run
-    assert @after_run
-  end
-
-  def test_should_succeed_if_block_result_is_true
-    @machine.around_transition { |block| @before_run = true; block.call; @after_run = true }
-    assert_equal true, @transition.run_callbacks { { success: true, result: true } }
-    assert @before_run
-    assert @after_run
-  end
-
-  def test_should_only_run_before_if_block_success_is_false
-    @after_run = false
-    @machine.around_transition { |block| @before_run = true; block.call; @after_run = true }
-    assert_equal true, @transition.run_callbacks { { success: false } }
-    assert @before_run
-    refute @after_run
-  end
-
-  def test_should_succeed_if_block_success_is_false
-    @machine.around_transition { |block| @before_run = true; block.call; @after_run = true }
-    assert_equal true, @transition.run_callbacks { { success: true } }
-    assert @before_run
-    assert @after_run
-  end
-end

data/test/unit/transition/transition_with_before_callbacks_skipped_test.rb

@@ -1,30 +0,0 @@
-require_relative '../../test_helper'
-
-class TransitionWithBeforeCallbacksSkippedTest < 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_not_run_before_callbacks
-    @run = false
-    @machine.before_transition { @run = true }
-
-    assert_equal false, @transition.run_callbacks(before: false)
-    refute @run
-  end
-
-  def test_should_run_failure_callbacks
-    @machine.after_failure { @run = true }
-
-    assert_equal false, @transition.run_callbacks(before: false)
-    assert @run
-  end
-end

data/test/unit/transition/transition_with_before_callbacks_test.rb

@@ -1,104 +0,0 @@
-require_relative '../../test_helper'
-
-class TransitionWithBeforeCallbacksTest < 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_run_before_callbacks
-    @machine.before_transition { @run = true }
-    result = @transition.run_callbacks
-
-    assert_equal true, result
-    assert_equal true, @run
-  end
-
-  def test_should_only_run_those_that_match_transition_context
-    @count = 0
-    callback = lambda { @count += 1 }
-
-    @machine.before_transition from: :parked, to: :idling, on: :park, do: callback
-    @machine.before_transition from: :parked, to: :parked, on: :park, do: callback
-    @machine.before_transition from: :parked, to: :idling, on: :ignite, do: callback
-    @machine.before_transition from: :idling, to: :idling, on: :park, do: callback
-    @transition.run_callbacks
-
-    assert_equal 1, @count
-  end
-
-  def test_should_pass_transition_as_argument
-    @machine.before_transition { |*args| @args = args }
-    @transition.run_callbacks
-
-    assert_equal [@object, @transition], @args
-  end
-
-  def test_should_catch_halts
-    @machine.before_transition { throw :halt }
-
-    result = @transition.run_callbacks
-    assert_equal false, result
-  end
-
-  def test_should_not_catch_exceptions
-    @machine.before_transition { fail ArgumentError }
-    assert_raises(ArgumentError) { @transition.run_callbacks }
-  end
-
-  def test_should_not_be_able_to_run_twice
-    @count = 0
-    @machine.before_transition { @count += 1 }
-    @transition.run_callbacks
-    @transition.run_callbacks
-    assert_equal 1, @count
-  end
-
-  def test_should_be_able_to_run_again_after_halt
-    @count = 0
-    @machine.before_transition { @count += 1; throw :halt }
-    @transition.run_callbacks
-    @transition.run_callbacks
-    assert_equal 2, @count
-  end
-
-  def test_should_be_able_to_run_again_after_resetting
-    @count = 0
-    @machine.before_transition { @count += 1 }
-    @transition.run_callbacks
-    @transition.reset
-    @transition.run_callbacks
-    assert_equal 2, @count
-  end
-
-  def test_should_succeed_if_block_result_is_false
-    @machine.before_transition { @run = true }
-    assert_equal true, @transition.run_callbacks { { result: false } }
-    assert @run
-  end
-
-  def test_should_succeed_if_block_result_is_true
-    @machine.before_transition { @run = true }
-    assert_equal true, @transition.run_callbacks { { result: true } }
-    assert @run
-  end
-
-  def test_should_succeed_if_block_success_is_false
-    @machine.before_transition { @run = true }
-    assert_equal true, @transition.run_callbacks { { success: false } }
-    assert @run
-  end
-
-  def test_should_succeed_if_block_success_is_true
-    @machine.before_transition { @run = true }
-    assert_equal true, @transition.run_callbacks { { success: true } }
-    assert @run
-  end
-end

data/test/unit/transition/transition_with_custom_machine_attribute_test.rb

@@ -1,28 +0,0 @@
-require_relative '../../test_helper'
-
-class TransitionWithCustomMachineAttributeTest < StateMachinesTest
-  def setup
-    @klass = Class.new
-    @machine = StateMachines::Machine.new(@klass, :state, attribute: :state_id)
-    @machine.state :off, value: 1
-    @machine.state :active, value: 2
-    @machine.event :activate
-
-    @object = @klass.new
-    @object.state_id = 1
-
-    @transition = StateMachines::Transition.new(@object, @machine, :activate, :off, :active)
-  end
-
-  def test_should_persist
-    @transition.persist
-    assert_equal 2, @object.state_id
-  end
-
-  def test_should_rollback
-    @object.state_id = 2
-    @transition.rollback
-
-    assert_equal 1, @object.state_id
-  end
-end

data/test/unit/transition/transition_with_different_states_test.rb

@@ -1,18 +0,0 @@
-require_relative '../../test_helper'
-
-class TransitionWithDifferentStatesTest < 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_not_be_loopback
-    refute @transition.loopback?
-  end
-end