state_machine 0.8.1 → 0.9.0

data/test/unit/transition_test.rb

@@ -61,6 +61,10 @@ class TransitionTest < Test::Unit::TestCase
     assert_nil @transition.action
   end
   
+  def test_should_not_be_transient
+    assert_equal false, @transition.transient?
+  end
+  
   def test_should_generate_attributes
     expected = {:object => @object, :attribute => :state, :event => :ignite, :from => 'parked', :to => 'idling'}
     assert_equal expected, @transition.attributes
@@ -350,16 +354,9 @@ class TransitionAfterBeingRolledBackTest < Test::Unit::TestCase
   end
 end
 
-class TransitionWithCallbacksTest < Test::Unit::TestCase
+class TransitionWithoutCallbacksTest < Test::Unit::TestCase
   def setup
-    @klass = Class.new do
-      attr_reader :saved, :save_state
-      
-      def save
-        @save_state = state
-        @saved = true
-      end
-    end
+    @klass = Class.new
     
     @machine = StateMachine::Machine.new(@klass)
     @machine.state :parked, :idling
@@ -370,24 +367,47 @@ class TransitionWithCallbacksTest < Test::Unit::TestCase
     @transition = StateMachine::Transition.new(@object, @machine, :ignite, :parked, :idling)
   end
   
-  def test_should_run_before_callbacks_on_before
-    @machine.before_transition(lambda {|object| @run = true})
-    result = @transition.before
+  def test_should_succeed
+    assert_equal true, @transition.run_callbacks
+  end
+  
+  def test_should_succeed_if_after_callbacks_skipped
+    assert_equal true, @transition.run_callbacks(:after => false)
+  end
+  
+  def test_should_call_block_if_provided
+    @transition.run_callbacks { @ran_block = true; {} }
+    assert @ran_block
+  end
+  
+  def test_should_track_block_result
+    @transition.run_callbacks {{:result => 1}}
+    assert_equal 1, @transition.result
+  end
+end
+
+class TransitionWithBeforeCallbacksTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
     
-    assert_equal true, result
-    assert_equal true, @run
+    @machine = StateMachine::Machine.new(@klass)
+    @machine.state :parked, :idling
+    @machine.event :ignite
+    
+    @object = @klass.new
+    @object.state = 'parked'
+    @transition = StateMachine::Transition.new(@object, @machine, :ignite, :parked, :idling)
   end
   
-  def test_should_run_before_callbacks_in_the_order_they_were_defined
-    @callbacks = []
-    @machine.before_transition(lambda {@callbacks << 1})
-    @machine.before_transition(lambda {@callbacks << 2})
-    @transition.before
+  def test_should_run_before_callbacks
+    @machine.before_transition {@run = true}
+    result = @transition.run_callbacks
     
-    assert_equal [1, 2], @callbacks
+    assert_equal true, result
+    assert_equal true, @run
   end
   
-  def test_should_only_run_before_callbacks_that_match_transition_context
+  def test_should_only_run_those_that_match_transition_context
     @count = 0
     callback = lambda {@count += 1}
     
@@ -395,76 +415,142 @@ class TransitionWithCallbacksTest < Test::Unit::TestCase
     @machine.before_transition :from => :parked, :to => :parked, :on => :park, :do => callback
     @machine.before_transition :from => :parked, :to => :idling, :on => :ignite, :do => callback
     @machine.before_transition :from => :idling, :to => :idling, :on => :park, :do => callback
-    @transition.before
+    @transition.run_callbacks
     
     assert_equal 1, @count
   end
   
-  def test_should_pass_transition_to_before_callbacks
-    @machine.before_transition(lambda {|*args| @args = args})
-    @transition.before
+  def test_should_pass_transition_as_argument
+    @machine.before_transition {|*args| @args = args}
+    @transition.run_callbacks
     
     assert_equal [@object, @transition], @args
   end
   
-  def test_should_catch_halted_before_callbacks
-    @machine.before_transition(lambda {throw :halt})
+  def test_should_catch_halts
+    @machine.before_transition {throw :halt}
     
     result = nil
-    assert_nothing_thrown { result = @transition.before }
+    assert_nothing_thrown { result = @transition.run_callbacks }
     assert_equal false, result
   end
   
-  def test_should_run_before_callbacks_on_perform_before_changing_the_state
-    @machine.before_transition(lambda {|object| @state = object.state})
-    @transition.perform
-    
-    assert_equal 'parked', @state
+  def test_should_not_catch_exceptions
+    @machine.before_transition {raise ArgumentError}
+    assert_raise(ArgumentError) { @transition.run_callbacks }
   end
   
-  def test_should_not_be_able_to_run_before_callbacks_twice
+  def test_should_not_be_able_to_run_twice
     @count = 0
-    @machine.before_transition(lambda {@count += 1})
-    @transition.before
-    @transition.before
+    @machine.before_transition {@count += 1}
+    @transition.run_callbacks
+    @transition.run_callbacks
     assert_equal 1, @count
   end
   
-  def test_should_be_able_to_run_before_callbacks_again_after_resetting
+  def test_should_be_able_to_run_again_after_halt
+    @count = 0
+    @machine.before_transition {@count += 1; throw :halt}
+    @transition.run_callbacks
+    @transition.run_callbacks
+    assert_equal 2, @count
+  end
+  
+  def test_should_be_able_to_run_again_after_resetting
     @count = 0
-    @machine.before_transition(lambda {@count += 1})
-    @transition.before
+    @machine.before_transition {@count += 1}
+    @transition.run_callbacks
     @transition.reset
-    @transition.before
+    @transition.run_callbacks
     assert_equal 2, @count
   end
   
-  def test_should_run_after_callbacks_on_after
-    @machine.after_transition(lambda {|object| @run = true})
-    result = @transition.after(true)
-    
-    assert_equal true, result
-    assert_equal true, @run
+  def test_should_succeed_if_block_result_is_false
+    @machine.before_transition {@run = true}
+    assert_equal true, @transition.run_callbacks {{:result => false}}
+    assert @run
   end
   
-  def test_should_set_result_on_after
-    @transition.after
-    assert_nil @transition.result
+  def test_should_succeed_if_block_result_is_true
+    @machine.before_transition {@run = true}
+    assert_equal true, @transition.run_callbacks {{:result => true}}
+    assert @run
+  end
+  
+  def test_should_succeed_if_block_success_is_false
+    @machine.before_transition {@run = true}
+    assert_equal true, @transition.run_callbacks {{:success => false}}
+    assert @run
+  end
+  
+  def test_should_succeed_if_block_success_is_false
+    @machine.before_transition {@run = true}
+    assert_equal true, @transition.run_callbacks {{:success => true}}
+    assert @run
+  end
+end
+
+class TransitionWithMultipleBeforeCallbacksTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
     
