state_machine 0.6.3 → 0.7.0

data/test/unit/event_test.rb

@@ -17,6 +17,10 @@ class EventByDefaultTest < Test::Unit::TestCase
     assert_equal :ignite, @event.name
   end
   
+  def test_should_have_a_qualified_name
+    assert_equal :ignite, @event.qualified_name
+  end
+  
   def test_should_not_have_any_guards
     assert @event.guards.empty?
   end
@@ -29,8 +33,8 @@ class EventByDefaultTest < Test::Unit::TestCase
     assert !@event.can_fire?(@object)
   end
   
-  def test_should_not_have_a_next_transition
-    assert_nil @event.next_transition(@object)
+  def test_should_not_have_a_transition
+    assert_nil @event.transition_for(@object)
   end
   
   def test_should_define_a_predicate
@@ -38,7 +42,7 @@ class EventByDefaultTest < Test::Unit::TestCase
   end
   
   def test_should_define_a_transition_accessor
-    assert @object.respond_to?(:next_ignite_transition)
+    assert @object.respond_to?(:ignite_transition)
   end
   
   def test_should_define_an_action
@@ -85,7 +89,7 @@ class EventWithConflictingHelpersTest < Test::Unit::TestCase
         0
       end
       
-      def next_ignite_transition
+      def ignite_transition
         0
       end
       
@@ -107,7 +111,7 @@ class EventWithConflictingHelpersTest < Test::Unit::TestCase
   end
   
   def test_should_not_redefine_transition_accessor
-    assert_equal 0, @object.next_ignite_transition
+    assert_equal 0, @object.ignite_transition
   end
   
   def test_should_not_redefine_action
@@ -124,7 +128,7 @@ class EventWithConflictingHelpersTest < Test::Unit::TestCase
         super ? 1 : 0
       end
       
-      def next_ignite_transition
+      def ignite_transition
         super ? 1 : 0
       end
       
@@ -143,34 +147,42 @@ class EventWithConflictingHelpersTest < Test::Unit::TestCase
     end
     
     assert_equal 0, @object.can_ignite?
-    assert_equal 0, @object.next_ignite_transition
+    assert_equal 0, @object.ignite_transition
     assert_equal 0, @object.ignite
-    assert_equal 0, @object.ignite!
+    assert_equal 1, @object.ignite!
   end
 end
 
 class EventWithNamespaceTest < Test::Unit::TestCase
   def setup
     @klass = Class.new
-    @machine = StateMachine::Machine.new(@klass, :namespace => 'car')
-    @event = StateMachine::Event.new(@machine, :ignite)
+    @machine = StateMachine::Machine.new(@klass, :namespace => 'alarm')
+    @event = StateMachine::Event.new(@machine, :enable)
     @object = @klass.new
   end
   
+  def test_should_have_a_name
+    assert_equal :enable, @event.name
+  end
+  
+  def test_should_have_a_qualified_name
+    assert_equal :enable_alarm, @event.qualified_name
+  end
+  
   def test_should_namespace_predicate
-    assert @object.respond_to?(:can_ignite_car?)
+    assert @object.respond_to?(:can_enable_alarm?)
   end
   
   def test_should_namespace_transition_accessor
-    assert @object.respond_to?(:next_ignite_car_transition)
+    assert @object.respond_to?(:enable_alarm_transition)
   end
   
   def test_should_namespace_action
-    assert @object.respond_to?(:ignite_car)
+    assert @object.respond_to?(:enable_alarm)
   end
   
   def test_should_namespace_bang_action
-    assert @object.respond_to?(:ignite_car!)
+    assert @object.respond_to?(:enable_alarm!)
   end
 end
 
@@ -253,19 +265,14 @@ class EventWithoutTransitionsTest < Test::Unit::TestCase
     assert !@event.can_fire?(@object)
   end
   
-  def test_should_not_have_a_next_transition
-    assert_nil @event.next_transition(@object)
+  def test_should_not_have_a_transition
+    assert_nil @event.transition_for(@object)
   end
   
   def test_should_not_fire
     assert !@event.fire(@object)
   end
   
