state_machines 0.4.0 → 0.6.0

data/test/unit/path/path_with_deep_target_reached_test.rb

@@ -1,50 +0,0 @@
-require_relative '../../test_helper'
-
-class PathWithDeepTargetReachedTest < StateMachinesTest
-  def setup
-    @klass = Class.new
-    @machine = StateMachines::Machine.new(@klass)
-    @machine.state :parked, :idling
-    @machine.event :ignite do
-      transition parked: :idling
-    end
-    @machine.event :shift_up do
-      transition parked: :first_gear
-    end
-    @machine.event :park do
-      transition [:idling, :first_gear] => :parked
-    end
-
-    @object = @klass.new
-    @object.state = 'parked'
-
-    @path = StateMachines::Path.new(@object, @machine, target: :parked)
-    @path.concat([
-                     @ignite_transition = StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling),
-                     @park_transition = StateMachines::Transition.new(@object, @machine, :park, :idling, :parked),
-                     @shift_up_transition = StateMachines::Transition.new(@object, @machine, :shift_up, :parked, :first_gear),
-                     @park_transition_2 = StateMachines::Transition.new(@object, @machine, :park, :first_gear, :parked)
-                 ])
-  end
-
-  def test_should_be_complete
-    assert_equal true, @path.complete?
-  end
-
-  def test_should_not_be_able_to_walk
-    walked = false
-    @path.walk { walked = true }
-    assert_equal false, walked
-  end
-
-  def test_should_not_be_able_to_walk_with_available_transitions
-    @machine.event :park do
-      transition parked: same
-    end
-
-    walked = false
-    @path.walk { walked = true }
-    assert_equal false, walked
-  end
-end
-

data/test/unit/path/path_with_deep_target_test.rb

@@ -1,40 +0,0 @@
-require_relative '../../test_helper'
-
-class PathWithDeepTargetTest < StateMachinesTest
-  def setup
-    @klass = Class.new
-    @machine = StateMachines::Machine.new(@klass)
-    @machine.state :parked, :idling
-    @machine.event :ignite do
-      transition parked: :idling
-    end
-    @machine.event :shift_up do
-      transition parked: :first_gear
-    end
-    @machine.event :park do
-      transition [:idling, :first_gear] => :parked
-    end
-
-    @object = @klass.new
-    @object.state = 'parked'
-
-    @path = StateMachines::Path.new(@object, @machine, target: :parked)
-    @path.concat([
-                     @ignite_transition = StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling),
-                     @park_transition = StateMachines::Transition.new(@object, @machine, :park, :idling, :parked),
-                     @shift_up_transition = StateMachines::Transition.new(@object, @machine, :shift_up, :parked, :first_gear)
-                 ])
-  end
-
-  def test_should_not_be_complete
-    assert_equal false, @path.complete?
-  end
-
-  def test_should_be_able_to_walk
-    paths = []
-    @path.walk { |path| paths << path }
-    assert_equal [
-                     [@ignite_transition, @park_transition, @shift_up_transition, StateMachines::Transition.new(@object, @machine, :park, :first_gear, :parked)]
-                 ], paths
-  end
-end

data/test/unit/path/path_with_duplicates_test.rb

@@ -1,32 +0,0 @@
-require_relative '../../test_helper'
-
-class PathWithDuplicatesTest < StateMachinesTest
-  def setup
-    @klass = Class.new
-    @machine = StateMachines::Machine.new(@klass)
-    @machine.state :parked, :idling
-    @machine.event :park, :ignite
-
-    @object = @klass.new
-    @object.state = 'parked'
-
-    @path = StateMachines::Path.new(@object, @machine)
-    @path.concat([
-                     @ignite_transition = StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling),
-                     @park_transition = StateMachines::Transition.new(@object, @machine, :park, :idling, :parked),
-                     @ignite_again_transition = StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling)
-                 ])
-  end
-
-  def test_should_not_include_duplicates_in_from_states
-    assert_equal [:parked, :idling], @path.from_states
-  end
-
-  def test_should_not_include_duplicates_in_to_states
-    assert_equal [:idling, :parked], @path.to_states
-  end
-
-  def test_should_not_include_duplicates_in_events
-    assert_equal [:ignite, :park], @path.events
-  end
-end

