state_machine 0.6.3 → 0.7.0

data/test/unit/node_collection_test.rb

@@ -2,13 +2,18 @@ require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
 
 class NodeCollectionByDefaultTest < Test::Unit::TestCase
   def setup
-    @collection = StateMachine::NodeCollection.new
+    @machine = StateMachine::Machine.new(Class.new)
+    @collection = StateMachine::NodeCollection.new(@machine)
   end
   
   def test_should_not_have_any_nodes
     assert_equal 0, @collection.length
   end
   
+  def test_should_have_a_machine
+    assert_equal @machine, @collection.machine
+  end
+  
   def test_should_index_by_name
     @collection << object = Struct.new(:name).new(:parked)
     assert_equal object, @collection[:parked]
@@ -17,11 +22,12 @@ end
 
 class NodeCollectionTest < Test::Unit::TestCase
   def setup
-    @collection = StateMachine::NodeCollection.new
+    @machine = StateMachine::Machine.new(Class.new)
+    @collection = StateMachine::NodeCollection.new(@machine)
   end
   
   def test_should_raise_exception_if_invalid_option_specified
-    exception = assert_raise(ArgumentError) { StateMachine::NodeCollection.new(:invalid => true) }
+    exception = assert_raise(ArgumentError) { StateMachine::NodeCollection.new(@machine, :invalid => true) }
     assert_equal 'Invalid key(s): invalid', exception.message
   end
   
@@ -38,7 +44,8 @@ end
 
 class NodeCollectionAfterBeingCopiedTest < Test::Unit::TestCase
   def setup
-    @collection = StateMachine::NodeCollection.new
+    machine = StateMachine::Machine.new(Class.new)
+    @collection = StateMachine::NodeCollection.new(machine)
     @collection << @parked = Struct.new(:name).new(:parked)
     
     @copied_collection = @collection.dup
@@ -62,7 +69,8 @@ end
 
 class NodeCollectionWithoutIndicesTest < Test::Unit::TestCase
   def setup
-    @collection = StateMachine::NodeCollection.new(:index => {})
+    machine = StateMachine::Machine.new(Class.new)
+    @collection = StateMachine::NodeCollection.new(machine, :index => {})
   end
   
   def test_should_allow_adding_node
@@ -90,7 +98,8 @@ end
 
 class NodeCollectionWithIndicesTest < Test::Unit::TestCase
   def setup
-    @collection = StateMachine::NodeCollection.new(:index => [:name, :value])
+    machine = StateMachine::Machine.new(Class.new)
+    @collection = StateMachine::NodeCollection.new(machine, :index => [:name, :value])
     
     @object = Struct.new(:name, :value).new(:parked, 1)
     @collection << @object
@@ -116,24 +125,25 @@ class NodeCollectionWithIndicesTest < Test::Unit::TestCase
   
   def test_should_use_first_index_by_default_on_fetch
     assert_equal @object, @collection.fetch(:parked)
-    exception = assert_raise(ArgumentError) { @collection.fetch(1) }
+    exception = assert_raise(IndexError) { @collection.fetch(1) }
     assert_equal '1 is an invalid name', exception.message
   end
   
   def test_should_allow_customizing_index_on_fetch
     assert_equal @object, @collection.fetch(1, :value)
-    exception = assert_raise(ArgumentError) { @collection.fetch(:parked, :value) }
+    exception = assert_raise(IndexError) { @collection.fetch(:parked, :value) }
     assert_equal ':parked is an invalid value', exception.message
   end
 end
 
 class NodeCollectionWithNodesTest < Test::Unit::TestCase
   def setup
-    @collection = StateMachine::NodeCollection.new
+    machine = StateMachine::Machine.new(Class.new)
+    @collection = StateMachine::NodeCollection.new(machine)
     
