state_machine 0.9.4 → 0.10.0

data/test/unit/callback_test.rb

@@ -3,7 +3,7 @@ require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
 class CallbackTest < Test::Unit::TestCase
   def test_should_raise_exception_if_invalid_type_specified
     exception = assert_raise(ArgumentError) { StateMachine::Callback.new(:invalid) {} }
-    assert_equal 'Type must be :before, :after, or :around', exception.message
+    assert_equal 'Type must be :before, :after, :around, or :failure', exception.message
   end
   
   def test_should_not_raise_exception_if_using_before_type
@@ -18,6 +18,10 @@ class CallbackTest < Test::Unit::TestCase
     assert_nothing_raised { StateMachine::Callback.new(:around) {} }
   end
   
+  def test_should_not_raise_exception_if_using_failure_type
+    assert_nothing_raised { StateMachine::Callback.new(:failure) {} }
+  end
+  
   def test_should_raise_exception_if_no_methods_specified
     exception = assert_raise(ArgumentError) { StateMachine::Callback.new(:before) }
     assert_equal 'Method(s) for callback must be specified', exception.message
@@ -61,10 +65,10 @@ class CallbackByDefaultTest < Test::Unit::TestCase
     assert_nil @callback.terminator
   end
   
-  def test_should_have_a_guard_with_all_matcher_requirements
-    assert_equal StateMachine::AllMatcher.instance, @callback.guard.event_requirement
-    assert_equal StateMachine::AllMatcher.instance, @callback.guard.state_requirements.first[:from]
-    assert_equal StateMachine::AllMatcher.instance, @callback.guard.state_requirements.first[:to]
+  def test_should_have_a_branch_with_all_matcher_requirements
+    assert_equal StateMachine::AllMatcher.instance, @callback.branch.event_requirement
+    assert_equal StateMachine::AllMatcher.instance, @callback.branch.state_requirements.first[:from]
+    assert_equal StateMachine::AllMatcher.instance, @callback.branch.state_requirements.first[:to]
   end
   
   def test_should_not_have_any_known_states
@@ -695,34 +699,3 @@ class CallbackWithAroundTypeAndBoundMethodTest < Test::Unit::TestCase
     assert_equal [1, 2, 3], context
   end
 end
-
-class CallbackSuccessMatcherTest < Test::Unit::TestCase
-  def setup
-    @object = Object.new
-  end
-  
-  def test_should_match_if_not_specified
-    callback = StateMachine::Callback.new(:before) {}
-    assert callback.matches_success?(true)
-  end
-  
-  def test_should_match_if_true_and_not_including_failures
-    callback = StateMachine::Callback.new(:before, :include_failures => false) {}
-    assert callback.matches_success?(true)
-  end
-  
-  def test_should_match_if_true_and_including_failures
-    callback = StateMachine::Callback.new(:before, :include_failures => true) {}
-    assert callback.matches_success?(true)
-  end
-  
-  def test_should_not_match_if_false_and_not_including_failures
-    callback = StateMachine::Callback.new(:before, :include_failures => false) {}
-    assert !callback.matches_success?(false)
-  end
-  
-  def test_Should_match_if_false_and_including_failures
-    callback = StateMachine::Callback.new(:before, :include_failures => true) {}
-    assert callback.matches_success?(false)
-  end
-end

data/test/unit/error_test.rb

@@ -0,0 +1,43 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class ErrorByDefaultTest < Test::Unit::TestCase
+  def setup
+    @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]
+  end
+end
+
+class ErrorWithMessageTest < Test::Unit::TestCase
+  def setup
+    @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(@machine, :invalid => true) }
+    assert_equal 'Invalid key(s): invalid', exception.message
+  end
+  
+  def test_should_raise_exception_on_lookup_if_invalid_index_specified
+    exception = assert_raise(ArgumentError) { @collection[:something, :invalid] }
+    assert_equal 'Invalid index: :invalid', exception.message
+  end
+  
+  def test_should_raise_exception_on_fetch_if_invalid_index_specified
+    exception = assert_raise(ArgumentError) { @collection.fetch(:something, :invalid) }
+    assert_equal 'Invalid index: :invalid', exception.message
+  end
+end