data/test/unit/path/path_with_encountered_transitions_test.rb

@@ -1,34 +0,0 @@
-require_relative '../../test_helper'
-
-class PathWithEncounteredTransitionsTest < StateMachinesTest
-  def setup
-    @klass = Class.new
-    @machine = StateMachines::Machine.new(@klass)
-    @machine.state :parked, :idling, :first_gear
-    @machine.event :ignite do
-      transition parked: :idling
-    end
-    @machine.event :park do
-      transition idling: :parked
-    end
-
-    @object = @klass.new
-    @object.state = 'parked'
-
-    @path = StateMachines::Path.new(@object, @machine)
-    @path.concat([
-                     @ignite_transition = StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling),
-                     @park_transition = StateMachines::Transition.new(@object, @machine, :park, :idling, :parked)
-                 ])
-  end
-
-  def test_should_be_complete
-    assert_equal true, @path.complete?
-  end
-
-  def test_should_not_be_able_to_walk
-    walked = false
-    @path.walk { walked = true }
-    assert_equal false, walked
-  end
-end

data/test/unit/path/path_with_guarded_transitions_test.rb

@@ -1,42 +0,0 @@
-require_relative '../../test_helper'
-
-class PathWithGuardedTransitionsTest < StateMachinesTest
-  def setup
-    @klass = Class.new
-    @machine = StateMachines::Machine.new(@klass)
-    @machine.state :parked, :idling
-    @machine.event :ignite
-    @machine.event :shift_up do
-      transition idling: :first_gear, if: lambda { false }
-    end
-
-    @object = @klass.new
-    @object.state = 'parked'
-  end
-
-  def test_should_not_walk_transitions_if_guard_enabled
-    path = StateMachines::Path.new(@object, @machine)
-    path.concat([
-                    StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling)
-                ])
-
-    paths = []
-    path.walk { |next_path| paths << next_path }
-
-    assert_equal [], paths
-  end
-
-  def test_should_not_walk_transitions_if_guard_disabled
-    path = StateMachines::Path.new(@object, @machine, guard: false)
-    path.concat([
-                    ignite_transition = StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling)
-                ])
-
-    paths = []
-    path.walk { |next_path| paths << next_path }
-
-    assert_equal [
-                     [ignite_transition, StateMachines::Transition.new(@object, @machine, :shift_up, :idling, :first_gear)]
-                 ], paths
-  end
-end

data/test/unit/path/path_with_reached_target_test.rb

@@ -1,35 +0,0 @@
-require_relative '../../test_helper'
-
-class PathWithReachedTargetTest < StateMachinesTest
-  def setup
-    @klass = Class.new
-    @machine = StateMachines::Machine.new(@klass)
-    @machine.state :parked, :idling
-    @machine.event :ignite do
-      transition parked: :idling
-    end
-    @machine.event :park do
-      transition idling: :parked
-    end
-
-    @object = @klass.new
-    @object.state = 'parked'
-
-    @path = StateMachines::Path.new(@object, @machine, target: :parked)
-    @path.concat([
-                     @ignite_transition = StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling),
-                     @park_transition = StateMachines::Transition.new(@object, @machine, :park, :idling, :parked)
-                 ])
-  end
-
-  def test_should_be_complete
-    assert_equal true, @path.complete?
-  end
-
-  def test_should_not_be_able_to_walk
-    walked = false
-    @path.walk { walked = true }
-    assert_equal false, walked
-  end
-end
-

data/test/unit/path/path_with_transitions_test.rb

