state_machine 0.4.3 → 0.5.0

data/test/unit/guard_test.rb

@@ -2,15 +2,16 @@ require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
 
 class GuardTest < Test::Unit::TestCase
   def setup
-    @guard = StateMachine::Guard.new(:to => 'on', :from => 'off')
+    @guard = StateMachine::Guard.new(:to => :idling, :from => :parked)
   end
   
   def test_should_raise_exception_if_invalid_option_specified
-    assert_raise(ArgumentError) { StateMachine::Guard.new(:invalid => true) }
+    exception = assert_raise(ArgumentError) { StateMachine::Guard.new(:invalid => true) }
+    assert_equal 'Invalid key(s): invalid', exception.message
   end
   
   def test_should_have_requirements
-    expected = {:to => %w(on), :from => %w(off)}
+    expected = {:to => [:idling], :from => [:parked]}
     assert_equal expected, @guard.requirements
   end
 end
@@ -30,134 +31,134 @@ class GuardWithNoRequirementsTest < Test::Unit::TestCase
   end
   
   def test_should_match_non_empty_query
-    assert @guard.matches?(@object, :from => 'off', :to => 'on', :on => 'turn_on')
+    assert @guard.matches?(@object, :to => :idling, :from => :parked, :on => :ignite)
   end
 end
 
-class GuardWithToRequirementTest < Test::Unit::TestCase
+class GuardWithFromRequirementTest < Test::Unit::TestCase
   def setup
     @object = Object.new
-    @guard = StateMachine::Guard.new(:to => 'on')
+    @guard = StateMachine::Guard.new(:from => :parked)
   end
   
   def test_should_match_if_not_specified
-    assert @guard.matches?(@object, :from => 'off')
+    assert @guard.matches?(@object, :to => :idling)
   end
   
   def test_should_match_if_included
-    assert @guard.matches?(@object, :to => 'on')
+    assert @guard.matches?(@object, :from => :parked)
   end
   
   def test_should_not_match_if_not_included
-    assert !@guard.matches?(@object, :to => 'off')
+    assert !@guard.matches?(@object, :from => :idling)
   end
   
   def test_should_not_match_if_nil
-    assert !@guard.matches?(@object, :to => nil)
+    assert !@guard.matches?(@object, :from => nil)
   end
   
-  def test_should_ignore_from
-    assert @guard.matches?(@object, :to => 'on', :from => 'off')
+  def test_should_ignore_to
+    assert @guard.matches?(@object, :from => :parked, :to => :idling)
   end
   
   def test_should_ignore_on
-    assert @guard.matches?(@object, :to => 'on', :on => 'turn_on')
+    assert @guard.matches?(@object, :from => :parked, :on => :ignite)
   end
   
   def test_should_be_included_in_known_states
-    assert_equal %w(on), @guard.known_states
+    assert_equal [:parked], @guard.known_states
   end
 end
 
-class GuardWithMultipleToRequirementsTest < Test::Unit::TestCase
+class GuardWithMultipleFromRequirementsTest < Test::Unit::TestCase
   def setup
     @object = Object.new
-    @guard = StateMachine::Guard.new(:to => %w(on off))
+    @guard = StateMachine::Guard.new(:from => [:idling, :parked])
   end
   
   def test_should_match_if_included
-    assert @guard.matches?(@object, :to => 'on')
+    assert @guard.matches?(@object, :from => :idling)
   end
   
   def test_should_not_match_if_not_included
-    assert !@guard.matches?(@object, :to => 'maybe')
+    assert !@guard.matches?(@object, :from => :first_gear)
   end
   
   def test_should_be_included_in_known_states
-    assert_equal %w(on off), @guard.known_states
+    assert_equal [:idling, :parked], @guard.known_states
   end
 end
 
-class GuardWithFromRequirementTest < Test::Unit::TestCase
+class GuardWithToRequirementTest < Test::Unit::TestCase
   def setup
     @object = Object.new
-    @guard = StateMachine::Guard.new(:from => 'on')
+    @guard = StateMachine::Guard.new(:to => :idling)
   end
   
   def test_should_match_if_not_specified
