state_machine 1.1.2 → 1.2.0

data/test/unit/integrations/mongoid_test.rb

@@ -5,35 +5,77 @@ require 'mongoid/version'
 
 # Establish database connection
 Mongoid.configure do |config|
-  config.master = Mongo::Connection.new('127.0.0.1', 27017, :slave_ok => true).db('test')
+  if Mongoid::VERSION =~ /^2\./
+    connection = Mongo::Connection.new('127.0.0.1', 27017, :slave_ok => true, :logger => Logger.new("#{File.dirname(__FILE__)}/../../mongoid.log"))
+    config.master = connection.db('test')
+  else
+    Mongoid.logger = Moped.logger = Logger.new("#{File.dirname(__FILE__)}/../../mongoid.log")
+    config.connect_to('test')
+  end
 end
 
+
 module MongoidTest
   class BaseTestCase < Test::Unit::TestCase
     def default_test
     end
     
+    def teardown
+      if @table_names
+        db = Mongoid::VERSION =~ /^2\./ ? Mongoid.master : Mongoid::Sessions.default
+        db.collections.each {|c| c.drop if @table_names.include?(c.name)}
+      end
+    end
+    
     protected
       # Creates a new Mongoid model (and the associated table)
-      def new_model(table_name = :foo, &block)
+      def new_model(name = :foo, &block)
+        table_name = "#{name}_#{rand(1000000)}"
+        @table_names ||= []
+        @table_names << table_name
         
         model = Class.new do
           (class << self; self; end).class_eval do
-            define_method(:name) { "MongoidTest::#{table_name.to_s.capitalize}" }
-            define_method(:to_s) { name }
+            define_method(:name) { "MongoidTest::#{name.to_s.capitalize}" }
+            define_method(:to_s) { self.name }
           end
         end
         
         model.class_eval do
           include Mongoid::Document
-          self.collection_name = table_name
+          if Mongoid::VERSION =~ /^2\./
+            self.collection_name = table_name
+          else
+            self.default_collection_name = table_name
+          end
           
           field :state, :type => String
         end
         model.class_eval(&block) if block_given?
-        model.collection.remove
         model
       end
+      
+      # Creates a new Mongoid observer
+      def new_observer(model, &block)
+        observer = Class.new(Mongoid::Observer) do
+          attr_accessor :notifications
+          
+          def initialize
+            super
+            @notifications = []
+          end
+        end
+        
+        (class << observer; self; end).class_eval do
+          define_method(:name) do
+            "#{model.name}Observer"
+          end
+        end
+        
+        observer.observe(model)
+        observer.class_eval(&block) if block_given?
+        observer
+      end
   end
   
   class IntegrationTest < BaseTestCase
@@ -54,7 +96,7 @@ module MongoidTest
     end
     
     def test_should_have_defaults
-      assert_equal e = {:action => :save}, StateMachine::Integrations::Mongoid.defaults
+      assert_equal({:action => :save}, StateMachine::Integrations::Mongoid.defaults)
     end
     
     def test_should_have_a_locale_path
@@ -123,7 +165,7 @@ module MongoidTest
   
   class MachineWithStaticInitialStateTest < BaseTestCase
     def setup
-      @model = new_model do
+      @model = new_model(:vehicle) do
         attr_accessor :value
       end
       @machine = StateMachine::Machine.new(@model, :initial => :parked)
@@ -155,7 +197,7 @@ module MongoidTest
     
     def test_should_set_attributes_prior_to_initialize_block
       state = nil
-      record = @model.new do |record|
+      @model.new do |record|
         state = record.state
       end
       
@@ -171,10 +213,25 @@ module MongoidTest
       assert_equal 'parked', state
     end
     
+    def test_should_persist_initial_state
+      record = @model.new
+      record.save
+      record.reload
+      assert_equal 'parked', record.state
+    end
+    
+    def test_should_persist_initial_state_on_dup
+      record = @model.create.dup
+      record.save
+      record.reload
+      assert_equal 'parked', record.state
+    end
+    
     def test_should_set_initial_state_before_setting_attributes
       @model.class_eval do
         attr_accessor :state_during_setter
         