-  def test_should_raise_exception_on_fire!
-    exception = assert_raise(StateMachine::InvalidTransition) { @event.fire!(@object) }
-    assert_equal 'Cannot transition state via :ignite from nil', exception.message
-  end
-  
   def test_should_not_change_the_current_state
     @event.fire(@object)
     assert_nil @object.state
@@ -314,19 +321,14 @@ class EventWithoutMatchingTransitionsTest < Test::Unit::TestCase
     assert !@event.can_fire?(@object)
   end
   
-  def test_should_not_have_a_next_transition
-    assert_nil @event.next_transition(@object)
+  def test_should_not_have_a_transition
+    assert_nil @event.transition_for(@object)
   end
   
   def test_should_not_fire
     assert !@event.fire(@object)
   end
   
-  def test_should_raise_exception_on_fire!
-    exception = assert_raise(StateMachine::InvalidTransition) { @event.fire!(@object) }
-    assert_equal 'Cannot transition state via :ignite from :idling', exception.message
-  end
-  
   def test_should_not_change_the_current_state
     @event.fire(@object)
     assert_equal 'idling', @object.state
@@ -336,8 +338,8 @@ end
 class EventWithMatchingDisabledTransitionsTest < Test::Unit::TestCase
   def setup
     StateMachine::Integrations.const_set('Custom', Module.new do
-      def invalidate(object, event)
-        (object.errors ||= []) << invalid_message(object, event)
+      def invalidate(object, attribute, message, values = [])
+        (object.errors ||= []) << generate_message(message, values)
       end
       
       def reset(object)
@@ -363,8 +365,8 @@ class EventWithMatchingDisabledTransitionsTest < Test::Unit::TestCase
     assert !@event.can_fire?(@object)
   end
   
-  def test_should_not_have_a_next_transition
-    assert_nil @event.next_transition(@object)
+  def test_should_not_have_a_transition
+    assert_nil @event.transition_for(@object)
   end
   
   def test_should_not_fire
@@ -378,14 +380,14 @@ class EventWithMatchingDisabledTransitionsTest < Test::Unit::TestCase
   
   def test_should_invalidate_the_state
     @event.fire(@object)
-    assert_equal ['cannot be transitioned via :ignite from :parked'], @object.errors
+    assert_equal ['cannot transition via "ignite"'], @object.errors
   end
   
   def test_should_reset_existing_error
     @object.errors = ['invalid']
     
     @event.fire(@object)
-    assert_equal ['cannot be transitioned via :ignite from :parked'], @object.errors
+    assert_equal ['cannot transition via "ignite"'], @object.errors
   end
   
   def teardown
@@ -396,8 +398,8 @@ end
 class EventWithMatchingEnabledTransitionsTest < Test::Unit::TestCase
   def setup
     StateMachine::Integrations.const_set('Custom', Module.new do
-      def invalidate(object, event)
-        (object.errors ||= []) << invalid_message(object, event)
+      def invalidate(object, attribute, message, values = [])
+        (object.errors ||= []) << generate_message(message, values)
       end
       
       def reset(object)
@@ -411,6 +413,7 @@ class EventWithMatchingEnabledTransitionsTest < Test::Unit::TestCase
     
     @machine = StateMachine::Machine.new(@klass, :integration => :custom)
     @machine.state :parked, :idling
+    @machine.event :ignite
     
     @event = StateMachine::Event.new(@machine, :ignite)
     @event.transition(:parked => :idling)
@@ -423,8 +426,8 @@ class EventWithMatchingEnabledTransitionsTest < Test::Unit::TestCase
     assert @event.can_fire?(@object)
   end
   
-  def test_should_have_a_next_transition
-    transition = @event.next_transition(@object)
+  def test_should_have_a_transition
+    transition = @event.transition_for(@object)
     assert_not_nil transition
     assert_equal 'parked', transition.from
     assert_equal 'idling', transition.to
@@ -462,6 +465,7 @@ class EventWithTransitionWithoutToStateTest < Test::Unit::TestCase
     @klass = Class.new
     @machine = StateMachine::Machine.new(@klass)
     @machine.state :parked
+    @machine.event :park
     
     @event = StateMachine::Event.new(@machine, :park)
     @event.transition(:from => :parked)
@@ -474,8 +478,8 @@ class EventWithTransitionWithoutToStateTest < Test::Unit::TestCase
     assert @event.can_fire?(@object)
   end
   
-  def test_should_have_a_next_transition
-    transition = @event.next_transition(@object)
+  def test_should_have_a_transition
+    transition = @event.transition_for(@object)
     assert_not_nil transition
     assert_equal 'parked', transition.from
     assert_equal 'parked', transition.to
@@ -496,8 +500,8 @@ class EventWithTransitionWithNilToStateTest < Test::Unit::TestCase
   def setup
     @klass = Class.new
     @machine = StateMachine::Machine.new(@klass)
-    @machine.state nil
-    @machine.state :idling
+    @machine.state nil, :idling
+    @machine.event :park
     
     @event = StateMachine::Event.new(@machine, :park)
     @event.transition(:idling => nil)
@@ -510,8 +514,8 @@ class EventWithTransitionWithNilToStateTest < Test::Unit::TestCase
     assert @event.can_fire?(@object)
   end
   
-  def test_should_have_a_next_transition
-    transition = @event.next_transition(@object)
+  def test_should_have_a_transition
+    transition = @event.transition_for(@object)
     assert_not_nil transition
     assert_equal 'idling', transition.from
     assert_equal nil, transition.to
@@ -533,6 +537,7 @@ class EventWithMultipleTransitionsTest < Test::Unit::TestCase
     @klass = Class.new
     @machine = StateMachine::Machine.new(@klass)
     @machine.state :parked, :idling
+    @machine.event :ignite
     
     @event = StateMachine::Event.new(@machine, :ignite)
     @event.transition(:idling => :idling)
@@ -546,8 +551,8 @@ class EventWithMultipleTransitionsTest < Test::Unit::TestCase
     assert @event.can_fire?(@object)
   end
   
-  def test_should_have_a_next_transition
-    transition = @event.next_transition(@object)
+  def test_should_have_a_transition
+    transition = @event.transition_for(@object)
     assert_not_nil transition
     assert_equal 'parked', transition.from
     assert_equal 'idling', transition.to

data/test/unit/integrations/active_record_test.rb

@@ -14,13 +14,6 @@ begin
   require 'active_record/fixtures'
   require 'active_record/test_case'
   
-  # Set default fixtures configuration
-  ActiveSupport::TestCase.class_eval do
-    self.fixture_path = File.dirname(__FILE__) + '/../../fixtures/'
-    self.use_instantiated_fixtures  = false
-    self.use_transactional_fixtures = true
-  end
-  
   # Establish database connection
   ActiveRecord::Base.establish_connection({'adapter' => 'sqlite3', 'database' => ':memory:'})
   ActiveRecord::Base.logger = Logger.new("#{File.dirname(__FILE__)}/../../active_record.log")
@@ -76,6 +69,10 @@ begin
         assert_equal :save, @machine.action
       end
       
+      def test_should_use_transactions
+        assert_equal true, @machine.use_transactions
+      end
+      
       def test_should_create_notifier_before_callback
         assert_equal 1, @machine.callbacks[:before].size
       end
@@ -168,10 +165,10 @@ begin
         record = @model.new
         record.state = 'parked'
         
-        @machine.invalidate(record, StateMachine::Event.new(@machine, :park))
+        @machine.invalidate(record, :state, :invalid_transition, [[:event, :park]])
         
         assert record.errors.invalid?(:state)
-        assert_equal 'cannot be transitioned via :park from :parked', record.errors.on(:state)
+        assert_equal 'cannot transition via "park"', record.errors.on(:state)
       end
       
       def test_should_clear_errors_on_reset
@@ -236,6 +233,23 @@ begin
       end
     end
     
+    class MachineWithConflictingPredicateTest < ActiveRecord::TestCase
+      def setup
+        @model = new_model do
+          def state?(*args)
+            true
+          end
+        end
+        
+        @machine = StateMachine::Machine.new(@model)
+        @record = @model.new
+      end
+      
+      def test_should_not_define_attribute_predicate
+        assert @record.state?
+      end
+    end
+    
     class MachineWithColumnStateAttributeTest < ActiveRecord::TestCase
       def setup
         @model = new_model
@@ -265,7 +279,7 @@ begin
       end
       
       def test_should_raise_exception_for_predicate_if_invalid_state_specified
-        assert_raise(ArgumentError) { @record.state?(:invalid) }
+        assert_raise(IndexError) { @record.state?(:invalid) }
       end
     end
     
@@ -322,7 +336,7 @@ begin
       end
       
       def test_should_raise_exception_for_predicate_if_invalid_state_specified
-        assert_raise(ArgumentError) { @record.status?(:invalid) }
+        assert_raise(IndexError) { @record.status?(:invalid) }
       end
       
       def test_should_set_initial_state_on_created_object
@@ -350,6 +364,7 @@ begin
         @model = new_model
         @machine = StateMachine::Machine.new(@model, :initial => :parked)
         @machine.other_states :idling
+        @machine.event :ignite
         
         @record = @model.new(:state => 'parked')
         @transition = StateMachine::Transition.new(@record, @machine, :ignite, :parked, :idling)
@@ -363,7 +378,7 @@ begin
         assert called
       end
       
-      def test_should_pass_record_into_before_callbacks_with_one_argument
+      def test_should_pass_record_to_before_callbacks_with_one_argument
         record = nil
         @machine.before_transition(lambda {|arg| record = arg})
         
@@ -371,7 +386,7 @@ begin
         assert_equal @record, record
       end
       
-      def test_should_pass_record_and_transition_into_before_callbacks_with_multiple_arguments
+      def test_should_pass_record_and_transition_to_before_callbacks_with_multiple_arguments
         callback_args = nil
         @machine.before_transition(lambda {|*args| callback_args = args})
         
@@ -395,7 +410,7 @@ begin
         assert called
       end
       
-      def test_should_pass_record_into_after_callbacks_with_one_argument
+      def test_should_pass_record_to_after_callbacks_with_one_argument
         record = nil
         @machine.after_transition(lambda {|arg| record = arg})
         
@@ -403,12 +418,12 @@ begin
         assert_equal @record, record
       end
       
-      def test_should_pass_record_transition_and_result_into_after_callbacks_with_multiple_arguments
+      def test_should_pass_record_and_transition_to_after_callbacks_with_multiple_arguments
         callback_args = nil
         @machine.after_transition(lambda {|*args| callback_args = args})
         
         @transition.perform
-        assert_equal [@record, @transition, true], callback_args
+        assert_equal [@record, @transition], callback_args
       end
       
       def test_should_run_after_callbacks_outside_the_context_of_the_record
@@ -458,6 +473,7 @@ begin
         @model = new_model
         @machine = StateMachine::Machine.new(@model)
         @machine.state :parked, :idling
+        @machine.event :ignite
         @machine.before_transition(lambda {@before_count += 1; false})
         @machine.before_transition(lambda {@before_count += 1})
         
@@ -491,6 +507,7 @@ begin
         
         @machine = StateMachine::Machine.new(@model)
         @machine.state :parked, :idling
+        @machine.event :ignite
         @record = @model.new(:state => 'parked')
         @transition = StateMachine::Transition.new(@record, @machine, :ignite, :parked, :idling)
         @result = @transition.perform
@@ -500,8 +517,8 @@ begin
         assert !@result
       end
       
-      def test_should_change_current_state
-        assert_equal 'idling', @record.state
+      def test_should_not_change_current_state
+        assert_equal 'parked', @record.state
       end
       
       def test_should_not_save_record
@@ -545,6 +562,7 @@ begin
         @model = new_model
         @machine = StateMachine::Machine.new(@model)
         @machine.state :parked, :idling
+        @machine.event :ignite
         @machine.after_transition(lambda {@after_count += 1; false})
         @machine.after_transition(lambda {@after_count += 1})
         
@@ -570,42 +588,98 @@ begin
       end
     end
     
+    class MachineWithEventAttributesOnValidationTest < ActiveRecord::TestCase
+      def setup
+        @model = new_model
+        @machine = StateMachine::Machine.new(@model)
+        @machine.event :ignite do
+          transition :parked => :idling
+        end
+        
+        @record = @model.new
+        @record.state = 'parked'
+        @record.state_event = 'ignite'
+      end
+      
+      def test_should_fail_if_event_is_invalid
+        @record.state_event = 'invalid'
+        assert !@record.valid?
+        assert_equal ['State event is invalid'], @record.errors.full_messages
+      end
+      
+      def test_should_fail_if_event_has_no_transition
+        @record.state = 'idling'
+        assert !@record.valid?
+        assert_equal ['State event cannot transition when idling'], @record.errors.full_messages
+      end
+      
+      def test_should_be_successful_if_event_has_transition
+        assert @record.valid?
+      end
+      
+      def test_should_run_before_callbacks
+        ran_callback = false
+        @machine.before_transition { ran_callback = true }
+        
+        @record.valid?
+        assert ran_callback
+      end
+      
+      def test_should_persist_new_state
+        @record.valid?
+        assert_equal 'idling', @record.state
+      end
+      
+      def test_should_not_run_after_callbacks
+        ran_callback = false
+        @machine.after_transition { ran_callback = true }
+        
+        @record.valid?
+        assert !ran_callback
+      end
+    end
+    
     class MachineWithObserversTest < ActiveRecord::TestCase
       def setup
         @model = new_model
         @machine = StateMachine::Machine.new(@model)
         @machine.state :parked, :idling
+        @machine.event :ignite
         @record = @model.new(:state => 'parked')
         @transition = StateMachine::Transition.new(@record, @machine, :ignite, :parked, :idling)
       end
       
-      def test_should_call_before_event_method
-        observer = new_observer(@model) do
-          def before_ignite(*args)
-            notifications << args
-          end
-        end
-        instance = observer.instance
+      def test_should_call_all_transition_callback_permutations
+        callbacks = [
+          :before_ignite_from_parked_to_idling,
+          :before_ignite_from_parked,
+          :before_ignite_to_idling,
+          :before_ignite,
+          :before_transition_state_from_parked_to_idling,
+          :before_transition_state_from_parked,
+          :before_transition_state_to_idling,
+          :before_transition_state,
+          :before_transition
+        ]
         
-        @transition.perform
-        assert_equal [[@record, @transition]], instance.notifications
-      end
-      
-      def test_should_call_before_transition_method
+        notified = false
         observer = new_observer(@model) do
-          def before_transition(*args)
-            notifications << args
+          callbacks.each do |callback|
+            define_method(callback) do |*args|
+              notifications << callback
+            end
           end
         end
+        
         instance = observer.instance
         
         @transition.perform
-        assert_equal [[@record, @transition]], instance.notifications
+        assert_equal callbacks, instance.notifications
       end
       
-      def test_should_call_after_event_method
+      def test_should_pass_record_and_transition_to_before_callbacks
         observer = new_observer(@model) do
-          def after_ignite(*args)
+          def before_transition(*args)
             notifications << args
           end
         end
@@ -615,7 +689,7 @@ begin
         assert_equal [[@record, @transition]], instance.notifications
       end
       
-      def test_should_call_after_transition_method
+      def test_should_pass_record_and_transition_to_after_callbacks
         observer = new_observer(@model) do
           def after_transition(*args)
             notifications << args
@@ -627,22 +701,6 @@ begin
         assert_equal [[@record, @transition]], instance.notifications
       end
       
-      def test_should_call_event_method_before_transition_method
-        observer = new_observer(@model) do
-          def before_ignite(*args)
-            notifications << :before_ignite
-          end
-          
-          def before_transition(*args)
-            notifications << :before_transition
-          end
-        end
-        instance = observer.instance
-        
-        @transition.perform
-        assert_equal [:before_ignite, :before_transition], instance.notifications
-      end
-      
       def test_should_call_methods_outside_the_context_of_the_record
         observer = new_observer(@model) do
           def before_ignite(*args)
@@ -659,15 +717,16 @@ begin
     class MachineWithNamespacedObserversTest < ActiveRecord::TestCase
       def setup
         @model = new_model
-        @machine = StateMachine::Machine.new(@model, :namespace => 'car')
-        @machine.state :parked, :idling
-        @record = @model.new(:state => 'parked')
-        @transition = StateMachine::Transition.new(@record, @machine, :ignite, :parked, :idling)
+        @machine = StateMachine::Machine.new(@model, :state, :namespace => 'alarm')
+        @machine.state :active, :off
+        @machine.event :enable
+        @record = @model.new(:state => 'off')
+        @transition = StateMachine::Transition.new(@record, @machine, :enable, :off, :active)
       end
       
       def test_should_call_namespaced_before_event_method
         observer = new_observer(@model) do
-          def before_ignite_car(*args)
+          def before_enable_alarm(*args)
             notifications << args
           end
         end
@@ -679,7 +738,7 @@ begin
       
       def test_should_call_namespaced_after_event_method
         observer = new_observer(@model) do
-          def after_ignite_car(*args)
+          def after_enable_alarm(*args)
             notifications << args
           end
         end
@@ -695,6 +754,7 @@ begin
         @model = new_model
         @machine = StateMachine::Machine.new(@model)
         @machine.state :parked, :idling
+        @machine.event :ignite
         @record = @model.new(:state => 'parked')
         @transition = StateMachine::Transition.new(@record, @machine, :ignite, :parked, :idling)
         
@@ -758,7 +818,7 @@ begin
             :activerecord => {
               :errors => {
                 :messages => {
-                  :invalid_transition => 'cannot {{event}} when {{value}}'
+                  :invalid_transition => 'cannot {{event}}'
                 }
               }
             }
@@ -770,8 +830,8 @@ begin
           
           record = @model.new(:state => 'idling')
           
-          machine.invalidate(record, event)
-          assert_equal 'cannot ignite when idling', record.errors.on(:state)
+          machine.invalidate(record, :state, :invalid_transition, [[:event, :ignite]])
+          assert_equal 'cannot ignite', record.errors.on(:state)
         end
         
         def test_should_invalidate_using_customized_i18n_key_if_specified
@@ -779,32 +839,30 @@ begin
             :activerecord => {
               :errors => {
                 :messages => {
-                  :bad_transition => 'cannot {{event}} when {{value}}'
+                  :bad_transition => 'cannot {{event}}'
                 }
               }
             }
           })
           
