state_machine 0.8.1 → 0.9.0

data/test/unit/integrations_test.rb

@@ -24,6 +24,10 @@ class IntegrationMatcherTest < Test::Unit::TestCase
 end
 
 class IntegrationFinderTest < Test::Unit::TestCase
+  def test_should_find_active_model
+    assert_equal StateMachine::Integrations::ActiveModel, StateMachine::Integrations.find(:active_model)
+  end
+  
   def test_should_find_active_record
     assert_equal StateMachine::Integrations::ActiveRecord, StateMachine::Integrations.find(:active_record)
   end
@@ -32,6 +36,10 @@ class IntegrationFinderTest < Test::Unit::TestCase
     assert_equal StateMachine::Integrations::DataMapper, StateMachine::Integrations.find(:data_mapper)
   end
   
+  def test_should_find_mongo_mapper
+    assert_equal StateMachine::Integrations::MongoMapper, StateMachine::Integrations.find(:mongo_mapper)
+  end
+  
   def test_should_find_sequel
     assert_equal StateMachine::Integrations::Sequel, StateMachine::Integrations.find(:sequel)
   end

data/test/unit/machine_collection_test.rb

@@ -101,9 +101,18 @@ class MachineCollectionStateInitializationTest < Test::Unit::TestCase
     assert_equal 'parked', @object.state
     assert_equal 'active', @object.alarm_state
   end
+  
+  def test_should_not_modify_ignore_option
+    ignore = ['state', 'alarm_state']
+    @machines.initialize_states(@object, :ignore => ignore)
+    
+    assert_nil @object.state
+    assert_nil @object.alarm_state
+    assert_equal ['state', 'alarm_state'], ignore
+  end
 end
 
-class MachineCollectionFireExplicitTest < Test::Unit::TestCase
+class MachineCollectionFireTest < Test::Unit::TestCase
   def setup
     @machines = StateMachine::MachineCollection.new
     
@@ -171,7 +180,7 @@ class MachineCollectionFireExplicitTest < Test::Unit::TestCase
   end
 end
 
-class MachineCollectionFireExplicitWithTransactionsTest < Test::Unit::TestCase
+class MachineCollectionFireWithTransactionsTest < Test::Unit::TestCase
   def setup
     @machines = StateMachine::MachineCollection.new
     
@@ -231,7 +240,7 @@ class MachineCollectionFireExplicitWithTransactionsTest < Test::Unit::TestCase
   end
 end
 
