state_machine 0.5.1 → 0.5.2

data/test/unit/assertions_test.rb

@@ -3,12 +3,38 @@ require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
 class AssertionsTest < Test::Unit::TestCase
   include StateMachine::Assertions
   
+  def default_test
+  end
+end
+
+class AssertValidKeysTest < AssertionsTest
   def test_should_not_raise_exception_if_key_is_valid
     assert_nothing_raised { assert_valid_keys({:name => 'foo', :value => 'bar'}, :name, :value, :force) }
   end
   
   def test_should_raise_exception_if_key_is_invalid
     exception = assert_raise(ArgumentError) { assert_valid_keys({:name => 'foo', :value => 'bar', :invalid => true}, :name, :value, :force) }
-    assert_match 'Invalid key(s): invalid', exception.message
+    assert_equal 'Invalid key(s): invalid', exception.message
+  end
+end
+
+class AssertExclusiveKeysTest < AssertionsTest
+  def test_should_not_raise_exception_if_no_keys_found
+    assert_nothing_raised { assert_exclusive_keys({:on => :park}, :only, :except) }
+  end
+  
+  def test_should_not_raise_exception_if_one_key_found
+    assert_nothing_raised { assert_exclusive_keys({:only => :parked}, :only, :except) }
+    assert_nothing_raised { assert_exclusive_keys({:except => :parked}, :only, :except) }
+  end
+  
+  def test_should_raise_exception_if_two_keys_found
+    exception = assert_raise(ArgumentError) { assert_exclusive_keys({:only => :parked, :except => :parked}, :only, :except) }
+    assert_equal 'Conflicting keys: only, except', exception.message
+  end
+  
+  def test_should_raise_exception_if_multiple_keys_found
+    exception = assert_raise(ArgumentError) { assert_exclusive_keys({:only => :parked, :except => :parked, :on => :park}, :only, :except, :with) }
+    assert_equal 'Conflicting keys: only, except', exception.message
   end
 end

data/test/unit/callback_test.rb

@@ -31,9 +31,10 @@ class CallbackByDefaultTest < Test::Unit::TestCase
     assert_nil @callback.terminator
   end
   
-  def test_should_have_a_guard_with_no_requirements
-    expected = {}
-    assert_equal expected, @callback.guard.requirements
+  def test_should_have_a_guard_with_all_matcher_requirements
+    assert_equal StateMachine::AllMatcher.instance, @callback.guard.event_requirement
+    assert_equal StateMachine::AllMatcher.instance, @callback.guard.state_requirement[:from]
+    assert_equal StateMachine::AllMatcher.instance, @callback.guard.state_requirement[:to]
   end
   
   def test_should_not_bind_to_the_object

data/test/unit/event_test.rb

@@ -64,7 +64,7 @@ class EventTest < Test::Unit::TestCase
   end
   
   def test_should_use_pretty_inspect
-    assert_match /#<StateMachine::Event name=:ignite transitions=\[\{.+\}\]>/, @event.inspect
+    assert_match "#<StateMachine::Event name=:ignite transitions=[:parked => :idling]>", @event.inspect
   end
 end
 

data/test/unit/guard_test.rb

@@ -10,9 +10,12 @@ class GuardTest < Test::Unit::TestCase
     assert_equal 'Invalid key(s): invalid', exception.message
   end
   
-  def test_should_have_requirements
-    expected = {:to => [:idling], :from => [:parked]}
-    assert_equal expected, @guard.requirements
+  def test_should_not_have_an_if_condition
+    assert_nil @guard.if_condition
+  end
+  
+  def test_should_not_have_an_unless_condition
+    assert_nil @guard.unless_condition
   end
 end
 
@@ -22,6 +25,18 @@ class GuardWithNoRequirementsTest < Test::Unit::TestCase
     @guard = StateMachine::Guard.new
   end
   
+  def test_should_use_all_matcher_for_event_requirement
+    assert_equal StateMachine::AllMatcher.instance, @guard.event_requirement
+  end
+  
+  def test_should_use_all_matcher_for_from_state_requirement
+    assert_equal StateMachine::AllMatcher.instance, @guard.state_requirement[:from]
+  end
+  
+  def test_should_use_all_matcher_for_to_state_requirement
+    assert_equal StateMachine::AllMatcher.instance, @guard.state_requirement[:to]
+  end
+  
   def test_should_match_nil_query
     assert @guard.matches?(@object, nil)
   end
