state_machine 0.9.4 → 0.10.0

data/test/unit/integrations/data_mapper_test.rb

@@ -26,12 +26,16 @@ module DataMapperTest
       def new_resource(create_table = :foo, &block)
         table_name = create_table || :foo
         
-        resource = Class.new
+        resource = Class.new do
+          (class << self; self; end).class_eval do
+            define_method(:name) { "DataMapperTest::#{table_name.to_s.capitalize}" }
+          end
+        end
+        
         resource.class_eval do
           include DataMapper::Resource
           
           storage_names[:default] = table_name.to_s
-          def self.name; "DataMapperTest::#{storage_names[:default].capitalize}"; end
           
           property :id, resource.class_eval('Serial')
           property :state, String
@@ -516,7 +520,7 @@ module DataMapperTest
     
       def test_should_have_changes_when_loaded_from_database
         record = @resource.get(@record.id)
-        assert record.dirty_attributes.blank?
+        assert record.dirty_attributes.empty?
       end
   end
   
@@ -617,6 +621,50 @@ module DataMapperTest
     end
   end
   
+  class MachineWithDirtyAttributeAndStateEventsTest < BaseTestCase
+    def setup
+      @resource = new_resource
+      @machine = StateMachine::Machine.new(@resource, :initial => :parked)
+      @machine.event :ignite
+      
+      @record = @resource.create
+      @record.state_event = 'ignite'
+    end
+    
+    def test_should_include_state_in_changed_attributes
+      assert_equal e = {@resource.properties[:state] => 'parked'}, @record.dirty_attributes
+    end
+    
+    def test_should_track_attribute_change
+      if Gem::Version.new(::DataMapper::VERSION) >= Gem::Version.new('0.10.3')
+        assert_equal e = {@resource.properties[:state] => 'parked'}, @record.original_attributes
+      elsif Gem::Version.new(::DataMapper::VERSION) >= Gem::Version.new('0.10.0')
+        assert_equal e = {@resource.properties[:state] => 'parked-ignored'}, @record.original_attributes
+      else
+        assert_equal e = {:state => 'parked-ignored'},  @record.original_values
+      end
+    end
+    
+    def test_should_not_reset_changes_on_multiple_changes
+      @record.state_event = 'ignite'
+      
+      if Gem::Version.new(::DataMapper::VERSION) >= Gem::Version.new('0.10.3')
+        assert_equal e = {@resource.properties[:state] => 'parked'}, @record.original_attributes
+      elsif Gem::Version.new(::DataMapper::VERSION) >= Gem::Version.new('0.10.0')
+        assert_equal e = {@resource.properties[:state] => 'parked-ignored'}, @record.original_attributes
+      else
+        assert_equal e = {:state => 'parked-ignored'},  @record.original_values
+      end
+    end
+    
+    def test_should_not_include_state_in_changed_attributes_if_nil
+      @record = @resource.create
+      @record.state_event = nil
+      
+      assert_equal e = {}, @record.dirty_attributes
+    end
+  end
+  
   class MachineWithoutTransactionsTest < BaseTestCase
     def setup
       @resource = new_resource
@@ -837,13 +885,8 @@ module DataMapperTest
       callbacks = []
       @machine.before_transition {callbacks << :before}
       @machine.after_transition {callbacks << :after}
-      @machine.after_transition(:include_failures => true) {callbacks << :after_failure}
+      @machine.after_failure {callbacks << :after_failure}
       @machine.around_transition {|block| callbacks << :around_before; block.call; callbacks << :around_after}
-      @machine.around_transition(:include_failures => true) do |block|
-        callbacks << :around_before_failure
-        block.call
-        callbacks << :around_after_failure
-      end
       
       @record = @resource.new(:state => 'parked')
       @transition = StateMachine::Transition.new(@record, @machine, :ignite, :parked, :idling)
@@ -865,7 +908,7 @@ module DataMapperTest
     end
     
     def test_should_run_before_callbacks_and_after_callbacks_with_failures
-      assert_equal [:before, :around_before, :around_before_failure, :around_after_failure, :after_failure], @callbacks
+      assert_equal [:before, :around_before, :after_failure], @callbacks
     end
   end
   