+        remove_method :value=
         define_method(:value=) do |value|
           self.state_during_setter = state
         end
@@ -189,7 +246,7 @@ module MongoidTest
       assert_equal 'parked', record.state
       
       record.state = 'idling'
-      record.process({})
+      record.attributes = {}
       assert_equal 'idling', record.state
     end
     
@@ -206,6 +263,65 @@ module MongoidTest
       record = @model.find(@model.create(:state => nil).id)
       assert_nil record.state
     end
+    
+    if Mongoid::VERSION >= '2.1.0'
+      def test_should_use_stored_values_when_loading_for_many_association
+        @machine.state :idling
+        
+        @model.belongs_to :owner, :class_name => 'MongoidTest::Owner'
+        MongoidTest.const_set('Vehicle', @model)
+        
+        owner_model = new_model(:owner) do
+          has_many :vehicles, :class_name => 'MongoidTest::Vehicle'
+        end
+        MongoidTest.const_set('Owner', owner_model)
+        
+        owner = owner_model.create
+        record = @model.create(:state => 'idling', :owner_id => owner.id)
+        assert_equal 'idling', owner.vehicles[0].state
+      end
+      
+      def test_should_use_stored_values_when_loading_for_one_association
+        @machine.state :idling
+        
+        @model.belongs_to :owner, :class_name => 'MongoidTest::Owner'
+        MongoidTest.const_set('Vehicle', @model)
+        
+        owner_model = new_model(:owner) do
+          has_one :vehicle, :class_name => 'MongoidTest::Vehicle'
+        end
+        MongoidTest.const_set('Owner', owner_model)
+        
+        owner = owner_model.create
+        record = @model.create(:state => 'idling', :owner_id => owner.id)
+        owner.reload
+        assert_equal 'idling', owner.vehicle.state
+      end
+      
+      def test_should_use_stored_values_when_loading_for_belongs_to_association
+        @machine.state :idling
+        
+        MongoidTest.const_set('Vehicle', @model)
+        
+        driver_model = new_model(:driver) do
+          belongs_to :vehicle, :class_name => 'MongoidTest::Vehicle'
+        end
+        MongoidTest.const_set('Driver', driver_model)
+        
+        record = @model.create(:state => 'idling')
+        driver = driver_model.create(:vehicle_id => record.id)
+        assert_equal 'idling', driver.vehicle.state
+      end
+    end
+    
+    def teardown
+      MongoidTest.class_eval do
+        remove_const('Vehicle') if defined?(MongoidTest::Vehicle)
+        remove_const('Owner') if defined?(MongoidTest::Owner)
+        remove_const('Driver') if defined?(MongoidTest::Driver)
+      end
+      super
+    end
   end
   
   class MachineWithDynamicInitialStateTest < BaseTestCase
@@ -238,7 +354,7 @@ module MongoidTest
     
     def test_should_set_attributes_prior_to_initialize_block
       state = nil
-      record = @model.new do |record|
+      @model.new do |record|
         state = record.state
       end
       
@@ -258,6 +374,7 @@ module MongoidTest
       @model.class_eval do
         attr_accessor :state_during_setter
         
+        remove_method :value=
         define_method(:value=) do |value|
           self.state_during_setter = state || 'nil'
         end
@@ -272,10 +389,24 @@ module MongoidTest
       assert_equal 'parked', record.state
       
       record.state = 'idling'
-      record.process({})
+      record.attributes = {}
       assert_equal 'idling', record.state
     end
     
+    def test_should_persist_initial_state
+      record = @model.new
+      record.save
+      record.reload
+      assert_equal 'parked', record.state
+    end
+    
+    def test_should_persist_initial_state_on_dup
+      record = @model.create.dup
+      record.save
+      record.reload
+      assert_equal 'parked', record.state
+    end
+    
     def test_should_use_stored_values_when_loading_from_database
       @machine.state :idling
       
@@ -303,8 +434,35 @@ module MongoidTest
     end
   end
   