@@ -41,6 +56,10 @@ class GuardWithFromRequirementTest < Test::Unit::TestCase
     @guard = StateMachine::Guard.new(:from => :parked)
   end
   
+  def test_should_use_a_whitelist_matcher
+    assert_instance_of StateMachine::WhitelistMatcher, @guard.state_requirement[:from]
+  end
+  
   def test_should_match_if_not_specified
     assert @guard.matches?(@object, :to => :idling)
   end
@@ -95,6 +114,10 @@ class GuardWithToRequirementTest < Test::Unit::TestCase
     @guard = StateMachine::Guard.new(:to => :idling)
   end
   
+  def test_should_use_a_whitelist_matcher
+    assert_instance_of StateMachine::WhitelistMatcher, @guard.state_requirement[:to]
+  end
+  
   def test_should_match_if_not_specified
     assert @guard.matches?(@object, :from => :parked)
   end
@@ -149,6 +172,10 @@ class GuardWithOnRequirementTest < Test::Unit::TestCase
     @guard = StateMachine::Guard.new(:on => :ignite)
   end
   
+  def test_should_use_a_whitelist_matcher
+    assert_instance_of StateMachine::WhitelistMatcher, @guard.event_requirement
+  end
+  
   def test_should_match_if_not_specified
     assert @guard.matches?(@object, :from => :parked)
   end
@@ -199,6 +226,10 @@ class GuardWithExceptFromRequirementTest < Test::Unit::TestCase
     @guard = StateMachine::Guard.new(:except_from => :parked)
   end
   
+  def test_should_use_a_blacklist_matcher
+    assert_instance_of StateMachine::BlacklistMatcher, @guard.state_requirement[:from]
+  end
+  
   def test_should_match_if_not_included
     assert @guard.matches?(@object, :from => :idling)
   end
@@ -249,6 +280,10 @@ class GuardWithExceptToRequirementTest < Test::Unit::TestCase
     @guard = StateMachine::Guard.new(:except_to => :idling)
   end
   
+  def test_should_use_a_blacklist_matcher
+    assert_instance_of StateMachine::BlacklistMatcher, @guard.state_requirement[:to]
+  end
+  
   def test_should_match_if_not_included
     assert @guard.matches?(@object, :to => :parked)
   end
@@ -299,6 +334,10 @@ class GuardWithExceptOnRequirementTest < Test::Unit::TestCase
     @guard = StateMachine::Guard.new(:except_on => :ignite)
   end
   
+  def test_should_use_a_blacklist_matcher
+    assert_instance_of StateMachine::BlacklistMatcher, @guard.event_requirement
+  end
+  
   def test_should_match_if_not_included
     assert @guard.matches?(@object, :on => :park)
   end
@@ -340,35 +379,23 @@ class GuardWithMultipleExceptOnRequirementsTest < Test::Unit::TestCase
 end
 
 class GuardWithConflictingFromRequirementsTest < Test::Unit::TestCase
-  def setup
-    @object = Object.new
-    @guard = StateMachine::Guard.new(:from => :parked, :except_from => :parked)
-  end
-  
-  def test_should_ignore_except_requirement
-    assert @guard.matches?(@object, :from => :parked)
+  def test_should_raise_an_exception
+    exception = assert_raise(ArgumentError) { StateMachine::Guard.new(:from => :parked, :except_from => :parked) }
+    assert_equal 'Conflicting keys: from, except_from', exception.message
   end
 end
 
 class GuardWithConflictingToRequirementsTest < Test::Unit::TestCase
-  def setup
-    @object = Object.new
-    @guard = StateMachine::Guard.new(:to => :idling, :except_to => :idling)
-  end
-  
-  def test_should_ignore_except_requirement
-    assert @guard.matches?(@object, :to => :idling)
+  def test_should_raise_an_exception
+    exception = assert_raise(ArgumentError) { StateMachine::Guard.new(:to => :idling, :except_to => :idling) }
+    assert_equal 'Conflicting keys: to, except_to', exception.message
   end
 end
 
 class GuardWithConflictingOnRequirementsTest < Test::Unit::TestCase