-    assert @guard.matches?(@object, :to => 'off')
+    assert @guard.matches?(@object, :from => :parked)
   end
   
   def test_should_match_if_included
-    assert @guard.matches?(@object, :from => 'on')
+    assert @guard.matches?(@object, :to => :idling)
   end
   
   def test_should_not_match_if_not_included
-    assert !@guard.matches?(@object, :from => 'off')
+    assert !@guard.matches?(@object, :to => :parked)
   end
   
   def test_should_not_match_if_nil
-    assert !@guard.matches?(@object, :from => nil)
+    assert !@guard.matches?(@object, :to => nil)
   end
   
-  def test_should_ignore_to
-    assert @guard.matches?(@object, :from => 'on', :to => 'off')
+  def test_should_ignore_from
+    assert @guard.matches?(@object, :to => :idling, :from => :parked)
   end
   
   def test_should_ignore_on
-    assert @guard.matches?(@object, :from => 'on', :on => 'turn_on')
+    assert @guard.matches?(@object, :to => :idling, :on => :ignite)
   end
   
   def test_should_be_included_in_known_states
-    assert_equal %w(on), @guard.known_states
+    assert_equal [:idling], @guard.known_states
   end
 end
 
-class GuardWithMultipleFromRequirementsTest < Test::Unit::TestCase
+class GuardWithMultipleToRequirementsTest < Test::Unit::TestCase
   def setup
     @object = Object.new
-    @guard = StateMachine::Guard.new(:from => %w(on off))
+    @guard = StateMachine::Guard.new(:to => [:idling, :parked])
   end
   
   def test_should_match_if_included
-    assert @guard.matches?(@object, :from => 'on')
+    assert @guard.matches?(@object, :to => :idling)
   end
   
   def test_should_not_match_if_not_included
-    assert !@guard.matches?(@object, :from => 'maybe')
+    assert !@guard.matches?(@object, :to => :first_gear)
   end
   
   def test_should_be_included_in_known_states
-    assert_equal %w(on off), @guard.known_states
+    assert_equal [:idling, :parked], @guard.known_states
   end
 end
 
 class GuardWithOnRequirementTest < Test::Unit::TestCase
   def setup
     @object = Object.new
-    @guard = StateMachine::Guard.new(:on => 'turn_on')
+    @guard = StateMachine::Guard.new(:on => :ignite)
   end
   
   def test_should_match_if_not_specified
-    assert @guard.matches?(@object, :from => 'off')
+    assert @guard.matches?(@object, :from => :parked)
   end
   
   def test_should_match_if_included
-    assert @guard.matches?(@object, :on => 'turn_on')
+    assert @guard.matches?(@object, :on => :ignite)
   end
   
   def test_should_not_match_if_not_included
-    assert !@guard.matches?(@object, :on => 'turn_off')
+    assert !@guard.matches?(@object, :on => :park)
   end
   
   def test_should_not_match_if_nil
@@ -165,11 +166,11 @@ class GuardWithOnRequirementTest < Test::Unit::TestCase
   end
   
   def test_should_ignore_to
-    assert @guard.matches?(@object, :on => 'turn_on', :to => 'off')
+    assert @guard.matches?(@object, :on => :ignite, :to => :parked)
   end
   
   def test_should_ignore_from
-    assert @guard.matches?(@object, :on => 'turn_on', :from => 'off')
+    assert @guard.matches?(@object, :on => :ignite, :from => :parked)
   end
   
   def test_should_not_be_included_in_known_states
@@ -180,130 +181,130 @@ end
 class GuardWithMultipleOnRequirementsTest < Test::Unit::TestCase
   def setup
     @object = Object.new
-    @guard = StateMachine::Guard.new(:on => %w(turn_on turn_off))
+    @guard = StateMachine::Guard.new(:on => [:ignite, :park])
   end
   
   def test_should_match_if_included
-    assert @guard.matches?(@object, :on => 'turn_on')
+    assert @guard.matches?(@object, :on => :ignite)
   end
   
   def test_should_not_match_if_not_included