-    @transition.after(1)
-    assert_equal 1, @transition.result
+    @machine = StateMachine::Machine.new(@klass)
+    @machine.state :parked, :idling
+    @machine.event :ignite
+    
+    @object = @klass.new
+    @object.state = 'parked'
+    @transition = StateMachine::Transition.new(@object, @machine, :ignite, :parked, :idling)
   end
   
-  def test_should_run_after_callbacks_in_the_order_they_were_defined
+  def test_should_run_in_the_order_they_were_defined
     @callbacks = []
-    @machine.after_transition(lambda {@callbacks << 1})
-    @machine.after_transition(lambda {@callbacks << 2})
-    @transition.after(true)
+    @machine.before_transition {@callbacks << 1}
+    @machine.before_transition {@callbacks << 2}
+    @transition.run_callbacks
     
     assert_equal [1, 2], @callbacks
   end
   
-  def test_should_only_run_after_callbacks_that_match_transition_context
+  def test_should_not_run_further_callbacks_if_halted
+    @callbacks = []
+    @machine.before_transition {@callbacks << 1; throw :halt}
+    @machine.before_transition {@callbacks << 2}
+    
+    assert_equal false, @transition.run_callbacks
+    assert_equal [1], @callbacks
+  end
+  
+  def test_should_fail_if_any_callback_halted
+    @machine.before_transition {true}
+    @machine.before_transition {throw :halt}
+    
+    assert_equal false, @transition.run_callbacks
+  end
+end
+
+class TransitionWithAfterCallbacksTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    
+    @machine = StateMachine::Machine.new(@klass)
+    @machine.state :parked, :idling
+    @machine.event :ignite
+    
+    @object = @klass.new
+    @object.state = 'parked'
+    @transition = StateMachine::Transition.new(@object, @machine, :ignite, :parked, :idling)
+  end
+  
+  def test_should_run_after_callbacks
+    @machine.after_transition {|object| @run = true}
+    result = @transition.run_callbacks
+    
+    assert_equal true, result
+    assert_equal true, @run
+  end
+  
+  def test_should_only_run_those_that_match_transition_context
     @count = 0
     callback = lambda {@count += 1}
     
@@ -472,119 +558,125 @@ class TransitionWithCallbacksTest < Test::Unit::TestCase
     @machine.after_transition :from => :parked, :to => :parked, :on => :park, :do => callback
     @machine.after_transition :from => :parked, :to => :idling, :on => :ignite, :do => callback
     @machine.after_transition :from => :idling, :to => :idling, :on => :park, :do => callback
-    @transition.after(true)
+    @transition.run_callbacks
     
     assert_equal 1, @count
   end
   
-  def test_should_not_run_after_callbacks_if_not_successful
-    @machine.after_transition(lambda {|object| @run = true})
-    @transition.after(nil, false)
+  def test_should_not_run_if_not_successful
+    @machine.after_transition {|object| @run = true}
+    @transition.run_callbacks {{:success => false}}
     assert !@run
   end
   
-  def test_should_pass_transition_to_after_callbacks
-    @machine.after_transition(lambda {|*args| @args = args})
-    
-    @transition.after(true)
-    assert_equal [@object, @transition], @args
-    assert_equal true, @transition.result
+  def test_should_run_if_not_successful_and_includes_failures
+    @machine.after_transition(:include_failures => true) {|object| @run = true}
+    @transition.run_callbacks {{:success => false}}
+    assert @run
+  end
+  
+  def test_should_run_if_successful
+    @machine.after_transition {|object| @run = true}
+    @transition.run_callbacks {{:success => true}}
+    assert @run
+  end
+  
+  def test_should_run_if_successful_and_includes_failures
+    @machine.after_transition(:include_failures => true) {|object| @run = true}
+    @transition.run_callbacks {{:success => true}}
+    assert @run
+  end
+  
+  def test_should_pass_transition_as_argument
+    @machine.after_transition {|*args| @args = args}
     
-    @transition.after(false)
+    @transition.run_callbacks
     assert_equal [@object, @transition], @args
-    assert_equal false, @transition.result
   end
   
-  def test_should_catch_halted_after_callbacks
-    @machine.after_transition(lambda {throw :halt})
+  def test_should_catch_halts
+    @machine.after_transition {throw :halt}
     
     result = nil
-    assert_nothing_thrown { result = @transition.after(true) }
+    assert_nothing_thrown { result = @transition.run_callbacks }
     assert_equal true, result
   end
   
-  def test_should_run_after_callbacks_on_perform_after_running_the_action
-    @machine.after_transition(lambda {|object| @state = object.state})
-    @transition.perform(true)
-    
-    assert_equal 'idling', @state
+  def test_should_not_catch_exceptions
+    @machine.after_transition {raise ArgumentError}
+    assert_raise(ArgumentError) { @transition.run_callbacks }
+  end
+  
+  def test_should_not_be_able_to_run_twice
+    @count = 0
+    @machine.after_transition {@count += 1}
+    @transition.run_callbacks
+    @transition.run_callbacks
+    assert_equal 1, @count
   end
   
-  def test_should_not_be_able_to_run_after_callbacks_twice
+  def test_should_not_be_able_to_run_twice_if_halted
     @count = 0
-    @machine.after_transition(lambda {@count += 1})
-    @transition.after
-    @transition.after
+    @machine.after_transition {@count += 1; throw :halt}
+    @transition.run_callbacks
+    @transition.run_callbacks
     assert_equal 1, @count
   end
   
-  def test_should_be_able_to_run_after_callbacks_again_after_resetting
+  def test_should_be_able_to_run_again_after_resetting
     @count = 0
-    @machine.after_transition(lambda {@count += 1})
-    @transition.after
+    @machine.after_transition {@count += 1}
+    @transition.run_callbacks
     @transition.reset
-    @transition.after
+    @transition.run_callbacks
     assert_equal 2, @count
   end
 end
 
-class TransitionAfterBeingPerformedTest < Test::Unit::TestCase
+class TransitionWithMultipleAfterCallbacksTest < Test::Unit::TestCase
   def setup
-    @klass = Class.new do
-      attr_reader :saved, :save_state
-      
-      def save
-        @save_state = state
-        @saved = true
-      end
-    end
+    @klass = Class.new
     
-    @machine = StateMachine::Machine.new(@klass, :action => :save)
+    @machine = StateMachine::Machine.new(@klass)
     @machine.state :parked, :idling
     @machine.event :ignite
     
     @object = @klass.new
     @object.state = 'parked'
     @transition = StateMachine::Transition.new(@object, @machine, :ignite, :parked, :idling)
-    @result = @transition.perform
-  end
-  
-  def test_should_have_empty_args
-    assert_equal [], @transition.args
-  end
-  
-  def test_should_have_a_result
-    assert_equal true, @transition.result
-  end
-  
-  def test_should_be_successful
-    assert_equal true, @result
   end
   