-  def setup
-    @object = Object.new
-    @guard = StateMachine::Guard.new(:on => :ignite, :except_on => :ignite)
-  end
-  
-  def test_should_ignore_except_requirement
-    assert @guard.matches?(@object, :on => :ignite)
+  def test_should_raise_an_exception
+    exception = assert_raise(ArgumentError) { StateMachine::Guard.new(:on => :ignite, :except_on => :ignite) }
+    assert_equal 'Conflicting keys: on, except_on', exception.message
   end
 end
 
@@ -440,6 +467,11 @@ class GuardWithIfConditionalTest < Test::Unit::TestCase
     @object = Object.new
   end
   
+  def test_should_have_an_if_condition
+    guard = StateMachine::Guard.new(:if => lambda {true})
+    assert_not_nil guard.if_condition
+  end
+  
   def test_should_match_if_true
     guard = StateMachine::Guard.new(:if => lambda {true})
     assert guard.matches?(@object)
@@ -456,6 +488,11 @@ class GuardWithUnlessConditionalTest < Test::Unit::TestCase
     @object = Object.new
   end
   
+  def test_should_have_an_unless_condition
+    guard = StateMachine::Guard.new(:unless => lambda {true})
+    assert_not_nil guard.unless_condition
+  end
+  
   def test_should_match_if_false
     guard = StateMachine::Guard.new(:unless => lambda {false})
     assert guard.matches?(@object)
@@ -468,18 +505,9 @@ class GuardWithUnlessConditionalTest < Test::Unit::TestCase
 end
 
 class GuardWithConflictingConditionalsTest < Test::Unit::TestCase
-  def setup
-    @object = Object.new
-  end
-  
-  def test_should_match_if_true
-    guard = StateMachine::Guard.new(:if => lambda {true}, :unless => lambda {true})
-    assert guard.matches?(@object)
-  end
-  
-  def test_should_not_match_if_false
-    guard = StateMachine::Guard.new(:if => lambda {false}, :unless => lambda {false})
-    assert !guard.matches?(@object)
+  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
   end
 end
 

data/test/unit/integrations/active_record_test.rb

@@ -307,6 +307,21 @@ begin
       end
     end
     
+    class MachineWithComplexPluralizationTest < ActiveRecord::TestCase
+      def setup
+        @model = new_model
+        @machine = StateMachine::Machine.new(@model, :status)
+      end
+      
+      def test_should_create_singular_with_scope
+        assert @model.respond_to?(:with_status)
+      end
+      
+      def test_should_create_plural_with_scope
+        assert @model.respond_to?(:with_statuses)
+      end
+    end
+    
     class MachineWithCallbacksTest < ActiveRecord::TestCase
       def setup
         @model = new_model

data/test/unit/integrations/data_mapper_test.rb

@@ -201,6 +201,21 @@ begin
       end
     end
     
+    class MachineWithComplexPluralizationTest < BaseTestCase
+      def setup
+        @resource = new_resource
+        @machine = StateMachine::Machine.new(@resource, :status)
+      end
+      
+      def test_should_create_singular_with_scope
+        assert @resource.respond_to?(:with_status)
+      end
+      
+      def test_should_create_plural_with_scope
+        assert @resource.respond_to?(:with_statuses)
+      end
+    end
+    
     class MachineWithNonColumnStateAttributeDefinedTest < BaseTestCase
       def setup
         @resource = new_resource do

data/test/unit/integrations/sequel_test.rb

@@ -202,6 +202,21 @@ begin
       end
     end
     
+    class MachineWithComplexPluralizationTest < BaseTestCase
+      def setup
+        @model = new_model
+        @machine = StateMachine::Machine.new(@model, :status)
+      end
+      
+      def test_should_create_singular_with_scope
+        assert @model.respond_to?(:with_status)
+      end
+      
+      def test_should_create_plural_with_scope
+        assert @model.respond_to?(:with_statuses)
+      end
+    end
+    
     class MachineWithCallbacksTest < BaseTestCase
       def setup
         @model = new_model

data/test/unit/matcher_test.rb

