state_machine 0.5.2 → 0.6.0

data/test/unit/callback_test.rb

@@ -10,9 +10,8 @@ class CallbackTest < Test::Unit::TestCase
     assert_nothing_raised { StateMachine::Callback.new(:do => :run) }
   end
   
-  def test_should_raise_exception_if_invalid_option_specified
-    exception = assert_raise(ArgumentError) { StateMachine::Callback.new(:do => :run, :invalid => true) }
-    assert_match 'Invalid key(s): invalid', exception.message
+  def test_should_not_raise_exception_if_implicit_option_specified
+    assert_nothing_raised { StateMachine::Callback.new(:do => :run, :invalid => true) }
   end
   
   def test_should_not_bind_to_objects
@@ -33,8 +32,8 @@ class CallbackByDefaultTest < Test::Unit::TestCase
   
   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]
+    assert_equal StateMachine::AllMatcher.instance, @callback.guard.state_requirements.first[:from]
+    assert_equal StateMachine::AllMatcher.instance, @callback.guard.state_requirements.first[:to]
   end
   
   def test_should_not_bind_to_the_object
@@ -57,7 +56,7 @@ class CallbackWithOnlyMethodTest < Test::Unit::TestCase
   end
 end
 
-class CallbackWithRequirementsTest < Test::Unit::TestCase
+class CallbackWithExplicitRequirementsTest < Test::Unit::TestCase
   def setup
     @object = Object.new
     @callback = StateMachine::Callback.new(:from => :parked, :to => :idling, :on => :ignite, :do => lambda {true})
@@ -88,6 +87,37 @@ class CallbackWithRequirementsTest < Test::Unit::TestCase
   end
 end
 
+class CallbackWithImplicitRequirementsTest < Test::Unit::TestCase
+  def setup
+    @object = Object.new
+    @callback = StateMachine::Callback.new(:parked => :idling, :on => :ignite, :do => lambda {true})
+  end
+  
+  def test_should_call_with_empty_context
+    assert @callback.call(@object, {})
+  end
+  
+  def test_should_not_call_if_from_not_included
+    assert !@callback.call(@object, :from => :idling)
+  end
+  
+  def test_should_not_call_if_to_not_included
+    assert !@callback.call(@object, :to => :parked)
+  end
+  
+  def test_should_not_call_if_on_not_included
+    assert !@callback.call(@object, :on => :park)
+  end
+  
+  def test_should_call_if_all_requirements_met
+    assert @callback.call(@object, :from => :parked, :to => :idling, :on => :ignite)
+  end
+  
+  def test_should_include_in_known_states
+    assert_equal [:parked, :idling], @callback.known_states
+  end
+end
+
 class CallbackWithIfConditionTest < Test::Unit::TestCase
   def setup
     @object = Object.new

data/test/unit/condition_proxy_test.rb