@@ -1083,7 +1126,7 @@ module DataMapperTest
           assert !ran_callback
         end
         
-        def test_should_run_after_callbacks_with_failures_enabled_if_validation_fails
+        def test_should_run_failure_callbacks_if_validation_fails
           @resource.class_eval do
             attr_accessor :seatbelt
             if respond_to?(:validates_presence_of)
@@ -1094,7 +1137,7 @@ module DataMapperTest
           end
           
           ran_callback = false
-          @machine.after_transition(:include_failures => true) { ran_callback = true }
+          @machine.after_failure { ran_callback = true }
           
           @record.valid?
           assert ran_callback
@@ -1125,23 +1168,6 @@ module DataMapperTest
           assert !ran_callback[0]
         end
         
-        def test_should_run_around_callbacks_after_yield_with_failures_enabled_if_validation_fails
-          @resource.class_eval do
-            attr_accessor :seatbelt
-            if respond_to?(:validates_presence_of)
-              validates_presence_of :seatbelt
-            else
-              validates_present :seatbelt
-            end
-          end
-          
-          ran_callback = [false]
-          @machine.around_transition(:include_failures => true) {|block| block.call; ran_callback[0] = true }
-          
-          @record.valid?
-          assert ran_callback[0]
-        end
-        
         def test_should_not_run_before_transitions_within_transaction
           @machine.before_transition { self.class.create; throw :halt }
           
@@ -1232,11 +1258,11 @@ module DataMapperTest
           assert !ran_callback
         end
         
-        def test_should_run_after_callbacks_with_failures_enabled_if_fails
+        def test_should_run_failure_callbacks_if_fails
           @resource.before(:create) { throw :halt }
           
           ran_callback = false
-          @machine.after_transition(:include_failures => true) { ran_callback = true }
+          @machine.after_failure { ran_callback = true }
           
           @record.save
           assert ran_callback
@@ -1260,16 +1286,6 @@ module DataMapperTest
           assert ran_callback[0]
         end
         
-        def test_should_run_around_callbacks_after_yield_with_failures_enabled_if_fails
-          @resource.before(:create) { throw :halt }
-          
-          ran_callback = [false]
-          @machine.around_transition(:include_failures => true) {|block| block.call; ran_callback[0] = true }
-          
-          @record.save
-          assert ran_callback[0]
-        end
-        
         def test_should_not_run_before_transitions_within_transaction
           @machine.before_transition { self.class.create; throw :halt }
           
@@ -1545,7 +1561,7 @@ module DataMapperTest
         assert !called
       end
       
-      def test_should_pass_transition_to_after_callbacks
+      def test_should_pass_transition_to_around_callbacks
         callback_args = nil
         
         observer = new_observer(@resource) do
@@ -1560,6 +1576,51 @@ module DataMapperTest
         assert_equal [@transition], callback_args
       end
       
+      def test_should_call_failure_callback_if_requirements_match
+        @resource.before(:create) { throw :halt } 
+        
+        called = false
+        
+        observer = new_observer(@resource) do
+          after_transition_failure :on => :ignite do
+            called = true
+          end
+        end
+        
+        @transition.perform
+        assert called
+      end
+      
+      def test_should_not_call_failure_callback_if_requirements_do_not_match
+        @resource.before(:create) { throw :halt } 
+        
+        called = false
+        
+        observer = new_observer(@resource) do
+          after_transition_failure :on => :park do
+            called = true
+          end
+        end
+        
+        @transition.perform
+        assert !called
+      end
+      
+      def test_should_pass_transition_to_failure_callbacks
+        @resource.before(:create) { throw :halt } 
+        
+        callback_args = nil
+        
+        observer = new_observer(@resource) do
+          after_transition_failure do |*args|
+            callback_args = args
+          end
+        end
+        
+        @transition.perform
+        assert_equal [@transition], callback_args
+      end
+      
       def test_should_raise_exception_if_targeting_invalid_machine
         assert_raise(RUBY_VERSION < '1.9' ? IndexError : KeyError) do
           new_observer(@resource) do
@@ -1570,7 +1631,7 @@ module DataMapperTest
       end
       
       def test_should_allow_targeting_specific_machine