-  class MachineWithColumnDefaultTest < BaseTestCase
+  class MachineWithDifferentSameDefaultTest < BaseTestCase
     def setup
+      @original_stderr, $stderr = $stderr, StringIO.new
+      
+      @model = new_model do
+        field :status, :type => String, :default => 'parked'
+      end
+      @machine = StateMachine::Machine.new(@model, :status, :initial => :parked)
+      @record = @model.new
+    end
+    
+    def test_should_use_machine_default
+      assert_equal 'parked', @record.status
+    end
+    
+    def test_should_not_generate_a_warning
+      assert_no_match(/have defined a different default/, $stderr.string)
+    end
+    
+    def teardown
+      $stderr = @original_stderr
+      super
+    end
+  end
+  
+  class MachineWithDifferentColumnDefaultTest < BaseTestCase
+    def setup
+      @original_stderr, $stderr = $stderr, StringIO.new
+      
       @model = new_model do
         field :status, :type => String, :default => 'idling'
       end
@@ -315,6 +473,41 @@ module MongoidTest
     def test_should_use_machine_default
       assert_equal 'parked', @record.status
     end
+    
+    def test_should_generate_a_warning
+      assert_match(/Both MongoidTest::Foo and its :status machine have defined a different default for "status". Use only one or the other for defining defaults to avoid unexpected behaviors\./, $stderr.string)
+    end
+    
+    def teardown
+      $stderr = @original_stderr
+      super
+    end
+  end
+  
+  class MachineWithDifferentIntegerColumnDefaultTest < BaseTestCase
+    def setup
+      @original_stderr, $stderr = $stderr, StringIO.new
+      
+      @model = new_model do
+        field :status, :type => Integer, :default => 0
+      end
+      @machine = StateMachine::Machine.new(@model, :status, :initial => :parked)
+      @machine.state :parked, :value => 1
+      @record = @model.new
+    end
+    
+    def test_should_use_machine_default
+      assert_equal 1, @record.status
+    end
+    
+    def test_should_generate_a_warning
+      assert_match(/Both MongoidTest::Foo and its :status machine have defined a different default for "status". Use only one or the other for defining defaults to avoid unexpected behaviors\./, $stderr.string)
+    end
+    
+    def teardown
+      $stderr = @original_stderr
+      super
+    end
   end
   
   class MachineWithConflictingPredicateTest < BaseTestCase
@@ -346,18 +539,19 @@ module MongoidTest
       @machine = StateMachine::Machine.new(@model)
       @machine.state :state
       
-      assert_match /^Instance method "state\?" is already defined in .*, use generic helper instead.*\n$/, $stderr.string
+      assert_match(/^Instance method "state\?" is already defined in .*, use generic helper instead.*\n$/, $stderr.string)
     end
     
     def test_should_output_warning_with_same_machine_attribute
       @machine = StateMachine::Machine.new(@model, :public_state, :attribute => :state)
       @machine.state :state
       
-      assert_match /^Instance method "state\?" is already defined in .*, use generic helper instead.*\n$/, $stderr.string
+      assert_match(/^Instance method "state\?" is already defined in .*, use generic helper instead.*\n$/, $stderr.string)
     end
     
     def teardown
       $stderr = @original_stderr
+      super
     end
   end
   
@@ -491,6 +685,27 @@ module MongoidTest
     end
   end
   
+  class MachineWithAliasedFieldTest < BaseTestCase
+    def setup
+      @model = new_model do
+        field :status, :as => :vehicle_status
+      end
+      
+      @machine = StateMachine::Machine.new(@model, :vehicle_status)
+      @machine.state :parked
+      
+      @record = @model.new
+    end
+    
+    def test_should_check_custom_attribute_for_predicate
+      @record.vehicle_status = nil
+      assert !@record.vehicle_status?(:parked)
+      
+      @record.vehicle_status = 'parked'
+      assert @record.vehicle_status?(:parked)
+    end
+  end
+  
   class MachineWithCustomAttributeTest < BaseTestCase
     def setup
       require 'stringio'
@@ -507,6 +722,7 @@ module MongoidTest
     
     def teardown
       $stderr = @original_stderr