@@ -1,54 +0,0 @@
-require_relative '../../test_helper'
-
-class PathWithTransitionsTest < StateMachinesTest
-  def setup
-    @klass = Class.new
-    @machine = StateMachines::Machine.new(@klass)
-    @machine.state :parked, :idling, :first_gear
-    @machine.event :ignite, :shift_up
-
-    @object = @klass.new
-    @object.state = 'parked'
-
-    @path = StateMachines::Path.new(@object, @machine)
-    @path.concat([
-                     @ignite_transition = StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling),
-                     @shift_up_transition = StateMachines::Transition.new(@object, @machine, :shift_up, :idling, :first_gear)
-                 ])
-  end
-
-  def test_should_enumerate_transitions
-    assert_equal [@ignite_transition, @shift_up_transition], @path
-  end
-
-  def test_should_have_a_from_name
-    assert_equal :parked, @path.from_name
-  end
-
-  def test_should_have_from_states
-    assert_equal [:parked, :idling], @path.from_states
-  end
-
-  def test_should_have_a_to_name
-    assert_equal :first_gear, @path.to_name
-  end
-
-  def test_should_have_to_states
-    assert_equal [:idling, :first_gear], @path.to_states
-  end
-
-  def test_should_have_events
-    assert_equal [:ignite, :shift_up], @path.events
-  end
-
-  def test_should_not_be_able_to_walk_anywhere
-    walked = false
-    @path.walk { walked = true }
-    assert_equal false, walked
-  end
-
-  def test_should_be_complete
-    assert_equal true, @path.complete?
-  end
-end
-

data/test/unit/path/path_with_unreached_target_test.rb

@@ -1,31 +0,0 @@
-require_relative '../../test_helper'
-
-class PathWithUnreachedTargetTest < StateMachinesTest
-  def setup
-    @klass = Class.new
-    @machine = StateMachines::Machine.new(@klass)
-    @machine.state :parked, :idling
-    @machine.event :ignite do
-      transition parked: :idling
-    end
-
-    @object = @klass.new
-    @object.state = 'parked'
-
-    @path = StateMachines::Path.new(@object, @machine, target: :parked)
-    @path.concat([
-                     @ignite_transition = StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling)
-                 ])
-  end
-
-  def test_should_not_be_complete
-    assert_equal false, @path.complete?
-  end
-
-  def test_should_not_be_able_to_walk
-    walked = false
-    @path.walk { walked = true }
-    assert_equal false, walked
-  end
-end
-

data/test/unit/path/path_without_transitions_test.rb

@@ -1,24 +0,0 @@
-require_relative '../../test_helper'
-
-class PathWithoutTransitionsTest < StateMachinesTest
-  def setup
-    @klass = Class.new
-    @machine = StateMachines::Machine.new(@klass)
-    @machine.state :parked, :idling
-    @machine.event :ignite
-
-    @object = @klass.new
-
-    @path = StateMachines::Path.new(@object, @machine)
-    @path.concat([
-                     @ignite_transition = StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling)
-                 ])
-  end
-
-  def test_should_not_be_able_to_walk_anywhere
-    walked = false
-    @path.walk { walked = true }
-    assert_equal false, walked
-  end
-end
-

data/test/unit/path_collection/path_collection_by_default_test.rb

@@ -1,46 +0,0 @@
-require_relative '../../test_helper'
-
-class PathCollectionByDefaultTest < StateMachinesTest
-  def setup
-    @klass = Class.new
-    @machine = StateMachines::Machine.new(@klass)
-    @machine.state :parked
-
-    @object = @klass.new
-    @object.state = 'parked'
-
-    @paths = StateMachines::PathCollection.new(@object, @machine)
-  end
-
-  def test_should_have_an_object
-    assert_equal @object, @paths.object
-  end
-
-  def test_should_have_a_machine
-    assert_equal @machine, @paths.machine
-  end
-
-  def test_should_have_a_from_name
-    assert_equal :parked, @paths.from_name
-  end
-
-  def test_should_not_have_a_to_name
-    assert_nil @paths.to_name
-  end
-
-  def test_should_have_no_from_states
-    assert_equal [], @paths.from_states
-  end
-
-  def test_should_have_no_to_states
-    assert_equal [], @paths.to_states
-  end
-
-  def test_should_have_no_events
-    assert_equal [], @paths.events
-  end
-
-  def test_should_have_no_paths
-    assert @paths.empty?
-  end
-end

data/test/unit/path_collection/path_collection_test.rb