-    @klass = Struct.new(:name)
-    @parked = @klass.new(:parked)
-    @idling = @klass.new(:idling)
+    @klass = Struct.new(:name, :machine)
+    @parked = @klass.new(:parked, machine)
+    @idling = @klass.new(:idling, machine)
     
     @collection << @parked
     @collection << @idling
@@ -150,11 +160,21 @@ class NodeCollectionWithNodesTest < Test::Unit::TestCase
     assert_equal @parked, @collection.at(0)
     assert_equal @idling, @collection.at(1)
   end
+  
+  def test_should_deep_copy_machine_changes
+    new_machine = StateMachine::Machine.new(Class.new)
+    @collection.machine = new_machine
+    
+    assert_equal new_machine, @collection.machine
+    assert_equal new_machine, @parked.machine
+    assert_equal new_machine, @idling.machine
+  end
 end
 
 class NodeCollectionAfterUpdateTest < Test::Unit::TestCase
   def setup
-    @collection = StateMachine::NodeCollection.new(:index => [:name, :value])
+    machine = StateMachine::Machine.new(Class.new)
+    @collection = StateMachine::NodeCollection.new(machine, :index => [:name, :value])
     
     @klass = Struct.new(:name, :value)
     @parked = @klass.new(:parked, 1)
@@ -185,20 +205,3 @@ class NodeCollectionAfterUpdateTest < Test::Unit::TestCase
     assert_nil @collection[1, :value]
   end
 end
-
-class NodeCollectionChangingMachineTest < Test::Unit::TestCase
-  def setup
-    @collection = StateMachine::NodeCollection.new
-    
-    @klass = Struct.new(:name, :machine)
-    @collection << @parked = @klass.new(:parked)
-    @collection << @idling = @klass.new(:idling)
-    
-    @collection.machine = :machine
-  end
-  
-  def test_should_update_each_node_machine
-    assert_equal :machine, @parked.machine
-    assert_equal :machine, @idling.machine
-  end
-end

data/test/unit/state_collection_test.rb

@@ -2,23 +2,130 @@ require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
 
 class StateCollectionByDefaultTest < Test::Unit::TestCase
   def setup
-    @states = StateMachine::StateCollection.new
+    @machine = StateMachine::Machine.new(Class.new)
+    @states = StateMachine::StateCollection.new(@machine)
   end
   
   def test_should_not_have_any_nodes
     assert_equal 0, @states.length
   end
   
+  def test_should_have_a_machine
+    assert_equal @machine, @states.machine
+  end
+  
   def test_should_be_empty_by_priority
     assert_equal [], @states.by_priority
   end
 end
 