+      super
     end
   end
   
@@ -544,6 +760,8 @@ module MongoidTest
     end
     
     def test_should_use_default_state_if_protected
+      Mongoid.logger = nil
+
       @model.class_eval do
         attr_protected :state
       end
@@ -556,7 +774,7 @@ module MongoidTest
   class MachineMultipleTest < BaseTestCase
     def setup
       @model = new_model do
-        field :status, :type => String, :default => 'idling'
+        field :status, :type => String
       end
       @state_machine = StateMachine::Machine.new(@model, :initial => :parked)
       @status_machine = StateMachine::Machine.new(@model, :status, :initial => :idling)
@@ -640,29 +858,19 @@ module MongoidTest
       @transition.perform(false)
     end
     
-    if ::Mongoid::VERSION =~ /^2\.0\./
-      def test_should_include_state_in_changed_attributes
-        assert_equal %w(state), @record.changed
-      end
-      
-      def test_should_not_track_attribute_changes
-        assert_equal %w(parked parked), @record.send(:attribute_change, 'state')
-      end
-    else
-      def test_should_not_include_state_in_changed_attributes
-        assert_equal [], @record.changed
-      end
-      
-      def test_should_not_track_attribute_changes
-        assert_equal nil, @record.send(:attribute_change, 'state')
-      end
+    def test_should_not_include_state_in_changed_attributes
+      assert_equal [], @record.changed
+    end
+    
+    def test_should_not_track_attribute_changes
+      assert_equal nil, @record.send(:attribute_change, 'state')
     end
   end
   
   class MachineWithDirtyAttributesAndCustomAttributeTest < BaseTestCase
     def setup
       @model = new_model do
-        field :status, :type => String, :default => 'idling'
+        field :status, :type => String
       end
       @machine = StateMachine::Machine.new(@model, :status, :initial => :parked)
       @machine.event :ignite
@@ -693,7 +901,7 @@ module MongoidTest
   class MachineWithDirtyAttributeAndCustomAttributesDuringLoopbackTest < BaseTestCase
     def setup
       @model = new_model do
-        field :status, :type => String, :default => 'idling'
+        field :status, :type => String
       end
       @machine = StateMachine::Machine.new(@model, :status, :initial => :parked)
       @machine.event :park
@@ -704,22 +912,12 @@ module MongoidTest
       @transition.perform(false)
     end
     
-    if ::Mongoid::VERSION =~ /^2\.0\./
-      def test_should_include_state_in_changed_attributes
-        assert_equal %w(status), @record.changed
-      end
-      
-      def test_should_track_attribute_changes
-        assert_equal %w(parked parked), @record.send(:attribute_change, 'status')
-      end
-    else
-      def test_should_include_state_in_changed_attributes
-        assert_equal [], @record.changed
-      end
-      
-      def test_should_track_attribute_changes
-        assert_equal nil, @record.send(:attribute_change, 'status')
-      end
+    def test_should_include_state_in_changed_attributes
+      assert_equal [], @record.changed
+    end
+    
+    def test_should_track_attribute_changes
+      assert_equal nil, @record.send(:attribute_change, 'status')
     end
   end
   
@@ -733,34 +931,12 @@ module MongoidTest
       @record.state_event = 'ignite'
     end
     
