state_machine 0.7.6 → 0.8.0

data/test/unit/guard_test.rb

@@ -404,6 +404,52 @@ class GuardWithMultipleExceptOnRequirementsTest < Test::Unit::TestCase
   end
 end
 
+class GuardWithFailuresExcludedTest < Test::Unit::TestCase
+  def setup
+    @object = Object.new
+    @guard = StateMachine::Guard.new(:include_failures => false)
+  end
+  
+  def test_should_use_a_blacklist_matcher
+    assert_instance_of StateMachine::WhitelistMatcher, @guard.success_requirement
+  end
+  
+  def test_should_match_if_not_specified
+    assert @guard.matches?(@object)
+  end
+  
+  def test_should_match_if_true
+    assert @guard.matches?(@object, :success => true)
+  end
+  
+  def test_should_not_match_if_false
+    assert !@guard.matches?(@object, :success => false)
+  end
+end
+
+class GuardWithFailuresIncludedTest < Test::Unit::TestCase
+  def setup
+    @object = Object.new
+    @guard = StateMachine::Guard.new(:include_failures => true)
+  end
+  
+  def test_should_use_all_matcher
+    assert_equal StateMachine::AllMatcher.instance, @guard.success_requirement
+  end
+  
+  def test_should_match_if_not_specified
+    assert @guard.matches?(@object)
+  end
+  
+  def test_should_match_if_true
+    assert @guard.matches?(@object, :success => true)
+  end
+  
+  def test_should_match_if_false
+    assert @guard.matches?(@object, :success => false)
+  end
+end
+
 class GuardWithConflictingFromRequirementsTest < Test::Unit::TestCase
   def test_should_raise_an_exception
     exception = assert_raise(ArgumentError) { StateMachine::Guard.new(:from => :parked, :except_from => :parked) }

data/test/unit/integrations/active_record_test.rb

@@ -168,15 +168,14 @@ begin
         
         @machine.invalidate(record, :state, :invalid_transition, [[:event, :park]])
         
-        assert record.errors.invalid?(:state)
-        assert_equal 'cannot transition via "park"', record.errors.on(:state)
+        assert_equal ['State cannot transition via "park"'], record.errors.full_messages
       end
       
       def test_should_auto_prefix_custom_attributes_on_invalidation
         record = @model.new
         @machine.invalidate(record, :event, :invalid)
         
-        assert_equal 'is invalid', record.errors.on(:state_event)
+        assert_equal ['State event is invalid'], record.errors.full_messages
       end
       
       def test_should_clear_errors_on_reset
@@ -185,7 +184,7 @@ begin
         record.errors.add(:state, 'is invalid')
         
         @machine.reset(record)
-        assert_nil record.errors.on(:id)
+        assert_equal [], record.errors.full_messages
       end
       
       def test_should_not_override_the_column_reader
@@ -229,15 +228,126 @@ begin
       end
     end
     
-    class MachineWithInitialStateTest < ActiveRecord::TestCase
+    class MachineWithStaticInitialStateTest < ActiveRecord::TestCase
       def setup
-        @model = new_model
+        @model = new_model do
+          attr_accessor :value
+        end
         @machine = StateMachine::Machine.new(@model, :initial => :parked)
-        @record = @model.new
       end
       
       def test_should_set_initial_state_on_created_object