-        @second_machine = StateMachine::Machine.new(@resource, :status)
+        @second_machine = StateMachine::Machine.new(@resource, :status, :namespace => 'alarm')
         @resource.auto_migrate!
         
         called_state = false
@@ -1593,7 +1654,7 @@ module DataMapperTest
       end
       
       def test_should_allow_targeting_multiple_specific_machines
-        @second_machine = StateMachine::Machine.new(@resource, :status)
+        @second_machine = StateMachine::Machine.new(@resource, :status, :namespace => 'alarm')
         @second_machine.state :parked, :idling
         @second_machine.event :ignite
         @resource.auto_migrate!

data/test/unit/integrations/mongo_mapper_test.rb

@@ -3,16 +3,21 @@ require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
 # Load library
 require 'rubygems'
 
-if ENV['VERSION'] && Gem::Version.new(ENV['VERSION']) <= Gem::Version.new('0.7.0') || !Gem.available?('>=0.7.0')
-  gem 'activesupport', '~>2.3'
-  require 'active_support'
+if ENV['VERSION']
+  if Gem::Version.new(ENV['VERSION']) >= Gem::Version.new('0.9.0')
+    gem 'activesupport', '~>3.0'
+    require 'active_support'
+  elsif Gem::Version.new(ENV['VERSION']) <= Gem::Version.new('0.7.0') || !Gem.available?('>=0.7.0')
+    gem 'activesupport', '~>2.3'
+    require 'active_support'
+  end
 end
 
 gem 'mongo_mapper', ENV['VERSION'] ? "=#{ENV['VERSION']}" : '>=0.5.5'
 require 'mongo_mapper'
 
 # Establish database connection
-MongoMapper.connection = Mongo::Connection.new('127.0.0.1', 27017, {:logger => Logger.new("#{File.dirname(__FILE__)}/../../mongo_mapper.log")})
+MongoMapper.connection = Mongo::Connection.new('127.0.0.1', 27017, {:logger => Logger.new("#{File.dirname(__FILE__)}/../../mongo_mapper.log"), :slave_ok => true})
 MongoMapper.database = 'test'
 
 module MongoMapperTest
@@ -25,12 +30,16 @@ module MongoMapperTest
       def new_model(table_name = :foo, &block)
         
         model = Class.new do
+          (class << self; self; end).class_eval do
+            define_method(:name) { "MongoMapperTest::#{table_name.to_s.capitalize}" }
+            define_method(:to_s) { name }
+          end
+        end
+        
+        model.class_eval do
           include MongoMapper::Document
           set_collection_name(table_name)
           
-          def self.name; "MongoMapperTest::#{collection_name}"; end
-          def self.to_s; "MongoMapperTest::#{collection_name}"; end
-          
           key :state, String
         end
         model.class_eval(&block) if block_given?
@@ -335,7 +344,7 @@ module MongoMapperTest
     end
     
     def test_should_define_a_new_key_for_the_attribute
-      assert_not_nil @model.keys[:status]
+      assert_not_nil @model.keys['status']
     end
     
     def test_should_define_a_reader_attribute_for_the_attribute
@@ -575,6 +584,37 @@ module MongoMapperTest
     end
   end
   
+  class MachineWithDirtyAttributeAndStateEventsTest < BaseTestCase
+    def setup
+      @model = new_model
+      @machine = StateMachine::Machine.new(@model, :initial => :parked)
+      @machine.event :ignite
+      
+      @record = @model.create
+      @record.state_event = 'ignite'
+    end
+    
+    def test_should_include_state_in_changed_attributes
+      assert_equal %w(state), @record.changed
+    end
+    
+    def test_should_track_attribute_change
+      assert_equal %w(parked parked), @record.changes['state']
+    end
+    
+    def test_should_not_reset_changes_on_multiple_changes
+      @record.state_event = 'ignite'
+      assert_equal %w(parked parked), @record.changes['state']
+    end
+    
+    def test_should_not_include_state_in_changed_attributes_if_nil
+      @record = @model.create
+      @record.state_event = nil
+      
+      assert_equal [], @record.changed
+    end
+  end
+  
   class MachineWithCallbacksTest < BaseTestCase
     def setup
       @model = new_model
@@ -710,27 +750,45 @@ module MongoMapperTest
       @result = @transition.perform
     end
     