@@ -1,24 +0,0 @@
-require_relative '../../test_helper'
-
-class PathCollectionTest < StateMachinesTest
-  def setup
-    @klass = Class.new
-    @machine = StateMachines::Machine.new(@klass)
-    @object = @klass.new
-  end
-
-  def test_should_raise_exception_if_invalid_option_specified
-    exception = assert_raises(ArgumentError) { StateMachines::PathCollection.new(@object, @machine, invalid: true) }
-    assert_equal 'Unknown key: :invalid. Valid keys are: :from, :to, :deep, :guard', exception.message
-  end
-
-  def test_should_raise_exception_if_invalid_from_state_specified
-    exception = assert_raises(IndexError) { StateMachines::PathCollection.new(@object, @machine, from: :invalid) }
-    assert_equal ':invalid is an invalid name', exception.message
-  end
-
-  def test_should_raise_exception_if_invalid_to_state_specified
-    exception = assert_raises(IndexError) { StateMachines::PathCollection.new(@object, @machine, to: :invalid) }
-    assert_equal ':invalid is an invalid name', exception.message
-  end
-end

data/test/unit/path_collection/path_collection_with_deep_paths_test.rb

@@ -1,43 +0,0 @@
-require_relative '../../test_helper'
-
-class PathCollectionWithDeepPathsTest < StateMachinesTest
-  def setup
-    @klass = Class.new
-    @machine = StateMachines::Machine.new(@klass)
-    @machine.state :parked, :idling
-    @machine.event :ignite do
-      transition parked: :idling
-    end
-    @machine.event :shift_up do
-      transition parked: :idling, idling: :first_gear
-    end
-    @machine.event :shift_down do
-      transition first_gear: :idling
-    end
-    @object = @klass.new
-    @object.state = 'parked'
-
-    @paths = StateMachines::PathCollection.new(@object, @machine, to: :idling, deep: true)
-  end
-
-  def test_should_allow_target_to_be_reached_more_than_once_per_path
-    assert_equal [
-      [
-        StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling)
-      ],
-      [
-        StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling),
-        StateMachines::Transition.new(@object, @machine, :shift_up, :idling, :first_gear),
-        StateMachines::Transition.new(@object, @machine, :shift_down, :first_gear, :idling)
-      ],
-      [
-        StateMachines::Transition.new(@object, @machine, :shift_up, :parked, :idling)
-      ],
-      [
-        StateMachines::Transition.new(@object, @machine, :shift_up, :parked, :idling),
-        StateMachines::Transition.new(@object, @machine, :shift_up, :idling, :first_gear),
-        StateMachines::Transition.new(@object, @machine, :shift_down, :first_gear, :idling)
-      ]
-    ], @paths
-  end
-end

data/test/unit/path_collection/path_collection_with_duplicate_nodes_test.rb

@@ -1,31 +0,0 @@
-require_relative '../../test_helper'
-
-class PathCollectionWithDuplicateNodesTest < StateMachinesTest
-  def setup
-    @klass = Class.new
-    @machine = StateMachines::Machine.new(@klass)
-    @machine.state :parked, :idling
-    @machine.event :shift_up do
-      transition parked: :idling, idling: :first_gear
-    end
-    @machine.event :park do
-      transition first_gear: :idling
-    end
-    @object = @klass.new
-    @object.state = 'parked'
-
-    @paths = StateMachines::PathCollection.new(@object, @machine)
-  end
-
-  def test_should_not_include_duplicates_in_from_states
-    assert_equal [:parked, :idling, :first_gear], @paths.from_states
-  end
-
-  def test_should_not_include_duplicates_in_to_states
-    assert_equal [:idling, :first_gear], @paths.to_states
-  end
-
-  def test_should_not_include_duplicates_in_events
-    assert_equal [:shift_up, :park], @paths.events
-  end
-end

data/test/unit/path_collection/path_collection_with_from_state_test.rb

@@ -1,27 +0,0 @@
-require_relative '../../test_helper'
-
-class PathCollectionWithFromStateTest < StateMachinesTest
-  def setup
-    @klass = Class.new
-    @machine = StateMachines::Machine.new(@klass)
-    @machine.state :parked, :idling, :first_gear
-    @machine.event :park do
-      transition idling: :parked
-    end
-
-    @object = @klass.new
-    @object.state = 'parked'
-
-    @paths = StateMachines::PathCollection.new(@object, @machine, from: :idling)
-  end
-
-  def test_should_generate_paths_from_custom_from_state
-    assert_equal [[
-      StateMachines::Transition.new(@object, @machine, :park, :idling, :parked)
-    ]], @paths
-  end
-
-  def test_should_have_a_from_name
-    assert_equal :idling, @paths.from_name
-  end
-end

