state_machine 0.5.2 → 0.6.0

data/test/unit/guard_test.rb

@@ -2,12 +2,11 @@ require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
 
 class GuardTest < Test::Unit::TestCase
   def setup
-    @guard = StateMachine::Guard.new(:to => :idling, :from => :parked)
+    @guard = StateMachine::Guard.new(:from => :parked, :to => :idling)
   end
   
-  def test_should_raise_exception_if_invalid_option_specified
-    exception = assert_raise(ArgumentError) { StateMachine::Guard.new(:invalid => true) }
-    assert_equal 'Invalid key(s): invalid', exception.message
+  def test_should_not_raise_exception_if_implicit_option_specified
+    assert_nothing_raised { StateMachine::Guard.new(:invalid => true) }
   end
   
   def test_should_not_have_an_if_condition
@@ -17,6 +16,10 @@ class GuardTest < Test::Unit::TestCase
   def test_should_not_have_an_unless_condition
     assert_nil @guard.unless_condition
   end
+  
+  def test_should_have_a_state_requirement
+    assert_equal 1, @guard.state_requirements.length
+  end
 end
 
 class GuardWithNoRequirementsTest < Test::Unit::TestCase
@@ -30,11 +33,11 @@ class GuardWithNoRequirementsTest < Test::Unit::TestCase
   end
   
   def test_should_use_all_matcher_for_from_state_requirement
-    assert_equal StateMachine::AllMatcher.instance, @guard.state_requirement[:from]
+    assert_equal StateMachine::AllMatcher.instance, @guard.state_requirements.first[:from]
   end
   
   def test_should_use_all_matcher_for_to_state_requirement
-    assert_equal StateMachine::AllMatcher.instance, @guard.state_requirement[:to]
+    assert_equal StateMachine::AllMatcher.instance, @guard.state_requirements.first[:to]
   end
   
   def test_should_match_nil_query
@@ -48,6 +51,14 @@ class GuardWithNoRequirementsTest < Test::Unit::TestCase
   def test_should_match_non_empty_query
     assert @guard.matches?(@object, :to => :idling, :from => :parked, :on => :ignite)
   end
+  
+  def test_should_include_all_requirements_in_match
+    match = @guard.match(@object, nil)
+    
+    assert_equal @guard.state_requirements.first[:from], match[:from]
+    assert_equal @guard.state_requirements.first[:to], match[:to]
+    assert_equal @guard.event_requirement, match[:on]
+  end
 end
 
 class GuardWithFromRequirementTest < Test::Unit::TestCase
@@ -57,7 +68,7 @@ class GuardWithFromRequirementTest < Test::Unit::TestCase
   end
   
   def test_should_use_a_whitelist_matcher
-    assert_instance_of StateMachine::WhitelistMatcher, @guard.state_requirement[:from]
+    assert_instance_of StateMachine::WhitelistMatcher, @guard.state_requirements.first[:from]
   end
   
   def test_should_match_if_not_specified
@@ -87,6 +98,11 @@ class GuardWithFromRequirementTest < Test::Unit::TestCase
   def test_should_be_included_in_known_states
     assert_equal [:parked], @guard.known_states
   end
+  
+  def test_should_include_requirement_in_match
+    match = @guard.match(@object, :from => :parked)
+    assert_equal @guard.state_requirements.first[:from], match[:from]
+  end
 end
 
 class GuardWithMultipleFromRequirementsTest < Test::Unit::TestCase
@@ -115,7 +131,7 @@ class GuardWithToRequirementTest < Test::Unit::TestCase
   end
   
   def test_should_use_a_whitelist_matcher
-    assert_instance_of StateMachine::WhitelistMatcher, @guard.state_requirement[:to]
+    assert_instance_of StateMachine::WhitelistMatcher, @guard.state_requirements.first[:to]
   end
   
   def test_should_match_if_not_specified
@@ -145,6 +161,11 @@ class GuardWithToRequirementTest < Test::Unit::TestCase
   def test_should_be_included_in_known_states
     assert_equal [:idling], @guard.known_states
   end
+  
+  def test_should_include_requirement_in_match
+    match = @guard.match(@object, :to => :idling)
+    assert_equal @guard.state_requirements.first[:to], match[:to]
+  end
 end
 
 class GuardWithMultipleToRequirementsTest < Test::Unit::TestCase
@@ -203,6 +224,11 @@ class GuardWithOnRequirementTest < Test::Unit::TestCase
   def test_should_not_be_included_in_known_states
     assert_equal [], @guard.known_states
   end
+  
+  def test_should_include_requirement_in_match
+    match = @guard.match(@object, :on => :ignite)
+    assert_equal @guard.event_requirement, match[:on]
+  end
 end
 
 class GuardWithMultipleOnRequirementsTest < Test::Unit::TestCase