-  def test_should_change_the_current_state
-    assert_equal 'idling', @object.state
+  def test_should_run_in_the_order_they_were_defined
+    @callbacks = []
+    @machine.after_transition {@callbacks << 1}
+    @machine.after_transition {@callbacks << 2}
+    @transition.run_callbacks
+    
+    assert_equal [1, 2], @callbacks
   end
   
-  def test_should_run_the_action
-    assert @object.saved
+  def test_should_not_run_further_callbacks_if_halted
+    @callbacks = []
+    @machine.after_transition {@callbacks << 1; throw :halt}
+    @machine.after_transition {@callbacks << 2}
+    
+    assert_equal true, @transition.run_callbacks
+    assert_equal [1], @callbacks
   end
   
-  def test_should_run_the_action_after_saving_the_state
-    assert_equal 'idling', @object.save_state
+  def test_should_fail_if_any_callback_halted
+    @machine.after_transition {true}
+    @machine.after_transition {throw :halt}
+    
+    assert_equal true, @transition.run_callbacks
   end
 end
 
-class TransitionWithPerformArgumentsTest < Test::Unit::TestCase
+class TransitionWithAroundCallbacksTest < Test::Unit::TestCase
   def setup
-    @klass = Class.new do
-      attr_reader :saved
-      
-      def save
-        @saved = true
-      end
-    end
+    @klass = Class.new
     
-    @machine = StateMachine::Machine.new(@klass, :action => :save)
+    @machine = StateMachine::Machine.new(@klass)
     @machine.state :parked, :idling
     @machine.event :ignite
     
@@ -593,308 +685,551 @@ class TransitionWithPerformArgumentsTest < Test::Unit::TestCase
     @transition = StateMachine::Transition.new(@object, @machine, :ignite, :parked, :idling)
   end
   
-  def test_should_have_arguments
-    @transition.perform(1, 2)
+  def test_should_run_around_callbacks
+    @machine.around_transition {|object, transition, block| @run_before = true; block.call; @run_after = true}
+    result = @transition.run_callbacks
     
-    assert_equal [1, 2], @transition.args
-    assert @object.saved
+    assert_equal true, result
+    assert_equal true, @run_before
+    assert_equal true, @run_after
   end
   
-  def test_should_not_include_run_action_in_arguments
-    @transition.perform(1, 2, false)
+  def test_should_only_run_those_that_match_transition_context
+    @count = 0
+    callback = lambda {|object, transition, block| @count += 1; block.call}
     
-    assert_equal [1, 2], @transition.args
-    assert !@object.saved
+    @machine.around_transition :from => :parked, :to => :idling, :on => :park, :do => callback
+    @machine.around_transition :from => :parked, :to => :parked, :on => :park, :do => callback
+    @machine.around_transition :from => :parked, :to => :idling, :on => :ignite, :do => callback
+    @machine.around_transition :from => :idling, :to => :idling, :on => :park, :do => callback
+    @transition.run_callbacks
+    
+    assert_equal 1, @count
   end
-end
-
-class TransitionWithoutRunningActionTest < Test::Unit::TestCase
-  def setup
-    @klass = Class.new do
-      attr_reader :saved
-      
-      def save
-        @saved = true
-      end
-    end
+  
+  def test_should_pass_transition_as_argument
+    @machine.around_transition {|*args| block = args.pop; @args = args; block.call}
+    @transition.run_callbacks
     
-    @machine = StateMachine::Machine.new(@klass, :action => :save)
-    @machine.state :parked, :idling
-    @machine.event :ignite
-    @machine.after_transition(lambda {|object| @run_after = true})
+    assert_equal [@object, @transition], @args
+  end
+  
+  def test_should_run_block_between_callback
+    @callbacks = []
+    @machine.around_transition {|block| @callbacks << :before; block.call; @callbacks << :after}
+    @transition.run_callbacks { @callbacks << :within; {:success => true} }
     
-    @object = @klass.new
-    @object.state = 'parked'
-    @transition = StateMachine::Transition.new(@object, @machine, :ignite, :parked, :idling)
-    @result = @transition.perform(false)
+    assert_equal [:before, :within, :after], @callbacks
   end
   
-  def test_should_have_empty_args
-    assert_equal [], @transition.args
+  def test_should_have_access_to_result_after_yield
+    @machine.around_transition {|block| @before_result = @transition.result; block.call; @after_result = @transition.result}
+    @transition.run_callbacks {{:result => 1, :success => true}}
+    
+    assert_nil @before_result
+    assert_equal 1, @after_result
   end
   
-  def test_should_not_have_a_result
-    assert_nil @transition.result
+  def test_should_catch_before_yield_halts
+    @machine.around_transition {throw :halt}
+    
+    result = nil
+    assert_nothing_thrown { result = @transition.run_callbacks }
+    assert_equal false, result
   end
   
-  def test_should_be_successful
-    assert_equal true, @result
+  def test_should_catch_after_yield_halts
+    @machine.around_transition {|block| block.call; throw :halt}
+    
+    result = nil
+    assert_nothing_thrown { result = @transition.run_callbacks }
+    assert_equal true, result
   end
   
-  def test_should_change_the_current_state
-    assert_equal 'idling', @object.state
+  def test_should_not_catch_before_yield
+    @machine.around_transition {raise ArgumentError}
+    assert_raise(ArgumentError) { @transition.run_callbacks }
   end
   
-  def test_should_not_run_the_action
-    assert !@object.saved
+  def test_should_not_catch_after_yield
+    @machine.around_transition {|block| block.call; raise ArgumentError}
+    assert_raise(ArgumentError) { @transition.run_callbacks }
   end
   
-  def test_should_run_after_callbacks
-    assert @run_after
+  def test_should_fail_if_not_yielded
+    @machine.around_transition {}
+    
+    result = nil
+    assert_nothing_thrown { result = @transition.run_callbacks }
+    assert_equal false, result
+  end
+  
+  def test_should_not_be_able_to_run_twice
+    @before_count = 0
+    @after_count = 0
+    @machine.around_transition {|block| @before_count += 1; block.call; @after_count += 1}
+    @transition.run_callbacks
+    @transition.run_callbacks
+    assert_equal 1, @before_count
+    assert_equal 1, @after_count
+  end
+  
+  def test_should_be_able_to_run_again_after_resetting
+    @before_count = 0
+    @after_count = 0
+    @machine.around_transition {|block| @before_count += 1; block.call; @after_count += 1}
+    @transition.run_callbacks
+    @transition.reset
+    @transition.run_callbacks
+    assert_equal 2, @before_count
+    assert_equal 2, @after_count
+  end
+  
+  def test_should_succeed_if_block_result_is_false
+    @machine.around_transition {|block| @before_run = true; block.call; @after_run = true}
+    assert_equal true, @transition.run_callbacks {{:success => true, :result => false}}
+    assert @before_run
+    assert @after_run
+  end
+  
+  def test_should_succeed_if_block_result_is_true
+    @machine.around_transition {|block| @before_run = true; block.call; @after_run = true}
+    assert_equal true, @transition.run_callbacks {{:success => true, :result => true}}
+    assert @before_run
+    assert @after_run
+  end
+  
+  def test_should_only_run_before_if_block_success_is_false
+    @machine.around_transition {|block| @before_run = true; block.call; @after_run = true}
+    assert_equal true, @transition.run_callbacks {{:success => false}}
+    assert @before_run
+    assert !@after_run
+  end
+  
+  def test_should_succeed_if_including_failure_and_block_success_is_false
+    @machine.around_transition(:include_failures => true) {|block| @before_run = true; block.call; @after_run = true}
+    assert_equal true, @transition.run_callbacks {{:success => false}}
+    assert @before_run
+    assert @after_run
+  end
+  
+  def test_should_succeed_if_block_success_is_false
+    @machine.around_transition {|block| @before_run = true; block.call; @after_run = true}
+    assert_equal true, @transition.run_callbacks {{:success => true}}
+    assert @before_run
+    assert @after_run
   end
 end
 