-    assert !@guard.matches?(@object, :on => 'turn_down')
+    assert !@guard.matches?(@object, :on => :shift_up)
   end
 end
 
-class GuardWithExceptToRequirementTest < Test::Unit::TestCase
+class GuardWithExceptFromRequirementTest < Test::Unit::TestCase
   def setup
     @object = Object.new
-    @guard = StateMachine::Guard.new(:except_to => 'off')
+    @guard = StateMachine::Guard.new(:except_from => :parked)
   end
   
   def test_should_match_if_not_included
-    assert @guard.matches?(@object, :to => 'on')
+    assert @guard.matches?(@object, :from => :idling)
   end
   
   def test_should_not_match_if_included
-    assert !@guard.matches?(@object, :to => 'off')
+    assert !@guard.matches?(@object, :from => :parked)
   end
   
   def test_should_match_if_nil
-    assert @guard.matches?(@object, :to => nil)
+    assert @guard.matches?(@object, :from => nil)
   end
   
-  def test_should_ignore_from
-    assert @guard.matches?(@object, :except_to => 'off', :from => 'off')
+  def test_should_ignore_to
+    assert @guard.matches?(@object, :from => :idling, :to => :parked)
   end
   
   def test_should_ignore_on
-    assert @guard.matches?(@object, :except_to => 'off', :on => 'turn_on')
+    assert @guard.matches?(@object, :from => :idling, :on => :ignite)
   end
   
   def test_should_be_included_in_known_states
-    assert_equal %w(off), @guard.known_states
+    assert_equal [:parked], @guard.known_states
   end
 end
 
-class GuardWithMultipleExceptToRequirementsTest < Test::Unit::TestCase
+class GuardWithMultipleExceptFromRequirementsTest < Test::Unit::TestCase
   def setup
     @object = Object.new
-    @guard = StateMachine::Guard.new(:except_to => %w(on off))
+    @guard = StateMachine::Guard.new(:except_from => [:idling, :parked])
   end
   
   def test_should_match_if_not_included
-    assert @guard.matches?(@object, :to => 'maybe')
+    assert @guard.matches?(@object, :from => :first_gear)
   end
   
   def test_should_not_match_if_included
-    assert !@guard.matches?(@object, :to => 'on')
+    assert !@guard.matches?(@object, :from => :idling)
   end
   
   def test_should_be_included_in_known_states
-    assert_equal %w(on off), @guard.known_states
+    assert_equal [:idling, :parked], @guard.known_states
   end
 end
 
-class GuardWithExceptFromRequirementTest < Test::Unit::TestCase
+class GuardWithExceptToRequirementTest < Test::Unit::TestCase
   def setup
     @object = Object.new
-    @guard = StateMachine::Guard.new(:except_from => 'off')
+    @guard = StateMachine::Guard.new(:except_to => :idling)
   end
   
   def test_should_match_if_not_included
-    assert @guard.matches?(@object, :from => 'on')
+    assert @guard.matches?(@object, :to => :parked)
   end
   
   def test_should_not_match_if_included
-    assert !@guard.matches?(@object, :from => 'off')
+    assert !@guard.matches?(@object, :to => :idling)
   end
   
   def test_should_match_if_nil
-    assert @guard.matches?(@object, :from => nil)
+    assert @guard.matches?(@object, :to => nil)
   end
   
-  def test_should_ignore_to
-    assert @guard.matches?(@object, :from => 'on', :to => 'off')
+  def test_should_ignore_from
+    assert @guard.matches?(@object, :to => :parked, :from => :idling)
   end
   
   def test_should_ignore_on
-    assert @guard.matches?(@object, :from => 'on', :on => 'turn_on')
+    assert @guard.matches?(@object, :to => :parked, :on => :ignite)
   end
   
   def test_should_be_included_in_known_states
-    assert_equal %w(off), @guard.known_states
+    assert_equal [:idling], @guard.known_states
   end
 end
 