data/test/unit/path_collection/path_collection_with_paths_test.rb

@@ -1,47 +0,0 @@
-require_relative '../../test_helper'
-
-class PathCollectionWithPathsTest < StateMachinesTest
-  def setup
-    @klass = Class.new
-    @machine = StateMachines::Machine.new(@klass)
-    @machine.state :parked, :idling, :first_gear
-    @machine.event :ignite do
-      transition parked: :idling
-    end
-    @machine.event :shift_up do
-      transition idling: :first_gear
-    end
-
-    @object = @klass.new
-    @object.state = 'parked'
-
-    @paths = StateMachines::PathCollection.new(@object, @machine)
-  end
-
-  def test_should_enumerate_paths
-    assert_equal [[
-      StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling),
-      StateMachines::Transition.new(@object, @machine, :shift_up, :idling, :first_gear)
-    ]], @paths
-  end
-
-  def test_should_have_a_from_name
-    assert_equal :parked, @paths.from_name
-  end
-
-  def test_should_not_have_a_to_name
-    assert_nil @paths.to_name
-  end
-
-  def test_should_have_from_states
-    assert_equal [:parked, :idling], @paths.from_states
-  end
-
-  def test_should_have_to_states
-    assert_equal [:idling, :first_gear], @paths.to_states
-  end
-
-  def test_should_have_no_events
-    assert_equal [:ignite, :shift_up], @paths.events
-  end
-end

data/test/unit/path_collection/path_collection_with_to_state_test.rb

@@ -1,29 +0,0 @@
-require_relative '../../test_helper'
-
-class PathCollectionWithToStateTest < StateMachinesTest
-  def setup
-    @klass = Class.new
-    @machine = StateMachines::Machine.new(@klass)
-    @machine.state :parked, :idling
-    @machine.event :ignite do
-      transition parked: :idling
-    end
-    @machine.event :shift_up do
-      transition parked: :idling, idling: :first_gear
-    end
-    @machine.event :shift_down do
-      transition first_gear: :idling
-    end
-    @object = @klass.new
-    @object.state = 'parked'
-
-    @paths = StateMachines::PathCollection.new(@object, @machine, to: :idling)
-  end
-
-  def test_should_stop_paths_once_target_state_reached
-    assert_equal [
-      [StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling)],
-      [StateMachines::Transition.new(@object, @machine, :shift_up, :parked, :idling)]
-    ], @paths
-  end
-end

data/test/unit/path_collection/path_with_guarded_paths_test.rb

@@ -1,25 +0,0 @@
-require_relative '../../test_helper'
-class PathWithGuardedPathsTest < StateMachinesTest
-  def setup
-    @klass = Class.new
-    @machine = StateMachines::Machine.new(@klass)
-    @machine.state :parked, :idling, :first_gear
-    @machine.event :ignite do
-      transition parked: :idling, if: lambda { false }
-    end
-
-    @object = @klass.new
-    @object.state = 'parked'
-  end
-
-  def test_should_not_enumerate_paths_if_guard_enabled
-    assert_equal [], StateMachines::PathCollection.new(@object, @machine)
-  end
-
-  def test_should_enumerate_paths_if_guard_disabled
-    paths = StateMachines::PathCollection.new(@object, @machine, guard: false)
-    assert_equal [[
-      StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling)
-    ]], paths
-  end
-end

data/test/unit/state/state_after_being_copied_test.rb

@@ -1,19 +0,0 @@
-require_relative '../../test_helper'
-
-class StateAfterBeingCopiedTest < StateMachinesTest
-  def setup
-    @machine = StateMachines::Machine.new(Class.new)
-    @machine.states << @state = StateMachines::State.new(@machine, :parked)
-    @copied_state = @state.dup
-  end
-
-  def test_should_not_have_the_context
-    state_context = nil
-    @state.context { state_context = self }
-
-    copied_state_context = nil
-    @copied_state.context { copied_state_context = self }
-
-    refute_same state_context, copied_state_context
-  end
-end