-class MachineCollectionFireExplicitWithValidationsTest < Test::Unit::TestCase
+class MachineCollectionFireWithValidationsTest < Test::Unit::TestCase
   def setup
     StateMachine::Integrations.const_set('Custom', Module.new do
       def invalidate(object, attribute, message, values = [])
@@ -284,7 +293,7 @@ class MachineCollectionFireExplicitWithValidationsTest < Test::Unit::TestCase
   end
 end
 
-class MachineCollectionFireImplicitTest < Test::Unit::TestCase
+class MachineCollectionTransitionsWithoutEventsTest < Test::Unit::TestCase
   def setup
     @klass = Class.new
     
@@ -294,507 +303,216 @@ class MachineCollectionFireImplicitTest < Test::Unit::TestCase
       transition :parked => :idling
     end
     
-    @saved = false
     @object = @klass.new
-  end
-  
-  def default_test
-  end
-end
-
-class MachineCollectionFireImplicitWithoutEventTest < MachineCollectionFireImplicitTest
-  def setup
-    super
-    
     @object.state_event = nil
-    @result = @machines.fire_event_attributes(@object, :save) { @saved = true }
-  end
-  
-  def test_should_be_successful
-    assert_equal true, @result
-  end
-  
-  def test_should_run_action
-    assert @saved
+    @transitions = @machines.transitions(@object, :save)
   end
   
-  def test_should_not_transition_state
-    assert_equal 'parked', @object.state
+  def test_should_be_empty
+    assert @transitions.empty?
   end
   
-  def test_should_not_change_event_attribute
-    assert_nil @object.state_event
-  end
-  
-  def test_should_not_have_event_transition
-    assert_nil @object.send(:state_event_transition)
+  def test_should_perform
+    assert_equal true, @transitions.perform
   end
 end
 
-class MachineCollectionFireImplicitWithBlankEventTest < MachineCollectionFireImplicitTest
+class MachineCollectionTransitionsWithBlankEventsTest < Test::Unit::TestCase
   def setup
-    super
+    @klass = Class.new
     
+    @machines = StateMachine::MachineCollection.new
+    @machines[:state] = @machine = StateMachine::Machine.new(@klass, :state, :initial => :parked, :action => :save)
+    @machine.event :ignite do
+      transition :parked => :idling
+    end
+    
+    @object = @klass.new
     @object.state_event = ''
-    @result = @machines.fire_event_attributes(@object, :save) { @saved = true }
+    @transitions = @machines.transitions(@object, :save)
   end
   
-  def test_should_be_successful
-    assert_equal true, @result
+  def test_should_be_empty
+    assert @transitions.empty?
   end
   
-  def test_should_run_action
-    assert @saved
-  end
-  
-  def test_should_not_transition_state
-    assert_equal 'parked', @object.state
-  end
-  
-  def test_should_not_change_event_attribute
-    assert_nil @object.state_event
-  end
-  
-  def test_should_not_have_event_transition
-    assert_nil @object.send(:state_event_transition)
+  def test_should_perform
+    assert_equal true, @transitions.perform
   end
 end
 
-class MachineCollectionFireImplicitWithInvalidEventTest < MachineCollectionFireImplicitTest
+class MachineCollectionTransitionsWithInvalidEventsTest < Test::Unit::TestCase
   def setup
-    super
+    @klass = Class.new
     
-    @object.state_event = 'invalid'
-    @result = @machines.fire_event_attributes(@object, :save) { @saved = true }
-  end
-  
-  def test_should_not_be_successful
-    assert_equal false, @result
-  end
-  
-  def test_should_not_run_action
-    assert !@saved
-  end
-  
-  def test_should_not_transition_state
-    assert_equal 'parked', @object.state
-  end
-  
-  def test_should_not_reset_event_attribute
-    assert_equal :invalid, @object.state_event
-  end
-  
-  def test_should_not_have_event_transition
-    assert_nil @object.send(:state_event_transition)
-  end
-end
-
-class MachineCollectionFireImplicitWithoutTransitionTest < MachineCollectionFireImplicitTest
-  def setup
-    super
+    @machines = StateMachine::MachineCollection.new
+    @machines[:state] = @machine = StateMachine::Machine.new(@klass, :state, :initial => :parked, :action => :save)
+    @machine.event :ignite do
+      transition :parked => :idling
+    end
     
-    @object.state = 'idling'
-    @object.state_event = 'ignite'
-    @result = @machines.fire_event_attributes(@object, :save) { @saved = true }
-  end
-  
-  def test_should_not_be_successful
-    assert_equal false, @result
-  end
-  
-  def test_should_not_run_action
-    assert !@saved
-  end
-  
-  def test_should_not_transition_state
-    assert_equal 'idling', @object.state
+    @object = @klass.new
+    @object.state_event = 'invalid'
+    @transitions = @machines.transitions(@object, :save)
   end
   
-  def test_should_not_reset_event_attribute
-    assert_equal :ignite, @object.state_event
+  def test_should_be_empty
+    assert @transitions.empty?
   end
   
-  def test_should_not_have_event_transition
-    assert_nil @object.send(:state_event_transition)
+  def test_should_not_perform
+    assert_equal false, @transitions.perform
   end
 end
 
-class MachineCollectionFireImplicitWithTransitionTest < MachineCollectionFireImplicitTest
+class MachineCollectionTransitionsWithoutTransitionTest < Test::Unit::TestCase
   def setup
-    super
-    
-    @state_event = nil
+    @klass = Class.new
     
-    @object.state_event = 'ignite'
-    @result = @machines.fire_event_attributes(@object, :save) do
-      @state_event = @object.state_event
-      @saved = true
+    @machines = StateMachine::MachineCollection.new
+    @machines[:state] = @machine = StateMachine::Machine.new(@klass, :state, :initial => :parked, :action => :save)
+    @machine.event :ignite do
+      transition :parked => :idling
     end
-  end
-  
-  def test_should_be_successful
-    assert_equal true, @result
-  end
-  
-  def test_should_run_action
-    assert @saved
-  end
-  
-  def test_should_not_have_event_while_running_action
-    assert_nil @state_event
-  end
-  
-  def test_should_transition_state
-    assert_equal 'idling', @object.state
-  end
-  
-  def test_should_reset_event_attribute
-    assert_nil @object.state_event
-  end
-  
-  def test_should_not_have_event_transition
-    assert_nil @object.send(:state_event_transition)
-  end
-  
-  def test_should_not_be_successful_if_fired_again
-    @object.state_event = 'ignite'
-    assert !@machines.fire_event_attributes(@object, :save) { true }
-  end
-end
-
-class MachineCollectionFireImplicitWithNonBooleanResultTest < MachineCollectionFireImplicitTest
-  def setup
-    super
-    
-    @action_value = Object.new
     
+    @object = @klass.new
+    @object.state = 'idling'
     @object.state_event = 'ignite'
-    @result = @machines.fire_event_attributes(@object, :save) do
-      @saved = true
-      @action_value
-    end
+    @transitions = @machines.transitions(@object, :save)
   end
   
-  def test_should_be_successful
-    assert_equal @action_value, @result
+  def test_should_be_empty
+    assert @transitions.empty?
   end
   
-  def test_should_run_action
-    assert @saved
-  end
-  
-  def test_should_transition_state
-    assert_equal 'idling', @object.state
+  def test_should_not_perform
+    assert_equal false, @transitions.perform
   end
 end
 
-class MachineCollectionFireImplicitWithActionFailureTest < MachineCollectionFireImplicitTest
+class MachineCollectionTransitionsWithTransitionTest < Test::Unit::TestCase
   def setup
-    super
+    @klass = Class.new
     
-    @object.state_event = 'ignite'
-    @result = @machines.fire_event_attributes(@object, :save) { false }
-  end
-  
-  def test_should_not_be_successful
-    assert_equal false, @result
-  end
-  
-  def test_should_not_transition_state
-    assert_equal 'parked', @object.state
-  end
-  
-  def test_should_not_reset_event_attribute
-    assert_equal :ignite, @object.state_event
-  end
-  
-  def test_should_not_have_event_transition
-    assert_nil @object.send(:state_event_transition)
-  end
-end
-
-class MachineCollectionFireImplicitWithActionErrorTest < MachineCollectionFireImplicitTest
-  def setup
-    super
+    @machines = StateMachine::MachineCollection.new
+    @machines[:state] = @machine = StateMachine::Machine.new(@klass, :state, :initial => :parked, :action => :save)
+    @machine.event :ignite do
+      transition :parked => :idling
+    end
     
+    @object = @klass.new
     @object.state_event = 'ignite'
-    assert_raise(ArgumentError) { @machines.fire_event_attributes(@object, :save) { raise ArgumentError } }
+    @transitions = @machines.transitions(@object, :save)
   end
   
-  def test_should_not_transition_state
-    assert_equal 'parked', @object.state
-  end
-  
-  def test_should_not_reset_event_attribute
-    assert_equal :ignite, @object.state_event
+  def test_should_not_be_empty
+    assert_equal 1, @transitions.length
   end
   
-  def test_should_not_have_event_transition
-    assert_nil @object.send(:state_event_transition)
+  def test_should_perform
+    assert_equal true, @transitions.perform
   end
 end
 
-class MachineCollectionFireImplicitPartialTest < MachineCollectionFireImplicitTest
+class MachineCollectionTransitionsWithSameActionsTest < Test::Unit::TestCase
   def setup
-    super
-    
-    @state_event = nil
-    @state_event_transition = nil
+    @klass = Class.new
     
-    @object.state_event = 'ignite'
-    @result = @machines.fire_event_attributes(@object, :save, false) do
-      @state_event = @object.state_event
-      @state_event_transition = @object.send(:state_event_transition)
-      true
+    @machines = StateMachine::MachineCollection.new
+    @machines[:state] = @machine = StateMachine::Machine.new(@klass, :state, :initial => :parked, :action => :save)
+    @machine.event :ignite do
+      transition :parked => :idling
     end
-  end
-  
-  def test_should_be_successful
-    assert @result
-  end
-  
-  def test_should_not_have_event_while_running_action
-    assert_nil @state_event
-  end
-  
-  def test_should_not_have_event_transition_while_running_action
-    assert_nil @state_event_transition
-  end
-  
-  def test_should_transition_state
-    assert_equal 'idling', @object.state
-  end
-  
-  def test_should_reset_event_attribute
-    assert_nil @object.state_event
-  end
-  
-  def test_should_have_event_transition
-    assert_not_nil @object.send(:state_event_transition)
-  end
-  
-  def test_should_reset_event_after_next_fire_on_success
-    assert @machines.fire_event_attributes(@object, :save) { true }
-    assert_equal 'idling', @object.state
-    assert_nil @object.state_event
-  end
-  
-  def test_should_reset_event_transition_after_next_fire_on_success
-    assert @machines.fire_event_attributes(@object, :save) { true }
-    assert_nil @object.send(:state_event_transition)
-  end
-  
-  def test_should_guard_transition_after_next_fire_on_success
-    @machines.fire_event_attributes(@object, :save) { true }
-    
-    @object.state = 'idling'
-    @object.state_event = 'ignite'
-    assert !@machines.fire_event_attributes(@object, :save) { true }
-  end
-  
-  def test_should_rollback_all_attributes_after_next_fire_on_failure
-    assert !@machines.fire_event_attributes(@object, :save) { false }
-    assert_equal 'parked', @object.state
-    assert_equal :ignite, @object.state_event
-    assert_nil @object.send(:state_event_transition)
-    
-    @object.state = 'idling'
-    assert !@machines.fire_event_attributes(@object, :save) { false }
-  end
-  
-  def test_should_guard_transition_after_next_fire_on_failure
-    @machines.fire_event_attributes(@object, :save) { false }
-    
-    @object.state = 'idling'
-    assert !@machines.fire_event_attributes(@object, :save) { true }
-  end
-  
-  def test_should_rollback_all_attributes_after_next_fire_on_error
-    assert_raise(ArgumentError) { @machines.fire_event_attributes(@object, :save) { raise ArgumentError } }
-    assert_equal 'parked', @object.state
-    assert_equal :ignite, @object.state_event
-    assert_nil @object.send(:state_event_transition)
-  end
-  
-  def test_should_guard_transition_after_next_fire_on_error
-    begin
-      @machines.fire_event_attributes(@object, :save) { raise ArgumentError }
-    rescue ArgumentError
+    @machines[:status] = @machine = StateMachine::Machine.new(@klass, :status, :initial => :first_gear, :action => :save)
+    @machine.event :shift_up do
+      transition :first_gear => :second_gear
     end
     
-    @object.state = 'idling'
-    assert !@machines.fire_event_attributes(@object, :save) { true }
-  end
-end
-
-class MachineCollectionFireImplicitPartialWithCallbacksTest < MachineCollectionFireImplicitTest
-  def setup
-    super
-    
+    @object = @klass.new
     @object.state_event = 'ignite'
+    @object.status_event = 'shift_up'
+    @transitions = @machines.transitions(@object, :save)
   end
   
-  def test_should_run_before_callbacks
-    ran_callback = false
-    @machine.before_transition { ran_callback = true }
-    @machines.fire_event_attributes(@object, :save, false) { true }
-    
-    assert ran_callback
-  end
-  
-  def test_should_not_have_event_during_before_callbacks
-    state_event = nil
-    @machine.before_transition {|object, transition| state_event = object.state_event }
-    @machines.fire_event_attributes(@object, :save, false) { true }
-    
-    assert_nil state_event
-  end
-  
-  def test_should_not_have_event_transition_during_before_callbacks
-    state_event_transition = nil
-    @machine.before_transition {|object, transition| state_event_transition = object.send(:state_event_transition) }
-    @machines.fire_event_attributes(@object, :save, false) { true }
-    
-    assert_nil state_event_transition
+  def test_should_not_be_empty
+    assert_equal 2, @transitions.length
   end
   
-  def test_should_not_run_after_callbacks
-    ran_callback = false
-    @machine.after_transition { ran_callback = true }
-    @machines.fire_event_attributes(@object, :save, false) { true }
-    
-    assert !ran_callback
-  end
-  
-  def test_should_not_have_event_during_after_callbacks
-    state_event = nil
-    @machine.after_transition {|object, transition| state_event = object.state_event }
-    @machines.fire_event_attributes(@object, :save, false) { true }
-    
-    assert_nil state_event
-  end
-  
-  def test_should_not_have_event_transition_during_after_callbacks
-    state_event_transition = nil
-    @machine.after_transition {|object, transition| state_event_transition = object.send(:state_event_transition) }
-    @machines.fire_event_attributes(@object, :save, false) { true }
-    
-    assert_nil state_event_transition
+  def test_should_perform
+    assert_equal true, @transitions.perform
   end
 end
 
-class MachineCollectionFireImplicitNestedPartialTest < MachineCollectionFireImplicitTest
+class MachineCollectionTransitionsWithDifferentActionsTest < Test::Unit::TestCase
   def setup
-    super
+    @klass = Class.new
     
-    @partial_result = nil
+    @machines = StateMachine::MachineCollection.new
+    @machines[:state] = @state = StateMachine::Machine.new(@klass, :state, :initial => :parked, :action => :save)
+    @state.event :ignite do
+      transition :parked => :idling
+    end
+    @machines[:status] = @status = StateMachine::Machine.new(@klass, :status, :initial => :first_gear, :action => :persist)
+    @status.event :shift_up do
+      transition :first_gear => :second_gear
+    end
     
+    @object = @klass.new
     @object.state_event = 'ignite'
-    @result = @machines.fire_event_attributes(@object, :save) do
-      @partial_result = @machines.fire_event_attributes(@object, :save, false) { true }
-      true
-    end
-  end
-  
-  def test_should_be_successful
-    assert @result
-  end
-  
-  def test_should_have_successful_partial_fire
-    assert @partial_result
-  end
-  
-  def test_should_transition_state
-    assert_equal 'idling', @object.state
+    @object.status_event = 'shift_up'
+    @transitions = @machines.transitions(@object, :save)
   end
   
-  def test_should_reset_event_attribute
-    assert_nil @object.state_event
-  end
-  
-  def test_should_reset_event_transition_attribute
-    assert_nil @object.send(:state_event_transition)
+  def test_should_only_select_matching_actions
+    assert_equal 1, @transitions.length
   end
 end
 
-class MachineCollectionFireImplicitWithDifferentActionsTest < MachineCollectionFireImplicitTest
+class MachineCollectionTransitionsWithExisitingTransitionsTest < Test::Unit::TestCase
   def setup
-    super
+    @klass = Class.new
     
-    @machines[:alarm_state] = @alarm_machine = StateMachine::Machine.new(@klass, :alarm_state, :initial => :active, :action => :save_alarm)
-    @alarm_machine.event :disable do
-      transition :active => :off
+    @machines = StateMachine::MachineCollection.new
+    @machines[:state] = @machine = StateMachine::Machine.new(@klass, :state, :initial => :parked, :action => :save)
+    @machine.event :ignite do
+      transition :parked => :idling
     end
     
-    @saved = false
     @object = @klass.new
-    @object.state_event = 'ignite'
-    @object.alarm_state_event = 'disable'
-    
-    @machines.fire_event_attributes(@object, :save) { true }
-  end
-  
-  def test_should_transition_states_for_action
-    assert_equal 'idling', @object.state
+    @object.send(:state_event_transition=, StateMachine::Transition.new(@object, @machine, :ignite, :parked, :idling))
+    @transitions = @machines.transitions(@object, :save)
   end
   
-  def test_should_reset_event_attribute_for_action
-    assert_nil @object.state_event
-  end
-  
-  def test_should_reset_event_transition_attribute_for_action
-    assert_nil @object.send(:state_event_transition)
-  end
-  
-  def test_should_not_transition_states_for_other_actions
-    assert_equal 'active', @object.alarm_state
+  def test_should_not_be_empty
+    assert_equal 1, @transitions.length
   end
   
-  def test_should_not_reset_event_attributes_for_other_actions
-    assert_equal :disable, @object.alarm_state_event
+  def test_should_perform
+    assert_equal true, @transitions.perform
   end
 end
 
-class MachineCollectionFireImplicitWithSameActionsTest < MachineCollectionFireImplicitTest
+class MachineCollectionTransitionsWithCustomOptionsTest < Test::Unit::TestCase
   def setup
-    super
+    @klass = Class.new
     
-    @machines[:alarm_state] = @alarm_machine = StateMachine::Machine.new(@klass, :alarm_state, :initial => :active, :action => :save)
-    @alarm_machine.event :disable do
-      transition :active => :off
+    @machines = StateMachine::MachineCollection.new
+    @machines[:state] = @machine = StateMachine::Machine.new(@klass, :state, :initial => :parked, :action => :save)
+    @machine.event :ignite do
+      transition :parked => :idling
     end
     
-    @saved = false
     @object = @klass.new
-    @object.state_event = 'ignite'
-    @object.alarm_state_event = 'disable'
-    
-    @machines.fire_event_attributes(@object, :save) { true }
+    @transitions = @machines.transitions(@object, :save, :after => false)
   end
   
-  def test_should_transition_all_states_for_action
-    assert_equal 'idling', @object.state
-    assert_equal 'off', @object.alarm_state
-  end
-  
-  def test_should_reset_all_event_attributes_for_action
-    assert_nil @object.state_event
-    assert_nil @object.alarm_state_event
+  def test_should_use_custom_options
+    assert @transitions.skip_after
   end
 end
 
-class MachineCollectionFireImplicitWithValidationsTest < Test::Unit::TestCase
+class MachineCollectionFireAttributesWithValidationsTest < Test::Unit::TestCase
   def setup
-    StateMachine::Integrations.const_set('Custom', Module.new do
-      def invalidate(object, attribute, message, values = [])
-        (object.errors ||= []) << generate_message(message, values)
-      end
-      
-      def reset(object)
-        object.errors = []
-      end
-    end)
-    
     @klass = Class.new do
       attr_accessor :errors
       
@@ -805,17 +523,27 @@ class MachineCollectionFireImplicitWithValidationsTest < Test::Unit::TestCase
     end
     
     @machines = StateMachine::MachineCollection.new
-    @machines[:state] = @machine = StateMachine::Machine.new(@klass, :state, :initial => :parked, :action => :save, :integration => :custom)
+    @machines[:state] = @machine = StateMachine::Machine.new(@klass, :state, :initial => :parked, :action => :save)
     @machine.event :ignite do
       transition :parked => :idling
     end
     
+    class << @machine
+      def invalidate(object, attribute, message, values = [])
+        (object.errors ||= []) << generate_message(message, values)
+      end
+      
+      def reset(object)
+        object.errors = []
+      end
+    end
+    
     @object = @klass.new
   end
   
   def test_should_invalidate_if_event_is_invalid
     @object.state_event = 'invalid'
-    @machines.fire_event_attributes(@object, :save) { true }
+    @machines.transitions(@object, :save)
     
     assert !@object.errors.empty?
   end
@@ -823,116 +551,15 @@ class MachineCollectionFireImplicitWithValidationsTest < Test::Unit::TestCase
   def test_should_invalidate_if_no_transition_exists
     @object.state = 'idling'
     @object.state_event = 'ignite'
-    @machines.fire_event_attributes(@object, :save) { true }
+    @machines.transitions(@object, :save)
     
     assert !@object.errors.empty?
   end
   
   def test_should_not_invalidate_if_transition_exists
     @object.state_event = 'ignite'
-    @machines.fire_event_attributes(@object, :save) { true }
+    @machines.transitions(@object, :save)
     
     assert @object.errors.empty?
   end
-  
-  def teardown
-    StateMachine::Integrations.send(:remove_const, 'Custom')
-  end
-end
-
-class MachineCollectionFireImplicitWithCustomMachineNameTest < MachineCollectionFireImplicitTest
-  def setup
-    super
-    
-    @object.state_event = 'ignite'
-  end
-  
-  def test_should_be_successful_on_complete_file
-    assert @machines.fire_event_attributes(@object, :save) { true }
-    assert_equal 'idling', @object.state
-    assert_nil @object.state_event
-    assert_nil @object.send(:state_event_transition)
-  end
-  
-  def test_should_be_successful_on_partial_fire
-    @machines.fire_event_attributes(@object, :save, false) { true }
-    assert_equal 'idling', @object.state
-    assert_nil @object.state_event
-    assert_not_nil @object.send(:state_event_transition)
-  end
-end
-
-class MachineFireImplicitWithMarshallingTest < MachineCollectionFireImplicitTest
-  def setup
-    super
-    self.class.const_set('Example', @klass)
-    
-    @object.state_event = 'ignite'
-  end
-  
-  def test_should_marshal_during_before_callbacks
-    @machine.before_transition {|object, transition| Marshal.dump(object)}
-    assert_nothing_raised { @machines.fire_event_attributes(@object, :save) { true } }
-  end
-  
-  def test_should_marshal_during_action
-    assert_nothing_raised do
-      @machines.fire_event_attributes(@object, :save) do
-         Marshal.dump(@object)
-         true
-      end
-    end
-  end
-  
-  def test_should_marshal_during_after_callbacks
-    @machine.after_transition {|object, transition| Marshal.dump(object)}
-    assert_nothing_raised { @machines.fire_event_attributes(@object, :save) { true } }
-  end
-  
-  def teardown
-    self.class.send(:remove_const, 'Example')
-  end
-end
-
-class MachineFireImplicitPartialWithMarshallingTest < MachineCollectionFireImplicitTest
-  def setup
-    super
-    self.class.const_set('Example', @klass)
-    
-    @object.state_event = 'ignite'
-  end
-  
-  def test_should_marshal_during_before_callbacks
-    @machine.before_transition {|object, transition| Marshal.dump(object)}
-    assert_nothing_raised do
-      @machines.fire_event_attributes(@object, :save, false) { true }
-      @machines.fire_event_attributes(@object, :save) { true }
-    end
-  end
-  
-  def test_should_marshal_during_action
-    assert_nothing_raised do
-      @machines.fire_event_attributes(@object, :save, false) do
-         Marshal.dump(@object)
-         true
-      end
-      
-      @machines.fire_event_attributes(@object, :save) do
-         Marshal.dump(@object)
-         true
-      end
-    end
-  end
-  
-  def test_should_marshal_during_after_callbacks
-    @machine.after_transition {|object, transition| Marshal.dump(object)}
-    assert_nothing_raised do
-      @machines.fire_event_attributes(@object, :save, false) { true }
-      @machines.fire_event_attributes(@object, :save) { true }
-    end
-  end
-  
-  def teardown
-    self.class.send(:remove_const, 'Example')
-  end
 end