data/test/unit/event_collection_test.rb

@@ -29,6 +29,7 @@ class EventCollectionTest < Test::Unit::TestCase
     @events = StateMachine::EventCollection.new(machine)
     
     @events << @open = StateMachine::Event.new(machine, :enable)
+    machine.events.concat(@events)
   end
   
   def test_should_index_by_name
@@ -50,42 +51,72 @@ class EventCollectionWithEventsWithTransitionsTest < Test::Unit::TestCase
     @machine = StateMachine::Machine.new(@klass, :initial => :parked)
     @events = StateMachine::EventCollection.new(@machine)
     
-    @machine.state :idling, :stalled
-    @machine.event :ignite
+    @machine.state :idling, :first_gear
     
     @events << @ignite = StateMachine::Event.new(@machine, :ignite)
     @ignite.transition :parked => :idling
-    @ignite.transition :stalled => :idling
-  end
-  
-  def test_should_only_include_valid_events_for_an_object
-    object = @klass.new
-    object.state = 'parked'
-    assert_equal [@ignite], @events.valid_for(object)
     
-    object.state = 'stalled'
-    assert_equal [@ignite], @events.valid_for(object)
+    @events << @park = StateMachine::Event.new(@machine, :park)
+    @park.transition :idling => :parked
     
-    object.state = 'idling'
-    assert_equal [], @events.valid_for(object)
-  end
-  
-  def test_should_only_include_valid_transitions_for_an_object
-    object = @klass.new
-    object.state = 'parked'
-    assert_equal [{:object => object, :attribute => :state, :event => :ignite, :from => 'parked', :to => 'idling'}], @events.transitions_for(object).map {|transition| transition.attributes}
+    @events << @shift_up = StateMachine::Event.new(@machine, :shift_up)
+    @shift_up.transition :parked => :first_gear
+    @shift_up.transition :idling => :first_gear, :if => lambda{false}
     
-    object.state = 'stalled'
-    assert_equal [{:object => object, :attribute => :state, :event => :ignite, :from => 'stalled', :to => 'idling'}], @events.transitions_for(object).map {|transition| transition.attributes}
+    @machine.events.concat(@events)
     
-    object.state = 'idling'
-    assert_equal [], @events.transitions_for(object)
+    @object = @klass.new
   end
   
-  def test_should_filter_valid_transitions_for_an_object_if_requirements_specified
-    object = @klass.new
-    assert_equal [{:object => object, :attribute => :state, :event => :ignite, :from => 'stalled', :to => 'idling'}], @events.transitions_for(object, :from => :stalled).map {|transition| transition.attributes}
-    assert_equal [], @events.transitions_for(object, :from => :idling).map {|transition| transition.attributes}
+  def test_should_find_valid_events_based_on_current_state
+    assert_equal [@ignite, @shift_up], @events.valid_for(@object)
+  end
+  
+  def test_should_filter_valid_events_by_from_state
+    assert_equal [@park], @events.valid_for(@object, :from => :idling)
+  end
+  
+  def test_should_filter_valid_events_by_to_state
+    assert_equal [@shift_up], @events.valid_for(@object, :to => :first_gear)
+  end
+  
+  def test_should_filter_valid_events_by_event
+    assert_equal [@ignite], @events.valid_for(@object, :on => :ignite)
+  end
+  
+  def test_should_filter_valid_events_by_multiple_requirements
+    assert_equal [], @events.valid_for(@object, :from => :idling, :to => :first_gear)
+  end
+  
+  def test_should_allow_finding_valid_events_without_guards
+    assert_equal [@shift_up], @events.valid_for(@object, :from => :idling, :to => :first_gear, :guard => false)
+  end
+  
+  def test_should_find_valid_transitions_based_on_current_state
+    assert_equal [
+      StateMachine::Transition.new(@object, @machine, :ignite, :parked, :idling),
+      StateMachine::Transition.new(@object, @machine, :shift_up, :parked, :first_gear)
+    ], @events.transitions_for(@object)
+  end
+  
+  def test_should_filter_valid_transitions_by_from_state
+    assert_equal [StateMachine::Transition.new(@object, @machine, :park, :idling, :parked)], @events.transitions_for(@object, :from => :idling)
+  end
+  
+  def test_should_filter_valid_transitions_by_to_state
+    assert_equal [StateMachine::Transition.new(@object, @machine, :shift_up, :parked, :first_gear)], @events.transitions_for(@object, :to => :first_gear)
+  end
+  
+  def test_should_filter_valid_transitions_by_event
+    assert_equal [StateMachine::Transition.new(@object, @machine, :ignite, :parked, :idling)], @events.transitions_for(@object, :on => :ignite)
+  end
+  
+  def test_should_filter_valid_transitions_by_multiple_requirements
+    assert_equal [], @events.transitions_for(@object, :from => :idling, :to => :first_gear)
+  end
+  
+  def test_should_allow_finding_valid_transitions_without_guards
+    assert_equal [StateMachine::Transition.new(@object, @machine, :shift_up, :idling, :first_gear)], @events.transitions_for(@object, :from => :idling, :to => :first_gear, :guard => false)
   end
 end
 