-    def test_should_be_successful
-      assert @result
-    end
-    
-    def test_should_change_current_state
-      assert_equal 'idling', @record.state
-    end
-    
-    def test_should_run_action
-      assert !@record.new_record?
-    end
-    
-    def test_should_run_further_callbacks
-      assert_equal [:before_1, :before_2, :around_before, :around_after, :after], @callbacks
+    if defined?(MongoMapper::Version) && MongoMapper::Version >= '0.9.0'
+      def test_should_not_be_successful
+        assert !@result
+      end
+      
+      def test_should_not_change_current_state
+        assert_equal 'parked', @record.state
+      end
+      
+      def test_should_not_run_action
+        assert @record.new_record?
+      end
+      
+      def test_should_not_run_further_callbacks
+        assert_equal [:before_1], @callbacks
+      end
+    else
+      def test_should_be_successful
+        assert @result
+      end
+      
+      def test_should_change_current_state
+        assert_equal 'idling', @record.state
+      end
+      
+      def test_should_run_action
+        assert !@record.new_record?
+      end
+      
+      def test_should_run_further_callbacks
+        assert_equal [:before_1, :before_2, :around_before, :around_after, :after], @callbacks
+      end
     end
   end
   
   class MachineWithFailedActionTest < BaseTestCase
     def setup
       @model = new_model do
-        validates_inclusion_of :state, :within => %w(first_gear)
+        validates_numericality_of :state
       end
       
       @machine = StateMachine::Machine.new(@model)
@@ -740,13 +798,8 @@ module MongoMapperTest
       @callbacks = []
       @machine.before_transition {@callbacks << :before}
       @machine.after_transition {@callbacks << :after}
-      @machine.after_transition(:include_failures => true) {@callbacks << :after_failure}
+      @machine.after_failure {@callbacks << :after_failure}
       @machine.around_transition {|block| @callbacks << :around_before; block.call; @callbacks << :around_after}
-      @machine.around_transition(:include_failures => true) do |block|
-        @callbacks << :around_before_failure
-        block.call
-        @callbacks << :around_after_failure
-      end
       
       @record = @model.new(:state => 'parked')
       @transition = StateMachine::Transition.new(@record, @machine, :ignite, :parked, :idling)
@@ -766,7 +819,7 @@ module MongoMapperTest
     end
     
     def test_should_run_before_callbacks_and_after_callbacks_with_failures
-      assert_equal [:before, :around_before, :around_before_failure, :around_after_failure, :after_failure], @callbacks
+      assert_equal [:before, :around_before, :after_failure], @callbacks
     end
   end
   
@@ -799,8 +852,14 @@ module MongoMapperTest
       assert !@record.new_record?
     end
     
-    def test_should_still_run_further_after_callbacks
-      assert_equal [:around_before, :around_after, :after_1, :after_2], @callbacks
+    if defined?(MongoMapper::Version) && MongoMapper::Version >= '0.9.0'
+      def test_should_not_run_further_after_callbacks
+        assert_equal [:around_before, :around_after, :after_1], @callbacks
+      end
+    else
+      def test_should_still_run_further_after_callbacks
+        assert_equal [:around_before, :around_after, :after_1, :after_2], @callbacks
+      end
     end
   end
   
@@ -814,6 +873,7 @@ module MongoMapperTest
     end
     
     def test_should_invalidate_using_errors
+      I18n.backend = I18n::Backend::Simple.new if Object.const_defined?(:ActiveModel)
       @record.state = 'parked'
       
       @machine.invalidate(@record, :state, :invalid_transition, [[:event, 'park']])
@@ -995,27 +1055,14 @@ module MongoMapperTest
       assert !ran_callback
     end
     
-    def test_should_run_around_callbacks_after_yield_with_failures_enabled_if_validation_fails
+    def test_should_run_failure_callbacks_if_validation_fails
       @model.class_eval do
         attr_accessor :seatbelt
         validates_presence_of :seatbelt
       end
       
       ran_callback = false
-      @machine.around_transition(:include_failures => true) {|block| block.call; 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 }
+      @machine.after_failure { ran_callback = true }
       
       @record.valid?
       assert ran_callback