-        assert_equal 'parked', @record.state
+        record = @model.new
+        assert_equal 'parked', record.state
+      end
+      
+      def test_should_still_set_attributes
+        record = @model.new(:value => 1)
+        assert_equal 1, record.value
+      end
+      
+      def test_should_still_allow_initialize_blocks
+        block_args = nil
+        record = @model.new do |*args|
+          block_args = args
+        end
+        
+        assert_equal [record], block_args
+      end
+      
+      def test_should_set_attributes_prior_to_after_initialize_hook
+        state = nil
+        @model.class_eval do
+          define_method(:after_initialize) do
+            state = self.state
+          end
+        end
+        @model.new
+        assert_equal 'parked', state
+      end
+      
+      def test_should_set_initial_state_before_setting_attributes
+        @model.class_eval do
+          attr_accessor :state_during_setter
+          
+          define_method(:value=) do |value|
+            self.state_during_setter = state
+          end
+        end
+        
+        record = @model.new(:value => 1)
+        assert_equal 'parked', record.state_during_setter
+      end
+      
+      def test_should_not_set_initial_state_after_already_initialized
+        record = @model.new(:value => 1)
+        assert_equal 'parked', record.state
+        
+        record.state = 'idling'
+        record.attributes = {}
+        assert_equal 'idling', record.state
+      end
+    end
+    
+    class MachineWithDynamicInitialStateTest < ActiveRecord::TestCase
+      def setup
+        @model = new_model do
+          attr_accessor :value
+        end
+        @machine = StateMachine::Machine.new(@model, :initial => lambda {|object| :parked})
+        @machine.state :parked
+      end
+      
+      def test_should_set_initial_state_on_created_object
+        record = @model.new
+        assert_equal 'parked', record.state
+      end
+      
+      def test_should_still_set_attributes
+        record = @model.new(:value => 1)
+        assert_equal 1, record.value
+      end
+      
+      def test_should_still_allow_initialize_blocks
+        block_args = nil
+        record = @model.new do |*args|
+          block_args = args
+        end
+        
+        assert_equal [record], block_args
+      end
+      
+      def test_should_set_attributes_prior_to_after_initialize_hook
+        state = nil
+        @model.class_eval do
+          define_method(:after_initialize) do
+            state = self.state
+          end
+        end
+        @model.new
+        assert_equal 'parked', state
+      end
+      
+      def test_should_set_initial_state_after_setting_attributes
+        @model.class_eval do
+          attr_accessor :state_during_setter
+          
+          define_method(:value=) do |value|
+            self.state_during_setter = state || 'nil'
+          end
+        end
+        
+        record = @model.new(:value => 1)
+        assert_equal 'nil', record.state_during_setter
+      end
+      
+      def test_should_not_set_initial_state_after_already_initialized
+        record = @model.new(:value => 1)
+        assert_equal 'parked', record.state
+        
+        record.state = 'idling'
+        record.attributes = {}
+        assert_equal 'idling', record.state
       end
     end
     
@@ -395,28 +505,31 @@ begin
     
     class MachineWithCustomAttributeTest < ActiveRecord::TestCase
       def setup
-        @model = new_model
-        @machine = StateMachine::Machine.new(@model, :status, :attribute => :state)
+        @model = new_model do
+          alias_attribute :vehicle_status, :state
+        end
+        
+        @machine = StateMachine::Machine.new(@model, :status, :attribute => :vehicle_status)
         @machine.state :parked
         
         @record = @model.new
       end
       
       def test_should_add_validation_errors_to_custom_attribute
-        @record.state = 'invalid'
+        @record.vehicle_status = 'invalid'
         
         assert !@record.valid?
-        assert_equal ['State is invalid'], @record.errors.full_messages
+        assert_equal ['Vehicle status is invalid'], @record.errors.full_messages
         
-        @record.state = 'parked'
+        @record.vehicle_status = 'parked'
         assert @record.valid?
       end
       
       def test_should_check_custom_attribute_for_predicate
-        @record.state = nil
+        @record.vehicle_status = nil
         assert !@record.status?(:parked)
         
-        @record.state = 'parked'
+        @record.vehicle_status = 'parked'
         assert @record.status?(:parked)
       end
     end
@@ -528,9 +641,46 @@ begin
       end
     end
     
+    class MachineWithLoopbackTest < ActiveRecord::TestCase
+      def setup
+        changed_attrs = nil
+        
+        @model = new_model do
+          connection.change_table(:foo) {|t| t.datetime(:updated_at)}
+          
+          define_method(:before_update) do
+            changed_attrs = changed_attributes.dup
+          end
+        end
+        
+        @machine = StateMachine::Machine.new(@model, :initial => :parked)
+        @machine.event :park
+        
+        @record = @model.create(:updated_at => Time.now - 1)
+        @timestamp = @record.updated_at
+        
+        @transition = StateMachine::Transition.new(@record, @machine, :park, :parked, :parked)
+        @transition.perform
+        
+        @changed_attrs = changed_attrs
+      end
+      
+      def test_should_include_state_in_changed_attributes
+        @changed_attrs.delete('updated_at')
+        
+        expected = {'state' => 'parked'}
+        assert_equal expected, @changed_attrs
+      end
+      
+      def test_should_update_record
+        assert_not_equal @timestamp, @record.updated_at
+      end
+    end
+    
     class MachineWithFailedBeforeCallbacksTest < ActiveRecord::TestCase
       def setup
         @before_count = 0
+        @after_count = 0
         
         @model = new_model
         @machine = StateMachine::Machine.new(@model)
@@ -538,6 +688,7 @@ begin
         @machine.event :ignite
         @machine.before_transition(lambda {@before_count += 1; false})
         @machine.before_transition(lambda {@before_count += 1})
+        @machine.after_transition(lambda {@after_count += 1})
         
         @record = @model.new(:state => 'parked')
         @transition = StateMachine::Transition.new(@record, @machine, :ignite, :parked, :idling)
@@ -559,6 +710,10 @@ begin
       def test_should_not_run_further_before_callbacks
         assert_equal 1, @before_count
       end