@@ -227,7 +253,7 @@ class GuardWithExceptFromRequirementTest < Test::Unit::TestCase
   end
   
   def test_should_use_a_blacklist_matcher
-    assert_instance_of StateMachine::BlacklistMatcher, @guard.state_requirement[:from]
+    assert_instance_of StateMachine::BlacklistMatcher, @guard.state_requirements.first[:from]
   end
   
   def test_should_match_if_not_included
@@ -281,7 +307,7 @@ class GuardWithExceptToRequirementTest < Test::Unit::TestCase
   end
   
   def test_should_use_a_blacklist_matcher
-    assert_instance_of StateMachine::BlacklistMatcher, @guard.state_requirement[:to]
+    assert_instance_of StateMachine::BlacklistMatcher, @guard.state_requirements.first[:to]
   end
   
   def test_should_match_if_not_included
@@ -425,6 +451,10 @@ class GuardWithDifferentRequirementsTest < Test::Unit::TestCase
     assert !@guard.matches?(@object, :on => :park)
   end
   
+  def test_should_be_nil_if_unmatched
+    assert_nil @guard.match(@object, :from => :parked, :to => :idling, :on => :park)
+  end
+  
   def test_should_include_all_known_states
     assert_equal [:parked, :idling], @guard.known_states
   end
@@ -462,6 +492,129 @@ class GuardWithNilRequirementsTest < Test::Unit::TestCase
   end
 end
 
+class GuardWithImplicitRequirementTest < Test::Unit::TestCase
+  def setup
+    @guard = StateMachine::Guard.new(:parked => :idling, :on => :ignite)
+  end
+  
+  def test_should_create_an_event_requirement
+    assert_instance_of StateMachine::WhitelistMatcher, @guard.event_requirement
+    assert_equal [:ignite], @guard.event_requirement.values
+  end
+  
+  def test_should_use_a_whitelist_from_matcher
+    assert_instance_of StateMachine::WhitelistMatcher, @guard.state_requirements.first[:from]
+  end
+  
+  def test_should_use_a_whitelist_to_matcher
+    assert_instance_of StateMachine::WhitelistMatcher, @guard.state_requirements.first[:to]
+  end
+end
+
+class GuardWithMultipleImplicitRequirementsTest < Test::Unit::TestCase
+  def setup
+    @object = Object.new
+    @guard = StateMachine::Guard.new(:parked => :idling, :idling => :first_gear, :on => :ignite)
+  end
+  
+  def test_should_create_multiple_state_requirements
+    assert_equal 2, @guard.state_requirements.length
+  end
+  
+  def test_should_not_match_event_as_state_requirement
+    assert !@guard.matches?(@object, :from => :on, :to => :ignite)
+  end
+  
+  def test_should_match_if_from_included_in_any
+    assert @guard.matches?(@object, :from => :parked)
+    assert @guard.matches?(@object, :from => :idling)
+  end
+  
+  def test_should_not_match_if_from_not_included_in_any
+    assert !@guard.matches?(@object, :from => :first_gear)
+  end
+  
+  def test_should_match_if_to_included_in_any
+    assert @guard.matches?(@object, :to => :idling)
+    assert @guard.matches?(@object, :to => :first_gear)
+  end
+  
+  def test_should_not_match_if_to_not_included_in_any
+    assert !@guard.matches?(@object, :to => :parked)
+  end
+  
+  def test_should_match_if_all_options_match
+    assert @guard.matches?(@object, :from => :parked, :to => :idling, :on => :ignite)
+    assert @guard.matches?(@object, :from => :idling, :to => :first_gear, :on => :ignite)
+  end
+  
+  def test_should_not_match_if_any_options_do_not_match
+    assert !@guard.matches?(@object, :from => :parked, :to => :idling, :on => :park)
+    assert !@guard.matches?(@object, :from => :parked, :to => :first_gear, :on => :park)
+  end
+  
+  def test_should_include_all_known_states
+    assert_equal [:first_gear, :idling, :parked], @guard.known_states.sort_by {|state| state.to_s}
+  end
+  
+  def test_should_not_duplicate_known_statse
+    guard = StateMachine::Guard.new(:parked => :idling, :first_gear => :idling)
+    assert_equal [:first_gear, :idling, :parked], guard.known_states.sort_by {|state| state.to_s}
+  end
+end
+
+class GuardWithImplicitFromRequirementMatcherTest < Test::Unit::TestCase
+  def setup
+    @matcher = StateMachine::BlacklistMatcher.new(:parked)
+    @guard = StateMachine::Guard.new(@matcher => :idling)
+  end
+  
+  def test_should_not_convert_from_to_whitelist_matcher
+    assert_equal @matcher, @guard.state_requirements.first[:from]
+  end
+  
+  def test_should_convert_to_to_whitelist_matcher
+    assert_instance_of StateMachine::WhitelistMatcher, @guard.state_requirements.first[:to]
+  end
+end
+
+class GuardWithImplicitToRequirementMatcherTest < Test::Unit::TestCase
+  def setup
+    @matcher = StateMachine::BlacklistMatcher.new(:idling)
+    @guard = StateMachine::Guard.new(:parked => @matcher)
+  end
+  
+  def test_should_convert_from_to_whitelist_matcher
+    assert_instance_of StateMachine::WhitelistMatcher, @guard.state_requirements.first[:from]
+  end
+  
+  def test_should_not_convert_to_to_whitelist_matcher
+    assert_equal @matcher, @guard.state_requirements.first[:to]
+  end
+end
+
+class GuardWithImplicitAndExplicitRequirementsTest < Test::Unit::TestCase
+  def setup
+    @guard = StateMachine::Guard.new(:parked => :idling, :from => :parked)
+  end
+  
+  def test_should_create_multiple_requirements
+    assert_equal 2, @guard.state_requirements.length
+  end
+  
+  def test_should_create_implicit_requirements_for_implicit_options
+    assert(@guard.state_requirements.any? do |state_requirement|
+      state_requirement[:from].values == [:parked] && state_requirement[:to].values == [:idling]
+    end)
+  end
+  
+  def test_should_create_implicit_requirements_for_explicit_options
+    assert(@guard.state_requirements.any? do |state_requirement|
+      state_requirement[:from].values == [:from] && state_requirement[:to].values == [:parked]
+    end)
+  end
+end
+
 class GuardWithIfConditionalTest < Test::Unit::TestCase
   def setup
     @object = Object.new