-class GuardWithMultipleExceptFromRequirementsTest < Test::Unit::TestCase
+class GuardWithMultipleExceptToRequirementsTest < Test::Unit::TestCase
   def setup
     @object = Object.new
-    @guard = StateMachine::Guard.new(:except_from => %w(on off))
+    @guard = StateMachine::Guard.new(:except_to => [:idling, :parked])
   end
   
   def test_should_match_if_not_included
-    assert @guard.matches?(@object, :from => 'maybe')
+    assert @guard.matches?(@object, :to => :first_gear)
   end
   
   def test_should_not_match_if_included
-    assert !@guard.matches?(@object, :from => 'on')
+    assert !@guard.matches?(@object, :to => :idling)
   end
   
   def test_should_be_included_in_known_states
-    assert_equal %w(on off), @guard.known_states
+    assert_equal [:idling, :parked], @guard.known_states
   end
 end
 
 class GuardWithExceptOnRequirementTest < Test::Unit::TestCase
   def setup
     @object = Object.new
-    @guard = StateMachine::Guard.new(:except_on => 'turn_off')
+    @guard = StateMachine::Guard.new(:except_on => :ignite)
   end
   
   def test_should_match_if_not_included
-    assert @guard.matches?(@object, :on => 'turn_on')
+    assert @guard.matches?(@object, :on => :park)
   end
   
   def test_should_not_match_if_included
-    assert !@guard.matches?(@object, :on => 'turn_off')
+    assert !@guard.matches?(@object, :on => :ignite)
   end
   
   def test_should_match_if_nil
@@ -311,11 +312,11 @@ class GuardWithExceptOnRequirementTest < Test::Unit::TestCase
   end
   
   def test_should_ignore_to
-    assert @guard.matches?(@object, :on => 'turn_on', :to => 'off')
+    assert @guard.matches?(@object, :on => :park, :to => :idling)
   end
   
   def test_should_ignore_from
-    assert @guard.matches?(@object, :on => 'turn_on', :from => 'off')
+    assert @guard.matches?(@object, :on => :park, :from => :parked)
   end
   
   def test_should_not_be_included_in_known_states
@@ -326,55 +327,55 @@ end
 class GuardWithMultipleExceptOnRequirementsTest < Test::Unit::TestCase
   def setup
     @object = Object.new
-    @guard = StateMachine::Guard.new(:except_on => %w(turn_on turn_off))
+    @guard = StateMachine::Guard.new(:except_on => [:ignite, :park])
   end
   
   def test_should_match_if_not_included
-    assert @guard.matches?(@object, :on => 'turn_down')
+    assert @guard.matches?(@object, :on => :shift_up)
   end
   
   def test_should_not_match_if_included
-    assert !@guard.matches?(@object, :on => 'turn_on')
+    assert !@guard.matches?(@object, :on => :ignite)
   end
 end
 
-class GuardWithConflictingToRequirementsTest < Test::Unit::TestCase
+class GuardWithConflictingFromRequirementsTest < Test::Unit::TestCase
   def setup
     @object = Object.new
-    @guard = StateMachine::Guard.new(:to => 'on', :except_to => 'on')
+    @guard = StateMachine::Guard.new(:from => :parked, :except_from => :parked)
   end
   
   def test_should_ignore_except_requirement
-    assert @guard.matches?(@object, :to => 'on')
+    assert @guard.matches?(@object, :from => :parked)
   end
 end
 
-class GuardWithConflictingFromRequirementsTest < Test::Unit::TestCase
+class GuardWithConflictingToRequirementsTest < Test::Unit::TestCase
   def setup
     @object = Object.new
-    @guard = StateMachine::Guard.new(:from => 'on', :except_from => 'on')
+    @guard = StateMachine::Guard.new(:to => :idling, :except_to => :idling)
   end
   
   def test_should_ignore_except_requirement
-    assert @guard.matches?(@object, :from => 'on')
+    assert @guard.matches?(@object, :to => :idling)
   end
 end
 
 class GuardWithConflictingOnRequirementsTest < Test::Unit::TestCase
   def setup
     @object = Object.new