+class StateCollectionTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+    @states = StateMachine::StateCollection.new(@machine)
+    
+    @states << @nil = StateMachine::State.new(@machine, nil)
+    @states << @parked = StateMachine::State.new(@machine, :parked)
+    @states << @idling = StateMachine::State.new(@machine, :idling)
+    
+    @object = @klass.new
+  end
+  
+  def test_should_index_by_name
+    assert_equal @parked, @states[:parked, :name]
+  end
+  
+  def test_should_index_by_name_by_default
+    assert_equal @parked, @states[:parked]
+  end
+  
+  def test_should_index_by_value
+    assert_equal @parked, @states['parked', :value]
+  end
+  
+  def test_should_not_match_if_value_does_not_match
+    assert !@states.matches?(@object, :parked)
+    assert !@states.matches?(@object, :idling)
+  end
+  
+  def test_should_match_if_value_matches
+    assert @states.matches?(@object, nil)
+  end
+  
+  def test_raise_exception_if_matching_invalid_state
+    assert_raise(IndexError) { @states.matches?(@object, :invalid) }
+  end
+  
+  def test_should_find_state_for_object_if_value_is_known
+    @object.state = 'parked'
+    assert_equal @parked, @states.match(@object)
+  end
+  
+  def test_should_raise_exception_if_finding_state_for_object_with_unknown_value
+    @object.state = 'invalid'
+    exception = assert_raise(ArgumentError) { @states.match(@object) }
+    assert_equal '"invalid" is not a known state value', exception.message
+  end
+end
+
+class StateCollectionWithCustomStateValuesTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+    @states = StateMachine::StateCollection.new(@machine)
+    
+    @states << @state = StateMachine::State.new(@machine, :parked, :value => 1)
+    
+    @object = @klass.new
+    @object.state = 1
+  end
+  
+  def test_should_match_if_value_matches
+    assert @states.matches?(@object, :parked)
+  end
+  
+  def test_should_not_match_if_value_does_not_match
+    @object.state = 2
+    assert !@states.matches?(@object, :parked)
+  end
+  
+  def test_should_find_state_for_object_if_value_is_known
+    assert_equal @state, @states.match(@object)
+  end
+end
+
+class StateCollectionWithStateMatchersTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+    @states = StateMachine::StateCollection.new(@machine)
+    
+    @states << @state = StateMachine::State.new(@machine, :parked, :if => lambda {|value| !value.nil?})
+    
+    @object = @klass.new
+    @object.state = 1
+  end
+  
+  def test_should_match_if_value_matches
+    assert @states.matches?(@object, :parked)
+  end
+  
+  def test_should_not_match_if_value_does_not_match
+    @object.state = nil
+    assert !@states.matches?(@object, :parked)
+  end
+  
+  def test_should_find_state_for_object_if_value_is_known
+    assert_equal @state, @states.match(@object)
+  end
+end
+
 class StateCollectionWithInitialStateTest < Test::Unit::TestCase
   def setup
     @machine = StateMachine::Machine.new(Class.new)
+    @states = StateMachine::StateCollection.new(@machine)
     
-    @states = StateMachine::StateCollection.new
     @states << @parked = StateMachine::State.new(@machine, :parked)
     @states << @idling = StateMachine::State.new(@machine, :idling)
     
@@ -54,8 +161,8 @@ end
 class StateCollectionWithStateBehaviorsTest < Test::Unit::TestCase
   def setup
     @machine = StateMachine::Machine.new(Class.new)
+    @states = StateMachine::StateCollection.new(@machine)
     
-    @states = StateMachine::StateCollection.new
     @states << @parked = StateMachine::State.new(@machine, :parked)
     @states << @idling = StateMachine::State.new(@machine, :idling)
     
@@ -91,8 +198,8 @@ end
 class StateCollectionWithEventTransitionsTest < Test::Unit::TestCase
   def setup
     @machine = StateMachine::Machine.new(Class.new)
+    @states = StateMachine::StateCollection.new(@machine)
     
-    @states = StateMachine::StateCollection.new
     @states << @parked = StateMachine::State.new(@machine, :parked)
     @states << @idling = StateMachine::State.new(@machine, :idling)
     
@@ -128,8 +235,8 @@ end
 class StateCollectionWithTransitionCallbacksTest < Test::Unit::TestCase
   def setup
     @machine = StateMachine::Machine.new(Class.new)
+    @states = StateMachine::StateCollection.new(@machine)
     
-    @states = StateMachine::StateCollection.new
     @states << @parked = StateMachine::State.new(@machine, :parked)
     @states << @idling = StateMachine::State.new(@machine, :idling)
     

data/test/unit/state_test.rb

@@ -14,6 +14,10 @@ class StateByDefaultTest < Test::Unit::TestCase
     assert_equal :parked, @state.name
   end
   
+  def test_should_have_a_qualified_name
+    assert_equal :parked, @state.name
+  end
+  
   def test_should_use_stringify_the_name_as_the_value
     assert_equal 'parked', @state.value
   end
@@ -81,6 +85,10 @@ class StateWithoutNameTest < Test::Unit::TestCase
     assert_nil @state.name
   end
   
+  def test_should_have_a_nil_qualified_name
+    assert_nil @state.qualified_name
+  end
+  
   def test_should_have_a_nil_value
     assert_nil @state.value
   end
