state_machine 0.3.1 → 0.4.0

data/test/test_helper.rb

@@ -1,13 +1,4 @@
-# Load the plugin testing framework
-$:.unshift("#{File.dirname(__FILE__)}/../../plugin_test_helper/lib")
-require 'rubygems'
-require 'plugin_test_helper'
+require 'test/unit'
 
-# Run the migrations
-ActiveRecord::Migrator.migrate("#{Rails.root}/db/migrate")
-
-# Mixin the factory helper
-require File.expand_path("#{File.dirname(__FILE__)}/factory")
-class Test::Unit::TestCase #:nodoc:
-  include Factory
-end
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require File.dirname(__FILE__) + '/../init'

data/test/unit/assertions_test.rb

@@ -0,0 +1,13 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class AssertionsTest < Test::Unit::TestCase
+  include StateMachine::Assertions
+  
+  def test_should_not_raise_exception_if_key_is_valid
+    assert_nothing_raised { assert_valid_keys({:name => 'foo', :value => 'bar'}, :name, :value, :force) }
+  end
+  
+  def test_should_raise_exception_if_key_is_invalid
+    assert_raise(ArgumentError) { assert_valid_keys({:name => 'foo', :value => 'bar', :invalid => true}, :name, :value, :force) }
+  end
+end

data/test/unit/callback_test.rb

