state_machine 0.6.3 → 0.7.0

data/test/unit/callback_test.rb

@@ -3,7 +3,7 @@ require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
 class CallbackTest < Test::Unit::TestCase
   def test_should_raise_exception_if_do_option_not_specified
     exception = assert_raise(ArgumentError) { StateMachine::Callback.new }
-    assert_match ':do callback must be specified', exception.message
+    assert_equal ':do callback must be specified', exception.message
   end
   
   def test_should_not_raise_exception_if_do_option_specified
@@ -17,6 +17,10 @@ class CallbackTest < Test::Unit::TestCase
   def test_should_not_bind_to_objects
     assert !StateMachine::Callback.bind_to_object
   end
+  
+  def test_should_not_have_a_terminator
+    assert_nil StateMachine::Callback.terminator
+  end
 end
 
 class CallbackByDefaultTest < Test::Unit::TestCase
@@ -236,3 +240,44 @@ class CallbackWithBoundObjectTest < Test::Unit::TestCase
     assert_equal [1, 2, 3], @callback.call(@object)
   end
 end
+
+class CallbackWithApplicationBoundObjectTest < Test::Unit::TestCase
+  def setup
+    @original_bind_to_object = StateMachine::Callback.bind_to_object
+    StateMachine::Callback.bind_to_object = true
+    
+    @object = Object.new
+    @callback = StateMachine::Callback.new(:do => lambda {|*args| self})
+  end
+  
+  def test_should_call_method_within_the_context_of_the_object
+    assert_equal @object, @callback.call(@object)
+  end
+  
+  def teardown
+    StateMachine::Callback.bind_to_object = @original_bind_to_object
+  end
+end
+
+class CallbackWithApplicationTerminatorTest < Test::Unit::TestCase
+  def setup
+    @original_terminator = StateMachine::Callback.bind_to_object
+    StateMachine::Callback.terminator = lambda {|result| result == false}
+    
+    @object = Object.new
+  end
+  
+  def test_should_not_halt_if_terminator_does_not_match
+    callback = StateMachine::Callback.new(:do => lambda {true})
+    assert_nothing_thrown { callback.call(@object) }
+  end
+  
+  def test_should_halt_if_terminator_matches
+    callback = StateMachine::Callback.new(:do => lambda {false})
+    assert_throws(:halt) { callback.call(@object) }
+  end
+  
+  def teardown
+    StateMachine::Callback.bind_to_object = @original_bind_to_object
+  end
+end

data/test/unit/condition_proxy_test.rb

@@ -31,10 +31,10 @@ class ConditionProxyTest < Test::Unit::TestCase
   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)
+    options = condition_proxy.validate[0]
     
     object = Validateable.new
-    validation.last[:if].call(object)
+    options[:if].call(object)
     
     assert_equal [object], condition_args
   end
@@ -49,10 +49,10 @@ class ConditionProxyTest < Test::Unit::TestCase
     end
     
     condition_proxy = StateMachine::ConditionProxy.new(klass, :callback)
-    validation = condition_proxy.validate(:name)
+    options = condition_proxy.validate[0]
     
     object = klass.new
-    validation.last[:if].call(object)
+    options[:if].call(object)
     
     assert object.callback_called
   end
@@ -63,10 +63,10 @@ class ConditionProxyTest < Test::Unit::TestCase
     end
     
     condition_proxy = StateMachine::ConditionProxy.new(klass, '@callback_called = true')
-    validation = condition_proxy.validate(:name)
+    options = condition_proxy.validate[0]
     
     object = klass.new
-    validation.last[:if].call(object)
+    options[:if].call(object)
     
     assert object.callback_called
   end
@@ -78,8 +78,7 @@ class ConditionProxyWithoutConditionsTest < Test::Unit::TestCase
     condition_proxy = StateMachine::ConditionProxy.new(Validateable, lambda {@proxy_result})
     
     @object = Validateable.new
-    @validation = condition_proxy.validate(:name)
-    @options = @validation.last
+    @options = condition_proxy.validate[0]
   end
   
   def test_should_have_options_configuration