@@ -107,6 +115,10 @@ class StateWithNameTest < Test::Unit::TestCase
     assert_equal :parked, @state.name
   end
   
+  def test_should_have_a_qualified_name
+    assert_equal :parked, @state.name
+  end
+  
   def test_should_use_stringify_the_name_as_the_value
     assert_equal 'parked', @state.value
   end
@@ -362,13 +374,21 @@ end
 class StateWithNamespaceTest < Test::Unit::TestCase
   def setup
     @klass = Class.new
-    @machine = StateMachine::Machine.new(@klass, :namespace => 'gear')
-    @state = StateMachine::State.new(@machine, :parked)
+    @machine = StateMachine::Machine.new(@klass, :namespace => 'alarm')
+    @state = StateMachine::State.new(@machine, :active)
     @object = @klass.new
   end
   
+  def test_should_have_a_name
+    assert_equal :active, @state.name
+  end
+  
+  def test_should_have_a_qualified_name
+    assert_equal :alarm_active, @state.qualified_name
+  end
+  
   def test_should_namespace_predicate
-    assert @object.respond_to?(:gear_parked?)
+    assert @object.respond_to?(:alarm_active?)
   end
 end
 

data/test/unit/transition_test.rb

@@ -5,6 +5,7 @@ class TransitionTest < Test::Unit::TestCase
     @klass = Class.new
     @machine = StateMachine::Machine.new(@klass)
     @machine.state :parked, :idling
+    @machine.event :ignite
     
     @object = @klass.new
     @object.state = 'parked'
@@ -24,6 +25,10 @@ class TransitionTest < Test::Unit::TestCase
     assert_equal :ignite, @transition.event
   end
   
+  def test_should_have_a_qualified_event
+    assert_equal :ignite, @transition.qualified_event
+  end
+  
   def test_should_have_a_from_value
     assert_equal 'parked', @transition.from
   end
@@ -32,6 +37,10 @@ class TransitionTest < Test::Unit::TestCase
     assert_equal :parked, @transition.from_name
   end
   
+  def test_should_have_a_qualified_from_name
+    assert_equal :parked, @transition.qualified_from_name
+  end
+  
   def test_should_have_a_to_value
     assert_equal 'idling', @transition.to
   end
@@ -40,26 +49,88 @@ class TransitionTest < Test::Unit::TestCase
     assert_equal :idling, @transition.to_name
   end
   
+  def test_should_have_a_qualified_to_name
+    assert_equal :idling, @transition.qualified_to_name
+  end
+  
   def test_should_have_an_attribute
     assert_equal :state, @transition.attribute
   end
   
+  def test_should_not_have_an_action
+    assert_nil @transition.action
+  end
+  
   def test_should_generate_attributes
     expected = {:object => @object, :attribute => :state, :event => :ignite, :from => 'parked', :to => 'idling'}
     assert_equal expected, @transition.attributes
   end
   
+  def test_should_have_empty_args
+    assert_equal [], @transition.args
+  end
+  
+  def test_should_not_have_a_result
+    assert_nil @transition.result
+  end
+  
   def test_should_use_pretty_inspect
     assert_equal '#<StateMachine::Transition attribute=:state event=:ignite from="parked" from_name=:parked to="idling" to_name=:idling>', @transition.inspect
   end
 end
 