@@ -1096,7 +1143,7 @@ module MongoMapperTest
     
     def test_should_not_run_after_callbacks_with_failures_disabled_if_fails
       @model.class_eval do
-        validates_inclusion_of :state, :within => %w(first_gear)
+        validates_numericality_of :state
       end
       
       ran_callback = false
@@ -1106,13 +1153,13 @@ module MongoMapperTest
       assert !ran_callback
     end
     
-    def test_should_run_after_callbacks_with_failures_enabled_if_fails
+    def test_should_run_failure_callbacks__if_fails
       @model.class_eval do
-        validates_inclusion_of :state, :within => %w(first_gear)
+        validates_numericality_of :state
       end
       
       ran_callback = false
-      @machine.after_transition(:include_failures => true) { ran_callback = true }
+      @machine.after_failure { ran_callback = true }
       
       begin; @record.save; rescue; end
       assert ran_callback
@@ -1120,7 +1167,7 @@ module MongoMapperTest
     
     def test_should_not_run_around_callbacks_with_failures_disabled_if_fails
       @model.class_eval do
-        validates_inclusion_of :state, :within => %w(first_gear)
+        validates_numericality_of :state
       end
       
       ran_callback = false
@@ -1137,18 +1184,6 @@ module MongoMapperTest
       @record.save
       assert ran_callback
     end
-    
-    def test_should_run_around_callbacks_after_yield_with_failures_enabled_if_fails
-      @model.class_eval do
-        validates_inclusion_of :state, :within => %w(first_gear)
-      end
-      
-      ran_callback = false
-      @machine.around_transition(:include_failures => true) {|block| block.call; ran_callback = true }
-      
-      begin; @record.save; rescue; end
-      assert ran_callback
-    end
   end
   
   class MachineWithEventAttributesOnSaveBangTest < BaseTestCase
@@ -1379,4 +1414,166 @@ module MongoMapperTest
       assert @model.respond_to?(:with_statuses)
     end
   end