@@ -114,8 +113,7 @@ class ConditionProxyWithIfConditionTest < Test::Unit::TestCase
     @object = Validateable.new
     
     @condition_result = nil
-    @validation = condition_proxy.validate(:name, :if => lambda {@condition_result})
-    @options = @validation.pop
+    @options = condition_proxy.validate(:if => lambda {@condition_result})[0]
   end
   
   def test_should_have_if_option
@@ -144,8 +142,7 @@ class ConditionProxyWithIfConditionTest < Test::Unit::TestCase
     end
     
     condition_proxy = StateMachine::ConditionProxy.new(klass, lambda {true})
-    validation = condition_proxy.validate(:name, :if => :callback)
-    options = validation.last
+    options = condition_proxy.validate(:if => :callback)[0]
     
     object = klass.new
     object.callback = false
@@ -161,8 +158,7 @@ class ConditionProxyWithIfConditionTest < Test::Unit::TestCase
     end
     
     condition_proxy = StateMachine::ConditionProxy.new(klass, lambda {true})
-    validation = condition_proxy.validate(:name, :if => '@callback')
-    options = validation.last
+    options = condition_proxy.validate(:if => '@callback')[0]
     
     object = klass.new
     object.callback = false
@@ -175,15 +171,13 @@ end
 
 class ConditionProxyWithMultipleIfConditionsTest < Test::Unit::TestCase
   def setup
-    @proxy_result = true
-    condition_proxy = StateMachine::ConditionProxy.new(Validateable, lambda {@proxy_result})
+    condition_proxy = StateMachine::ConditionProxy.new(Validateable, lambda {true})
     
     @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
+    @options = condition_proxy.validate(:if => [lambda {@first_condition_result}, lambda {@second_condition_result}])[0]
   end
   
   def test_should_be_true_if_all_conditions_are_true
@@ -211,8 +205,7 @@ class ConditionProxyWithUnlessConditionTest < Test::Unit::TestCase
     @object = Validateable.new
     
     @condition_result = nil
-    @validation = condition_proxy.validate(:name, :unless => lambda {@condition_result})
-    @options = @validation.pop
+    @options = condition_proxy.validate(:unless => lambda {@condition_result})[0]
   end
   
   def test_should_have_if_option
@@ -241,8 +234,7 @@ class ConditionProxyWithUnlessConditionTest < Test::Unit::TestCase
     end
     
     condition_proxy = StateMachine::ConditionProxy.new(klass, lambda {true})
-    validation = condition_proxy.validate(:name, :unless => :callback)
-    options = validation.last
+    options = condition_proxy.validate(:unless => :callback)[0]
     
     object = klass.new
     object.callback = true
@@ -258,8 +250,7 @@ class ConditionProxyWithUnlessConditionTest < Test::Unit::TestCase
     end
     
     condition_proxy = StateMachine::ConditionProxy.new(klass, lambda {true})
-    validation = condition_proxy.validate(:name, :unless => '@callback')
-    options = validation.last
+    options = condition_proxy.validate(:unless => '@callback')[0]
     
     object = klass.new
     object.callback = true
@@ -272,15 +263,13 @@ end
 
 class ConditionProxyWithMultipleUnlessConditionsTest < Test::Unit::TestCase
   def setup
-    @proxy_result = true
-    condition_proxy = StateMachine::ConditionProxy.new(Validateable, lambda {@proxy_result})
+    condition_proxy = StateMachine::ConditionProxy.new(Validateable, lambda {true})
     
     @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
+    @options = condition_proxy.validate(:unless => [lambda {@first_condition_result}, lambda {@second_condition_result}])[0]
   end
   
   def test_should_be_true_if_all_conditions_are_false
@@ -299,3 +288,41 @@ class ConditionProxyWithMultipleUnlessConditionsTest < Test::Unit::TestCase
     assert !@options[:if].call(@object)
   end
 end