+class TransitionWithoutEventTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+    @machine.state :parked, :idling
+    
+    @object = @klass.new
+    @object.state = 'parked'
+    
+    @transition = StateMachine::Transition.new(@object, @machine, nil, :parked, :idling)
+  end
+  
+  def test_should_not_have_an_event
+    assert_nil @transition.event
+  end
+  
+  def test_should_not_have_a_qualified_event
+    assert_nil @transition.qualified_event
+  end
+end
+
+class TransitionWithInvalidNodesTest < 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'
+  end
+  
+  def test_should_raise_exception_with_invalid_event
+    assert_raise(IndexError) { StateMachine::Transition.new(@object, @machine, :invalid, :parked, :idling) }
+  end
+  
+  def test_should_raise_exception_with_invalid_from_state
+    assert_raise(IndexError) { StateMachine::Transition.new(@object, @machine, :ignite, :invalid, :idling) }
+  end
+  
+  def test_should_raise_exception_with_invalid_to_state
+    assert_raise(IndexError) { StateMachine::Transition.new(@object, @machine, :ignite, :parked, :invalid) }
+  end
+end
+
 class TransitionWithDynamicToValueTest < Test::Unit::TestCase
   def setup
     @klass = Class.new
     @machine = StateMachine::Machine.new(@klass)
     @machine.state :parked
     @machine.state :idling, :value => lambda {1}
+    @machine.event :ignite
     
     @object = @klass.new
     @object.state = 'parked'
@@ -71,72 +142,167 @@ class TransitionWithDynamicToValueTest < Test::Unit::TestCase
   end
 end
 
-class TransitionAfterBeingPerformedTest < Test::Unit::TestCase
+class TransitionLoopbackTest < 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
+    @machine.event :park
     
-    @machine = StateMachine::Machine.new(@klass, :action => :save)
+    @object = @klass.new
+    @object.state = 'parked'
+    @transition = StateMachine::Transition.new(@object, @machine, :park, :parked, :parked)
+  end
+  
+  def test_should_be_loopback
+    assert @transition.loopback?
+  end
+end
+
+class TransitionWithDifferentStatesTest < 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)
-    @result = @transition.perform
   end
   
-  def test_should_be_successful
-    assert_equal true, @result
+  def test_should_not_be_loopback
+    assert !@transition.loopback?
+  end
+end
+
+class TransitionWithNamespaceTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass, :namespace => 'alarm')
+    @machine.state :off, :active
+    @machine.event :activate
+    
+    @object = @klass.new
+    @object.state = 'off'
+    
+    @transition = StateMachine::Transition.new(@object, @machine, :activate, :off, :active)
   end
   
-  def test_should_the_current_state
-    assert_equal 'idling', @object.state
+  def test_should_have_an_event
+    assert_equal :activate, @transition.event
   end
   
-  def test_should_run_the_action
-    assert @object.saved
+  def test_should_have_a_qualified_event
+    assert_equal :activate_alarm, @transition.qualified_event
   end
   
-  def test_should_run_the_action_after_saving_the_state
-    assert_equal 'idling', @object.save_state
+  def test_should_have_a_from_name
+    assert_equal :off, @transition.from_name
+  end
+  
+  def test_should_have_a_qualified_from_name
+    assert_equal :alarm_off, @transition.qualified_from_name
+  end
+  
+  def test_should_have_a_to_name
+    assert_equal :active, @transition.to_name
+  end
+  
+  def test_should_have_a_qualified_to_name
+    assert_equal :alarm_active, @transition.qualified_to_name
   end
 end
 
-class TransitionWithoutRunningActionTest < Test::Unit::TestCase
+class TransitionWithActionTest < Test::Unit::TestCase
   def setup
     @klass = Class.new do
-      attr_reader :saved
-      
       def save
-        @saved = true
       end
     end
     
     @machine = StateMachine::Machine.new(@klass, :action => :save)
     @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(false)
   end
   
-  def test_should_be_successful
-    assert_equal true, @result
+  def test_should_have_an_action
+    assert_equal :save, @transition.action
   end
   
-  def test_should_the_current_state
+  def test_should_not_have_a_result
+    assert_nil @transition.result
+  end
+end
+
+class TransitionAfterBeingPersistedTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass, :action => :save)
+    @machine.state :parked, :idling
+    @machine.event :ignite
+    
+    @object = @klass.new
+    @object.state = 'parked'
+    
+    @transition = StateMachine::Transition.new(@object, @machine, :ignite, :parked, :idling)
+    @transition.persist
+  end
+  
+  def test_should_update_state_value
     assert_equal 'idling', @object.state
   end
   