@@ -0,0 +1,301 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class Validateable
+  class << self
+    def validate(*args, &block)
+      args << block if block_given?
+      args
+    end
+  end
+end
+
+class ConditionProxyTest < Test::Unit::TestCase
+  def test_should_call_class_with_same_arguments
+    options = {}
+    condition_proxy = StateMachine::ConditionProxy.new(Validateable, lambda {})
+    validation = condition_proxy.validate(:name, options)
+    
+    assert_equal [:name, options], validation
+  end
+  
+  def test_should_pass_block_through_to_class
+    options = {}
+    condition_proxy = StateMachine::ConditionProxy.new(Validateable, lambda {})
+    
+    proxy_block = lambda {}
+    validation = condition_proxy.validate(:name, options, &proxy_block)
+    
+    assert_equal [:name, options, proxy_block], validation
+  end
+  
+  def test_should_pass_object_into_proxy_condition
+    condition_args = []
+    condition_proxy = StateMachine::ConditionProxy.new(Validateable, lambda {|*args| condition_args = args})
+    validation = condition_proxy.validate(:name)
+    
+    object = Validateable.new
+    validation.last[:if].call(object)
+    
+    assert_equal [object], condition_args
+  end
+  
+  def test_should_evaluate_symbol_condition
+    klass = Class.new(Validateable) do
+      attr_accessor :callback_called
+      
+      def callback
+        @callback_called = true
+      end
+    end
+    
+    condition_proxy = StateMachine::ConditionProxy.new(klass, :callback)
+    validation = condition_proxy.validate(:name)
+    
+    object = klass.new
+    validation.last[:if].call(object)
+    
+    assert object.callback_called
+  end
+  
+  def test_should_evaluate_string_condition
+    klass = Class.new(Validateable) do
+      attr_accessor :callback_called
+    end
+    
+    condition_proxy = StateMachine::ConditionProxy.new(klass, '@callback_called = true')
+    validation = condition_proxy.validate(:name)
+    
+    object = klass.new
+    validation.last[:if].call(object)
+    
+    assert object.callback_called
+  end
+end
+
+class ConditionProxyWithoutConditionsTest < Test::Unit::TestCase
+  def setup
+    @proxy_result = nil
+    condition_proxy = StateMachine::ConditionProxy.new(Validateable, lambda {@proxy_result})
+    
+    @object = Validateable.new
+    @validation = condition_proxy.validate(:name)
+    @options = @validation.last
+  end
+  
+  def test_should_have_options_configuration
+    assert_instance_of Hash, @options
+  end
+  
+  def test_should_have_if_option
+    assert_not_nil @options[:if]
+  end
+  
+  def test_should_be_false_if_proxy_condition_is_false
+    @proxy_result = false
+    assert !@options[:if].call(@object)
+  end
+  
+  def test_should_be_true_if_proxy_condition_is_true
+    @proxy_result = true
+    assert @options[:if].call(@object)
+  end
+  
+  def test_should_be_true_if_proxy_condition_is_not_true
+    @proxy_result = 1
+    assert @options[:if].call(@object)
+  end
+end
+
+class ConditionProxyWithIfConditionTest < Test::Unit::TestCase
+  def setup
+    @proxy_result = nil
+    condition_proxy = StateMachine::ConditionProxy.new(Validateable, lambda {@proxy_result})
+    
+    @object = Validateable.new
+    
+    @condition_result = nil
+    @validation = condition_proxy.validate(:name, :if => lambda {@condition_result})
+    @options = @validation.pop
+  end
+  
+  def test_should_have_if_option
+    assert_not_nil @options[:if]
+  end
+  
+  def test_should_be_false_if_proxy_condition_is_false
+    @proxy_result = false
+    assert !@options[:if].call(@object)
+  end
+  
+  def test_should_be_false_if_original_condition_is_false
+    @condition_result = false
+    assert !@options[:if].call(@object)
+  end
+  
+  def test_should_be_true_if_proxy_and_original_condition_are_true
+    @proxy_result = true
+    @condition_result = true
+    assert @options[:if].call(@object)
+  end
+  
+  def test_should_evaluate_symbol_condition
+    klass = Class.new(Validateable) do
+      attr_accessor :callback
+    end
+    
+    condition_proxy = StateMachine::ConditionProxy.new(klass, lambda {true})
+    validation = condition_proxy.validate(:name, :if => :callback)
+    options = validation.last
+    
+    object = klass.new
+    object.callback = false
+    assert !options[:if].call(object)
+    
+    object.callback = true
+    assert options[:if].call(object)
+  end
+  
+  def test_should_evaluate_string_condition
+    klass = Class.new(Validateable) do
+      attr_accessor :callback
+    end
+    
+    condition_proxy = StateMachine::ConditionProxy.new(klass, lambda {true})
+    validation = condition_proxy.validate(:name, :if => '@callback')
+    options = validation.last
+    
+    object = klass.new
+    object.callback = false
+    assert !options[:if].call(object)
+    
+    object.callback = true
+    assert options[:if].call(object)
+  end
+end
+
+class ConditionProxyWithMultipleIfConditionsTest < Test::Unit::TestCase
+  def setup
+    @proxy_result = true
+    condition_proxy = StateMachine::ConditionProxy.new(Validateable, lambda {@proxy_result})
+    
+    @object = Validateable.new
+    
+    @first_condition_result = nil
+    @second_condition_result = nil
+    @validation = condition_proxy.validate(:name, :if => [lambda {@first_condition_result}, lambda {@second_condition_result}])
+    @options = @validation.pop
+  end
+  
+  def test_should_be_true_if_all_conditions_are_true
+    @first_condition_result = true
+    @second_condition_result = true
+    assert @options[:if].call(@object)
+  end
+  
+  def test_should_be_false_if_any_condition_is_false
+    @first_condition_result = true
+    @second_condition_result = false
+    assert !@options[:if].call(@object)
+    
+    @first_condition_result = false
+    @second_condition_result = true
+    assert !@options[:if].call(@object)
+  end
+end
+
+class ConditionProxyWithUnlessConditionTest < Test::Unit::TestCase
+  def setup
+    @proxy_result = nil
+    condition_proxy = StateMachine::ConditionProxy.new(Validateable, lambda {@proxy_result})
+    
+    @object = Validateable.new
+    
+    @condition_result = nil
+    @validation = condition_proxy.validate(:name, :unless => lambda {@condition_result})
+    @options = @validation.pop
+  end
+  
+  def test_should_have_if_option
+    assert_not_nil @options[:if]
+  end
+  
+  def test_should_be_false_if_proxy_condition_is_false
+    @proxy_result = false
+    assert !@options[:if].call(@object)
+  end
+  
+  def test_should_be_false_if_original_condition_is_true
+    @condition_result = true
+    assert !@options[:if].call(@object)
+  end
+  
+  def test_should_be_true_if_proxy_is_true_and_original_condition_is_false
+    @proxy_result = true
+    @condition_result = false
+    assert @options[:if].call(@object)
+  end
+  
+  def test_should_evaluate_symbol_condition
+    klass = Class.new(Validateable) do
+      attr_accessor :callback
+    end
+    
+    condition_proxy = StateMachine::ConditionProxy.new(klass, lambda {true})
+    validation = condition_proxy.validate(:name, :unless => :callback)
+    options = validation.last
+    
+    object = klass.new
+    object.callback = true
+    assert !options[:if].call(object)
+    
+    object.callback = false
+    assert options[:if].call(object)
+  end
+  
+  def test_should_evaluate_string_condition
+    klass = Class.new(Validateable) do
+      attr_accessor :callback
+    end
+    
+    condition_proxy = StateMachine::ConditionProxy.new(klass, lambda {true})
+    validation = condition_proxy.validate(:name, :unless => '@callback')
+    options = validation.last
+    
+    object = klass.new
+    object.callback = true
+    assert !options[:if].call(object)
+    
+    object.callback = false
+    assert options[:if].call(object)
+  end
+end
+
+class ConditionProxyWithMultipleUnlessConditionsTest < Test::Unit::TestCase
+  def setup
+    @proxy_result = true
+    condition_proxy = StateMachine::ConditionProxy.new(Validateable, lambda {@proxy_result})
+    
+    @object = Validateable.new
+    
+    @first_condition_result = nil
+    @second_condition_result = nil
+    @validation = condition_proxy.validate(:name, :unless => [lambda {@first_condition_result}, lambda {@second_condition_result}])
+    @options = @validation.pop
+  end
+  
+  def test_should_be_true_if_all_conditions_are_false
+    @first_condition_result = false
+    @second_condition_result = false
+    assert @options[:if].call(@object)
+  end
+  
+  def test_should_be_false_if_any_condition_is_true
+    @first_condition_result = true
+    @second_condition_result = false
+    assert !@options[:if].call(@object)
+    
+    @first_condition_result = false
+    @second_condition_result = true
+    assert !@options[:if].call(@object)
+  end
+end