+
+class ConditionProxyWithIfAndUnlessConditionsTest < Test::Unit::TestCase
+  def setup
+    condition_proxy = StateMachine::ConditionProxy.new(Validateable, lambda {true})
+    
+    @object = Validateable.new
+    
+    @if_condition_result = nil
+    @unless_condition_result = nil
+    @options = condition_proxy.validate(:if => lambda {@if_condition_result}, :unless => lambda {@unless_condition_result})[0]
+  end
+  
+  def test_should_be_false_if_if_condition_is_false
+    @if_condition_result = false
+    @unless_condition_result = false
+    assert !@options[:if].call(@object)
+    
+    @if_condition_result = false
+    @unless_condition_result = true
+    assert !@options[:if].call(@object)
+  end
+  
+  def test_should_be_false_if_unless_condition_is_true
+    @if_condition_result = false
+    @unless_condition_result = true
+    assert !@options[:if].call(@object)
+    
+    @if_condition_result = true
+    @unless_condition_result = true
+    assert !@options[:if].call(@object)
+  end
+  
+  def test_should_be_true_if_if_condition_is_true_and_unless_condition_is_false
+    @if_condition_result = true
+    @unless_condition_result = false
+    assert @options[:if].call(@object)
+  end
+end

data/test/unit/event_collection_test.rb