-          machine = StateMachine::Machine.new(@model, :invalid_message => :bad_transition)
+          machine = StateMachine::Machine.new(@model, :messages => {:invalid_transition => :bad_transition})
           machine.state :parked, :idling
-          event = StateMachine::Event.new(machine, :ignite)
           
           record = @model.new(:state => 'idling')
           
-          machine.invalidate(record, event)
-          assert_equal 'cannot ignite when idling', record.errors.on(:state)
+          machine.invalidate(record, :state, :invalid_transition, [[:event, :ignite]])
+          assert_equal 'cannot ignite', record.errors.on(:state)
         end
       end
       
       def test_should_invalidate_using_customized_i18n_string_if_specified
-        machine = StateMachine::Machine.new(@model, :invalid_message => 'cannot {{event}} when {{value}}')
+        machine = StateMachine::Machine.new(@model, :messages => {:invalid_transition => 'cannot {{event}}'})
         machine.state :parked, :idling
-        event = StateMachine::Event.new(machine, :ignite)
         
         record = @model.new(:state => 'idling')
         
-        machine.invalidate(record, event)
-        assert_equal 'cannot ignite when idling', record.errors.on(:state)
+        machine.invalidate(record, :state, :invalid_transition, [[:event, :ignite]])
+        assert_equal 'cannot ignite', record.errors.on(:state)
       end
     else
       $stderr.puts 'Skipping ActiveRecord I18n tests. `gem install active_record` >= v2.2.0 and try again.'