-class TransitionWithTransactionsTest < Test::Unit::TestCase
+class TransitionWithMultipleAroundCallbacksTest < Test::Unit::TestCase
   def setup
-    @klass = Class.new do
-      class << self
-        attr_accessor :running_transaction
-      end
-      
-      attr_accessor :result
-      
-      def save
-        @result = self.class.running_transaction
-        true
-      end
-    end
+    @klass = Class.new
     
-    @machine = StateMachine::Machine.new(@klass, :action => :save)
+    @machine = StateMachine::Machine.new(@klass)
     @machine.state :parked, :idling
     @machine.event :ignite
     
     @object = @klass.new
     @object.state = 'parked'
     @transition = StateMachine::Transition.new(@object, @machine, :ignite, :parked, :idling)
-    
-    class << @machine
-      def within_transaction(object)
-        owner_class.running_transaction = object
-        yield
-        owner_class.running_transaction = false
-      end
-    end
   end
   
-  def test_should_run_blocks_within_transaction_for_object
-    @transition.within_transaction do
-      @result = @klass.running_transaction
-    end
+  def test_should_before_yield_in_the_order_they_were_defined
+    @callbacks = []
+    @machine.around_transition {|block| @callbacks << 1; block.call}
+    @machine.around_transition {|block| @callbacks << 2; block.call}
+    @transition.run_callbacks
     
-    assert_equal @object, @result
+    assert_equal [1, 2], @callbacks
   end
   
-  def test_should_run_before_callbacks_within_transaction
-    @machine.before_transition(lambda {|object| @result = @klass.running_transaction})
-    @transition.perform
+  def test_should_before_yield_multiple_methods_in_the_order_they_were_defined
+    @callbacks = []
+    @machine.around_transition(lambda {|block| @callbacks << 1; block.call}, lambda {|block| @callbacks << 2; block.call})
+    @machine.around_transition(lambda {|block| @callbacks << 3; block.call}, lambda {|block| @callbacks << 4; block.call})
+    @transition.run_callbacks
     
-    assert_equal @object, @result
+    assert_equal [1, 2, 3, 4], @callbacks
   end
   
-  def test_should_run_action_within_transaction
-    @transition.perform
+  def test_should_after_yield_in_the_reverse_order_they_were_defined
+    @callbacks = []
+    @machine.around_transition {|block| block.call; @callbacks << 1}
+    @machine.around_transition {|block| block.call; @callbacks << 2}
+    @transition.run_callbacks
     
-    assert_equal @object, @object.result
+    assert_equal [2, 1], @callbacks
   end
   
-  def test_should_run_after_callbacks_within_transaction
-    @machine.after_transition(lambda {|object| @result = @klass.running_transaction})
-    @transition.perform
+  def test_should_after_yield_multiple_methods_in_the_reverse_order_they_were_defined
+    @callbacks = []
+    @machine.around_transition(lambda {|block| block.call; @callbacks << 1}) {|block| block.call; @callbacks << 2}
+    @machine.around_transition(lambda {|block| block.call; @callbacks << 3}) {|block| block.call; @callbacks << 4}
+    @transition.run_callbacks
     
-    assert_equal @object, @result
+    assert_equal [4, 3, 2, 1], @callbacks
+  end
+  
+  def test_should_run_block_between_callback
+    @callbacks = []
+    @machine.around_transition {|block| @callbacks << :before_1; block.call; @callbacks << :after_1}
+    @machine.around_transition {|block| @callbacks << :before_2; block.call; @callbacks << :after_2}
+    @transition.run_callbacks { @callbacks << :within; {:success => true} }
+    
+    assert_equal [:before_1, :before_2, :within, :after_2, :after_1], @callbacks
+  end
+  
+  def test_should_have_access_to_result_after_yield
+    @machine.around_transition {|block| @before_result_1 = @transition.result; block.call; @after_result_1 = @transition.result}
+    @machine.around_transition {|block| @before_result_2 = @transition.result; block.call; @after_result_2 = @transition.result}
+    @transition.run_callbacks {{:result => 1, :success => true}}
+    
+    assert_nil @before_result_1
+    assert_nil @before_result_2
+    assert_equal 1, @after_result_1
+    assert_equal 1, @after_result_2
+  end
+  
+  def test_should_fail_if_any_before_yield_halted
+    @machine.around_transition {|block| block.call}
+    @machine.around_transition {throw :halt}
+    
+    assert_equal false, @transition.run_callbacks
+  end
+  
+  def test_should_not_continue_around_callbacks_if_before_yield_halted
+    @callbacks = []
+    @machine.around_transition {@callbacks << 1; throw :halt}
+    @machine.around_transition {|block| @callbacks << 2; block.call; @callbacks << 3}
+    
+    assert_equal false, @transition.run_callbacks
+    assert_equal [1], @callbacks
+  end
+  
+  def test_should_not_continue_around_callbacks_if_later_before_yield_halted
+    @callbacks = []
+    @machine.around_transition {|block| block.call; @callbacks << 1}
+    @machine.around_transition {throw :halt}
+    
+    @transition.run_callbacks
+    assert_equal [], @callbacks
+  end
+  
+  def test_should_not_run_further_callbacks_if_after_yield_halted
+    @callbacks = []
+    @machine.around_transition {|block| block.call; @callbacks << 1}
+    @machine.around_transition {|block| block.call; throw :halt}
+    
+    assert_equal true, @transition.run_callbacks
+    assert_equal [], @callbacks
+  end
+  
+  def test_should_fail_if_any_fail_to_yield
+    @callbacks = []
+    @machine.around_transition {@callbacks << 1}
+    @machine.around_transition {|block| @callbacks << 2; block.call; @callbacks << 3}
+    
+    assert_equal false, @transition.run_callbacks
+    assert_equal [1], @callbacks
   end
 end
 