@@ -481,6 +634,30 @@ class GuardWithIfConditionalTest < Test::Unit::TestCase
     guard = StateMachine::Guard.new(:if => lambda {false})
     assert !guard.matches?(@object)
   end
+  
+  def test_should_be_nil_if_unmatched
+    guard = StateMachine::Guard.new(:if => lambda {false})
+    assert_nil guard.match(@object)
+  end
+end
+
+class GuardWithMultipleIfConditionalsTest < Test::Unit::TestCase
+  def setup
+    @object = Object.new
+  end
+  
+  def test_should_match_if_all_are_true
+    guard = StateMachine::Guard.new(:if => [lambda {true}, lambda {true}])
+    assert guard.match(@object)
+  end
+  
+  def test_should_not_match_if_any_are_false
+    guard = StateMachine::Guard.new(:if => [lambda {true}, lambda {false}])
+    assert !guard.match(@object)
+    
+    guard = StateMachine::Guard.new(:if => [lambda {false}, lambda {true}])
+    assert !guard.match(@object)
+  end
 end
 
 class GuardWithUnlessConditionalTest < Test::Unit::TestCase
@@ -502,12 +679,51 @@ class GuardWithUnlessConditionalTest < Test::Unit::TestCase
     guard = StateMachine::Guard.new(:unless => lambda {true})
     assert !guard.matches?(@object)
   end
+  
+  def test_should_be_nil_if_unmatched
+    guard = StateMachine::Guard.new(:unless => lambda {true})
+    assert_nil guard.match(@object)
+  end
+end
+
+class GuardWithMultipleUnlessConditionalsTest < Test::Unit::TestCase
+  def setup
+    @object = Object.new
+  end
+  
+  def test_should_match_if_all_are_false
+    guard = StateMachine::Guard.new(:unless => [lambda {false}, lambda {false}])
+    assert guard.match(@object)
+  end
+  
+  def test_should_not_match_if_any_are_true
+    guard = StateMachine::Guard.new(:unless => [lambda {true}, lambda {false}])
+    assert !guard.match(@object)
+    
+    guard = StateMachine::Guard.new(:unless => [lambda {false}, lambda {true}])
+    assert !guard.match(@object)
+  end
 end
 
 class GuardWithConflictingConditionalsTest < Test::Unit::TestCase