@@ -0,0 +1,189 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class CallbackTest < Test::Unit::TestCase
+  def test_should_raise_exception_if_do_option_not_specified
+    assert_raise(ArgumentError) { StateMachine::Callback.new }
+  end
+  
+  def test_should_not_raise_exception_if_do_option_specified
+    assert_nothing_raised { StateMachine::Callback.new(:do => :run) }
+  end
+  
+  def test_should_raise_exception_if_invalid_option_specified
+    assert_raise(ArgumentError) { StateMachine::Callback.new(:do => :run, :invalid => true) }
+  end
+  
+  def test_should_not_bind_to_objects
+    assert !StateMachine::Callback.bind_to_object
+  end
+end
+
+class CallbackByDefaultTest < Test::Unit::TestCase
+  def setup
+    @object = Object.new
+    @method = lambda {|*args| args.unshift(self)}
+    @callback = StateMachine::Callback.new(:do => @method)
+  end
+  
+  def test_should_not_have_a_terminator
+    assert_nil @callback.terminator
+  end
+  
+  def test_should_have_a_guard_with_no_requirements
+    expected = {}
+    assert_equal expected, @callback.guard.requirements
+  end
+  
+  def test_should_not_bind_to_the_object
+    assert_equal [self, @object], @callback.call(@object)
+  end
+  
+  def test_should_not_have_any_known_states
+    assert_equal [], @callback.known_states
+  end
+end
+
+class CallbackWithOnlyMethodTest < Test::Unit::TestCase
+  def setup
+    @object = Object.new
+    @callback = StateMachine::Callback.new(lambda {true})
+  end
+  
+  def test_should_call_with_empty_context
+    assert @callback.call(@object)
+  end
+end
+
+class CallbackWithRequirementsTest < Test::Unit::TestCase
+  def setup
+    @object = Object.new
+    @callback = StateMachine::Callback.new(:from => 'off', :to => 'on', :on => 'turn_on', :do => lambda {true})
+  end
+  
+  def test_should_call_with_empty_context
+    assert @callback.call(@object, {})
+  end
+  
+  def test_should_not_call_if_from_not_included
+    assert !@callback.call(@object, :from => 'on')
+  end
+  
+  def test_should_not_call_if_to_not_included
+    assert !@callback.call(@object, :to => 'off')
+  end
+  
+  def test_should_not_call_if_on_not_included
+    assert !@callback.call(@object, :on => 'turn_off')
+  end
+  
+  def test_should_call_if_all_requirements_met
+    assert @callback.call(@object, :from => 'off', :to => 'on', :on => 'turn_on')
+  end
+  
+  def test_should_include_in_known_states
+    assert_equal %w(off on), @callback.known_states.sort
+  end
+end
+
+class CallbackWithIfConditionalTest < Test::Unit::TestCase
+  def setup
+    @object = Object.new
+  end
+  
+  def test_should_call_if_true
+    callback = StateMachine::Callback.new(:if => lambda {true}, :do => lambda {true})
+    assert callback.call(@object)
+  end
+  
+  def test_should_not_call_if_false
+    callback = StateMachine::Callback.new(:if => lambda {false}, :do => lambda {true})
+    assert !callback.call(@object)
+  end
+end
+
+class CallbackWithUnlessConditionalTest < Test::Unit::TestCase
+  def setup
+    @object = Object.new
+  end
+  
+  def test_should_call_if_false
+    callback = StateMachine::Callback.new(:unless => lambda {false}, :do => lambda {true})
+    assert callback.call(@object)
+  end
+  
+  def test_should_not_call_if_true
+    callback = StateMachine::Callback.new(:unless => lambda {true}, :do => lambda {true})
+    assert !callback.call(@object)
+  end
+end
+
+class CallbackWithoutTerminatorTest < Test::Unit::TestCase
+  def setup
+    @object = Object.new
+  end
+  
+  def test_should_not_halt_if_result_is_false
+    callback = StateMachine::Callback.new(:do => lambda {false}, :terminator => nil)
+    assert_nothing_thrown { callback.call(@object) }
+  end
+end
+
+class CallbackWithTerminatorTest < Test::Unit::TestCase
+  def setup
+    @object = Object.new
+  end
+  
+  def test_should_not_halt_if_terminator_does_not_match
+    callback = StateMachine::Callback.new(:do => lambda {false}, :terminator => lambda {|result| false})
+    assert_nothing_thrown { callback.call(@object) }
+  end
+  
+  def test_should_halt_if_terminator_matches
+    callback = StateMachine::Callback.new(:do => lambda {false}, :terminator => lambda {|result| true})
+    assert_throws(:halt) { callback.call(@object) }
+  end
+end
+
+class CallbackWithoutArgumentsTest < Test::Unit::TestCase
+  def setup
+    @object = Object.new
+    @callback = StateMachine::Callback.new(:do => lambda {|object| object})
+  end
+  
+  def test_should_call_method_with_object_as_argument
+    assert_equal @object, @callback.call(@object, {}, 1, 2, 3)
+  end
+end
+
+class CallbackWithArgumentsTest < Test::Unit::TestCase
+  def setup
+    @object = Object.new
+    @callback = StateMachine::Callback.new(:do => lambda {|*args| args})
+  end
+  
+  def test_should_call_method_with_all_arguments
+    assert_equal [@object, 1, 2, 3], @callback.call(@object, {}, 1, 2, 3)
+  end
+end
+
+class CallbackWithUnboundObjectTest < Test::Unit::TestCase
+  def setup
+    @object = Object.new
+    @callback = StateMachine::Callback.new(:do => lambda {|*args| args.unshift(self)})
+  end
+  
+  def test_should_call_method_outside_the_context_of_the_object
+    assert_equal [self, @object, 1, 2, 3], @callback.call(@object, {}, 1, 2, 3)
+  end
+end
+
+class CallbackWithBoundObjectTest < Test::Unit::TestCase
+  def setup
+    @object = Object.new
+    @callback = StateMachine::Callback.new(:do => lambda {|*args| args.unshift(self)}, :bind_to_object => true)
+  end
+  
+  def test_should_call_method_within_the_context_of_the_object
+    assert_equal [@object, 1, 2, 3], @callback.call(@object, {}, 1, 2, 3)
+  end
+end

data/test/unit/eval_helpers_test.rb