-    @guard = StateMachine::Guard.new(:on => 'turn_on', :except_on => 'turn_on')
+    @guard = StateMachine::Guard.new(:on => :ignite, :except_on => :ignite)
   end
   
   def test_should_ignore_except_requirement
-    assert @guard.matches?(@object, :on => 'turn_on')
+    assert @guard.matches?(@object, :on => :ignite)
   end
 end
 
 class GuardWithDifferentRequirementsTest < Test::Unit::TestCase
   def setup
     @object = Object.new
-    @guard = StateMachine::Guard.new(:from => 'off', :to => 'on', :on => 'turn_on')
+    @guard = StateMachine::Guard.new(:from => :parked, :to => :idling, :on => :ignite)
   end
   
   def test_should_match_empty_query
@@ -382,28 +383,28 @@ class GuardWithDifferentRequirementsTest < Test::Unit::TestCase
   end
   
   def test_should_match_if_all_requirements_match
-    assert @guard.matches?(@object, :from => 'off', :to => 'on', :on => 'turn_on')
+    assert @guard.matches?(@object, :from => :parked, :to => :idling, :on => :ignite)
   end
   
   def test_should_not_match_if_from_not_included
-    assert !@guard.matches?(@object, :from => 'on')
+    assert !@guard.matches?(@object, :from => :idling)
   end
   
   def test_should_not_match_if_to_not_included
-    assert !@guard.matches?(@object, :to => 'off')
+    assert !@guard.matches?(@object, :to => :parked)
   end
   
   def test_should_not_match_if_on_not_included
-    assert !@guard.matches?(@object, :on => 'turn_off')
+    assert !@guard.matches?(@object, :on => :park)
   end
   
   def test_should_include_all_known_states
-    assert_equal %w(off on), @guard.known_states.sort
+    assert_equal [:parked, :idling], @guard.known_states
   end
   
   def test_should_not_duplicate_known_statse
-    guard = StateMachine::Guard.new(:except_from => 'on', :to => 'on', :on => 'turn_on')
-    assert_equal %w(on), guard.known_states
+    guard = StateMachine::Guard.new(:except_from => :idling, :to => :idling, :on => :ignite)
+    assert_equal [:idling], guard.known_states
   end
 end
 
@@ -422,11 +423,11 @@ class GuardWithNilRequirementsTest < Test::Unit::TestCase
   end
   
   def test_should_not_match_if_from_not_included
-    assert !@guard.matches?(@object, :from => 'off')
+    assert !@guard.matches?(@object, :from => :parked)
   end
   
   def test_should_not_match_if_to_not_included
-    assert !@guard.matches?(@object, :to => 'on')
+    assert !@guard.matches?(@object, :to => :idling)
   end
   
   def test_should_include_all_known_states
@@ -490,13 +491,13 @@ begin
   class GuardDrawingTest < Test::Unit::TestCase
     def setup
       @machine = StateMachine::Machine.new(Class.new)
-      states = %w(parked idling)
+      states = [:parked, :idling]
       
       graph = GraphViz.new('G')
-      states.each {|state| graph.add_node(state)}
+      states.each {|state| graph.add_node(state.to_s)}
       
-      @guard = StateMachine::Guard.new(:from => 'idling', :to => 'parked')
-      @edges = @guard.draw(graph, 'park', states)
+      @guard = StateMachine::Guard.new(:from => :idling, :to => :parked)
+      @edges = @guard.draw(graph, :park, states)
     end
     
     def test_should_create_edges
@@ -519,19 +520,19 @@ begin
   class GuardDrawingWithFromRequirementTest < Test::Unit::TestCase
     def setup
       @machine = StateMachine::Machine.new(Class.new)
-      states = %w(parked idling first_gear)
+      states = [:parked, :idling, :first_gear]
       
       graph = GraphViz.new('G')
-      states.each {|state| graph.add_node(state)}
+      states.each {|state| graph.add_node(state.to_s)}
       