-class TransitionHaltedDuringBeforeCallbacksTest < Test::Unit::TestCase
+class TransitionWithMixedCallbacksTest < Test::Unit::TestCase
   def setup
-    @klass = Class.new do
-      class << self; attr_accessor :cancelled_transaction; end
-      attr_reader :saved
-      
-      def save
-        @saved = true
-      end
-    end
-    @before_count = 0
-    @after_count = 0
+    @klass = Class.new
     
-    @machine = StateMachine::Machine.new(@klass, :action => :save)
+    @machine = StateMachine::Machine.new(@klass)
     @machine.state :parked, :idling
     @machine.event :ignite
-    class << @machine
-      def within_transaction(object)
-        owner_class.cancelled_transaction = yield == false
-      end
-    end
-    
-    @machine.before_transition lambda {@before_count += 1; throw :halt}
-    @machine.before_transition lambda {@before_count += 1}
-    @machine.after_transition lambda {@after_count += 1}
     
     @object = @klass.new
     @object.state = 'parked'
     @transition = StateMachine::Transition.new(@object, @machine, :ignite, :parked, :idling)
-    @result = @transition.perform
   end
   
-  def test_should_not_be_successful
-    assert_equal false, @result
+  def test_should_before_and_around_callbacks_in_order_defined
+    @callbacks = []
+    @machine.before_transition {@callbacks << :before_1}
+    @machine.around_transition {|block| @callbacks << :around; block.call}
+    @machine.before_transition {@callbacks << :before_2}
+    
+    assert_equal true, @transition.run_callbacks
+    assert_equal [:before_1, :around, :before_2], @callbacks
   end
   
-  def test_should_not_change_current_state
-    assert_equal 'parked', @object.state
+  def test_should_run_around_callbacks_before_after_callbacks
+    @callbacks = []
+    @machine.after_transition {@callbacks << :after_1}
+    @machine.around_transition {|block| block.call; @callbacks << :after_2}
+    @machine.after_transition {@callbacks << :after_3}
+    
+    assert_equal true, @transition.run_callbacks
+    assert_equal [:after_2, :after_1, :after_3], @callbacks
   end
   
-  def test_should_not_run_action
-    assert !@object.saved
+  def test_should_have_access_to_result_for_both_after_and_around_callbacks
+    @machine.after_transition {@after_result = @transition.result}
+    @machine.around_transition {|block| block.call; @around_result = @transition.result}
+    
+    @transition.run_callbacks {{:result => 1, :success => true}}
+    assert_equal 1, @after_result
+    assert_equal 1, @around_result
   end
   
-  def test_should_not_run_further_before_callbacks
-    assert_equal 1, @before_count
+  def test_should_not_run_further_callbacks_if_before_callback_halts
+    @callbacks = []
+    @machine.before_transition {@callbacks << :before_1}
+    @machine.around_transition {|block| @callbacks << :before_around_1; block.call; @callbacks << :after_around_1}
+    @machine.before_transition {@callbacks << :before_2; throw :halt}
+    @machine.around_transition {|block| @callbacks << :before_around_2; block.call; @callbacks << :after_around_2}
+    @machine.after_transition {@callbacks << :after}
+    
+    assert_equal false, @transition.run_callbacks
+    assert_equal [:before_1, :before_around_1, :before_2], @callbacks
   end
   
-  def test_should_not_run_after_callbacks
-    assert_equal 0, @after_count
+  def test_should_not_run_further_callbacks_if_before_yield_halts
+    @callbacks = []
+    @machine.before_transition {@callbacks << :before_1}
+    @machine.around_transition {|block| @callbacks << :before_around_1; throw :halt}
+    @machine.before_transition {@callbacks << :before_2; throw :halt}
+    @machine.around_transition {|block| @callbacks << :before_around_2; block.call; @callbacks << :after_around_2}
+    @machine.after_transition {@callbacks << :after}
+    
+    assert_equal false, @transition.run_callbacks
+    assert_equal [:before_1, :before_around_1], @callbacks
+  end
+  
+  def test_should_not_run_further_callbacks_if_around_callback_fails_to_yield
+    @callbacks = []
+    @machine.before_transition {@callbacks << :before_1}
+    @machine.around_transition {|block| @callbacks << :before_around_1}
+    @machine.before_transition {@callbacks << :before_2; throw :halt}
+    @machine.around_transition {|block| @callbacks << :before_around_2; block.call; @callbacks << :after_around_2}
+    @machine.after_transition {@callbacks << :after}
+    
+    assert_equal false, @transition.run_callbacks
+    assert_equal [:before_1, :before_around_1], @callbacks
+  end
+  
+  def test_should_not_run_further_callbacks_if_after_yield_halts
+    @callbacks = []
+    @machine.before_transition {@callbacks << :before_1}
+    @machine.around_transition {|block| @callbacks << :before_around_1; block.call; @callbacks << :after_around_1; throw :halt}
+    @machine.before_transition {@callbacks << :before_2}
+    @machine.around_transition {|block| @callbacks << :before_around_2; block.call; @callbacks << :after_around_2}
+    @machine.after_transition {@callbacks << :after}
+    
+    assert_equal true, @transition.run_callbacks
+    assert_equal [:before_1, :before_around_1, :before_2, :before_around_2, :after_around_2, :after_around_1], @callbacks
+  end
+  
+  def test_should_not_run_further_callbacks_if_after_callback_halts
+    @callbacks = []
+    @machine.before_transition {@callbacks << :before_1}
+    @machine.around_transition {|block| @callbacks << :before_around_1; block.call; @callbacks << :after_around_1}
+    @machine.before_transition {@callbacks << :before_2}
+    @machine.around_transition {|block| @callbacks << :before_around_2; block.call; @callbacks << :after_around_2}
+    @machine.after_transition {@callbacks << :after_1; throw :halt}
+    @machine.after_transition {@callbacks << :after_2}
+    
+    assert_equal true, @transition.run_callbacks
+    assert_equal [:before_1, :before_around_1, :before_2, :before_around_2, :after_around_2, :after_around_1, :after_1], @callbacks
   end
   
-  def test_should_cancel_the_transaction
-    assert @klass.cancelled_transaction
+  def test_should_run_any_callbacks_that_include_failures_if_block_success_is_false
+    @callbacks = []
+    @machine.around_transition {|block| block.call; @callbacks << :after_around_1}
+    @machine.around_transition(:include_failures => true) {|block| block.call; @callbacks << :after_around_2}
+    @machine.after_transition {@callbacks << :after_1}
+    @machine.after_transition(:include_failures => true) {@callbacks << :after_2}
+    
+    assert_equal true, @transition.run_callbacks {{:success => false}}
+    assert_equal [:after_around_2, :after_2], @callbacks
   end
 end
 
-class TransitionHaltedAfterCallbackTest < Test::Unit::TestCase
+class TransitionWithAfterCallbacksSkippedTest < Test::Unit::TestCase
   def setup