@@ -103,6 +134,8 @@ class EventCollectionWithMultipleEventsTest < Test::Unit::TestCase
     
     @events << @shift_down = StateMachine::Event.new(@machine, :shift_down)
     @shift_down.transition :first_gear => :parked
+    
+    @machine.events.concat(@events)
   end
   
   def test_should_only_include_all_valid_events_for_an_object
@@ -117,9 +150,8 @@ class EventCollectionWithoutMachineActionTest < Test::Unit::TestCase
     @klass = Class.new
     @machine = StateMachine::Machine.new(@klass, :initial => :parked)
     @events = StateMachine::EventCollection.new(@machine)
-    
-    @machine.event :ignite
     @events << StateMachine::Event.new(@machine, :ignite)
+    @machine.events.concat(@events)
     
     @object = @klass.new
   end
@@ -139,9 +171,9 @@ class EventCollectionAttributeWithMachineActionTest < Test::Unit::TestCase
     @machine = StateMachine::Machine.new(@klass, :initial => :parked, :action => :save)
     @events = StateMachine::EventCollection.new(@machine)
     
-    @machine.event :ignite
     @machine.state :parked, :idling
     @events << @ignite = StateMachine::Event.new(@machine, :ignite)
+    @machine.events.concat(@events)
     
     @object = @klass.new
   end
@@ -200,9 +232,9 @@ class EventCollectionAttributeWithNamespacedMachineTest < Test::Unit::TestCase
     @machine = StateMachine::Machine.new(@klass, :namespace => 'alarm', :initial => :active, :action => :save)
     @events = StateMachine::EventCollection.new(@machine)
     
-    @machine.event :disable
     @machine.state :active, :off
     @events << @disable = StateMachine::Event.new(@machine, :disable)
+    @machine.events.concat(@events)
     
     @object = @klass.new
   end