+      
+      def test_should_not_run_after_callbacks
+        assert_equal 0, @after_count
+      end
     end
     
     class MachineWithFailedActionTest < ActiveRecord::TestCase
@@ -570,6 +725,14 @@ begin
         @machine = StateMachine::Machine.new(@model)
         @machine.state :parked, :idling
         @machine.event :ignite
+        
+        @before_transition_called = false
+        @after_transition_called = false
+        @after_transition_with_failures_called = false
+        @machine.before_transition(lambda {@before_transition_called = true})
+        @machine.after_transition(lambda {@after_transition_called = true})
+        @machine.after_transition(lambda {@after_transition_with_failures_called = true}, :include_failures => true)
+        
         @record = @model.new(:state => 'parked')
         @transition = StateMachine::Transition.new(@record, @machine, :ignite, :parked, :idling)
         @result = @transition.perform
@@ -586,6 +749,18 @@ begin
       def test_should_not_save_record
         assert @record.new_record?
       end
+      
+      def test_should_run_before_callback
+        assert @before_transition_called
+      end
+      
+      def test_should_not_run_after_callback_if_not_including_failures
+        assert !@after_transition_called
+      end
+      
+      def test_should_run_after_callback_if_including_failures
+        assert @after_transition_with_failures_called
+      end
     end
     
     class MachineWithValidationsTest < ActiveRecord::TestCase
@@ -722,6 +897,32 @@ begin
         @record.valid?
         assert !ran_callback
       end
+      
+      def test_should_not_run_after_callbacks_with_failures_disabled_if_validation_fails
+        @model.class_eval do
+          attr_accessor :seatbelt
+          validates_presence_of :seatbelt
+        end
+        
+        ran_callback = false
+        @machine.after_transition { ran_callback = true }
+        
+        @record.valid?
+        assert !ran_callback
+      end
+      
+      def test_should_run_after_callbacks_with_failures_enabled_if_validation_fails
+        @model.class_eval do
+          attr_accessor :seatbelt
+          validates_presence_of :seatbelt
+        end
+        
+        ran_callback = false
+        @machine.after_transition(:include_failures => true) { ran_callback = true }
+        
+        @record.valid?
+        assert ran_callback
+      end
     end
     
     class MachineWithEventAttributesOnSaveBangTest < ActiveRecord::TestCase
@@ -759,6 +960,14 @@ begin
         assert ran_callback
       end
       
+      def test_should_run_before_callbacks_once
+        before_count = 0
+        @machine.before_transition { before_count += 1 }
+        
+        @record.save!
+        assert_equal 1, before_count
+      end
+      
       def test_should_persist_new_state
         @record.save!
         assert_equal 'idling', @record.state
@@ -771,6 +980,26 @@ begin
         @record.save!
         assert ran_callback
       end
+      
+      def test_should_not_run_after_callbacks_with_failures_disabled_if_fails
+        @model.before_create {|record| false}
+        
+        ran_callback = false
+        @machine.after_transition { ran_callback = true }
+        
+        begin; @record.save!; rescue; end
+        assert !ran_callback
+      end
+      
+      def test_should_run_after_callbacks_with_failures_enabled_if_fails
+        @model.before_create {|record| false}
+        
+        ran_callback = false
+        @machine.after_transition(:include_failures => true) { ran_callback = true }
+        
+        begin; @record.save!; rescue; end
+        assert ran_callback
+      end
     end
     
     class MachineWithEventAttributesOnCustomActionTest < ActiveRecord::TestCase
@@ -1004,7 +1233,7 @@ begin
           record = @model.new(:state => 'idling')
           
           machine.invalidate(record, :state, :invalid_transition, [[:event, :ignite]])
-          assert_equal 'cannot ignite', record.errors.on(:state)
+          assert_equal ['State cannot ignite'], record.errors.full_messages
         end
         
         def test_should_invalidate_using_customized_i18n_key_if_specified
@@ -1024,7 +1253,7 @@ begin
           record = @model.new(:state => 'idling')
           
           machine.invalidate(record, :state, :invalid_transition, [[:event, :ignite]])
-          assert_equal 'cannot ignite', record.errors.on(:state)
+          assert_equal ['State cannot ignite'], record.errors.full_messages
         end
         
         def test_should_invalidate_using_customized_i18n_string_if_specified
@@ -1034,7 +1263,7 @@ begin
           record = @model.new(:state => 'idling')
           
           machine.invalidate(record, :state, :invalid_transition, [[:event, :ignite]])
-          assert_equal 'cannot ignite', record.errors.on(:state)
+          assert_equal ['State cannot ignite'], record.errors.full_messages
         end
         
         def test_should_only_add_locale_once_in_load_path