@@ -0,0 +1,228 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class EventCollectionByDefaultTest < Test::Unit::TestCase
+  def setup
+    @machine = StateMachine::Machine.new(Class.new)
+    @events = StateMachine::EventCollection.new(@machine)
+  end
+  
+  def test_should_not_have_any_nodes
+    assert_equal 0, @events.length
+  end
+  
+  def test_should_have_a_machine
+    assert_equal @machine, @events.machine
+  end
+  
+  def test_should_not_have_any_valid_events_for_an_object
+    assert @events.valid_for(@object).empty?
+  end
+  
+  def test_should_not_have_any_transitions_for_an_object
+    assert @events.transitions_for(@object).empty?
+  end
+end
+
+class EventCollectionTest < Test::Unit::TestCase
+  def setup
+    machine = StateMachine::Machine.new(Class.new, :namespace => 'alarm')
+    @events = StateMachine::EventCollection.new(machine)
+    
+    @events << @open = StateMachine::Event.new(machine, :enable)
+  end
+  
+  def test_should_index_by_name
+    assert_equal @open, @events[:enable, :name]
+  end
+  
+  def test_should_index_by_name_by_default
+    assert_equal @open, @events[:enable]
+  end
+  
+  def test_should_index_by_qualified_name
+    assert_equal @open, @events[:enable_alarm, :qualified_name]
+  end
+end
+
+class EventCollectionWithEventsWithTransitionsTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass, :initial => :parked)
+    @events = StateMachine::EventCollection.new(@machine)
+    
+    @machine.state :idling, :stalled
+    @machine.event :ignite
+    
+    @events << @ignite = StateMachine::Event.new(@machine, :ignite)
+    @ignite.transition :parked => :idling
+    @ignite.transition :stalled => :idling
+  end
+  
+  def test_should_only_include_valid_events_for_an_object
+    object = @klass.new
+    object.state = 'parked'
+    assert_equal [@ignite], @events.valid_for(object)
+    
+    object.state = 'stalled'
+    assert_equal [@ignite], @events.valid_for(object)
+    
+    object.state = 'idling'
+    assert_equal [], @events.valid_for(object)
+  end
+  
+  def test_should_only_include_valid_transitions_for_an_object
+    object = @klass.new
+    object.state = 'parked'
+    assert_equal [{:object => object, :attribute => :state, :event => :ignite, :from => 'parked', :to => 'idling'}], @events.transitions_for(object).map {|transition| transition.attributes}
+    
+    object.state = 'stalled'
+    assert_equal [{:object => object, :attribute => :state, :event => :ignite, :from => 'stalled', :to => 'idling'}], @events.transitions_for(object).map {|transition| transition.attributes}
+    
+    object.state = 'idling'
+    assert_equal [], @events.transitions_for(object)
+  end
+end
+
+class EventCollectionWithMultipleEventsTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass, :initial => :parked)
+    @events = StateMachine::EventCollection.new(@machine)
+    
+    @machine.state :first_gear
+    @machine.event :park, :shift_down
+    
+    @events << @park = StateMachine::Event.new(@machine, :park)
+    @park.transition :first_gear => :parked
+    
+    @events << @shift_down = StateMachine::Event.new(@machine, :shift_down)
+    @shift_down.transition :first_gear => :parked
+  end
+  
+  def test_should_only_include_all_valid_events_for_an_object
+    object = @klass.new
+    object.state = 'first_gear'
+    assert_equal [@park, @shift_down], @events.valid_for(object)
+  end
+end
+
+class EventCollectionWithoutMachineActionTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass, :initial => :parked)
+    @events = StateMachine::EventCollection.new(@machine)
+    
+    @machine.event :ignite
+    @events << StateMachine::Event.new(@machine, :ignite)
+    
+    @object = @klass.new
+  end
+  
+  def test_should_not_have_an_attribute_transition
+    assert_nil @events.attribute_transition_for(@object)
+  end
+end
+
+class EventCollectionAttributeWithMachineActionTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new do
+      def save
+      end
+    end
+    
+    @machine = StateMachine::Machine.new(@klass, :initial => :parked, :action => :save)
+    @events = StateMachine::EventCollection.new(@machine)
+    
+    @machine.event :ignite
+    @machine.state :parked, :idling
+    @events << @ignite = StateMachine::Event.new(@machine, :ignite)
+    
+    @object = @klass.new
+  end
+  
+  def test_should_not_have_transition_if_nil
+    @object.state_event = nil
+    assert_nil @events.attribute_transition_for(@object)
+  end
+  
+  def test_should_not_have_transition_if_empty
+    @object.state_event = ''
+    assert_nil @events.attribute_transition_for(@object)
+  end
+  
+  def test_should_have_invalid_transition_if_invalid_event_specified
+    @object.state_event = 'invalid'
+    assert_equal false, @events.attribute_transition_for(@object)
+  end
+  
+  def test_should_have_invalid_transition_if_event_cannot_be_fired
+    @object.state_event = 'ignite'
+    assert_equal false, @events.attribute_transition_for(@object)
+  end
+  
+  def test_should_have_valid_transition_if_event_can_be_fired
+    @ignite.transition :parked => :idling
+    @object.state_event = 'ignite'
+    
+    assert_instance_of StateMachine::Transition, @events.attribute_transition_for(@object)
+  end
+end
+
+class EventCollectionWithValidationsTest < Test::Unit::TestCase
+  def setup
+    StateMachine::Integrations.const_set('Custom', Module.new do
+      def invalidate(object, attribute, message, values = [])
+        (object.errors ||= []) << generate_message(message, values)
+      end
+      
+      def reset(object)
+        object.errors = []
+      end
+    end)
+    
+    @klass = Class.new do
+      attr_accessor :errors
+      
+      def initialize
+        @errors = []
+        super
+      end
+    end
+    
+    @machine = StateMachine::Machine.new(@klass, :initial => :parked, :action => :save, :integration => :custom)
+    @events = StateMachine::EventCollection.new(@machine)
+    
+    @machine.event :ignite
+    @machine.state :parked, :idling
+    @events << @ignite = StateMachine::Event.new(@machine, :ignite)
+    
+    @object = @klass.new
+  end
+  
+  def test_should_invalidate_if_invalid_event_specified
+    @object.state_event = 'invalid'
+    @events.attribute_transition_for(@object, true)
+    
+    assert_equal ['is invalid'], @object.errors
+  end
+  
+  def test_should_invalidate_if_event_cannot_be_fired
+    @object.state = 'idling'
+    @object.state_event = 'ignite'
+    @events.attribute_transition_for(@object, true)
+    
+    assert_equal ['cannot transition when idling'], @object.errors
+  end
+  
+  def test_should_not_invalidate_event_can_be_fired
+    @ignite.transition :parked => :idling
+    @object.state_event = 'ignite'
+    @events.attribute_transition_for(@object, true)
+    
+    assert_equal [], @object.errors
+  end
+  
+  def teardown
+    StateMachine::Integrations.send(:remove_const, 'Custom')
+  end
+end