-    if ::Mongoid::VERSION =~ /^2\.0\./
-      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.send(:attribute_change, 'state')
-      end
-      
-      def test_should_not_reset_changes_on_multiple_changes
-        @record.state_event = 'ignite'
-        assert_equal %w(parked parked), @record.send(:attribute_change, '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
-    else
-      def test_should_not_include_state_in_changed_attributes
-        assert_equal [], @record.changed
-      end
-      
-      def test_should_not_track_attribute_change
-        assert_equal nil, @record.send(:attribute_change, 'state')
-      end
+    def test_should_not_include_state_in_changed_attributes
+      assert_equal [], @record.changed
+    end
+    
+    def test_should_not_track_attribute_change
+      assert_equal nil, @record.send(:attribute_change, 'state')
     end
   end
   
@@ -858,11 +1034,21 @@ module MongoidTest
     def test_should_run_around_callbacks
       before_called = false
       after_called = false
-      @machine.around_transition {|block| before_called = true; block.call; after_called = true}
+      ensure_called = 0
+      @machine.around_transition do |block|
+        before_called = true
+        begin
+          block.call
+        ensure
+          ensure_called += 1
+        end
+        after_called = true
+      end
       
       @transition.perform
       assert before_called
       assert after_called
+      assert_equal ensure_called, 1
     end
     
     def test_should_include_transition_states_in_known_states
@@ -895,6 +1081,29 @@ module MongoidTest
       
       assert_equal [1, 2, 3], @record.callback_result
     end
+    
+    def test_should_run_in_expected_order
+      expected = [
+        :before_transition, :before_validation, :after_validation,
+        :before_save, :before_create, :after_create, :after_save,
+        :after_transition
+      ]
+      
+      callbacks = []
+      @model.before_validation { callbacks << :before_validation }
+      @model.after_validation { callbacks << :after_validation }
+      @model.before_save { callbacks << :before_save }
+      @model.before_create { callbacks << :before_create }
+      @model.after_create { callbacks << :after_create }
+      @model.after_save { callbacks << :after_save }
+      
+      @machine.before_transition { callbacks << :before_transition }
+      @machine.after_transition { callbacks << :after_transition }
+      
+      @transition.perform
+      
+      assert_equal expected, callbacks
+    end
   end
   
   class MachineWithFailedBeforeCallbacksTest < BaseTestCase
@@ -932,6 +1141,44 @@ module MongoidTest
     end
   end
   
+  class MachineNestedActionTest < BaseTestCase
+    def setup
+      @callbacks = []
+      
+      @model = new_model
+      @machine = StateMachine::Machine.new(@model)
+      @machine.event :ignite do
+        transition :parked => :idling
+      end
+      
+      @record = @model.new(:state => 'parked')
+    end
+    
+    def test_should_allow_transition_prior_to_creation_if_skipping_action
+      record = @record
+      @model.before_create { record.ignite(false) }
+      result = @record.save
+      
+      assert_equal true, result
+      assert_equal "idling", @record.state
+      @record.reload
+      assert_equal "idling", @record.state
+    end
+    
+    if Mongoid::VERSION !~ /^2\.1\./
+      def test_should_allow_transition_after_creation
+        record = @record
+        @model.after_create { record.ignite }
+        result = @record.save
+        
+        assert_equal true, result
+        assert_equal "idling", @record.state
+        @record.reload
+        assert_equal "idling", @record.state
+      end
+    end
+  end
+  
   class MachineWithFailedActionTest < BaseTestCase
     def setup
       @model = new_model do
@@ -971,7 +1218,7 @@ module MongoidTest
   end
   
   class MachineWithFailedAfterCallbacksTest < BaseTestCase
-     def setup
+    def setup
       @callbacks = []
       
       @model = new_model
@@ -1051,10 +1298,7 @@ module MongoidTest
   
   class MachineWithValidationsAndCustomAttributeTest < BaseTestCase
     def setup
-      @model = new_model do
-        alias_attribute :status, :state
-      end
-      
+      @model = new_model
       @machine = StateMachine::Machine.new(@model, :status, :attribute => :state)
       @machine.state :parked
       
@@ -1163,7 +1407,11 @@ module MongoidTest
       ran_callback = false
       @machine.around_transition {|block| ran_callback = true; block.call }
       
-      @record.valid?
+      begin
+        @record.valid?
+      rescue ArgumentError
+        raise if StateMachine::Transition.pause_supported?
+      end
       assert ran_callback
     end
     
@@ -1197,7 +1445,11 @@ module MongoidTest
       ran_callback = false
       @machine.around_transition {|block| block.call; ran_callback = true }
       
-      @record.valid?
+      begin
+        @record.valid?
+      rescue ArgumentError
+        raise if StateMachine::Transition.pause_supported?
+      end
       assert !ran_callback
     end
     
@@ -1343,6 +1595,85 @@ module MongoidTest
       @record.save
       assert ran_callback
     end
+    
+    def test_should_allow_additional_transitions_to_new_state_in_after_transitions
+      @machine.event :park do
+        transition :idling => :parked
+      end
+      
+      @machine.after_transition(:on => :ignite) { @record.park }
+      
+      @record.save
+      assert_equal 'parked', @record.state
+      
+      @record.reload
+      assert_equal 'parked', @record.state
+    end
+    
+    def test_should_allow_additional_transitions_to_previous_state_in_after_transitions
+      @machine.event :shift_up do
+        transition :idling => :first_gear
+      end
+      
+      @machine.after_transition(:on => :ignite) { @record.shift_up }
+      
+      @record.save
+      assert_equal 'first_gear', @record.state
+      
+      @record.reload
+      assert_equal 'first_gear', @record.state
+    end
+  end
+  
+  if Mongoid::VERSION >= '2.1.0'
+    class MachineWithEventAttributesOnAutosaveTest < BaseTestCase
+      def setup
+        @vehicle_model = new_model(:vehicle) do
+          belongs_to :owner, :class_name => 'MongoidTest::Owner'
+        end
+        MongoidTest.const_set('Vehicle', @vehicle_model)
+        
+        @owner_model = new_model(:owner)
+        MongoidTest.const_set('Owner', @owner_model)
+        
+        machine = StateMachine::Machine.new(@vehicle_model)
+        machine.event :ignite do
+          transition :parked => :idling
+        end
+        
+        @owner = @owner_model.create
+      end
+      
+      def test_should_persist_many_association
+        @owner_model.has_many :vehicles, :class_name => 'MongoidTest::Vehicle', :autosave => true
+        @vehicle = @vehicle_model.create(:state => 'parked', :owner_id => @owner.id)
+        
+        @owner.vehicles[0].state_event = 'ignite'
+        @owner.save
+        
+        @vehicle.reload
+        assert_equal 'idling', @vehicle.state
+      end
+      
+      def test_should_persist_one_association
+        @owner_model.has_one :vehicle, :class_name => 'MongoidTest::Vehicle', :autosave => true
+        @vehicle = @vehicle_model.create(:state => 'parked', :owner_id => @owner.id)
+        
+        @owner.vehicle.state_event = 'ignite'
+        @owner.save
+        
+        @vehicle.reload
+        assert_equal 'idling', @vehicle.state
+      end
+      
+      def teardown
+        MongoidTest.class_eval do
+          remove_const('Vehicle')
+          remove_const('Owner')
+        end
+        super
+      end
+    end
   end
   
   class MachineWithEventAttributesOnSaveBangTest < BaseTestCase
@@ -1409,11 +1740,6 @@ module MongoidTest
       assert_equal 'idling', @record.state
     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 }