-  def test_should_not_run_the_action
-    assert !@object.saved
+  def test_should_not_change_from_state
+    assert_equal 'parked', @transition.from
+  end
+  
+  def test_should_not_change_to_state
+    assert_equal 'idling', @transition.to
+  end
+  
+  def test_should_revert_to_from_state_on_rollback
+    @transition.rollback
+    assert_equal 'parked', @object.state
+  end
+end
+
+class TransitionAfterBeingRolledBackTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass, :action => :save)
+    @machine.state :parked, :idling
+    @machine.event :ignite
+    
+    @object = @klass.new
+    @object.state = 'parked'
+    
+    @transition = StateMachine::Transition.new(@object, @machine, :ignite, :parked, :idling)
+    @object.state = 'idling'
+    
+    @transition.rollback
+  end
+  
+  def test_should_update_state_value_to_from_state
+    assert_equal 'parked', @object.state
+  end
+  
+  def test_should_not_change_from_state
+    assert_equal 'parked', @transition.from
+  end
+  
+  def test_should_not_change_to_state
+    assert_equal 'idling', @transition.to
+  end
+  
+  def test_should_still_be_able_to_persist
+    @transition.persist
+    assert_equal 'idling', @object.state
   end
 end
 
@@ -153,40 +319,26 @@ class TransitionWithCallbacksTest < Test::Unit::TestCase
     
     @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_before_changing_the_state
-    @machine.before_transition(lambda {|object| @state = object.state})
-    @transition.perform
-    
-    assert_equal 'parked', @state
-  end
-  
-  def test_should_run_after_callbacks_after_running_the_action
-    @machine.after_transition(lambda {|object| @state = object.state})
-    @transition.perform
+  def test_should_run_before_callbacks_on_before
+    @machine.before_transition(lambda {|object| @run = true})
+    result = @transition.before
     
-    assert_equal 'idling', @state
+    assert_equal true, result
+    assert_equal true, @run
   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.perform
-    
-    assert_equal [1, 2], @callbacks
-  end
-  
-  def test_should_run_after_callbacks_in_the_order_they_were_defined
-    @callbacks = []
-    @machine.after_transition(lambda {@callbacks << 1})
-    @machine.after_transition(lambda {@callbacks << 2})
-    @transition.perform
+    @transition.before
     
     assert_equal [1, 2], @callbacks
   end
@@ -199,11 +351,58 @@ 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.perform
+    @transition.before
     
     assert_equal 1, @count
   end
   
+  def test_should_pass_transition_to_before_callbacks
+    @machine.before_transition(lambda {|*args| @args = args})
+    @transition.before
+    
+    assert_equal [@object, @transition], @args
+  end
+  
+  def test_should_catch_halted_before_callbacks
+    @machine.before_transition(lambda {throw :halt})
+    
+    result = nil
+    assert_nothing_thrown { result = @transition.before }
+    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
+  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
+  end
+  
+  def test_should_set_result_on_after
+    @transition.after
+    assert_nil @transition.result
+    
+    @transition.after(1)
+    assert_equal 1, @transition.result
+  end
+  
+  def test_should_run_after_callbacks_in_the_order_they_were_defined
+    @callbacks = []
+    @machine.after_transition(lambda {@callbacks << 1})
+    @machine.after_transition(lambda {@callbacks << 2})
+    @transition.after(true)
+    
+    assert_equal [1, 2], @callbacks
+  end
+  
   def test_should_only_run_after_callbacks_that_match_transition_context
     @count = 0
     callback = lambda {@count += 1}
@@ -212,90 +411,229 @@ 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.perform
+    @transition.after(true)
     
     assert_equal 1, @count
   end
   
-  def test_should_pass_transition_to_before_callbacks
-    @machine.before_transition(lambda {|*args| @args = args})
-    @transition.perform
+  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
     
+    @transition.after(false)
     assert_equal [@object, @transition], @args