data/test/unit/event_test.rb

@@ -54,7 +54,7 @@ class EventTest < Test::Unit::TestCase
   def setup
     @machine = StateMachine::Machine.new(Class.new)
     @event = StateMachine::Event.new(@machine, :ignite)
-    @event.transition :to => :idling, :from => :parked
+    @event.transition :parked => :idling
   end
   
   def test_should_allow_changing_machine
@@ -63,6 +63,16 @@ class EventTest < Test::Unit::TestCase
     assert_equal new_machine, @event.machine
   end
   
+  def test_should_provide_matcher_helpers_during_initialization
+    matchers = []
+    
+    @event.instance_eval do
+      matchers = [all, any, same]
+    end
+    
+    assert_equal [StateMachine::AllMatcher.instance, StateMachine::AllMatcher.instance, StateMachine::LoopbackMatcher.instance], matchers
+  end
+  
   def test_should_use_pretty_inspect
     assert_match "#<StateMachine::Event name=:ignite transitions=[:parked => :idling]>", @event.inspect
   end
@@ -99,8 +109,8 @@ class EventTransitionsTest < Test::Unit::TestCase
     @event = StateMachine::Event.new(@machine, :ignite)
   end
   
-  def test_should_raise_exception_if_invalid_option_specified
-    assert_raise(ArgumentError) {@event.transition(:invalid => true)}
+  def test_should_not_raise_exception_if_implicit_option_specified
+    assert_nothing_raised {@event.transition(:invalid => true)}
   end
   
   def test_should_not_allow_on_option
