state_machine 0.9.4 → 0.10.0

data/test/unit/node_collection_test.rb

@@ -138,12 +138,12 @@ end
 
 class NodeCollectionWithNodesTest < Test::Unit::TestCase
   def setup
-    machine = StateMachine::Machine.new(Class.new)
-    @collection = StateMachine::NodeCollection.new(machine)
+    @machine = StateMachine::Machine.new(Class.new)
+    @collection = StateMachine::NodeCollection.new(@machine)
     
     @klass = Struct.new(:name, :machine)
-    @parked = @klass.new(:parked, machine)
-    @idling = @klass.new(:idling, machine)
+    @parked = @klass.new(:parked, @machine)
+    @idling = @klass.new(:idling, @machine)
     
     @collection << @parked
     @collection << @idling
@@ -156,6 +156,16 @@ class NodeCollectionWithNodesTest < Test::Unit::TestCase
     assert_equal [@parked, @idling], order
   end
   
+  def test_should_be_able_to_concatenate_multiple_nodes
+    @first_gear = @klass.new(:first_gear, @machine)
+    @second_gear = @klass.new(:second_gear, @machine)
+    @collection.concat([@first_gear, @second_gear])
+    
+    order = []
+    @collection.each {|object| order << object}
+    assert_equal [@parked, @idling, @first_gear, @second_gear], order
+  end
+  
   def test_should_be_able_to_access_by_index
     assert_equal @parked, @collection.at(0)
     assert_equal @idling, @collection.at(1)

data/test/unit/path_collection_test.rb