+    assert_equal false, @transition.result
   end
   
-  def test_should_pass_transition_and_action_result_to_after_callbacks
-    @machine.after_transition(lambda {|*args| @args = args})
-    @transition.perform
+  def test_should_catch_halted_after_callbacks
+    @machine.after_transition(lambda {throw :halt})
+    
+    result = nil
+    assert_nothing_thrown { result = @transition.after(true) }
+    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 [@object, @transition, true], @args
+    assert_equal 'idling', @state
   end
 end
 
-class TransitionHaltedDuringBeforeCallbacksTest < Test::Unit::TestCase
+class TransitionAfterBeingPerformedTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new do
+      attr_reader :saved, :save_state
+      
+      def save
+        @save_state = state
+        @saved = true
+      end
+    end
+    
+    @machine = StateMachine::Machine.new(@klass, :action => :save)
+    @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
+  end
+  
+  def test_should_run_the_action
+    assert @object.saved
+  end
+  
+  def test_should_run_the_action_after_saving_the_state
+    assert_equal 'idling', @object.save_state
+  end
+end
+
+class TransitionWithPerformArgumentsTest < 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
     
     @machine = StateMachine::Machine.new(@klass, :action => :save)
     @machine.state :parked, :idling
-    class << @machine
-      def within_transaction(object)
-        owner_class.cancelled_transaction = yield == false
+    @machine.event :ignite
+    
+    @object = @klass.new
+    @object.state = 'parked'
+    @transition = StateMachine::Transition.new(@object, @machine, :ignite, :parked, :idling)
+  end
+  
+  def test_should_have_arguments
+    @transition.perform(1, 2)
+    
+    assert_equal [1, 2], @transition.args
+    assert @object.saved
+  end
+  
+  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 TransitionWithoutRunningActionTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new do
+      attr_reader :saved
+      
+      def save
+        @saved = true
       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}
+    @machine = StateMachine::Machine.new(@klass, :action => :save)
+    @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
+    @result = @transition.perform(false)
   end
   
-  def test_should_not_be_successful
-    assert !@result
+  def test_should_have_empty_args
+    assert_equal [], @transition.args
   end
   
-  def test_should_not_change_current_state
-    assert_equal 'parked', @object.state
+  def test_should_not_have_a_result
+    assert_nil @transition.result
   end
   
-  def test_should_not_run_action
+  def test_should_be_successful
+    assert_equal true, @result
+  end
+  
+  def test_should_change_the_current_state
+    assert_equal 'idling', @object.state
+  end
+  
+  def test_should_not_run_the_action
     assert !@object.saved
   end
+end
+
+class TransitionWithTransactionsTest < 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
+    
+    @machine = StateMachine::Machine.new(@klass, :action => :save)
+    @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_not_run_further_before_callbacks
-    assert_equal 1, @before_count
+  def test_should_run_blocks_within_transaction_for_object
+    @transition.within_transaction do
+      @result = @klass.running_transaction
+    end
+    
+    assert_equal @object, @result
   end
   
-  def test_should_not_run_after_callbacks
-    assert_equal 0, @after_count
+  def test_should_run_before_callbacks_within_transaction
+    @machine.before_transition(lambda {|object| @result = @klass.running_transaction})
+    @transition.perform
+    
+    assert_equal @object, @result
   end
   
-  def test_should_cancel_the_transaction
-    assert @klass.cancelled_transaction
+  def test_should_run_action_within_transaction
+    @transition.perform
+    
+    assert_equal @object, @object.result
+  end
+  
+  def test_should_run_after_callbacks_within_transaction
+    @machine.after_transition(lambda {|object| @result = @klass.running_transaction})
+    @transition.perform
+    
+    assert_equal @object, @result
   end
 end
 
-class TransitionHaltedDuringActionTest < Test::Unit::TestCase
+class TransitionHaltedDuringBeforeCallbacksTest < Test::Unit::TestCase
   def setup
     @klass = Class.new do
       class << self; attr_accessor :cancelled_transaction; end
       attr_reader :saved
       
       def save