+  
+  if defined?(ActiveModel)
+    class MachineWithInternationalizationTest < BaseTestCase
+      def setup
+        I18n.backend = I18n::Backend::Simple.new
+        
+        # Initialize the backend
+        StateMachine::Machine.new(new_model)
+        I18n.backend.translate(:en, 'mongo_mapper.errors.messages.invalid_transition', :event => 'ignite', :value => 'idling')
+        
+        @model = new_model
+      end
+      
+      def test_should_use_defaults
+        I18n.backend.store_translations(:en, {
+          :mongo_mapper => {:errors => {:messages => {:invalid_transition => 'cannot %{event}'}}}
+        })
+        
+        machine = StateMachine::Machine.new(@model)
+        machine.state :parked, :idling
+        machine.event :ignite
+        
+        record = @model.new(:state => 'idling')
+        
+        machine.invalidate(record, :state, :invalid_transition, [[:event, 'ignite']])
+        assert_equal ['State cannot ignite'], record.errors.full_messages
+      end
+      
+      def test_should_allow_customized_error_key
+        I18n.backend.store_translations(:en, {
+          :mongo_mapper => {:errors => {:messages => {:bad_transition => 'cannot %{event}'}}}
+        })
+        
+        machine = StateMachine::Machine.new(@model, :messages => {:invalid_transition => :bad_transition})
+        machine.state :parked, :idling
+        
+        record = @model.new(:state => 'idling')
+        
+        machine.invalidate(record, :state, :invalid_transition, [[:event, 'ignite']])
+        assert_equal ['State cannot ignite'], record.errors.full_messages
+      end
+      
+      def test_should_allow_customized_error_string
+        machine = StateMachine::Machine.new(@model, :messages => {:invalid_transition => 'cannot %{event}'})
+        machine.state :parked, :idling
+        
+        record = @model.new(:state => 'idling')
+        
+        machine.invalidate(record, :state, :invalid_transition, [[:event, 'ignite']])
+        assert_equal ['State cannot ignite'], record.errors.full_messages
+      end
+      
+      def test_should_allow_customized_state_key_scoped_to_class_and_machine
+        I18n.backend.store_translations(:en, {
+          :mongo_mapper => {:state_machines => {:'mongo_mapper_test/foo' => {:state => {:states => {:parked => 'shutdown'}}}}}
+        })
+        
+        machine = StateMachine::Machine.new(@model)
+        machine.state :parked
+        
+        assert_equal 'shutdown', machine.state(:parked).human_name
+      end
+      
+      def test_should_allow_customized_state_key_scoped_to_machine
+        I18n.backend.store_translations(:en, {
+          :mongo_mapper => {:state_machines => {:state => {:states => {:parked => 'shutdown'}}}}
+        })
+        
+        machine = StateMachine::Machine.new(@model)
+        machine.state :parked
+        
+        assert_equal 'shutdown', machine.state(:parked).human_name
+      end
+      
+      def test_should_allow_customized_state_key_unscoped
+        I18n.backend.store_translations(:en, {
+          :mongo_mapper => {:state_machines => {:states => {:parked => 'shutdown'}}}
+        })
+        
+        machine = StateMachine::Machine.new(@model)
+        machine.state :parked
+        
+        assert_equal 'shutdown', machine.state(:parked).human_name
+      end
+      
+      def test_should_allow_customized_event_key_scoped_to_class_and_machine
+        I18n.backend.store_translations(:en, {
+          :mongo_mapper => {:state_machines => {:'mongo_mapper_test/foo' => {:state => {:events => {:park => 'stop'}}}}}
+        })
+        
+        machine = StateMachine::Machine.new(@model)
+        machine.event :park
+        
+        assert_equal 'stop', machine.event(:park).human_name
+      end
+      
+      def test_should_allow_customized_event_key_scoped_to_machine
+        I18n.backend.store_translations(:en, {
+          :mongo_mapper => {:state_machines => {:state => {:events => {:park => 'stop'}}}}
+        })
+        
+        machine = StateMachine::Machine.new(@model)
+        machine.event :park
+        
+        assert_equal 'stop', machine.event(:park).human_name
+      end
+      
+      def test_should_allow_customized_event_key_unscoped
+        I18n.backend.store_translations(:en, {
+          :mongo_mapper => {:state_machines => {:events => {:park => 'stop'}}}
+        })
+        
+        machine = StateMachine::Machine.new(@model)
+        machine.event :park
+        
+        assert_equal 'stop', machine.event(:park).human_name
+      end
+      
+      def test_should_only_add_locale_once_in_load_path
+        assert_equal 1, I18n.load_path.select {|path| path =~ %r{mongo_mapper/locale\.rb$}}.length
+        
+        # Create another MongoMapper model that will triger the i18n feature
+        new_model
+        
+        assert_equal 1, I18n.load_path.select {|path| path =~ %r{mongo_mapper/locale\.rb$}}.length
+      end
+      
+      def test_should_add_locale_to_beginning_of_load_path
+        @original_load_path = I18n.load_path
+        I18n.backend = I18n::Backend::Simple.new
+        
+        app_locale = File.dirname(__FILE__) + '/../../files/en.yml'
+        default_locale = File.dirname(__FILE__) + '/../../../lib/state_machine/integrations/mongo_mapper/locale.rb'
+        I18n.load_path = [app_locale]
+        
+        StateMachine::Machine.new(@model)
+        
+        assert_equal [default_locale, app_locale].map {|path| File.expand_path(path)}, I18n.load_path.map {|path| File.expand_path(path)}
+      ensure
+        I18n.load_path = @original_load_path
+      end
+      
+      def test_should_prefer_other_locales_first
+        @original_load_path = I18n.load_path
+        I18n.backend = I18n::Backend::Simple.new
+        I18n.load_path = [File.dirname(__FILE__) + '/../../files/en.yml']
+        
+        machine = StateMachine::Machine.new(@model)
+        machine.state :parked, :idling
+        machine.event :ignite
+        
+        record = @model.new(:state => 'idling')
+        
+        machine.invalidate(record, :state, :invalid_transition, [[:event, 'ignite']])
+        assert_equal ['State cannot transition'], record.errors.full_messages
+      ensure
+        I18n.load_path = @original_load_path
+      end
+    end
+  else
+    $stderr.puts 'Skipping MongoMapper I18n tests. `gem install mongo_mapper` >= v0.9.0 and try again.'
+  end
 end