data/test/unit/integrations/data_mapper_test.rb

@@ -25,7 +25,7 @@ begin
             storage_names[:default] = 'foo'
             def self.name; 'DataMapperTest::Foo'; end
             
-            property :id, Integer, :serial => true
+            property :id, DataMapper::Types::Serial
             property :state, String
             
             auto_migrate! if auto_migrate
@@ -375,6 +375,45 @@ begin
       end
     end
     
+    class MachineWithLoopbackTest < BaseTestCase
+      def setup
+        dirty_attributes = nil
+        
+        @resource = new_resource do
+          property :updated_at, DateTime
+          auto_migrate!
+          
+          # Simulate dm-timestamps
+          before :update do
+            dirty_attributes = self.dirty_attributes.dup
+            
+            return unless dirty?
+            self.updated_at = DateTime.now
+          end
+        end
+        
+        @machine = StateMachine::Machine.new(@resource, :initial => :parked)
+        @machine.event :park
+        
+        @record = @resource.create(:updated_at => Time.now - 1)
+        @timestamp = @record.updated_at
+        
+        @transition = StateMachine::Transition.new(@record, @machine, :park, :parked, :parked)
+        @transition.perform
+        
+        @dirty_attributes = dirty_attributes
+      end
+      
+      def test_should_include_state_in_dirty_attributes
+        expected = {@resource.properties[:state] => 'parked'}
+        assert_equal expected, @dirty_attributes
+      end
+      
+      def test_should_update_record
+        assert_not_equal @timestamp, @record.updated_at
+      end
+    end
+    
     begin
       gem 'dm-observer', ENV['DM_VERSION'] ? "=#{ENV['DM_VERSION']}" : '>=0.9.4'
       require 'dm-observer'
@@ -721,6 +760,109 @@ begin
           @record.valid?
           assert !ran_callback
         end
+        
+        def test_should_not_run_after_callbacks_with_failures_disabled_if_validation_fails
+          @resource.class_eval do
+            attr_accessor :seatbelt
+            validates_present :seatbelt
+          end
+          
+          ran_callback = false
+          @machine.after_transition { ran_callback = true }
+          
+          @record.valid?
+          assert !ran_callback
+        end
+        
+        def test_should_run_after_callbacks_with_failures_enabled_if_validation_fails
+          @resource.class_eval do
+            attr_accessor :seatbelt
+            validates_present :seatbelt
+          end
+          
+          ran_callback = false
+          @machine.after_transition(:include_failures => true) { ran_callback = true }
+          
+          @record.valid?
+          assert ran_callback
+        end
+      end
+      
+      class MachineWithEventAttributesOnSaveTest < BaseTestCase
+        def setup
+          @resource = new_resource
+          @machine = StateMachine::Machine.new(@resource)
+          @machine.event :ignite do
+            transition :parked => :idling
+          end
+          
+          @record = @resource.new
+          @record.state = 'parked'
+          @record.state_event = 'ignite'
+        end
+        
+        def test_should_fail_if_event_is_invalid
+          @record.state_event = 'invalid'
+          assert !@record.save
+        end
+        
+        def test_should_fail_if_event_has_no_transition
+          @record.state = 'idling'
+          assert !@record.save
+        end
+        
+        def test_should_be_successful_if_event_has_transition
+          assert_equal true, @record.save
+        end
+        
+        def test_should_run_before_callbacks
+          ran_callback = false
+          @machine.before_transition { ran_callback = true }
+          
+          @record.save
+          assert ran_callback
+        end
+        
+        def test_should_run_before_callbacks_once
+          before_count = 0
+          @machine.before_transition { before_count += 1 }
+          
+          @record.save
+          assert_equal 1, before_count
+        end
+        
+        def test_should_persist_new_state
+          @record.save
+          assert_equal 'idling', @record.state
+        end
+        
+        def test_should_run_after_callbacks
+          ran_callback = false
+          @machine.after_transition { ran_callback = true }
+          
+          @record.save
+          assert ran_callback
+        end
+        
+        def test_should_not_run_after_callbacks_with_failures_disabled_if_fails
+          @resource.before(:create) { throw :halt }
+          
+          ran_callback = false
+          @machine.after_transition { ran_callback = true }
+          
+          @record.save
+          assert !ran_callback
+        end
+        
+        def test_should_run_after_callbacks_with_failures_enabled_if_fails
+          @resource.before(:create) { throw :halt }
+          
+          ran_callback = false
+          @machine.after_transition(:include_failures => true) { ran_callback = true }
+          
+          @record.save
+          assert ran_callback
+        end
       end
       
       class MachineWithEventAttributesOnCustomActionTest < BaseTestCase