@@ -0,0 +1,266 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class PathCollectionByDefaultTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+    @machine.state :parked
+    
+    @object = @klass.new
+    @object.state = 'parked'
+    
+    @paths = StateMachine::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
+
+class PathCollectionTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+    @object = @klass.new
+  end
+  
+  def test_should_raise_exception_if_invalid_option_specified
+    exception = assert_raise(ArgumentError) {StateMachine::PathCollection.new(@object, @machine, :invalid => true)}
+    assert_equal 'Invalid key(s): invalid', exception.message
+  end
+  
+  def test_should_raise_exception_if_invalid_from_state_specified
+    exception = assert_raise(IndexError) {StateMachine::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_raise(IndexError) {StateMachine::PathCollection.new(@object, @machine, :to => :invalid)}
+    assert_equal ':invalid is an invalid name', exception.message
+  end
+end
+
+class PathCollectionWithPathsTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::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 = StateMachine::PathCollection.new(@object, @machine)
+  end
+  
+  def test_should_enumerate_paths
+    assert_equal [[
+      StateMachine::Transition.new(@object, @machine, :ignite, :parked, :idling),
+      StateMachine::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
+
+class PathWithGuardedPathsTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::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 [], StateMachine::PathCollection.new(@object, @machine)
+  end
+  
+  def test_should_enumerate_paths_if_guard_disabled
+    paths = StateMachine::PathCollection.new(@object, @machine, :guard => false)
+    assert_equal [[
+      StateMachine::Transition.new(@object, @machine, :ignite, :parked, :idling)
+    ]], paths
+  end
+end
+
+class PathCollectionWithDuplicateNodesTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::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 = StateMachine::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
+
+class PathCollectionWithFromStateTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+    @machine.state :parked, :idling, :first_gear
+    @machine.event :park do
+      transition :idling => :parked
+    end
+    
+    @object = @klass.new
+    @object.state = 'parked'
+    
+    @paths = StateMachine::PathCollection.new(@object, @machine, :from => :idling)
+  end
+  
+  def test_should_generate_paths_from_custom_from_state
+    assert_equal [[
+      StateMachine::Transition.new(@object, @machine, :park, :idling, :parked)
+    ]], @paths
+  end
+  
+  def test_should_have_a_from_name
+    assert_equal :idling, @paths.from_name
+  end
+end
+
+class PathCollectionWithToStateTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::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 = StateMachine::PathCollection.new(@object, @machine, :to => :idling)
+  end
+  
+  def test_should_stop_paths_once_target_state_reached
+    assert_equal [
+      [StateMachine::Transition.new(@object, @machine, :ignite, :parked, :idling)],
+      [StateMachine::Transition.new(@object, @machine, :shift_up, :parked, :idling)]
+    ], @paths
+  end
+end
+
+class PathCollectionWithDeepPathsTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::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 = StateMachine::PathCollection.new(@object, @machine, :to => :idling, :deep => true)
+  end
+  
+  def test_should_allow_target_to_be_reached_more_than_once_per_path
+    assert_equal [
+      [
+        StateMachine::Transition.new(@object, @machine, :ignite, :parked, :idling)
+      ],
+      [
+        StateMachine::Transition.new(@object, @machine, :ignite, :parked, :idling),
+        StateMachine::Transition.new(@object, @machine, :shift_up, :idling, :first_gear),
+        StateMachine::Transition.new(@object, @machine, :shift_down, :first_gear, :idling)
+      ],
+      [
+        StateMachine::Transition.new(@object, @machine, :shift_up, :parked, :idling)
+      ],
+      [
+        StateMachine::Transition.new(@object, @machine, :shift_up, :parked, :idling),
+        StateMachine::Transition.new(@object, @machine, :shift_up, :idling, :first_gear),
+        StateMachine::Transition.new(@object, @machine, :shift_down, :first_gear, :idling)
+      ]
+    ], @paths
+  end
+end

data/test/unit/path_test.rb

@@ -0,0 +1,485 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class PathByDefaultTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+    @object = @klass.new
+    
+    @path = StateMachine::Path.new(@object, @machine)
+  end
+  
+  def test_should_have_an_object
+    assert_equal @object, @path.object
+  end
+  
+  def test_should_have_a_machine
+    assert_equal @machine, @path.machine
+  end
+  
+  def test_should_not_have_walked_anywhere
+    assert_equal [], @path
+  end
+  
+  def test_should_not_have_a_from_name
+    assert_nil @path.from_name
+  end
+  
+  def test_should_have_no_from_states
+    assert_equal [], @path.from_states
+  end
+  
+  def test_should_not_have_a_to_name
+    assert_nil @path.to_name
+  end
+  
+  def test_should_have_no_to_states
+    assert_equal [], @path.to_states
+  end
+  
+  def test_should_have_no_events
+    assert_equal [], @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_not_be_complete
+    assert_equal false, @path.complete?
+  end
+end
+
+class PathTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+    @object = @klass.new
+  end
+  
+  def test_should_raise_exception_if_invalid_option_specified
+    exception = assert_raise(ArgumentError) {StateMachine::Path.new(@object, @machine, :invalid => true)}
+    assert_equal 'Invalid key(s): invalid', exception.message
+  end
+end
+
+class PathWithoutTransitionsTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+    @machine.state :parked, :idling
+    @machine.event :ignite
+    
+    @object = @klass.new
+    
+    @path = StateMachine::Path.new(@object, @machine)
+    @path.concat([
+      @ignite_transition = StateMachine::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
+
+class PathWithTransitionsTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+    @machine.state :parked, :idling, :first_gear
+    @machine.event :ignite, :shift_up
+    
+    @object = @klass.new
+    @object.state = 'parked'
+    
+    @path = StateMachine::Path.new(@object, @machine)
+    @path.concat([
+      @ignite_transition = StateMachine::Transition.new(@object, @machine, :ignite, :parked, :idling),
+      @shift_up_transition = StateMachine::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
+
+class PathWithDuplicatesTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+    @machine.state :parked, :idling
+    @machine.event :park, :ignite
+    
+    @object = @klass.new
+    @object.state = 'parked'
+    
+    @path = StateMachine::Path.new(@object, @machine)
+    @path.concat([
+      @ignite_transition = StateMachine::Transition.new(@object, @machine, :ignite, :parked, :idling),
+      @park_transition = StateMachine::Transition.new(@object, @machine, :park, :idling, :parked),
+      @ignite_again_transition = StateMachine::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
+
+class PathWithAvailableTransitionsTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+    @machine.state :parked, :idling, :first_gear
+    @machine.event :ignite
+    @machine.event :shift_up do
+      transition :idling => :first_gear
+    end
+    @machine.event :park do
+      transition :idling => :parked
+    end
+    
+    @object = @klass.new
+    @object.state = 'parked'
+    
+    @path = StateMachine::Path.new(@object, @machine)
+    @path.concat([
+      @ignite_transition = StateMachine::Transition.new(@object, @machine, :ignite, :parked, :idling)
+    ])
+  end
+  
+  def test_should_not_be_complete
+    assert !@path.complete?
+  end
+  
+  def test_should_walk_each_available_transition
+    paths = []
+    @path.walk {|path| paths << path}
+    
+    assert_equal [
+      [@ignite_transition, StateMachine::Transition.new(@object, @machine, :shift_up, :idling, :first_gear)],
+      [@ignite_transition, StateMachine::Transition.new(@object, @machine, :park, :idling, :parked)]
+    ], paths
+  end
+  
+  def test_should_yield_path_instances_when_walking
+    @path.walk do |path|
+      assert_instance_of StateMachine::Path, path
+    end
+  end
+  
+  def test_should_not_modify_current_path_after_walking
+    @path.walk {}
+    assert_equal [@ignite_transition], @path
+  end
+  
+  def test_should_not_modify_object_after_walking
+    @path.walk {}
+    assert_equal 'parked', @object.state
+  end
+end
+
+class PathWithGuardedTransitionsTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::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 = StateMachine::Path.new(@object, @machine)
+    path.concat([
+      ignite_transition = StateMachine::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 = StateMachine::Path.new(@object, @machine, :guard => false)
+    path.concat([
+      ignite_transition = StateMachine::Transition.new(@object, @machine, :ignite, :parked, :idling)
+    ])
+    
+    paths = []
+    path.walk {|next_path| paths << next_path}
+    
+    assert_equal [
+      [ignite_transition, StateMachine::Transition.new(@object, @machine, :shift_up, :idling, :first_gear)]
+    ], paths
+  end
+end
+
+class PathWithEncounteredTransitionsTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::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 = StateMachine::Path.new(@object, @machine)
+    @path.concat([
+      @ignite_transition = StateMachine::Transition.new(@object, @machine, :ignite, :parked, :idling),
+      @park_transition = StateMachine::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
+
+class PathWithUnreachedTargetTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+    @machine.state :parked, :idling
+    @machine.event :ignite do
+      transition :parked => :idling
+    end
+    
+    @object = @klass.new
+    @object.state = 'parked'
+    
+    @path = StateMachine::Path.new(@object, @machine, :target => :parked)
+    @path.concat([
+      @ignite_transition = StateMachine::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
+
+class PathWithReachedTargetTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::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 = StateMachine::Path.new(@object, @machine, :target => :parked)
+    @path.concat([
+      @ignite_transition = StateMachine::Transition.new(@object, @machine, :ignite, :parked, :idling),
+      @park_transition = StateMachine::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
+
+class PathWithAvailableTransitionsAfterReachingTargetTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::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 = StateMachine::Path.new(@object, @machine, :target => :parked)
+    @path.concat([
+      @ignite_transition = StateMachine::Transition.new(@object, @machine, :ignite, :parked, :idling),
+      @park_transition = StateMachine::Transition.new(@object, @machine, :park, :idling, :parked)
+    ])
+  end
+  
+  def test_should_be_complete
+    assert_equal true, @path.complete?
+  end
+  
+  def test_should_be_able_to_walk
+    paths = []
+    @path.walk {|path| paths << path}
+    assert_equal [
+      [@ignite_transition, @park_transition, StateMachine::Transition.new(@object, @machine, :shift_up, :parked, :first_gear)]
+    ], paths
+  end
+end
+
+class PathWithDeepTargetTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::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 = StateMachine::Path.new(@object, @machine, :target => :parked)
+    @path.concat([
+      @ignite_transition = StateMachine::Transition.new(@object, @machine, :ignite, :parked, :idling),
+      @park_transition = StateMachine::Transition.new(@object, @machine, :park, :idling, :parked),
+      @shift_up_transition = StateMachine::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, StateMachine::Transition.new(@object, @machine, :park, :first_gear, :parked)]
+    ], paths
+  end
+end
+
+class PathWithDeepTargetReachedTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::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 = StateMachine::Path.new(@object, @machine, :target => :parked)
+    @path.concat([
+      @ignite_transition = StateMachine::Transition.new(@object, @machine, :ignite, :parked, :idling),
+      @park_transition = StateMachine::Transition.new(@object, @machine, :park, :idling, :parked),
+      @shift_up_transition = StateMachine::Transition.new(@object, @machine, :shift_up, :parked, :first_gear),
+      @park_transition_2 = StateMachine::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