-      @guard = StateMachine::Guard.new(:from => %w(idling first_gear), :to => 'parked')
-      @edges = @guard.draw(graph, 'park', states)
+      @guard = StateMachine::Guard.new(:from => [:idling, :first_gear], :to => :parked)
+      @edges = @guard.draw(graph, :park, states)
     end
     
     def test_should_generate_edges_for_each_valid_from_state
-      %w(idling first_gear).each_with_index do |from_state, index|
+      [:idling, :first_gear].each_with_index do |from_state, index|
         edge = @edges[index]
-        assert_equal from_state, edge.instance_variable_get('@xNodeOne')
+        assert_equal from_state.to_s, edge.instance_variable_get('@xNodeOne')
         assert_equal 'parked', edge.instance_variable_get('@xNodeTwo')
       end
     end
@@ -540,13 +541,13 @@ begin
   class GuardDrawingWithExceptFromRequirementTest < Test::Unit::TestCase
     def setup
       @machine = StateMachine::Machine.new(Class.new)
-      states = %w(parked idling first_gear)
+      states = [:parked, :idling, :first_gear]
       
       graph = GraphViz.new('G')
-      states.each {|state| graph.add_node(state)}
+      states.each {|state| graph.add_node(state.to_s)}
       
-      @guard = StateMachine::Guard.new(:except_from => 'parked', :to => 'parked')
-      @edges = @guard.draw(graph, 'park', states)
+      @guard = StateMachine::Guard.new(:except_from => :parked, :to => :parked)
+      @edges = @guard.draw(graph, :park, states)
     end
     
     def test_should_generate_edges_for_each_valid_from_state
@@ -561,13 +562,13 @@ begin
   class GuardDrawingWithoutFromRequirementTest < Test::Unit::TestCase
     def setup
       @machine = StateMachine::Machine.new(Class.new)
-      states = %w(parked idling first_gear)
+      states = [:parked, :idling, :first_gear]
       
       graph = GraphViz.new('G')
-      states.each {|state| graph.add_node(state)}
+      states.each {|state| graph.add_node(state.to_s)}
       
-      @guard = StateMachine::Guard.new(:to => 'parked')
-      @edges = @guard.draw(graph, 'park', states)
+      @guard = StateMachine::Guard.new(:to => :parked)
+      @edges = @guard.draw(graph, :park, states)
     end
     
     def test_should_generate_edges_for_each_valid_from_state
@@ -586,8 +587,8 @@ begin
       graph = GraphViz.new('G')
       graph.add_node('parked')
       
-      @guard = StateMachine::Guard.new(:from => 'parked')
-      @edges = @guard.draw(graph, 'park', ['parked'])
+      @guard = StateMachine::Guard.new(:from => :parked)
+      @edges = @guard.draw(graph, :park, [:parked])
     end
     
     def test_should_create_loopback_edge
@@ -595,29 +596,6 @@ begin
       assert_equal 'parked', @edges.first.instance_variable_get('@xNodeTwo')
     end
   end
-  
-  class GuardWithProcStatesTest < Test::Unit::TestCase
-    def setup
-      @machine = StateMachine::Machine.new(Class.new)
-      @from_state = lambda {}
-      @to_state = lambda {}
-      states = [@from_state, @to_state]
-      
-      graph = GraphViz.new('G')
-      states.each {|state| graph.add_node("lambda#{state.object_id.abs}")}
-      
-      @guard = StateMachine::Guard.new(:from => @from_state, :to => @to_state)
-      @edges = @guard.draw(graph, 'park', states)
-    end
-    
-    def test_should_use_state_id_for_from_state
-      assert_equal "lambda#{@from_state.object_id.abs}", @edges.first.instance_variable_get('@xNodeOne')
-    end
-    
-    def test_should_use_state_id_for_to_state
-      assert_equal "lambda#{@to_state.object_id.abs}", @edges.first.instance_variable_get('@xNodeTwo')
-    end
-  end
 rescue LoadError
   $stderr.puts 'Skipping GraphViz StateMachine::Guard tests. `gem install ruby-graphviz` and try again.'
 end