@@ -1470,6 +1796,186 @@ module MongoidTest
     end
   end
   
+  class MachineWithObserversTest < BaseTestCase
+    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_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
+      ]
+      
+      observer = new_observer(@model) do
+        callbacks.each do |callback|
+          define_method(callback) do |*args|
+            notifications << callback
+          end
+        end
+      end
+      
+      instance = observer.instance
+      
+      @transition.perform
+      assert_equal callbacks, instance.notifications
+    end
+    
+    def test_should_call_no_transition_callbacks_when_observers_disabled
+      return unless ::ActiveModel::VERSION::MAJOR >= 3 && ::ActiveModel::VERSION::MINOR >= 1
+      
+      callbacks = [
+        :before_ignite,
+        :before_transition
+      ]
+      
+      observer = new_observer(@model) do
+        callbacks.each do |callback|
+          define_method(callback) do |*args|
+            notifications << callback
+          end
+        end
+      end
+      
+      instance = observer.instance
+      
+      @model.observers.disable(observer) do
+        @transition.perform
+      end
+      
+      assert_equal [], instance.notifications
+    end
+    
+    def test_should_pass_record_and_transition_to_before_callbacks
+      observer = new_observer(@model) do
+        def before_transition(*args)
+          notifications << args
+        end
+      end
+      instance = observer.instance
+      
+      @transition.perform
+      assert_equal [[@record, @transition]], instance.notifications
+    end
+    
+    def test_should_pass_record_and_transition_to_after_callbacks
+      observer = new_observer(@model) do
+        def after_transition(*args)
+          notifications << args
+        end
+      end
+      instance = observer.instance
+      
+      @transition.perform
+      assert_equal [[@record, @transition]], instance.notifications
+    end
+    
+    def test_should_call_methods_outside_the_context_of_the_record
+      observer = new_observer(@model) do
+        def before_ignite(*args)
+          notifications << self
+        end
+      end
+      instance = observer.instance
+      
+      @transition.perform
+      assert_equal [instance], instance.notifications
+    end
+    
+    def test_should_support_nil_from_states
+      callbacks = [
+        :before_ignite_from_nil_to_idling,
+        :before_ignite_from_nil,
+        :before_transition_state_from_nil_to_idling,
+        :before_transition_state_from_nil
+      ]
+      
+      observer = new_observer(@model) do
+        callbacks.each do |callback|
+          define_method(callback) do |*args|
+            notifications << callback
+          end
+        end
+      end
+      
+      instance = observer.instance
+      
+      transition = StateMachine::Transition.new(@record, @machine, :ignite, nil, :idling)
+      transition.perform
+      assert_equal callbacks, instance.notifications
+    end
+    
+    def test_should_support_nil_to_states
+      callbacks = [
+        :before_ignite_from_parked_to_nil,
+        :before_ignite_to_nil,
+        :before_transition_state_from_parked_to_nil,
+        :before_transition_state_to_nil
+      ]
+      
+      observer = new_observer(@model) do
+        callbacks.each do |callback|
+          define_method(callback) do |*args|
+            notifications << callback
+          end
+        end
+      end
+      
+      instance = observer.instance
+      
+      transition = StateMachine::Transition.new(@record, @machine, :ignite, :parked, nil)
+      transition.perform
+      assert_equal callbacks, instance.notifications
+    end
+  end
+  
+  class MachineWithNamespacedObserversTest < BaseTestCase
+    def setup
+      @model = new_model
+      @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_enable_alarm(*args)
+          notifications << args
+        end
+      end
+      instance = observer.instance
+      
+      @transition.perform
+      assert_equal [[@record, @transition]], instance.notifications
+    end
+    
+    def test_should_call_namespaced_after_event_method
+      observer = new_observer(@model) do
+        def after_enable_alarm(*args)
+          notifications << args
+        end
+      end
+      instance = observer.instance
+      
+      @transition.perform
+      assert_equal [[@record, @transition]], instance.notifications
+    end
+  end
+  
   class MachineWithScopesTest < BaseTestCase
     def setup
       @model = new_model