-  def test_should_raise_an_exception
-    exception = assert_raise(ArgumentError) { StateMachine::Guard.new(:if => lambda {true}, :unless => lambda {true}) }
-    assert_equal 'Conflicting keys: if, unless', exception.message
+  def test_should_match_if_if_is_true_and_unless_is_false
+    guard = StateMachine::Guard.new(:if => lambda {true}, :unless => lambda {false})
+    assert guard.match(@object)
+  end
+  
+  def test_should_not_match_if_if_is_false_and_unless_is_true
+    guard = StateMachine::Guard.new(:if => lambda {false}, :unless => lambda {true})
+    assert !guard.match(@object)
+  end
+  
+  def test_should_not_match_if_if_is_false_and_unless_is_false
+    guard = StateMachine::Guard.new(:if => lambda {false}, :unless => lambda {false})
+    assert !guard.match(@object)
+  end
+  
+  def test_should_not_match_if_if_is_true_and_unless_is_true
+    guard = StateMachine::Guard.new(:if => lambda {true}, :unless => lambda {true})
+    assert !guard.match(@object)
   end
 end
 
@@ -624,6 +840,23 @@ begin
       assert_equal 'parked', @edges.first.instance_variable_get('@xNodeTwo')
     end
   end
+  
+  class GuardDrawingWithNilStateTest < Test::Unit::TestCase
+    def setup
+      @machine = StateMachine::Machine.new(Class.new)
+      
+      graph = GraphViz.new('G')
+      graph.add_node('parked')
+      
+      @guard = StateMachine::Guard.new(:from => :idling, :to => nil)
+      @edges = @guard.draw(graph, :park, [nil, :idling])
+    end
+    
+    def test_should_generate_edges_for_each_valid_from_state
+      assert_equal 'idling', @edges.first.instance_variable_get('@xNodeOne')
+      assert_equal 'nil', @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

data/test/unit/integrations/active_record_test.rb

@@ -486,6 +486,35 @@ begin
       end
     end
     
+    class MachineWithStateDrivenValidationsTest < ActiveRecord::TestCase
+      def setup
+        @model = new_model do
+          attr_accessor :seatbelt
+        end
+        
+        @machine = StateMachine::Machine.new(@model)
+        @machine.state :first_gear, :second_gear do
+          validates_presence_of :seatbelt
+        end
+        @machine.other_states :parked
+      end
+      
+      def test_should_be_valid_if_validation_fails_outside_state_scope
+        record = @model.new(:state => 'parked', :seatbelt => nil)
+        assert record.valid?
+      end
+      
+      def test_should_be_invalid_if_validation_fails_within_state_scope
+        record = @model.new(:state => 'first_gear', :seatbelt => nil)
+        assert !record.valid?
+      end
+      
+      def test_should_be_valid_if_validation_succeeds_within_state_scope
+        record = @model.new(:state => 'second_gear', :seatbelt => true)
+        assert record.valid?
+      end
+    end
+    
     class MachineWithFailedAfterCallbacksTest < ActiveRecord::TestCase
        def setup
         @after_count = 0

data/test/unit/integrations/data_mapper_test.rb

@@ -334,6 +334,16 @@ begin
           @transition = StateMachine::Transition.new(@record, @machine, :ignite, :parked, :idling)
         end
         
+        def test_should_provide_matcher_helpers
+          matchers = []
+          
+          new_observer(@resource) do
+            matchers = [all, any, same]
+          end
+          
+          assert_equal [StateMachine::AllMatcher.instance, StateMachine::AllMatcher.instance, StateMachine::LoopbackMatcher.instance], matchers
+        end
+        
         def test_should_call_before_transition_callback_if_requirements_match
           called = false
           
@@ -476,6 +486,41 @@ begin
     rescue LoadError
       $stderr.puts 'Skipping DataMapper Observer tests. `gem install dm-observer` and try again.'
     end
+    
+    begin
+      require 'dm-validations'
+      
+      class MachineWithStateDrivenValidationsTest < BaseTestCase
+        def setup
+          @resource = new_resource do
+            attr_accessor :seatbelt
+          end
+          
+          @machine = StateMachine::Machine.new(@resource)
+          @machine.state :first_gear, :second_gear do
+            validates_present :seatbelt
+          end
+          @machine.other_states :parked
+        end
+        
+        def test_should_be_valid_if_validation_fails_outside_state_scope
+          record = @resource.new(:state => 'parked', :seatbelt => nil)
+          assert record.valid?
+        end
+        
+        def test_should_be_invalid_if_validation_fails_within_state_scope
+          record = @resource.new(:state => 'first_gear', :seatbelt => nil)
+          assert !record.valid?
+        end
+        
+        def test_should_be_valid_if_validation_succeeds_within_state_scope
+          record = @resource.new(:state => 'second_gear', :seatbelt => true)
+          assert record.valid?
+        end
+      end
+    rescue LoadError
+      $stderr.puts 'Skipping DataMapper Validation tests. `gem install dm-validations` and try again.'
+    end
   end
 rescue LoadError
   $stderr.puts 'Skipping DataMapper tests. `gem install dm-core cucumber rspec hoe launchy do_sqlite3` and try again.'