@@ -131,11 +141,11 @@ class EventTransitionsTest < Test::Unit::TestCase
   end
   
   def test_should_allow_transitioning_from_a_single_state
-    assert @event.transition(:to => :idling, :from => :parked)
+    assert @event.transition(:parked => :idling)
   end
   
   def test_should_allow_transitioning_from_multiple_states
-    assert @event.transition(:to => :idling, :from => [:parked, :idling])
+    assert @event.transition([:parked, :idling] => :idling)
   end
   
   def test_should_have_transitions
@@ -196,8 +206,8 @@ class EventWithTransitionsTest < Test::Unit::TestCase
     @klass = Class.new
     @machine = StateMachine::Machine.new(@klass)
     @event = StateMachine::Event.new(@machine, :ignite)
-    @event.transition(:to => :idling, :from => :parked)
-    @event.transition(:to => :idling, :except_from => :first_gear)
+    @event.transition(:parked => :idling)
+    @event.transition(:first_gear => :idling)
   end
   
   def test_should_include_all_transition_states_in_known_states
@@ -206,10 +216,14 @@ class EventWithTransitionsTest < Test::Unit::TestCase
   
   def test_should_include_new_transition_states_after_calling_known_states
     @event.known_states
-    @event.transition(:to => :idling, :from => :stalled)
+    @event.transition(:stalled => :idling)
     
     assert_equal [:parked, :idling, :first_gear, :stalled], @event.known_states
   end
+  
+  def test_should_use_pretty_inspect
+    assert_match "#<StateMachine::Event name=:ignite transitions=[:parked => :idling, :first_gear => :idling]>", @event.inspect
+  end
 end
 
 class EventWithoutMatchingTransitionsTest < Test::Unit::TestCase
@@ -219,7 +233,7 @@ class EventWithoutMatchingTransitionsTest < Test::Unit::TestCase
     @machine.state :parked, :idling
     
     @event = StateMachine::Event.new(@machine, :ignite)
-    @event.transition(:to => :idling, :from => :parked)
+    @event.transition(:parked => :idling)
     
     @object = @klass.new
     @object.state = 'idling'
@@ -255,7 +269,7 @@ class EventWithMatchingDisabledTransitionsTest < Test::Unit::TestCase
     @machine.state :parked, :idling
     
     @event = StateMachine::Event.new(@machine, :ignite)
-    @event.transition(:to => :idling, :from => :parked, :if => lambda {false})
+    @event.transition(:parked => :idling, :if => lambda {false})
     
     @object = @klass.new
     @object.state = 'parked'
@@ -286,7 +300,7 @@ class EventWithMatchingEnabledTransitionsTest < Test::Unit::TestCase
     @machine.state :parked, :idling
     
     @event = StateMachine::Event.new(@machine, :ignite)
-    @event.transition(:to => :idling, :from => :parked)
+    @event.transition(:parked => :idling)
     
     @object = @klass.new
     @object.state = 'parked'
@@ -353,11 +367,11 @@ class EventWithTransitionWithNilToStateTest < Test::Unit::TestCase
   def setup
     @klass = Class.new
     @machine = StateMachine::Machine.new(@klass)
-    @machine.state :parked, :value => nil
+    @machine.state nil
     @machine.state :idling
     
     @event = StateMachine::Event.new(@machine, :park)
-    @event.transition(:from => :idling, :to => :parked)
+    @event.transition(:idling => nil)
     
     @object = @klass.new
     @object.state = 'idling'
@@ -392,8 +406,8 @@ class EventWithMultipleTransitionsTest < Test::Unit::TestCase
     @machine.state :parked, :idling
     
     @event = StateMachine::Event.new(@machine, :ignite)
-    @event.transition(:to => :idling, :from => :idling)
-    @event.transition(:to => :idling, :from => :parked) # This one should get used
+    @event.transition(:idling => :idling)
+    @event.transition(:parked => :idling) # This one should get used
     
     @object = @klass.new
     @object.state = 'parked'
@@ -437,8 +451,8 @@ begin
       states.each {|state| graph.add_node(state.to_s)}
       
       @event = StateMachine::Event.new(@machine , :park)
-      @event.transition :from => :idling, :to => :parked
-      @event.transition :from => :first_gear, :to => :parked
+      @event.transition :parked => :idling
+      @event.transition :first_gear => :parked
       @event.transition :except_from => :parked, :to => :parked
       
       @edges = @event.draw(graph)