-    @klass = Class.new do
-      class << self; attr_accessor :cancelled_transaction; end
-      attr_reader :saved
-      
-      def save
-        @saved = true
-      end
-    end
-    @before_count = 0
-    @after_count = 0
+    @klass = Class.new
     
-    @machine = StateMachine::Machine.new(@klass, :action => :save)
+    @machine = StateMachine::Machine.new(@klass)
     @machine.state :parked, :idling
     @machine.event :ignite
-    class << @machine
-      def within_transaction(object)
-        owner_class.cancelled_transaction = yield == false
-      end
-    end
-    
-    @machine.before_transition lambda {@before_count += 1}
-    @machine.after_transition lambda {@after_count += 1; throw :halt}
-    @machine.after_transition lambda {@after_count += 1}
     
     @object = @klass.new
     @object.state = 'parked'
     @transition = StateMachine::Transition.new(@object, @machine, :ignite, :parked, :idling)
-    @result = @transition.perform
   end
   
-  def test_should_be_successful
-    assert_equal true, @result
+  def test_should_run_before_callbacks
+    @machine.before_transition {@run = true}
+    
+    assert_equal true, @transition.run_callbacks(:after => false)
+    assert @run
   end
   
-  def test_should_change_current_state
-    assert_equal 'idling', @object.state
+  def test_should_run_around_callbacks_before_yield
+    @machine.around_transition {|block| @run = true; block.call}
+    
+    assert_equal true, @transition.run_callbacks(:after => false)
+    assert @run
   end
   
-  def test_should_run_before_callbacks
-    assert_equal 1, @before_count
+  def test_should_not_run_after_callbacks
+    @machine.after_transition {@run = true}
+    
+    assert_equal true, @transition.run_callbacks(:after => false)
+    assert !@run
   end
   
-  def test_should_not_run_further_after_callbacks
-    assert_equal 1, @after_count
+  def test_should_not_run_around_callbacks_after_yield
+    @machine.around_transition {|block| block.call; @run = true}
+    
+    assert_equal true, @transition.run_callbacks(:after => false)
+    assert !@run
+  end
+  
+  def test_should_run_after_callbacks_that_include_failures_if_block_success_is_false
+    @machine.after_transition(:include_failures => true) {@run = true}
+    
+    assert_equal true, @transition.run_callbacks(:after => false) {{:success => false}}
+    assert @run
+  end
+  
+  def test_should_run_around_callbacks_that_include_failures_if_block_success_is_false
+    @machine.around_transition(:include_failures => true) {|block| block.call; @run = true}
+    
+    assert_equal true, @transition.run_callbacks(:after => false) {{:success => false}}
+    assert @run
+  end
+  
+  def test_should_continue_around_transition_execution_on_second_call
+    @callbacks = []
+    @machine.around_transition {|block| @callbacks << :before_around_1; block.call; @callbacks << :after_around_1}
+    @machine.around_transition {|block| @callbacks << :before_around_2; block.call; @callbacks << :after_around_2}
+    @machine.after_transition {@callbacks << :after}
+    
+    assert_equal true, @transition.run_callbacks(:after => false)
+    assert_equal [:before_around_1, :before_around_2], @callbacks
+    
+    assert_equal true, @transition.run_callbacks
+    assert_equal [:before_around_1, :before_around_2, :after_around_2, :after_around_1, :after], @callbacks
+  end
+  
+  def test_should_not_run_further_callbacks_if_halted_during_continue_around_transition
+    @callbacks = []
+    @machine.around_transition {|block| @callbacks << :before_around_1; block.call; @callbacks << :after_around_1}
+    @machine.around_transition {|block| @callbacks << :before_around_2; block.call; @callbacks << :after_around_2; throw :halt}
+    @machine.after_transition {@callbacks << :after}
+    
+    assert_equal true, @transition.run_callbacks(:after => false)
+    assert_equal [:before_around_1, :before_around_2], @callbacks
+    
+    assert_equal true, @transition.run_callbacks
+    assert_equal [:before_around_1, :before_around_2, :after_around_2], @callbacks
+  end
+  
+  def test_should_not_be_able_to_continue_twice
+    @count = 0
+    @machine.around_transition {|block| block.call; @count += 1}
+    @machine.after_transition {@count += 1}
+    
+    @transition.run_callbacks(:after => false)
+    
+    2.times do
+      assert_equal true, @transition.run_callbacks
+      assert_equal 2, @count
+    end
+  end
+  
+  def test_should_not_be_able_to_continue_again_after_halted
+    @count = 0
+    @machine.around_transition {|block| block.call; @count += 1; throw :halt}
+    @machine.after_transition {@count += 1}
+    
+    @transition.run_callbacks(:after => false)
+    
+    2.times do
+      assert_equal true, @transition.run_callbacks
+      assert_equal 1, @count
+    end
+  end
+  
+  def test_should_have_access_to_result_after_continued
+    @machine.around_transition {|block| @around_before_result = @transition.result; block.call; @around_after_result = @transition.result}
+    @machine.after_transition {@after_result = @transition.result}
+    
+    @transition.run_callbacks(:after => false)
+    @transition.run_callbacks {{:result => 1}}
+    
+    assert_nil @around_before_result
+    assert_equal 1, @around_after_result
+    assert_equal 1, @after_result
   end
   
-  def test_should_not_cancel_the_transaction
-    assert !@klass.cancelled_transaction
+  def test_should_raise_exceptions_during_around_callbacks_after_yield_in_second_execution
+    @machine.around_transition {|block| block.call; raise ArgumentError}
+    
+    assert_nothing_raised { @transition.run_callbacks(:after => false) }
+    assert_raise(ArgumentError) { @transition.run_callbacks }
   end
 end
 
-class TransitionWithActionFailedTest < Test::Unit::TestCase
+class TransitionAfterBeingPerformedTest < Test::Unit::TestCase
   def setup
     @klass = Class.new do
-      class << self; attr_accessor :cancelled_transaction; end
-      attr_reader :saved
+      attr_reader :saved, :save_state
       
       def save
-        false
+        @save_state = state
+        @saved = true
+        1
       end
     end
-    @before_count = 0
-    @after_count = 0
     
     @machine = StateMachine::Machine.new(@klass, :action => :save)
     @machine.state :parked, :idling
     @machine.event :ignite
-    class << @machine
-      def within_transaction(object)
-        owner_class.cancelled_transaction = yield == false
-      end
-    end
-    
-    @machine.before_transition lambda {@before_count += 1}
-    @machine.after_transition lambda {@after_count += 1}
-    @machine.after_transition lambda {@after_count += 1}, :include_failures => true
     
     @object = @klass.new
+    @object.state = 'parked'
     @transition = StateMachine::Transition.new(@object, @machine, :ignite, :parked, :idling)