@@ -1484,7 +1990,7 @@ module MongoidTest
     
     def test_should_only_include_records_with_state_in_singular_with_scope
       parked = @model.create :state => 'parked'
-      idling = @model.create :state => 'idling'
+      @model.create :state => 'idling'
       
       assert_equal [parked], @model.with_state(:parked).to_a
     end
@@ -1545,15 +2051,16 @@ module MongoidTest
       
       MongoidTest.const_set('Foo', @model)
       
-      @subclass = Class.new(@model) do
-        def self.name
-          'MongoidTest::SubFoo'
+      # Remove the #name override so that Mongoid picks up the subclass name
+      # properly
+      class << @model; remove_method(:name); end
+      @subclass = MongoidTest.class_eval <<-end_eval
+        class SubFoo < MongoidTest::Foo
+          self
         end
-      end
+      end_eval
       @subclass_machine = @subclass.state_machine(:state) {}
       @subclass_machine.state :parked, :idling, :first_gear
-      
-      MongoidTest.const_set('SubFoo', @subclass)
     end
     
     def test_should_only_include_records_with_subclass_states_in_with_scope
@@ -1574,6 +2081,7 @@ module MongoidTest
     def teardown
       MongoidTest.send(:remove_const, 'SubFoo')
       MongoidTest.send(:remove_const, 'Foo')
+      super
     end
   end