@@ -0,0 +1,92 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class EvalHelperTest < Test::Unit::TestCase
+  include StateMachine::EvalHelpers
+  
+  def setup
+    @object = Object.new
+  end
+  
+  def test_should_raise_exception_if_method_is_not_symbol_string_or_proc
+     assert_raise(ArgumentError) { evaluate_method(@object, 1) }
+  end
+end
+
+class EvalHelpersSymbolTest < Test::Unit::TestCase
+  include StateMachine::EvalHelpers
+  
+  def setup
+    class << (@object = Object.new)
+      def callback
+        true
+      end
+    end
+  end
+  
+  def test_should_call_method_on_object_with_no_arguments
+    assert evaluate_method(@object, :callback, 1, 2, 3)
+  end
+end
+
+class EvalHelperSymbolWithArgumentsTest < Test::Unit::TestCase
+  include StateMachine::EvalHelpers
+  
+  def setup
+    class << (@object = Object.new)
+      def callback(*args)
+        args
+      end
+    end
+  end
+  
+  def test_should_call_method_with_all_arguments
+    assert_equal [1, 2, 3], evaluate_method(@object, :callback, 1, 2, 3)
+  end
+end
+
+class EvalHelperStringTest < Test::Unit::TestCase
+  include StateMachine::EvalHelpers
+  
+  def setup
+    @object = Object.new
+  end
+  
+  def test_should_evaluate_string
+    assert_equal 1, evaluate_method(@object, '1')
+  end
+  
+  def test_should_evaluate_string_within_object_context
+    @object.instance_variable_set('@value', 1)
+    assert_equal 1, evaluate_method(@object, '@value')
+  end
+  
+  def test_should_ignore_additional_arguments
+    assert_equal 1, evaluate_method(@object, '1', 2, 3, 4)
+  end
+end
+
+class EvalHelperProcTest < Test::Unit::TestCase
+  include StateMachine::EvalHelpers
+  
+  def setup
+    @object = Object.new
+    @proc = lambda {|obj| obj}
+  end
+  
+  def test_should_call_proc_with_object_as_argument
+    assert_equal @object, evaluate_method(@object, @proc, 1, 2, 3)
+  end
+end
+
+class EvalHelperProcWithArgumentsTest < Test::Unit::TestCase
+  include StateMachine::EvalHelpers
+  
+  def setup
+    @object = Object.new
+    @proc = lambda {|*args| args}
+  end
+  
+  def test_should_call_method_with_all_arguments
+    assert_equal [@object, 1, 2, 3], evaluate_method(@object, @proc, 1, 2, 3)
+  end
+end

data/test/unit/event_test.rb

@@ -2,10 +2,22 @@ require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
 
 class EventTest < Test::Unit::TestCase
   def setup
-    @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state')
-    @event = PluginAWeek::StateMachine::Event.new(@machine, 'turn_on')
+    @machine = StateMachine::Machine.new(Class.new)
+    @event = StateMachine::Event.new(@machine, 'turn_on')
+  end
+  
+  def test_should_raise_exception_if_invalid_option_specified
+    assert_raise(ArgumentError) {StateMachine::Event.new(@machine, 'turn_on', :invalid => true)}
+  end
+end
+
+class EventByDefaultTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+    @event = StateMachine::Event.new(@machine, 'turn_on')
     
-    @switch = new_switch
+    @object = @klass.new
   end
   
   def test_should_have_a_machine
@@ -16,49 +28,77 @@ class EventTest < Test::Unit::TestCase
     assert_equal 'turn_on', @event.name
   end
   
-  def test_should_not_have_any_transitions
-    assert @event.transitions.empty?
+  def test_should_not_have_any_guards
+    assert @event.guards.empty?
   end
   
-  def test_should_define_an_event_action_on_the_owner_class
-    assert @switch.respond_to?(:turn_on)
+  def test_should_have_no_known_states
+    assert @event.known_states.empty?
   end
   
-  def test_should_define_an_event_bang_action_on_the_owner_class
-    assert @switch.respond_to?(:turn_on!)
+  def test_should_not_be_able_to_fire
+    assert !@event.can_fire?(@object)
+  end
+  
+  def test_should_not_have_a_next_transition
+    assert_nil @event.next_transition(@object)
   end
   
   def test_should_define_an_event_predicate_on_the_owner_class
-    assert @switch.respond_to?(:can_turn_on?)
+    assert @object.respond_to?(:can_turn_on?)
   end
   
-  def test_should_raise_exception_if_invalid_option_specified
-    assert_raise(ArgumentError) {PluginAWeek::StateMachine::Event.new(@machine, 'turn_on', :invalid => true)}
+  def test_should_define_an_event_transition_accessor_on_the_owner_class
+    assert @object.respond_to?(:next_turn_on_transition)
+  end
+  
+  def test_should_define_an_event_action_on_the_owner_class
+    assert @object.respond_to?(:turn_on)
+  end
+  
+  def test_should_define_an_event_bang_action_on_the_owner_class
+    assert @object.respond_to?(:turn_on!)
   end
 end
 
-class EventDefiningTransitionsTest < Test::Unit::TestCase
+class EventTransitionsTest < Test::Unit::TestCase
   def setup
-    @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state', :initial => 'off')
-    @event = PluginAWeek::StateMachine::Event.new(@machine, 'turn_on')
+    @machine = StateMachine::Machine.new(Class.new)
+    @event = StateMachine::Event.new(@machine, 'turn_on')
   end
   
   def test_should_raise_exception_if_invalid_option_specified
     assert_raise(ArgumentError) {@event.transition(:invalid => true)}
   end
   