+    @result = @transition.perform
   end
   
-  def test_should_not_be_successful
-    assert_equal false, @transition.perform
+  def test_should_have_empty_args
+    assert_equal [], @transition.args
   end
   
-  def test_should_not_change_current_state
-    @transition.perform
-    assert_nil @object.state
+  def test_should_have_a_result
+    assert_equal 1, @transition.result
   end
   
-  def test_should_run_before_callbacks
-    @transition.perform
-    assert_equal 1, @before_count
+  def test_should_be_successful
+    assert_equal true, @result
   end
   
-  def test_should_only_run_after_callbacks_that_include_failures
-    @transition.perform
-    assert_equal 1, @after_count
+  def test_should_change_the_current_state
+    assert_equal 'idling', @object.state
   end
   
-  def test_should_cancel_the_transaction
-    @transition.perform
-    assert @klass.cancelled_transaction
+  def test_should_run_the_action
+    assert @object.saved
   end
   
-  def test_should_interpret_nil_as_failure
-    @klass.class_eval do
-      def save
-        nil
-      end
-    end
-    
-    assert_equal false, @transition.perform
+  def test_should_run_the_action_after_saving_the_state
+    assert_equal 'idling', @object.save_state
   end
 end
 
-class TransitionWithActionErrorTest < Test::Unit::TestCase
+class TransitionWithPerformArgumentsTest < Test::Unit::TestCase
   def setup
     @klass = Class.new do
+      attr_reader :saved
+      
       def save
-        raise ArgumentError
+        @saved = true
       end
     end
     
@@ -905,308 +1240,125 @@ class TransitionWithActionErrorTest < Test::Unit::TestCase
     @object = @klass.new
     @object.state = 'parked'
     @transition = StateMachine::Transition.new(@object, @machine, :ignite, :parked, :idling)
-    
-    @raised = true
-    begin
-      @transition.perform
-      @raised = false
-    rescue ArgumentError
-    end
   end
   
-  def test_should_not_catch_exception
-    assert @raised
+  def test_should_have_arguments
+    @transition.perform(1, 2)
+    
+    assert_equal [1, 2], @transition.args
+    assert @object.saved
   end
   
-  def test_should_not_change_current_state
-    assert_equal 'parked', @object.state
+  def test_should_not_include_run_action_in_arguments
+    @transition.perform(1, 2, false)
+    
+    assert_equal [1, 2], @transition.args
+    assert !@object.saved
   end
 end
 
-class TransitionsInParallelTest < Test::Unit::TestCase
+class TransitionWithoutRunningActionTest < Test::Unit::TestCase
   def setup
     @klass = Class.new do
-      attr_reader :persisted
-      
-      def initialize
-        @persisted = []
-        @state = 'parked'
-        @status = 'first_gear'
-        super
-      end
-      
-      def state=(value)
-        @persisted << value
-        @state = value
-      end
+      attr_reader :saved
       
-      def status=(value)
-        @persisted << value
-        @status = value
+      def save
+        @saved = true
       end
     end
     
-    @state = StateMachine::Machine.new(@klass, :state)
-    @state.event :ignite
-    @state.state :parked, :idling
-    
-    @status = StateMachine::Machine.new(@klass, :status)
-    @status.event :shift_up
-    @status.state :first_gear, :second_gear
-    
-    @object = @klass.new
-    @state_transition = StateMachine::Transition.new(@object, @state, :ignite, :parked, :idling)
-    @status_transition = StateMachine::Transition.new(@object, @status, :shift_up, :first_gear, :second_gear)
-    
-    @result = StateMachine::Transition.perform([@state_transition, @status_transition])
-  end
-  
-  def test_should_raise_exception_if_attempted_on_the_same_state_machine
-    exception = assert_raise(ArgumentError) { StateMachine::Transition.perform([@state_transition, @state_transition]) }
-    assert_equal 'Cannot perform multiple transitions in parallel for the same state machine attribute', exception.message
-  end
-  
-  def test_should_perform
-    assert_equal true, @result
-  end
-  
-  def test_should_persist_first_state
-    assert_equal 'idling', @object.state
-  end
-  
-  def test_should_persist_second_state
-    assert_equal 'second_gear', @object.status
-  end
-  
-  def test_should_persist_in_order
-    assert_equal ['idling', 'second_gear'], @object.persisted
-  end
-  
-  def test_should_have_args_in_transitions
-    assert_equal [], @state_transition.args
-    assert_equal [], @status_transition.args
-  end
-end
-
-class TransitionsInParallelWithCallbacksTest < Test::Unit::TestCase
-  def setup
-    @klass = Class.new
-    
-    @before_callbacks = []
-    @after_callbacks = []
-    
-    @state = StateMachine::Machine.new(@klass, :state, :initial => :parked)
-    @state.event :ignite
-    @state.state :parked, :idling
-    @state.before_transition lambda {@before_callbacks << :state}
-    @state.after_transition lambda {@after_callbacks << :state}
-    
-    @status = StateMachine::Machine.new(@klass, :status, :initial => :first_gear)
-    @status.event :shift_up
-    @status.state :first_gear, :second_gear
-    @status.before_transition lambda {@before_callbacks << :status}
-    @status.after_transition lambda {@after_callbacks << :status}
+    @machine = StateMachine::Machine.new(@klass, :action => :save)
+    @machine.state :parked, :idling
+    @machine.event :ignite
+    @machine.after_transition {|object| @run_after = true}
     
     @object = @klass.new
-    @state_transition = StateMachine::Transition.new(@object, @state, :ignite, :parked, :idling)
-    @status_transition = StateMachine::Transition.new(@object, @status, :shift_up, :first_gear, :second_gear)
-  end
-  
-  def test_should_run_before_callbacks_in_order
-    perform
-    assert_equal [:state, :status], @before_callbacks
-  end
-  
-  def test_should_run_after_callbacks_in_order
-    perform
-    assert_equal [:state, :status], @after_callbacks
+    @object.state = 'parked'
+    @transition = StateMachine::Transition.new(@object, @machine, :ignite, :parked, :idling)
+    @result = @transition.perform(false)
   end
   
-  def test_should_not_run_after_callbacks_if_disabled
-    perform(:after => false)
-    assert_equal [], @after_callbacks
+  def test_should_have_empty_args
+    assert_equal [], @transition.args
   end
   
-  def test_should_halt_if_before_callback_halted_for_first_transition
-    @state.before_transition lambda {throw :halt}
-    
-    assert_equal false, perform
-    assert_equal [:state], @before_callbacks
-    assert_equal 'parked', @object.state
-    assert_equal 'first_gear', @object.status
-    assert_equal [], @after_callbacks
+  def test_should_not_have_a_result
+    assert_nil @transition.result
   end
   