@@ -228,6 +260,8 @@ end
 class EventCollectionWithValidationsTest < Test::Unit::TestCase
   def setup
     StateMachine::Integrations.const_set('Custom', Module.new do
+      include StateMachine::Integrations::Base
+      
       def invalidate(object, attribute, message, values = [])
         (object.errors ||= []) << generate_message(message, values)
       end
@@ -249,9 +283,9 @@ class EventCollectionWithValidationsTest < Test::Unit::TestCase
     @machine = StateMachine::Machine.new(@klass, :initial => :parked, :action => :save, :integration => :custom)
     @events = StateMachine::EventCollection.new(@machine)
     
-    @machine.event :ignite
     @parked, @idling = @machine.state :parked, :idling
     @events << @ignite = StateMachine::Event.new(@machine, :ignite)
+    @machine.events.concat(@events)
     
     @object = @klass.new
   end
@@ -303,9 +337,9 @@ class EventCollectionWithCustomMachineAttributeTest < Test::Unit::TestCase
     @machine = StateMachine::Machine.new(@klass, :state, :attribute => :state_id, :initial => :parked, :action => :save)
     @events = StateMachine::EventCollection.new(@machine)
     
-    @machine.event :ignite
     @machine.state :parked, :idling
     @events << @ignite = StateMachine::Event.new(@machine, :ignite)
+    @machine.events.concat(@events)
     
     @object = @klass.new
   end

data/test/unit/event_test.rb

@@ -4,7 +4,7 @@ class EventByDefaultTest < Test::Unit::TestCase
   def setup
     @klass = Class.new
     @machine = StateMachine::Machine.new(@klass)
-    @event = StateMachine::Event.new(@machine, :ignite)
+    @machine.events << @event = StateMachine::Event.new(@machine, :ignite)
     
     @object = @klass.new
   end
@@ -25,8 +25,8 @@ class EventByDefaultTest < Test::Unit::TestCase
     assert_equal 'ignite', @event.human_name
   end
   
-  def test_should_not_have_any_guards
-    assert @event.guards.empty?
+  def test_should_not_have_any_branches
+    assert @event.branches.empty?
   end
   
   def test_should_have_no_known_states
@@ -61,7 +61,7 @@ end
 class EventTest < Test::Unit::TestCase
   def setup
     @machine = StateMachine::Machine.new(Class.new)
-    @event = StateMachine::Event.new(@machine, :ignite)
+    @machine.events << @event = StateMachine::Event.new(@machine, :ignite)
     @event.transition :parked => :idling
   end
   
@@ -95,7 +95,7 @@ class EventWithHumanNameTest < Test::Unit::TestCase
   def setup
     @klass = Class.new
     @machine = StateMachine::Machine.new(@klass)
-    @event = StateMachine::Event.new(@machine, :ignite, :human_name => 'start')
+    @machine.events << @event = StateMachine::Event.new(@machine, :ignite, :human_name => 'start')
   end
   
   def test_should_use_custom_human_name
@@ -107,7 +107,7 @@ class EventWithDynamicHumanNameTest < Test::Unit::TestCase
   def setup
     @klass = Class.new
     @machine = StateMachine::Machine.new(@klass)
-    @event = StateMachine::Event.new(@machine, :ignite, :human_name => lambda {|event, object| ['start', object]})
+    @machine.events << @event = StateMachine::Event.new(@machine, :ignite, :human_name => lambda {|event, object| ['start', object]})
   end
   
   def test_should_use_custom_human_name
@@ -147,7 +147,7 @@ class EventWithConflictingHelpersTest < Test::Unit::TestCase
       end
     end
     @machine = StateMachine::Machine.new(@klass)
-    @state = StateMachine::Event.new(@machine, :ignite)
+    @machine.events << @event = StateMachine::Event.new(@machine, :ignite)
     @object = @klass.new
   end
   
@@ -198,11 +198,58 @@ class EventWithConflictingHelpersTest < Test::Unit::TestCase
   end
 end
 
+class EventWithConflictingMachineTest < Test::Unit::TestCase
+  def setup
+    require 'stringio'
+    @original_stderr, $stderr = $stderr, StringIO.new
+    
+    @klass = Class.new
+    @state_machine = StateMachine::Machine.new(@klass, :state)
+    @state_machine.state :parked, :idling
+    @state_machine.events << @state_event = StateMachine::Event.new(@state_machine, :ignite)
+  end
+  
+  def test_should_not_overwrite_first_event
+    @status_machine = StateMachine::Machine.new(@klass, :status)
+    @status_machine.state :first_gear, :second_gear
+    @status_machine.events << @status_event = StateMachine::Event.new(@status_machine, :ignite)
+    
+    @object = @klass.new
+    @object.state = 'parked'
+    @object.status = 'first_gear'
+    
+    @state_event.transition(:parked => :idling)
+    @status_event.transition(:parked => :first_gear)
+    
+    @object.ignite
+    assert_equal 'idling', @object.state
+    assert_equal 'first_gear', @object.status
+  end
+  
+  def test_should_output_warning
+    @status_machine = StateMachine::Machine.new(@klass, :status)
+    @status_machine.events << @status_event = StateMachine::Event.new(@status_machine, :ignite)
+    
+    assert_equal "Event :ignite for :status is already defined in :state\n", $stderr.string
+  end
+  
+  def test_should_not_output_warning_if_using_different_namespace
+    @status_machine = StateMachine::Machine.new(@klass, :status, :namespace => 'alarm')
+    @status_machine.events << @status_event = StateMachine::Event.new(@status_machine, :ignite)
+    
+    assert_equal '', $stderr.string
+  end
+  
+  def teardown
+    $stderr = @original_stderr
+  end
+end
+
 class EventWithNamespaceTest < Test::Unit::TestCase
   def setup
     @klass = Class.new
     @machine = StateMachine::Machine.new(@klass, :namespace => 'alarm')
-    @event = StateMachine::Event.new(@machine, :enable)
+    @machine.events << @event = StateMachine::Event.new(@machine, :enable)
     @object = @klass.new
   end
   
@@ -234,7 +281,7 @@ end
 class EventTransitionsTest < Test::Unit::TestCase
   def setup
     @machine = StateMachine::Machine.new(Class.new)
-    @event = StateMachine::Event.new(@machine, :ignite)
+    @machine.events << @event = StateMachine::Event.new(@machine, :ignite)
   end
   
   def test_should_not_raise_exception_if_implicit_option_specified
@@ -247,9 +294,9 @@ class EventTransitionsTest < Test::Unit::TestCase
   end
   
   def test_should_automatically_set_on_option
-    guard = @event.transition(:to => :idling)
-    assert_instance_of StateMachine::WhitelistMatcher, guard.event_requirement
-    assert_equal [:ignite], guard.event_requirement.values
+    branch = @event.transition(:to => :idling)
+    assert_instance_of StateMachine::WhitelistMatcher, branch.event_requirement
+    assert_equal [:ignite], branch.event_requirement.values
   end
   
   def test_should_not_allow_except_to_option
@@ -283,20 +330,20 @@ class EventTransitionsTest < Test::Unit::TestCase
   end
   
   def test_should_have_transitions
-    guard = @event.transition(:to => :idling)
-    assert_equal [guard], @event.guards
+    branch = @event.transition(:to => :idling)
+    assert_equal [branch], @event.branches
   end
 end
 
 class EventAfterBeingCopiedTest < Test::Unit::TestCase
   def setup
     @machine = StateMachine::Machine.new(Class.new)
-    @event = StateMachine::Event.new(@machine, :ignite)
+    @machine.events << @event = StateMachine::Event.new(@machine, :ignite)
     @copied_event = @event.dup
   end
   
-  def test_should_not_have_the_same_collection_of_guards
-    assert_not_same @event.guards, @copied_event.guards
+  def test_should_not_have_the_same_collection_of_branches
+    assert_not_same @event.branches, @copied_event.branches
   end
   
   def test_should_not_have_the_same_collection_of_known_states
@@ -308,7 +355,7 @@ class EventWithoutTransitionsTest < Test::Unit::TestCase
   def setup
     @klass = Class.new
     @machine = StateMachine::Machine.new(@klass)
-    @event = StateMachine::Event.new(@machine, :ignite)
+    @machine.events << @event = StateMachine::Event.new(@machine, :ignite)
     @object = @klass.new
   end
   
@@ -334,7 +381,7 @@ class EventWithTransitionsTest < Test::Unit::TestCase
   def setup
     @klass = Class.new
     @machine = StateMachine::Machine.new(@klass)
-    @event = StateMachine::Event.new(@machine, :ignite)
+    @machine.events << @event = StateMachine::Event.new(@machine, :ignite)
     @event.transition(:parked => :idling)
     @event.transition(:first_gear => :idling)
   end
@@ -361,7 +408,7 @@ class EventWithoutMatchingTransitionsTest < Test::Unit::TestCase
     @machine = StateMachine::Machine.new(@klass)
     @machine.state :parked, :idling
     
-    @event = StateMachine::Event.new(@machine, :ignite)
+    @machine.events << @event = StateMachine::Event.new(@machine, :ignite)
     @event.transition(:parked => :idling)
     
     @object = @klass.new
@@ -372,10 +419,18 @@ class EventWithoutMatchingTransitionsTest < Test::Unit::TestCase
     assert !@event.can_fire?(@object)
   end
   
+  def test_should_be_able_to_fire_with_custom_from_state
+    assert @event.can_fire?(@object, :from => :parked)
+  end
+  
   def test_should_not_have_a_transition
     assert_nil @event.transition_for(@object)
   end
   
+  def test_should_have_a_transition_with_custom_from_state
+    assert_not_nil @event.transition_for(@object, :from => :parked)
+  end
+  
   def test_should_not_fire
     assert !@event.fire(@object)
   end
@@ -389,6 +444,8 @@ end
 class EventWithMatchingDisabledTransitionsTest < Test::Unit::TestCase
   def setup
     StateMachine::Integrations.const_set('Custom', Module.new do
+      include StateMachine::Integrations::Base
+      
       def invalidate(object, attribute, message, values = [])
         (object.errors ||= []) << generate_message(message, values)
       end
@@ -405,7 +462,7 @@ class EventWithMatchingDisabledTransitionsTest < Test::Unit::TestCase
     @machine = StateMachine::Machine.new(@klass, :integration => :custom)
     @machine.state :parked, :idling
     
-    @event = StateMachine::Event.new(@machine, :ignite)
+    @machine.events << @event = StateMachine::Event.new(@machine, :ignite)
     @event.transition(:parked => :idling, :if => lambda {false})
     
     @object = @klass.new
@@ -416,10 +473,18 @@ class EventWithMatchingDisabledTransitionsTest < Test::Unit::TestCase
     assert !@event.can_fire?(@object)
   end
   
+  def test_should_be_able_to_fire_with_disabled_guards
+    assert @event.can_fire?(@object, :guard => false)
+  end
+  
   def test_should_not_have_a_transition
     assert_nil @event.transition_for(@object)
   end
   
+  def test_should_have_a_transition_with_disabled_guards
+    assert_not_nil @event.transition_for(@object, :guard => false)
+  end
+  
   def test_should_not_fire
     assert !@event.fire(@object)
   end
@@ -447,6 +512,22 @@ class EventWithMatchingDisabledTransitionsTest < Test::Unit::TestCase
     assert_equal ['cannot transition via "ignite"'], @object.errors
   end
   
+  def test_should_run_failure_callbacks
+    callback_args = nil
+    @machine.after_failure {|*args| callback_args = args}
+    
+    @event.fire(@object)
+    
+    object, transition = callback_args
+    assert_equal @object, object
+    assert_not_nil transition
+    assert_equal @object, transition.object
+    assert_equal @machine, transition.machine
+    assert_equal :ignite, transition.event
+    assert_equal :parked, transition.from_name
+    assert_equal :parked, transition.to_name
+  end
+  
   def teardown
     StateMachine::Integrations.send(:remove_const, 'Custom')
   end
@@ -455,6 +536,8 @@ end
 class EventWithMatchingEnabledTransitionsTest < Test::Unit::TestCase
   def setup
     StateMachine::Integrations.const_set('Custom', Module.new do
+      include StateMachine::Integrations::Base
+      
       def invalidate(object, attribute, message, values = [])
         (object.errors ||= []) << generate_message(message, values)
       end
@@ -470,9 +553,8 @@ class EventWithMatchingEnabledTransitionsTest < Test::Unit::TestCase
     
     @machine = StateMachine::Machine.new(@klass, :integration => :custom)
     @machine.state :parked, :idling
-    @machine.event :ignite
     
-    @event = StateMachine::Event.new(@machine, :ignite)
+    @machine.events << @event = StateMachine::Event.new(@machine, :ignite)
     @event.transition(:parked => :idling)
     
     @object = @klass.new
@@ -522,9 +604,8 @@ class EventWithTransitionWithoutToStateTest < Test::Unit::TestCase
     @klass = Class.new
     @machine = StateMachine::Machine.new(@klass)
     @machine.state :parked
-    @machine.event :park
     
-    @event = StateMachine::Event.new(@machine, :park)
+    @machine.events << @event = StateMachine::Event.new(@machine, :park)
     @event.transition(:from => :parked)
     
     @object = @klass.new
@@ -558,9 +639,8 @@ class EventWithTransitionWithNilToStateTest < Test::Unit::TestCase
     @klass = Class.new
     @machine = StateMachine::Machine.new(@klass)
     @machine.state nil, :idling
-    @machine.event :park
     
-    @event = StateMachine::Event.new(@machine, :park)
+    @machine.events << @event = StateMachine::Event.new(@machine, :park)
     @event.transition(:idling => nil)
     
     @object = @klass.new
@@ -594,9 +674,8 @@ class EventWithMultipleTransitionsTest < Test::Unit::TestCase
     @klass = Class.new
     @machine = StateMachine::Machine.new(@klass)
     @machine.state :parked, :idling
-    @machine.event :ignite
     
-    @event = StateMachine::Event.new(@machine, :ignite)
+    @machine.events << @event = StateMachine::Event.new(@machine, :ignite)
     @event.transition(:idling => :idling)
     @event.transition(:parked => :idling) # This one should get used
     @event.transition(:parked => :parked)
@@ -635,12 +714,9 @@ class EventWithMultipleTransitionsTest < Test::Unit::TestCase
     assert_equal :ignite, transition.event
   end
   
-  def test_should_allow_specific_transition_selection_using_on
-    transition = @event.transition_for(@object, :on => :park)
-    assert_nil transition
-    
-    transition = @event.transition_for(@object, :on => :ignite)
-    assert_not_nil transition
+  def test_should_not_allow_specific_transition_selection_using_on
+    exception = assert_raise(ArgumentError) { @event.transition_for(@object, :on => :park) }
+    assert_equal 'Invalid key(s): on', exception.message
   end
   
   def test_should_fire
@@ -689,9 +765,8 @@ class EventWithInvalidCurrentStateTest < Test::Unit::TestCase
     @klass = Class.new
     @machine = StateMachine::Machine.new(@klass)
     @machine.state :parked, :idling
-    @machine.event :ignite
     
-    @event = StateMachine::Event.new(@machine, :ignite)
+    @machine.events << @event = StateMachine::Event.new(@machine, :ignite)
     @event.transition(:parked => :idling)
     
     @object = @klass.new
@@ -714,6 +789,58 @@ class EventWithInvalidCurrentStateTest < Test::Unit::TestCase
   end
 end
 
+class EventOnFailureTest < Test::Unit::TestCase
+  def setup
+    StateMachine::Integrations.const_set('Custom', Module.new do
+      include StateMachine::Integrations::Base
+      
+      def invalidate(object, attribute, message, values = [])
+        (object.errors ||= []) << generate_message(message, values)
+      end
+      
+      def reset(object)
+        object.errors = []
+      end
+    end)
+    
+    @klass = Class.new do
+      attr_accessor :errors
+    end
+    
+    @machine = StateMachine::Machine.new(@klass, :integration => :custom)
+    @machine.state :parked
+    @machine.events << @event = StateMachine::Event.new(@machine, :ignite)
+    
+    @object = @klass.new
+    @object.state = 'parked'
+  end
+  
+  def test_should_invalidate_the_state
+    @event.fire(@object)
+    assert_equal ['cannot transition via "ignite"'], @object.errors
+  end
+  
+  def test_should_run_failure_callbacks
+    callback_args = nil
+    @machine.after_failure {|*args| callback_args = args}
+    
+    @event.fire(@object)
+    
+    object, transition = callback_args
+    assert_equal @object, object
+    assert_not_nil transition
+    assert_equal @object, transition.object
+    assert_equal @machine, transition.machine
+    assert_equal :ignite, transition.event
+    assert_equal :parked, transition.from_name
+    assert_equal :parked, transition.to_name
+  end
+  
+  def teardown
+    StateMachine::Integrations.send(:remove_const, 'Custom')
+  end
+end
+
 class EventWithMarshallingTest < Test::Unit::TestCase
   def setup
     @klass = Class.new do
@@ -774,7 +901,7 @@ begin
       graph = GraphViz.new('G')
       states.each {|state| graph.add_node(state.to_s)}
       
-      @event = StateMachine::Event.new(@machine , :park)
+      @machine.events << @event = StateMachine::Event.new(@machine , :park)
       @event.transition :parked => :idling
       @event.transition :first_gear => :parked
       @event.transition :except_from => :parked, :to => :parked