-        throw :halt
+        @saved = true
       end
     end
     @before_count = 0
@@ -303,12 +641,14 @@ class TransitionHaltedDuringActionTest < Test::Unit::TestCase
     
     @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; throw :halt}
     @machine.before_transition lambda {@before_count += 1}
     @machine.after_transition lambda {@after_count += 1}
     
@@ -322,11 +662,15 @@ class TransitionHaltedDuringActionTest < Test::Unit::TestCase
     assert !@result
   end
   
-  def test_should_change_current_state
-    assert_equal 'idling', @object.state
+  def test_should_not_change_current_state
+    assert_equal 'parked', @object.state
   end
   
-  def test_should_run_before_callbacks
+  def test_should_not_run_action
+    assert !@object.saved
+  end
+  
+  def test_should_not_run_further_before_callbacks
     assert_equal 1, @before_count
   end
   
@@ -354,6 +698,7 @@ class TransitionHaltedAfterCallbackTest < Test::Unit::TestCase
     
     @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
@@ -391,7 +736,7 @@ class TransitionHaltedAfterCallbackTest < Test::Unit::TestCase
   end
 end
 
-class TransitionWithFailedActionTest < Test::Unit::TestCase
+class TransitionWithActionFailedTest < Test::Unit::TestCase
   def setup
     @klass = Class.new do
       class << self; attr_accessor :cancelled_transaction; end
@@ -406,6 +751,7 @@ class TransitionWithFailedActionTest < Test::Unit::TestCase
     
     @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
@@ -424,8 +770,8 @@ class TransitionWithFailedActionTest < Test::Unit::TestCase
     assert !@result
   end
   
-  def test_should_change_current_state
-    assert_equal 'idling', @object.state
+  def test_should_not_change_current_state
+    assert_nil @object.state
   end
   
   def test_should_run_before_callbacks
@@ -440,3 +786,318 @@ class TransitionWithFailedActionTest < Test::Unit::TestCase
     assert @klass.cancelled_transaction
   end
 end
+
+class TransitionWithActionErrorTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new do
+      def save
+        raise ArgumentError
+      end
+    end
+    
+    @machine = StateMachine::Machine.new(@klass, :action => :save)
+    @machine.state :parked, :idling
+    @machine.event :ignite
+    
+    @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
+  end
+  
+  def test_should_not_change_current_state
+    assert_equal 'parked', @object.state
+  end
+end
+
+class TransitionsInParallelTest < 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
+      
+      def status=(value)
+        @persisted << value
+        @status = value
+      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}
+    
+    @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
+  end
+  
+  def test_should_not_run_after_callbacks_if_disabled
+    perform(:after => false)
+    assert_equal [], @after_callbacks
+  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
+  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
+  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
+    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
+  end
+  
+  private
+    def perform(options = {})
+      StateMachine::Transition.perform([@state_transition, @status_transition], options)
+    end
+end
+
+class TransitionsInParallelWithActionsTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new do
+      attr_reader :actions
+      
+      def save_state
+        (@actions ||= []) << :save_state
+        :save_state
+      end
+      
+      def save_status
+        (@actions ||= []) << :save_status
+        :save_status
+      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
+    
+    @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
+    
+    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
+      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
+    end
+    
+    begin; perform; rescue; end
+    assert_equal 'parked', @object.state
+    assert_equal 'first_gear', @object.status
+  end
+  
+  private
+    def perform(options = {})
+      StateMachine::Transition.perform([@state_transition, @status_transition], options)
+    end
+end
+
+class TransitionsWithPerformBlockTest < 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
+    
+    @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 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 !StateMachine::Transition.perform([@state_transition, @status_transition]) { false }
+    assert_equal 'parked', @object.state
+    assert_equal 'first_gear', @object.status
+  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
+  end
+end