-  def test_should_halt_if_before_callback_halted_for_second_transition
-    @status.before_transition lambda {throw :halt}
-    
-    assert_equal false, perform
-    assert_equal [:state, :status], @before_callbacks
-    assert_equal 'parked', @object.state
-    assert_equal 'first_gear', @object.status
-    assert_equal [], @after_callbacks
+  def test_should_be_successful
+    assert_equal true, @result
   end
   
-  def test_should_perform_if_after_callback_halted_for_first_transition
-    @state.after_transition lambda {throw :halt}
-    @state.after_transition lambda {@after_callbacks << :invalid}
-    
-    assert_equal true, perform
-    assert_equal [:state, :status], @before_callbacks
+  def test_should_change_the_current_state
     assert_equal 'idling', @object.state
-    assert_equal 'second_gear', @object.status
-    assert_equal [:state, :status], @after_callbacks
   end
   
-  def test_should_perform_if_after_callback_halted_for_second_transition
-    @status.after_transition lambda {throw :halt}
-    @status.after_transition lambda {@after_callbacks << :invalid}
-    
-    assert_equal true, perform
-    assert_equal [:state, :status], @before_callbacks
-    assert_equal 'idling', @object.state
-    assert_equal 'second_gear', @object.status
-    assert_equal [:state, :status], @after_callbacks
+  def test_should_not_run_the_action
+    assert !@object.saved
   end
   
-  private
-    def perform(options = {})
-      StateMachine::Transition.perform([@state_transition, @status_transition], options)
-    end
+  def test_should_run_after_callbacks
+    assert @run_after
+  end
 end
 
-class TransitionsInParallelWithActionsTest < Test::Unit::TestCase
+class TransitionWithTransactionsTest < Test::Unit::TestCase
   def setup
     @klass = Class.new do
-      attr_reader :actions
-      
-      def save_state
-        (@actions ||= []) << :save_state
-        :save_state
+      class << self
+        attr_accessor :running_transaction
       end
       
-      def save_status
-        (@actions ||= []) << :save_status
-        :save_status
+      attr_accessor :result
+      
+      def save
+        @result = self.class.running_transaction
+        true
       end
     end
     
-    @state = StateMachine::Machine.new(@klass, :state, :initial => :parked, :action => :save_state)
-    @state.event :ignite
-    @state.state :parked, :idling
-    
-    @status = StateMachine::Machine.new(@klass, :status, :initial => :first_gear, :action => :save_status)
-    @status.event :shift_up
-    @status.state :first_gear, :second_gear
+    @machine = StateMachine::Machine.new(@klass, :action => :save)
+    @machine.state :parked, :idling
+    @machine.event :ignite
     
     @object = @klass.new
-    @state_transition = StateMachine::Transition.new(@object, @state, :ignite, :parked, :idling)
-    @status_transition = StateMachine::Transition.new(@object, @status, :shift_up, :first_gear, :second_gear)
-  end
-  
-  def test_should_run_actions_in_order
-    perform
-    assert_equal [:save_state, :save_status], @object.actions
-  end
-  
-  def test_should_store_action_specific_results
-    perform
-    assert_equal :save_state, @state_transition.result
-    assert_equal :save_status, @status_transition.result
-  end
-  
-  def test_should_not_perform_if_action_fails_for_first_transition
-    @klass.class_eval do
-      def save_state
-        false
-      end
-    end
-    
-    assert_equal false, perform
-    assert_equal 'parked', @object.state
-    assert_equal 'first_gear', @object.status
-  end
-  
-  def test_should_not_perform_if_action_fails_for_second_transition
-    @klass.class_eval do
-      def save_status
-        false
-      end
-    end
+    @object.state = 'parked'
+    @transition = StateMachine::Transition.new(@object, @machine, :ignite, :parked, :idling)
     
-    assert_equal false, perform
-    assert_equal 'parked', @object.state
-    assert_equal 'first_gear', @object.status
-  end
-  
-  def test_should_rollback_if_action_errors_for_first_transition
-    @klass.class_eval do
-      def save_state
-        raise ArgumentError
+    class << @machine
+      def within_transaction(object)
+        owner_class.running_transaction = object
+        yield
+        owner_class.running_transaction = false
       end
     end
-    
-    begin; perform; rescue; end
-    assert_equal 'parked', @object.state
-    assert_equal 'first_gear', @object.status
   end
   
-  def test_should_rollback_if_action_errors_for_second_transition
-    @klass.class_eval do
-      def save_status
-        raise ArgumentError
-      end
+  def test_should_run_blocks_within_transaction_for_object
+    @transition.within_transaction do
+      @result = @klass.running_transaction
     end
     
-    begin; perform; rescue; end
-    assert_equal 'parked', @object.state
-    assert_equal 'first_gear', @object.status
+    assert_equal @object, @result
   end
-  
-  private
-    def perform(options = {})
-      StateMachine::Transition.perform([@state_transition, @status_transition], options)
-    end
 end
 
-class TransitionsWithPerformBlockTest < Test::Unit::TestCase
+class TransitionTransientTest < Test::Unit::TestCase
   def setup
     @klass = Class.new
     
-    @state = StateMachine::Machine.new(@klass, :state, :initial => :parked)
-    @state.event :ignite
-    @state.state :parked, :idling
-    
-    @status = StateMachine::Machine.new(@klass, :status, :initial => :first_gear)
-    @status.event :shift_up
-    @status.state :first_gear, :second_gear
+    @machine = StateMachine::Machine.new(@klass)
+    @machine.state :parked, :idling
+    @machine.event :ignite
     
     @object = @klass.new
-    @state_transition = StateMachine::Transition.new(@object, @state, :ignite, :parked, :idling)
-    @status_transition = StateMachine::Transition.new(@object, @status, :shift_up, :first_gear, :second_gear)
-  end
-  
-  def test_should_be_perform_if_result_is_not_false
-    assert_equal true, StateMachine::Transition.perform([@state_transition, @status_transition]) { true }
-    assert_equal 'idling', @object.state
-    assert_equal 'second_gear', @object.status
-  end
-  
-  def test_should_not_perform_if_result_is_false
-    assert_equal false, StateMachine::Transition.perform([@state_transition, @status_transition]) { false }
-    assert_equal 'parked', @object.state
-    assert_equal 'first_gear', @object.status
-  end
-  
-  def test_should_not_perform_if_result_is_nil
-    assert_equal false, StateMachine::Transition.perform([@state_transition, @status_transition]) { nil }
-    assert_equal 'parked', @object.state
-    assert_equal 'first_gear', @object.status
+    @object.state = 'parked'
+    @transition = StateMachine::Transition.new(@object, @machine, :ignite, :parked, :idling)
+    @transition.transient = true
   end
   
-  def test_should_use_result_as_transition_result
-    StateMachine::Transition.perform([@state_transition, @status_transition]) { 1 }
-    assert_equal 1, @state_transition.result
-    assert_equal 1, @status_transition.result
+  def test_should_be_transient
+    assert @transition.transient?
   end
 end