-  def test_should_raise_exception_if_to_option_not_specified
-    assert_raise(ArgumentError) {@event.transition(:from => 'off')}
+  def test_should_not_raise_exception_if_to_option_not_specified
+    assert_nothing_raised {@event.transition(:from => 'off')}
   end
   
   def test_should_not_raise_exception_if_from_option_not_specified
     assert_nothing_raised {@event.transition(:to => 'on')}
   end
   
+  def test_should_not_allow_on_option
+    assert_raise(ArgumentError) {@event.transition(:on => 'turn_on')}
+  end
+  
+  def test_should_not_allow_except_to_option
+    assert_raise(ArgumentError) {@event.transition(:except_to => 'off')}
+  end
+  
+  def test_should_not_allow_except_on_option
+    assert_raise(ArgumentError) {@event.transition(:except_on => 'turn_on')}
+  end
+  
   def test_should_allow_transitioning_without_a_from_state
     assert @event.transition(:to => 'on')
   end
   
+  def test_should_allow_transitioning_without_a_to_state
+    assert @event.transition(:from => 'off')
+  end
+  
   def test_should_allow_transitioning_from_a_single_state
     assert @event.transition(:to => 'on', :from => 'off')
   end
@@ -68,168 +108,262 @@ class EventDefiningTransitionsTest < Test::Unit::TestCase
   end
   
   def test_should_have_transitions
-    transition = @event.transition(:to => 'on')
-    assert_equal [transition], @event.transitions
+    guard = @event.transition(:to => 'on')
+    assert_equal [guard], @event.guards
   end
 end
 
 class EventAfterBeingCopiedTest < Test::Unit::TestCase
   def setup
-    @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state', :initial => 'off')
-    @event = PluginAWeek::StateMachine::Event.new(@machine, 'turn_on')
+    @machine = StateMachine::Machine.new(Class.new)
+    @event = StateMachine::Event.new(@machine, 'turn_on')
+    @event.known_states # Call so that it's cached
     @copied_event = @event.dup
   end
   
-  def test_should_not_have_the_same_collection_of_transitions
-    assert_not_same @copied_event.transitions, @event.transitions
+  def test_should_not_have_the_same_collection_of_guards
+    assert_not_same @event.guards, @copied_event.guards
+  end
+  
+  def test_should_not_have_the_same_collection_of_known_states
+    assert_not_same @event.known_states, @copied_event.known_states
   end
 end
 
 class EventWithoutTransitionsTest < Test::Unit::TestCase
   def setup
-    @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state', :initial => 'off')
-    @event = PluginAWeek::StateMachine::Event.new(@machine, 'turn_on')
-    @switch = create_switch(:state => 'off')
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+    @event = StateMachine::Event.new(@machine, 'turn_on')
+    @object = @klass.new
   end
   
   def test_should_not_be_able_to_fire
-    assert !@event.can_fire?(@switch)
+    assert !@event.can_fire?(@object)
+  end
+  
+  def test_should_not_have_a_next_transition
+    assert_nil @event.next_transition(@object)
   end
   
   def test_should_not_fire
-    assert !@event.fire(@switch)
+    assert !@event.fire(@object)
   end
   
   def test_should_not_change_the_current_state
-    @event.fire(@switch)
-    assert_equal 'off', @switch.state
+    @event.fire(@object)
+    assert_nil @object.state
+  end
+end
+
+class EventWithTransitionsTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+    @event = StateMachine::Event.new(@machine, 'turn_on')
+    @event.transition(:to => 'on', :from => 'off')
+    @event.transition(:to => 'on', :except_from => 'maybe')
   end
   
-  def test_should_raise_exception_during_fire!
-    assert_raise(PluginAWeek::StateMachine::InvalidTransition) {@event.fire!(@switch)}
+  def test_should_include_all_transition_states_in_known_states
+    assert_equal %w(maybe off on), @event.known_states.sort
+  end
+  
+  def test_should_include_new_transition_states_after_calling_known_states
+    @event.known_states
+    @event.transition(:to => 'error')
+    
+    assert_equal %w(error maybe off on), @event.known_states.sort
   end
 end
 