@@ -0,0 +1,155 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class MatcherByDefaultTest < Test::Unit::TestCase
+  def setup
+    @matcher = StateMachine::Matcher.new
+  end
+  
+  def test_should_have_no_values
+    assert_equal [], @matcher.values
+  end
+  
+  def test_should_filter_all_values
+    assert_equal [], @matcher.filter([:parked, :idling])
+  end
+end
+
+class MatcherWithValueTest < Test::Unit::TestCase
+  def setup
+    @matcher = StateMachine::Matcher.new(nil)
+  end
+  
+  def test_should_have_values
+    assert_equal [nil], @matcher.values
+  end
+  
+  def test_should_filter_unknown_values
+    assert_equal [nil], @matcher.filter([nil, :parked])
+  end
+end
+
+class MatcherWithMultipleValuesTest < Test::Unit::TestCase
+  def setup
+    @matcher = StateMachine::Matcher.new([:parked, :idling])
+  end
+  
+  def test_should_have_values
+    assert_equal [:parked, :idling], @matcher.values
+  end
+  
+  def test_should_filter_unknown_values
+    assert_equal [:parked], @matcher.filter([:parked, :first_gear])
+  end
+end
+
+class AllMatcherTest < Test::Unit::TestCase
+  def setup
+    @matcher = StateMachine::AllMatcher.instance
+  end
+  
+  def test_should_have_no_values
+    assert_equal [], @matcher.values
+  end
+  
+  def test_should_always_match
+    [nil, :parked, :idling].each {|value| assert @matcher.matches?(value)}
+  end
+  
+  def test_should_not_filter_any_values
+    assert_equal [:parked, :idling], @matcher.filter([:parked, :idling])
+  end
+  
+  def test_should_generate_blacklist_matcher_after_subtraction
+    matcher = @matcher - [:parked, :idling]
+    assert_instance_of StateMachine::BlacklistMatcher, matcher
+    assert_equal [:parked, :idling], matcher.values
+  end
+  
+  def test_should_have_a_description
+    assert_equal 'all', @matcher.description
+  end
+end
+
+class WhitelistMatcherTest < Test::Unit::TestCase
+  def setup
+    @matcher = StateMachine::WhitelistMatcher.new([:parked, :idling])
+  end
+  
+  def test_should_have_values
+    assert_equal [:parked, :idling], @matcher.values
+  end
+  
+  def test_should_filter_unknown_values
+    assert_equal [:parked, :idling], @matcher.filter([:parked, :idling, :first_gear])
+  end
+  
+  def test_should_match_known_values
+    assert @matcher.matches?(:parked)
+  end
+  
+  def test_should_not_match_unknown_values
+    assert !@matcher.matches?(:first_gear)
+  end
+  
+  def test_should_have_a_description
+    assert_equal '[:parked, :idling]', @matcher.description
+    
+    matcher = StateMachine::WhitelistMatcher.new([:parked])
+    assert_equal ':parked', matcher.description
+  end
+end
+
+class BlacklistMatcherTest < Test::Unit::TestCase
+  def setup
+    @matcher = StateMachine::BlacklistMatcher.new([:parked, :idling])
+  end
+  
+  def test_should_have_values
+    assert_equal [:parked, :idling], @matcher.values
+  end
+  
+  def test_should_filter_known_values
+    assert_equal [:first_gear], @matcher.filter([:parked, :idling, :first_gear])
+  end
+  
+  def test_should_match_unknown_values
+    assert @matcher.matches?(:first_gear)
+  end
+  
+  def test_should_not_match_known_values
+    assert !@matcher.matches?(:parked)
+  end
+  
+  def test_should_have_a_description
+    assert_equal 'all - [:parked, :idling]', @matcher.description
+    
+    matcher = StateMachine::BlacklistMatcher.new([:parked])
+    assert_equal 'all - :parked', matcher.description
+  end
+end
+
+class LoopbackMatcherTest < Test::Unit::TestCase
+  def setup
+    @matcher = StateMachine::LoopbackMatcher.instance
+  end
+  
+  def test_should_have_no_values
+    assert_equal [], @matcher.values
+  end
+  
+  def test_should_filter_all_values
+    assert_equal [], @matcher.filter([:parked, :idling])
+  end
+  
+  def test_should_match_if_from_context_is_same
+    assert @matcher.matches?(:parked, :from => :parked)
+  end
+  
+  def test_should_not_match_if_from_context_is_different
+    assert !@matcher.matches?(:parked, :from => :idling)
+  end
+  
+  def test_should_have_a_description
+    assert_equal 'same', @matcher.description
+  end
+end