-class EventWithTransitionsTest < Test::Unit::TestCase
+class EventWithoutMatchingTransitionsTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+    @event = StateMachine::Event.new(@machine, 'turn_on')
+    @event.transition(:to => 'on', :from => 'off')
+    
+    @object = @klass.new
+    @object.state = 'on'
+  end
+  
+  def test_should_not_be_able_to_fire
+    assert !@event.can_fire?(@object)
+  end
+  
+  def test_should_not_have_a_next_transition
+    assert_nil @event.next_transition(@object)
+  end
+  
+  def test_should_not_fire
+    assert !@event.fire(@object)
+  end
+  
+  def test_should_not_change_the_current_state
+    @event.fire(@object)
+    assert_equal 'on', @object.state
+  end
+end
+
+class EventWithMatchingDisabledTransitionsTest < Test::Unit::TestCase
   def setup
-    @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state', :initial => 'off')
-    @event = PluginAWeek::StateMachine::Event.new(@machine, 'turn_on')
-    @event.transition :to => 'error', :from => 'on'
-    @switch = create_switch(:state => 'off')
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+    @event = StateMachine::Event.new(@machine, 'turn_on')
+    @event.transition(:to => 'on', :from => 'off', :if => lambda {false})
+    
+    @object = @klass.new
+    @object.state = 'off'
   end
   
-  def test_should_not_be_able_to_fire_if_no_transitions_are_matched
-    assert !@event.can_fire?(@switch)
+  def test_should_not_be_able_to_fire
+    assert !@event.can_fire?(@object)
   end
   
-  def test_should_not_fire_if_no_transitions_are_matched
-    assert !@event.fire(@switch)
-    assert_equal 'off', @switch.state
+  def test_should_not_have_a_next_transition
+    assert_nil @event.next_transition(@object)
   end
   
-  def test_should_raise_exception_if_no_transitions_are_matched_during_fire!
-    assert_raise(PluginAWeek::StateMachine::InvalidTransition) {@event.fire!(@switch)}
-    assert_equal 'off', @switch.state
+  def test_should_not_fire
+    assert !@event.fire(@object)
   end
   
-  def test_should_be_able_to_fire_if_transition_is_matched
-    @event.transition :to => 'on'
-    assert @event.can_fire?(@switch)
+  def test_should_not_change_the_current_state
+    @event.fire(@object)
+    assert_equal 'off', @object.state
+  end
+end
+
+class EventWithMatchingEnabledTransitionsTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+    @event = StateMachine::Event.new(@machine, 'turn_on')
+    @event.transition(:to => 'on', :from => 'off')
+    
+    @object = @klass.new
+    @object.state = 'off'
   end
   
-  def test_should_fire_if_transition_is_matched
-    @event.transition :to => 'on'
-    assert @event.fire(@switch)
-    assert_equal 'on', @switch.state
+  def test_should_be_able_to_fire
+    assert @event.can_fire?(@object)
   end
   
-  def test_should_fire_if_transition_with_from_state_is_matched
-    @event.transition :to => 'on', :from => 'off'
-    assert @event.fire(@switch)
-    assert_equal 'on', @switch.state
+  def test_should_have_a_next_transition
+    transition = @event.next_transition(@object)
+    assert_not_nil transition
+    assert_equal 'off', transition.from
+    assert_equal 'on', transition.to
+    assert_equal 'turn_on', transition.event
   end
   
-  def test_should_fire_if_transition_with_multiple_from_states_is_matched
-    @event.transition :to => 'on', :from => %w(off on)
-    assert @event.fire(@switch)
-    assert_equal 'on', @switch.state
+  def test_should_fire
+    assert @event.fire(@object)
   end
   
-  def test_should_not_fire_if_validation_failed
-    @event.transition :to => 'on', :from => 'off'
-    @switch.fail_validation = true
-    assert !@event.fire(@switch)
+  def test_should_change_the_current_state
+    @event.fire(@object)
+    assert_equal 'on', @object.state
+  end
+end
+
+class EventWithTransitionWithoutToStateTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+    @event = StateMachine::Event.new(@machine, 'turn_off')
+    @event.transition(:from => 'off')
     
-    @switch.reload
-    assert_equal 'off', @switch.state
+    @object = @klass.new
+    @object.state = 'off'
+  end
+  
+  def test_should_be_able_to_fire
+    assert @event.can_fire?(@object)
+  end
+  
+  def test_should_have_a_next_transition
+    transition = @event.next_transition(@object)
+    assert_not_nil transition
+    assert_equal 'off', transition.from
+    assert_equal 'off', transition.to
+    assert_equal 'turn_off', transition.event
   end
   
-  def test_should_raise_exception_if_validation_failed_during_fire!
-    @event.transition :to => 'on', :from => 'off'
-    @switch.fail_validation = true
-    assert_raise(ActiveRecord::RecordInvalid) {@event.fire!(@switch)}
+  def test_should_fire
+    assert @event.fire(@object)
   end
   
-  def test_should_not_fire_if_save_failed
-    @event.transition :to => 'on', :from => 'off'
-    @switch.fail_save = true
-    assert !@event.fire(@switch)
+  def test_should_not_change_the_current_state
+    @event.fire(@object)
+    assert_equal 'off', @object.state
+  end
+end
+
+class EventWithTransitionWithDynamicToStateTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+    @event = StateMachine::Event.new(@machine, 'turn_on')
+    @event.transition(:to => lambda {'on'}, :from => 'off')
     
-    @switch.reload
-    assert_equal 'off', @switch.state
+    @object = @klass.new
+    @object.state = 'off'
+  end
+  
+  def test_should_be_able_to_fire
+    assert @event.can_fire?(@object)
+  end
+  
+  def test_should_have_a_next_transition
+    transition = @event.next_transition(@object)
+    assert_not_nil transition
+    assert_equal 'off', transition.from
+    assert_equal 'on', transition.to
+    assert_equal 'turn_on', transition.event
   end
   
-  def test_should_raise_exception_if_save_failed_during_fire!
-    @event.transition :to => 'on', :from => 'off'
-    @switch.fail_save = true
-    assert_raise(ActiveRecord::RecordNotSaved) {@event.fire!(@switch)}
+  def test_should_fire
+    assert @event.fire(@object)
   end
   
-  def test_should_not_raise_exception_if_transition_is_matched_during_fire!
-    @event.transition :to => 'on', :from => 'off'
-    assert @event.fire!(@switch)
-    assert_equal 'on', @switch.state
+  def test_should_change_the_current_state
+    @event.fire(@object)
+    assert_equal 'on', @object.state
   end
 end
 
-class EventWithinTransactionTest < Test::Unit::TestCase
+class EventWithMultipleTransitionsTest < Test::Unit::TestCase
   def setup
-    @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state', :initial => 'off')
-    @event = PluginAWeek::StateMachine::Event.new(@machine, 'turn_on')
-    @event.transition :to => 'on', :from => 'off'
-    @switch = create_switch(:state => 'off')
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+    @event = StateMachine::Event.new(@machine, 'turn_on')
+    @event.transition(:to => 'on', :from => 'on')
+    @event.transition(:to => 'on', :from => 'off') # This one should get used
     
-    Switch.define_callbacks :before_transition_state
+    @object = @klass.new
+    @object.state = 'off'
   end
   
-  def test_should_save_all_records_within_transaction_if_performed
-    Switch.before_transition_state lambda {|record| Switch.create(:state => 'pending'); true}, :from => 'off'
-    assert @event.fire(@switch)
-    assert_equal 'on', @switch.state
-    assert_equal 'pending', Switch.find(:all).last.state
+  def test_should_be_able_to_fire
+    assert @event.can_fire?(@object)
   end
   
-  uses_transaction :test_should_rollback_all_records_within_transaction_if_not_performed
-  def test_should_rollback_all_records_within_transaction_if_not_performed
-    Switch.before_transition_state lambda {|record| Switch.create(:state => 'pending'); false}, :from => 'off'
-    assert !@event.fire(@switch)
-    assert_equal 1, Switch.count
-  ensure
-    Switch.destroy_all
+  def test_should_have_a_next_transition
+    transition = @event.next_transition(@object)
+    assert_not_nil transition
+    assert_equal 'off', transition.from
+    assert_equal 'on', transition.to
+    assert_equal 'turn_on', transition.event
   end
   
-  uses_transaction :test_should_rollback_all_records_within_transaction_if_not_performed!
-  def test_should_rollback_all_records_within_transaction_if_not_performed!
-    Switch.before_transition_state lambda {|record| Switch.create(:state => 'pending'); false}, :from => 'off'
-    assert_raise(PluginAWeek::StateMachine::InvalidTransition) {@event.fire!(@switch)}
-    assert_equal 1, Switch.count
-  ensure
-    Switch.destroy_all
+  def test_should_fire
+    assert @event.fire(@object)
   end
   
-  def teardown
-    Switch.class_eval do
-      @before_transition_state_callbacks = nil
-    end
+  def test_should_change_the_current_state
+    @event.fire(@object)
+    assert_equal 'on', @object.state
   end
 end