state_machine 0.2.1 → 0.3.0

data/test/unit/machine_test.rb

@@ -26,12 +26,6 @@ class MachineByDefaultTest < Test::Unit::TestCase
   end
 end
 
-class MachineWithInvalidOptionsTest < Test::Unit::TestCase
-  def test_should_throw_an_exception
-    assert_raise(ArgumentError) {PluginAWeek::StateMachine::Machine.new(Switch, 'state', :invalid => true)}
-  end
-end
-
 class MachineWithInitialStateTest < Test::Unit::TestCase
   def setup
     @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state', :initial => 'off')
@@ -40,15 +34,11 @@ class MachineWithInitialStateTest < Test::Unit::TestCase
   def test_should_have_an_initial_state
     assert_equal 'off', @machine.initial_state(new_switch)
   end
-  
-  def test_should_have_an_initial_state_without_processing
-    assert_equal 'off', @machine.initial_state_without_processing
-  end
 end
 
 class MachineWithDynamicInitialStateTest < Test::Unit::TestCase
   def setup
-    @initial_state = Proc.new {|switch| switch.initial_state}
+    @initial_state = lambda {|switch| switch.initial_state}
     @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state', :initial => @initial_state)
   end
   
@@ -56,10 +46,6 @@ class MachineWithDynamicInitialStateTest < Test::Unit::TestCase
     assert_equal 'off', @machine.initial_state(new_switch(:initial_state => 'off'))
     assert_equal 'on', @machine.initial_state(new_switch(:initial_state => 'on'))
   end
-  
-  def test_should_have_an_initial_state_without_processing
-    assert_equal @initial_state, @machine.initial_state_without_processing
-  end
 end
 
 class MachineTest < Test::Unit::TestCase
@@ -80,6 +66,74 @@ class MachineTest < Test::Unit::TestCase
     
     assert_equal [on, off], Switch.with_states('on', 'off')
   end
+  
+  def test_should_raise_exception_if_invalid_option_specified
+    assert_raise(ArgumentError) {PluginAWeek::StateMachine::Machine.new(Switch, 'state', :invalid => true)}
+  end
+  
+  def test_should_symbolize_attribute
+    machine = PluginAWeek::StateMachine::Machine.new(Switch, :state)
+    assert_equal 'state', machine.attribute
+  end
+end
+
+class MachineAfterBeingCopiedTest < Test::Unit::TestCase
+  def setup
+    @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state')
+    @machine.event(:turn_on) {}
+    
+    @copied_machine = @machine.dup
+  end
+  
+  def test_should_not_have_the_same_collection_of_states
+    assert_not_same @copied_machine.states, @machine.states
+  end
+  
+  def test_should_not_have_the_same_collection_of_events
+    assert_not_same @copied_machine.events, @machine.events
+  end
+  
+  def test_should_copy_each_event
+    assert_not_same @copied_machine.events['turn_on'], @machine.events['turn_on']
+  end
+  
+  def test_should_update_machine_for_each_event
+    assert_equal @copied_machine, @copied_machine.events['turn_on'].machine
+  end
+  
+  def test_should_not_update_machine_for_original_event
+    assert_equal @machine, @machine.events['turn_on'].machine
+  end
+end
+
+class MachineAfterChangingContextTest < Test::Unit::TestCase
+  def setup
+    @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state')
+  end
+  
+  def test_should_create_copy_of_machine
+    new_machine = @machine.within_context(ToggleSwitch)
+    assert_not_same @machine, new_machine
+  end
+  
+  def test_should_update_owner_clas
+    new_machine = @machine.within_context(ToggleSwitch)
+    assert_equal ToggleSwitch, new_machine.owner_class
+  end
+  
+  def test_should_update_initial_state
+    new_machine = @machine.within_context(ToggleSwitch, :initial => 'off')
+    assert_equal 'off', new_machine.initial_state(new_switch)
+  end
+  
+  def test_should_not_update_initial_state_if_not_provided
+    new_machine = @machine.within_context(ToggleSwitch)
+    assert_nil new_machine.initial_state(new_switch)
+  end
+  
+  def test_raise_exception_if_invalid_option_specified
+    assert_raise(ArgumentError) {@machine.within_context(ToggleSwitch, :invalid => true)}
+  end
 end
 
 class MachineWithConflictingNamedScopesTest < Test::Unit::TestCase
@@ -131,6 +185,18 @@ class MachineWithEventsTest < Test::Unit::TestCase
   end
 end
 
+class MachineWithExistingEventTest < Test::Unit::TestCase
+  def setup
+    @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state')
+    @event = @machine.event(:turn_on) {}
+    @same_event = @machine.event(:turn_on) {}
+  end
+  
+  def test_should_not_create_new_event
+    assert_same @event, @same_event
+  end
+end
+
 class MachineWithEventsAndTransitionsTest < Test::Unit::TestCase
   def setup
     @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state')
@@ -144,19 +210,22 @@ class MachineWithEventsAndTransitionsTest < Test::Unit::TestCase
     assert_equal %w(turn_on), @machine.events.keys
   end
   
-  def test_should_have_states
-    assert_equal %w(on off error unknown), @machine.states
+  def test_should_track_states_defined_in_event_transitions
+    assert_equal %w(error off on unknown), @machine.states
+  end
+  
+  def test_should_not_duplicate_states_defined_in_multiple_event_transitions
+    @machine.event :turn_off do
+      transition :to => 'off', :from => 'on'
+    end
+    
+    assert_equal %w(error off on unknown), @machine.states
   end
 end
 
-class MachineWithStateCallbacksTest < Test::Unit::TestCase
+class MachineWithTransitionCallbacksTest < Test::Unit::TestCase
   def setup
     @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state')
-    @machine.before_exit 'off', Proc.new {|switch, value| switch.callbacks << 'before_exit'}
-    @machine.before_enter 'on', Proc.new {|switch, value| switch.callbacks << 'before_enter'}
-    @machine.after_exit 'off', Proc.new {|switch, value| switch.callbacks << 'after_exit'}
-    @machine.after_enter 'on', Proc.new {|switch, value| switch.callbacks << 'after_enter'}
-    
     @event = @machine.event :turn_on do
       transition :to => 'on', :from => 'off'
     end
@@ -164,19 +233,74 @@ class MachineWithStateCallbacksTest < Test::Unit::TestCase
     @switch = create_switch(:state => 'off')
   end
   
+  def test_should_raise_exception_if_invalid_option_specified
+    assert_raise(ArgumentError) {@machine.before_transition :invalid => true}
+  end
+  
+  def test_should_raise_exception_if_do_option_not_specified
+    assert_raise(ArgumentError) {@machine.before_transition :to => 'on'}
+  end
+  
   def test_should_invoke_callbacks_during_transition
+    @machine.before_transition lambda {|switch| switch.callbacks << 'before'}
+    @machine.after_transition lambda {|switch| switch.callbacks << 'after'}
+    
+    @event.fire(@switch)
+    assert_equal %w(before after), @switch.callbacks
+  end
+  
+  def test_should_support_from_query
+    @machine.before_transition :from => 'off', :do => lambda {|switch| switch.callbacks << 'off'}
+    @machine.before_transition :from => 'on', :do => lambda {|switch| switch.callbacks << 'on'}
+    
+    @event.fire(@switch)
+    assert_equal %w(off), @switch.callbacks
+  end
+  
+  def test_should_support_except_from_query
+    @machine.before_transition :except_from => 'off', :do => lambda {|switch| switch.callbacks << 'off'}
+    @machine.before_transition :except_from => 'on', :do => lambda {|switch| switch.callbacks << 'on'}
+    
+    @event.fire(@switch)
+    assert_equal %w(on), @switch.callbacks
+  end
+  
+  def test_should_support_to_query
+    @machine.before_transition :to => 'off', :do => lambda {|switch| switch.callbacks << 'off'}
+    @machine.before_transition :to => 'on', :do => lambda {|switch| switch.callbacks << 'on'}
+    
+    @event.fire(@switch)
+    assert_equal %w(on), @switch.callbacks
+  end
+  
+  def test_should_support_except_to_query
+    @machine.before_transition :except_to => 'off', :do => lambda {|switch| switch.callbacks << 'off'}
+    @machine.before_transition :except_to => 'on', :do => lambda {|switch| switch.callbacks << 'on'}
+    
+    @event.fire(@switch)
+    assert_equal %w(off), @switch.callbacks
+  end
+  
+  def test_should_support_on_query
+    @machine.before_transition :on => 'turn_off', :do => lambda {|switch| switch.callbacks << 'turn_off'}
+    @machine.before_transition :on => 'turn_on', :do => lambda {|switch| switch.callbacks << 'turn_on'}
+    
+    @event.fire(@switch)
+    assert_equal %w(turn_on), @switch.callbacks
+  end
+  
+  def test_should_support_except_on_query
+    @machine.before_transition :except_on => 'turn_off', :do => lambda {|switch| switch.callbacks << 'turn_off'}
+    @machine.before_transition :except_on => 'turn_on', :do => lambda {|switch| switch.callbacks << 'turn_on'}
+    
     @event.fire(@switch)
-    assert_equal %w(before_exit before_enter after_exit after_enter), @switch.callbacks
+    assert_equal %w(turn_off), @switch.callbacks
   end
   
   def teardown
     Switch.class_eval do
-      @transition_on_turn_on_callbacks = nil
-      @transition_bang_on_turn_on_callbacks = nil
-      @before_exit_state_off_callbacks = nil
-      @before_enter_state_on_callbacks = nil
-      @after_exit_state_off_callbacks = nil
-      @after_enter_state_on_callbacks = nil
+      @before_transition_state_callbacks = nil
+      @after_transition_state_callbacks = nil
     end
   end
 end

data/test/unit/state_machine_test.rb

@@ -72,45 +72,55 @@ class StateMachineAfterInitializedWithDynamicInitialStateTest < Test::Unit::Test
   end
 end
 
-class StateMachineAfterCreatedTest < Test::Unit::TestCase
+class StateMachineWithSubclassTest < Test::Unit::TestCase
   def setup
-    machine = Switch.state_machine(:state, :initial => 'off')
+    @machine = Switch.state_machine(:state, :initial => 'on') do
+      event :turn_on do
+        transition :to => 'on', :from => 'off'
+      end
+    end
     
-    machine.before_exit 'off', Proc.new {|switch, value| switch.callbacks << 'before_exit'}
-    machine.before_enter 'off', Proc.new {|switch, value| switch.callbacks << 'before_enter'}
-    machine.after_exit 'off', Proc.new {|switch, value| switch.callbacks << 'after_exit'}
-    machine.after_enter 'off', Proc.new {|switch, value| switch.callbacks << 'after_enter'}
+    # Need to add this since the state machine isn't defined directly within the
+    # class
+    ToggleSwitch.write_inheritable_attribute :state_machines, {'state' => @machine}
     
-    @switch = create_switch
+    @new_machine = ToggleSwitch.state_machine(:state, :initial => 'off') do
+      event :turn_on do
+        transition :to => 'off', :from => 'on'
+      end
+      
+      event :replace do
+        transition :to => 'under_repair', :from => 'off'
+      end
+    end
   end
   
-  def test_should_invoke_after_enter_callbacks_for_initial_state
-    assert_equal %w(after_enter), @switch.callbacks
+  def test_should_not_have_the_same_machine_as_the_superclass
+    assert_not_same @machine, @new_machine
   end
   
-  def teardown
-    Switch.write_inheritable_attribute(:state_machines, {})
-    
-    Switch.class_eval do
-      @transition_on_turn_on_callbacks = nil
-      @transition_bang_on_turn_on_callbacks = nil
-      @before_exit_state_off_callbacks = nil
-      @before_enter_state_on_callbacks = nil
-      @after_exit_state_off_callbacks = nil
-      @after_enter_state_on_callbacks = nil
-    end
+  def test_should_use_new_initial_state
+    assert_equal 'off', @new_machine.initial_state(new_switch)
   end
-end
-
-class StateMachineWithSubclassTest < Test::Unit::TestCase
-  def setup
-    Switch.state_machine(:state, :initial => 'on')
-    ToggleSwitch.state_machine(:state, :initial => 'off')
+  
+  def test_should_not_change_original_initial_state
+    assert_equal 'on', @machine.initial_state(new_switch)
+  end
+  
+  def test_should_define_new_events_on_subclass
+    assert new_toggle_switch.respond_to?(:replace)
+  end
+  
+  def test_should_not_define_new_events_on_superclass
+    assert !new_switch.respond_to?(:replace)
+  end
+  
+  def test_should_define_new_transitions_on_subclass
+    assert_equal 2, @new_machine.events['turn_on'].transitions.length
   end
   
-  def test_should_be_able_to_override_initial_state
-    assert_equal 'on', Switch.new.state
-    assert_equal 'off', ToggleSwitch.new.state
+  def test_should_not_define_new_transitions_on_superclass
+    assert_equal 1, @machine.events['turn_on'].transitions.length
   end
   
   def teardown

data/test/unit/transition_test.rb

@@ -2,33 +2,126 @@ require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
 
 class TransitionTest < Test::Unit::TestCase
   def setup
-    @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state', :initial => 'off')
+    @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state')
     @event = PluginAWeek::StateMachine::Event.new(@machine, 'turn_on')
     @transition = PluginAWeek::StateMachine::Transition.new(@event, :to => 'on')
   end
   
-  def test_should_not_have_any_from_states
-    assert @transition.from_states.empty?
+  def test_should_have_an_event
+    assert_not_nil @transition.event
   end
   
-  def test_should_not_be_a_loopback_if_from_state_is_different
-    assert !@transition.loopback?('off')
+  def test_should_have_options
+    assert_not_nil @transition.options
   end
   
-  def test_should_have_a_to_state
-    assert_equal 'on', @transition.to_state
+  def test_should_match_any_from_state
+    assert @transition.matches?('off')
+    assert @transition.matches?('on')
   end
   
-  def test_should_be_loopback_if_from_state_is_same
-    assert @transition.loopback?('on')
+  def test_should_match_empty_query
+    assert @transition.matches?('off', {})
+  end
+  
+  def test_should_match_if_from_state_included
+    assert @transition.matches?('off', :from => 'off')
+  end
+  
+  def test_should_not_match_if_from_state_not_included
+    assert !@transition.matches?('off', :from => 'on')
+  end
+  
+  def test_should_allow_matching_of_multiple_from_states
+    assert @transition.matches?('off', :from => %w(on off))
+  end
+  
+  def test_should_match_if_except_from_state_not_included
+    assert @transition.matches?('off', :except_from => 'on')
+  end
+  
+  def test_should_not_match_if_except_from_state_included
+    assert !@transition.matches?('off', :except_from => 'off')
+  end
+  
+  def test_should_allow_matching_of_multiple_except_from_states
+    assert @transition.matches?('off', :except_from => %w(on maybe))
+  end
+  
+  def test_should_match_if_to_state_included
+    assert @transition.matches?('off', :to => 'on')
+  end
+  
+  def test_should_not_match_if_to_state_not_included
+    assert !@transition.matches?('off', :to => 'off')
+  end
+  
+  def test_should_allow_matching_of_multiple_to_states
+    assert @transition.matches?('off', :to => %w(on off))
+  end
+  
+  def test_should_match_if_except_to_state_not_included
+    assert @transition.matches?('off', :except_to => 'off')
+  end
+  
+  def test_should_not_match_if_except_to_state_included
+    assert !@transition.matches?('off', :except_to => 'on')
+  end
+  
+  def test_should_allow_matching_of_multiple_except_to_states
+    assert @transition.matches?('off', :except_to => %w(off maybe))
+  end
+  
+  def test_should_match_if_on_event_included
+    assert @transition.matches?('off', :on => 'turn_on')
+  end
+  
+  def test_should_not_match_if_on_event_not_included
+    assert !@transition.matches?('off', :on => 'turn_off')
+  end
+  
+  def test_should_allow_matching_of_multiple_on_events
+    assert @transition.matches?('off', :on => %w(turn_off turn_on))
+  end
+  
+  def test_should_match_if_except_on_event_not_included
+    assert @transition.matches?('off', :except_on => 'turn_off')
+  end
+  
+  def test_should_not_match_if_except_on_event_included
+    assert !@transition.matches?('off', :except_on => 'turn_on')
+  end
+  
+  def test_should_allow_matching_of_multiple_except_on_events
+    assert @transition.matches?('off', :except_on => %w(turn_off not_sure))
+  end
+  
+  def test_should_match_if_from_state_and_to_state_match
+    assert @transition.matches?('off', :from => 'off', :to => 'on')
+  end
+  
+  def test_should_not_match_if_from_state_matches_but_not_to_state
+    assert !@transition.matches?('off', :from => 'off', :to => 'off')
+  end
+  
+  def test_should_not_match_if_to_state_matches_but_not_from_state
+    assert !@transition.matches?('off', :from => 'on', :to => 'on')
+  end
+  
+  def test_should_match_if_from_state_to_state_and_on_event_match
+    assert @transition.matches?('off', :from => 'off', :to => 'on', :on => 'turn_on')
+  end
+  
+  def test_should_not_match_if_from_state_and_to_state_match_but_not_on_event
+    assert !@transition.matches?('off', :from => 'off', :to => 'on', :on => 'turn_off')
   end
   
   def test_should_be_able_to_perform_on_all_states
     record = new_switch(:state => 'off')
-    assert @transition.can_perform_on?(record)
+    assert @transition.can_perform?(record)
     
     record = new_switch(:state => 'on')
-    assert @transition.can_perform_on?(record)
+    assert @transition.can_perform?(record)
   end
   
   def test_should_perform_for_all_states
@@ -76,16 +169,61 @@ class TransitionTest < Test::Unit::TestCase
   end
 end
 
+class TransitionWithConditionalTest < Test::Unit::TestCase
+  def setup
+    @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state')
+    @event = PluginAWeek::StateMachine::Event.new(@machine, 'turn_on')
+    @switch = create_switch(:state => 'off')
+  end
+  
+  def test_should_be_able_to_perform_if_if_is_true
+    transition = PluginAWeek::StateMachine::Transition.new(@event, :to => 'on', :if => lambda {true})
+    assert transition.can_perform?(@switch)
+  end
+  
+  def test_should_not_be_able_to_perform_if_if_is_false
+    transition = PluginAWeek::StateMachine::Transition.new(@event, :to => 'on', :if => lambda {false})
+    assert !transition.can_perform?(@switch)
+  end
+  
+  def test_should_be_able_to_perform_if_unless_is_false
+    transition = PluginAWeek::StateMachine::Transition.new(@event, :to => 'on', :unless => lambda {false})
+    assert transition.can_perform?(@switch)
+  end
+  
+  def test_should_not_be_able_to_perform_if_unless_is_true
+    transition = PluginAWeek::StateMachine::Transition.new(@event, :to => 'on', :unless => lambda {true})
+    assert !transition.can_perform?(@switch)
+  end
+  
+  def test_should_pass_in_record_as_argument
+    transition = PluginAWeek::StateMachine::Transition.new(@event, :to => 'on', :if => lambda {|record| !record.nil?})
+    assert transition.can_perform?(@switch)
+  end
+  
+  def test_should_be_able_to_perform_if_method_evaluates_to_true
+    @switch.data = true
+    transition = PluginAWeek::StateMachine::Transition.new(@event, :to => 'on', :if => :data)
+    assert transition.can_perform?(@switch)
+  end
+  
+  def test_should_not_be_able_to_perform_if_method_evaluates_to_false
+    @switch.data = false
+    transition = PluginAWeek::StateMachine::Transition.new(@event, :to => 'on', :if => :data)
+    assert !transition.can_perform?(@switch)
+  end
+end
+
 class TransitionWithLoopbackTest < Test::Unit::TestCase
   def setup
-    @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state', :initial => 'off')
+    @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state')
     @event = PluginAWeek::StateMachine::Event.new(@machine, 'turn_on')
     @transition = PluginAWeek::StateMachine::Transition.new(@event, :to => 'on', :from => 'on')
   end
   
   def test_should_be_able_to_perform
     record = new_switch(:state => 'on')
-    assert @transition.can_perform_on?(record)
+    assert @transition.can_perform?(record)
   end
   
   def test_should_perform_for_valid_from_state
@@ -96,23 +234,19 @@ end
 
 class TransitionWithFromStateTest < Test::Unit::TestCase
   def setup
-    @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state', :initial => 'off')
+    @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state')
     @event = PluginAWeek::StateMachine::Event.new(@machine, 'turn_on')
     @transition = PluginAWeek::StateMachine::Transition.new(@event, :to => 'on', :from => 'off')
   end
   
-  def test_should_have_a_from_state
-    assert_equal ['off'], @transition.from_states
-  end
-  
   def test_should_not_be_able_to_perform_if_record_state_is_not_from_state
     record = new_switch(:state => 'on')
-    assert !@transition.can_perform_on?(record)
+    assert !@transition.can_perform?(record)
   end
   
   def test_should_be_able_to_perform_if_record_state_is_from_state
     record = new_switch(:state => 'off')
-    assert @transition.can_perform_on?(record)
+    assert @transition.can_perform?(record)
   end
   
   def test_should_perform_for_valid_from_state
@@ -123,26 +257,22 @@ end
 
 class TransitionWithMultipleFromStatesTest < Test::Unit::TestCase
   def setup
-    @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state', :initial => 'off')
+    @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state')
     @event = PluginAWeek::StateMachine::Event.new(@machine, 'turn_on')
     @transition = PluginAWeek::StateMachine::Transition.new(@event, :to => 'on', :from => %w(off on))
   end
   
-  def test_should_have_multiple_from_states
-    assert_equal ['off', 'on'], @transition.from_states
-  end
-  
   def test_should_not_be_able_to_perform_if_record_state_is_not_from_state
     record = new_switch(:state => 'unknown')
-    assert !@transition.can_perform_on?(record)
+    assert !@transition.can_perform?(record)
   end
   
   def test_should_be_able_to_perform_if_record_state_is_any_from_state
     record = new_switch(:state => 'off')
-    assert @transition.can_perform_on?(record)
+    assert @transition.can_perform?(record)
     
     record = new_switch(:state => 'on')
-    assert @transition.can_perform_on?(record)
+    assert @transition.can_perform?(record)
   end
   
   def test_should_perform_for_any_valid_from_state
@@ -156,23 +286,19 @@ end
 
 class TransitionWithMismatchedFromStatesRequiredTest < Test::Unit::TestCase
   def setup
-    @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state', :initial => 'off')
+    @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state')
     @event = PluginAWeek::StateMachine::Event.new(@machine, 'turn_on')
     @transition = PluginAWeek::StateMachine::Transition.new(@event, :to => 'on', :except_from => 'on')
   end
   
-  def test_should_have_a_from_state
-    assert_equal ['on'], @transition.from_states
-  end
-  
   def test_should_be_able_to_perform_if_record_state_is_not_from_state
     record = new_switch(:state => 'off')
-    assert @transition.can_perform_on?(record)
+    assert @transition.can_perform?(record)
   end
   
   def test_should_not_be_able_to_perform_if_record_state_is_from_state
     record = new_switch(:state => 'on')
-    assert !@transition.can_perform_on?(record)
+    assert !@transition.can_perform?(record)
   end
   
   def test_should_perform_for_valid_from_state
@@ -182,13 +308,13 @@ class TransitionWithMismatchedFromStatesRequiredTest < Test::Unit::TestCase
   
   def test_should_not_perform_for_invalid_from_state
     record = new_switch(:state => 'on')
-    assert !@transition.can_perform_on?(record)
+    assert !@transition.can_perform?(record)
   end
 end
 
 class TransitionAfterBeingPerformedTest < Test::Unit::TestCase
   def setup
-    @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state', :initial => 'off')
+    @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state')
     @event = PluginAWeek::StateMachine::Event.new(@machine, 'turn_on')
     @transition = PluginAWeek::StateMachine::Transition.new(@event, :to => 'on', :from => 'off')
     
@@ -202,303 +328,306 @@ class TransitionAfterBeingPerformedTest < Test::Unit::TestCase
   end
   
   def test_should_no_longer_be_able_to_perform_on_the_record
-    assert !@transition.can_perform_on?(@record)
+    assert !@transition.can_perform?(@record)
   end
 end
 
 class TransitionWithLoopbackAfterBeingPerformedTest < Test::Unit::TestCase
   def setup
-    @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state', :initial => 'off')
+    @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state')
     @event = PluginAWeek::StateMachine::Event.new(@machine, 'turn_on')
     @transition = PluginAWeek::StateMachine::Transition.new(@event, :to => 'on', :from => 'on')
     
     @record = create_switch(:state => 'on')
+    @record.kind = 'light'
     @transition.perform(@record)
     @record.reload
   end
   
-  def test_should_not_update_the_attribute
+  def test_should_have_the_same_attribute
     assert_equal 'on', @record.state
   end
   
+  def test_should_save_the_record
+    assert_equal 'light', @record.kind
+  end
+  
   def test_should_still_be_able_to_perform_on_the_record
-    assert @transition.can_perform_on?(@record)
+    assert @transition.can_perform?(@record)
   end
 end
 
 class TransitionWithCallbacksTest < Test::Unit::TestCase
   def setup
-    @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state', :initial => 'off')
+    @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state')
     @event = PluginAWeek::StateMachine::Event.new(@machine, 'turn_on')
     @transition = PluginAWeek::StateMachine::Transition.new(@event, :to => 'on', :from => 'off')
     @record = create_switch(:state => 'off')
     
-    Switch.define_callbacks :before_exit_state_off, :before_enter_state_on, :after_exit_state_off, :after_enter_state_on
-  end
-  
-  def test_should_not_perform_if_before_exit_callback_fails
-    Switch.before_exit_state_off Proc.new {|record| false}
-    Switch.before_enter_state_on Proc.new {|record| record.callbacks << 'before_enter'; true}
-    Switch.after_exit_state_off Proc.new {|record| record.callbacks << 'after_exit'; true}
-    Switch.after_enter_state_on Proc.new {|record| record.callbacks << 'after_enter'; true}
-    
-    assert !@transition.perform(@record)
-    assert_equal [], @record.callbacks
+    Switch.define_callbacks :before_transition_state, :after_transition_state
   end
   
-  def test_should_raise_exception_if_before_exit_callback_fails_during_perform!
-    Switch.before_exit_state_off Proc.new {|record| false}
+  def test_should_include_record_in_callback
+    Switch.before_transition_state lambda {|record| record == @record}
     
-    assert_raise(PluginAWeek::StateMachine::InvalidTransition) {@transition.perform!(@record)}
+    assert @transition.perform(@record)
   end
   
-  def test_should_not_perform_if_before_enter_callback_fails
-    Switch.before_exit_state_off Proc.new {|record| record.callbacks << 'before_exit'; true}
-    Switch.before_enter_state_on Proc.new {|record| false}
-    Switch.after_exit_state_off Proc.new {|record| record.callbacks << 'after_exit'; true}
-    Switch.after_enter_state_on Proc.new {|record| record.callbacks << 'after_enter'; true}
+  def test_should_not_perform_if_before_callback_fails
+    Switch.before_transition_state lambda {|record| false}
+    Switch.after_transition_state lambda {|record| record.callbacks << 'after'; true}
     
     assert !@transition.perform(@record)
-    assert_equal %w(before_exit), @record.callbacks
+    assert_equal [], @record.callbacks
   end
   
-  def test_should_raise_exception_if_after_enter_callback_fails_during_perform!
-    Switch.before_exit_state_off Proc.new {|record| record.callbacks << 'before_exit'; true}
-    Switch.before_enter_state_on Proc.new {|record| false}
+  def test_should_raise_exception_if_before_callback_fails_during_perform!
+    Switch.before_transition_state lambda {|record| false}
     
     assert_raise(PluginAWeek::StateMachine::InvalidTransition) {@transition.perform!(@record)}
   end
   
-  def test_should_perform_if_after_exit_callback_fails
-    Switch.before_exit_state_off Proc.new {|record| record.callbacks << 'before_exit'; true}
-    Switch.before_enter_state_on Proc.new {|record| record.callbacks << 'before_enter'; true}
-    Switch.after_exit_state_off Proc.new {|record| false}
-    Switch.after_enter_state_on Proc.new {|record| record.callbacks << 'after_enter'; true}
+  def test_should_perform_if_after_callback_fails
+    Switch.before_transition_state lambda {|record| record.callbacks << 'before'; true}
+    Switch.after_transition_state lambda {|record| false}
     
     assert @transition.perform(@record)
-    assert_equal %w(before_exit before_enter after_enter), @record.callbacks
+    assert_equal %w(before), @record.callbacks
   end
   
-  def test_should_not_raise_exception_if_after_exit_callback_fails_during_perform!
-    Switch.before_exit_state_off Proc.new {|record| record.callbacks << 'before_exit'; true}
-    Switch.before_enter_state_on Proc.new {|record| record.callbacks << 'before_enter'; true}
-    Switch.after_exit_state_off Proc.new {|record| false}
-    Switch.after_enter_state_on Proc.new {|record| record.callbacks << 'after_enter'; true}
+  def test_should_not_raise_exception_if_after_callback_fails_during_perform!
+    Switch.before_transition_state lambda {|record| record.callbacks << 'before'; true}
+    Switch.after_transition_state lambda {|record| false}
     
     assert @transition.perform!(@record)
   end
   
-  def test_should_perform_if_after_enter_callback_fails
-    Switch.before_exit_state_off Proc.new {|record| record.callbacks << 'before_exit'; true}
-    Switch.before_enter_state_on Proc.new {|record| record.callbacks << 'before_enter'; true}
-    Switch.after_exit_state_off Proc.new {|record| record.callbacks << 'after_exit'; true}
-    Switch.after_enter_state_on Proc.new {|record| false}
+  def test_should_perform_if_all_callbacks_are_successful
+    Switch.before_transition_state lambda {|record| record.callbacks << 'before'; true}
+    Switch.after_transition_state lambda {|record| record.callbacks << 'after'; true}
     
     assert @transition.perform(@record)
-    assert_equal %w(before_exit before_enter after_exit), @record.callbacks
+    assert_equal %w(before after), @record.callbacks
   end
   
-  def test_should_not_raise_exception_if_after_enter_callback_fails_during_perform!
-    Switch.before_exit_state_off Proc.new {|record| record.callbacks << 'before_exit'; true}
-    Switch.before_enter_state_on Proc.new {|record| record.callbacks << 'before_enter'; true}
-    Switch.after_exit_state_off Proc.new {|record| record.callbacks << 'after_exit'; true}
-    Switch.after_enter_state_on Proc.new {|record| false}
+  def test_should_stop_before_callbacks_if_any_fail
+    Switch.before_transition_state lambda {|record| false}
+    Switch.before_transition_state lambda {|record| record.callbacks << 'before_2'; true}
     
-    assert @transition.perform!(@record)
+    assert !@transition.perform(@record)
+    assert_equal [], @record.callbacks
   end
   
-  def test_should_perform_if_all_callbacks_are_successful
-    Switch.before_exit_state_off Proc.new {|record| record.callbacks << 'before_exit'; true}
-    Switch.before_enter_state_on Proc.new {|record| record.callbacks << 'before_enter'; true}
-    Switch.after_exit_state_off Proc.new {|record| record.callbacks << 'after_exit'; true}
-    Switch.after_enter_state_on Proc.new {|record| record.callbacks << 'after_enter'; true}
+  def test_should_stop_after_callbacks_if_any_fail
+    Switch.after_transition_state lambda {|record| false}
+    Switch.after_transition_state lambda {|record| record.callbacks << 'after_2'; true}
     
     assert @transition.perform(@record)
-    assert_equal %w(before_exit before_enter after_exit after_enter), @record.callbacks
+    assert_equal [], @record.callbacks
   end
   
-  def test_should_stop_before_exit_callbacks_if_any_fail
-    Switch.before_exit_state_off Proc.new {|record| false}
-    Switch.before_exit_state_off Proc.new {|record| record.callbacks << 'before_exit'; true}
+  def teardown
+    Switch.class_eval do
+      @before_transition_state_callbacks = nil
+      @after_transition_state_callbacks = nil
+    end
+  end
+end
+
+class TransitionWithCallbackConditionalsTest < Test::Unit::TestCase
+  def setup
+    @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state')
+    @event = PluginAWeek::StateMachine::Event.new(@machine, 'turn_on')
+    @transition = PluginAWeek::StateMachine::Transition.new(@event, :to => 'on', :from => 'off')
+    @record = create_switch(:state => 'off')
+    @invoked = false
     
-    assert !@transition.perform(@record)
-    assert_equal [], @record.callbacks
+    Switch.define_callbacks :before_transition_state, :after_transition_state
   end
   
-  def test_should_stop_before_enter_callbacks_if_any_fail
-    Switch.before_enter_state_on Proc.new {|record| false}
-    Switch.before_enter_state_on Proc.new {|record| record.callbacks << 'before_enter'; true}
-    
-    assert !@transition.perform(@record)
-    assert_equal [], @record.callbacks
+  def test_should_invoke_callback_if_if_is_true
+    Switch.before_transition_state lambda {|record| @invoked = true}, :if => lambda {true}
+    @transition.perform(@record)
+    assert @invoked
   end
   
-  def test_should_stop_after_exit_callbacks_if_any_fail
-    Switch.after_exit_state_off Proc.new {|record| false}
-    Switch.after_exit_state_off Proc.new {|record| record.callbacks << 'after_exit'; true}
-    
-    assert @transition.perform(@record)
-    assert_equal [], @record.callbacks
+  def test_should_not_invoke_callback_if_if_is_false
+    Switch.before_transition_state lambda {|record| @invoked = true}, :if => lambda {false}
+    @transition.perform(@record)
+    assert !@invoked
   end
   
-  def test_should_stop_after_enter_callbacks_if_any_fail
-    Switch.after_enter_state_on Proc.new {|record| false}
-    Switch.after_enter_state_on Proc.new {|record| record.callbacks << 'after_enter'; true}
-    
-    assert @transition.perform(@record)
-    assert_equal [], @record.callbacks
+  def test_should_invoke_callback_if_unless_is_false
+    Switch.before_transition_state lambda {|record| @invoked = true}, :unless => lambda {false}
+    @transition.perform(@record)
+    assert @invoked
+  end
+  
+  def test_should_not_invoke_callback_if_unless_is_true
+    Switch.before_transition_state lambda {|record| @invoked = true}, :unless => lambda {true}
+    @transition.perform(@record)
+    assert !@invoked
   end
   
   def teardown
     Switch.class_eval do
-      @before_exit_state_off_callbacks = nil
-      @before_enter_state_on_callbacks = nil
-      @after_exit_state_off_callbacks = nil
-      @after_enter_state_on_callbacks = nil
+      @before_transition_state_callbacks = nil
+      @after_transition_state_callbacks = nil
     end
   end
 end
 
-class TransitionWithoutFromStateAndCallbacksTest < Test::Unit::TestCase
+class TransitionWithCallbackQueryTest < Test::Unit::TestCase
   def setup
-    @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state', :initial => 'off')
+    @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state')
     @event = PluginAWeek::StateMachine::Event.new(@machine, 'turn_on')
-    @transition = PluginAWeek::StateMachine::Transition.new(@event, :to => 'on')
+    @transition = PluginAWeek::StateMachine::Transition.new(@event, :to => 'on', :from => 'off')
     @record = create_switch(:state => 'off')
     
-    Switch.define_callbacks :before_exit_state_off, :before_enter_state_on, :after_exit_state_off, :after_enter_state_on
+    Switch.define_callbacks :before_transition_state, :after_transition_state
   end
   
-  def test_should_not_perform_if_before_exit_callback_fails
-    Switch.before_exit_state_off Proc.new {|record| false}
-    Switch.before_enter_state_on Proc.new {|record| record.callbacks << 'before_enter'; true}
-    Switch.after_exit_state_off Proc.new {|record| record.callbacks << 'after_exit'; true}
-    Switch.after_enter_state_on Proc.new {|record| record.callbacks << 'after_enter'; true}
-    
-    assert !@transition.perform(@record)
-    assert_equal [], @record.callbacks
+  def test_should_invoke_callback_if_from_state_included
+    Switch.before_transition_state lambda {|record| @invoked = true}, :from => 'off'
+    @transition.perform(@record)
+    assert @invoked
   end
   
-  def test_should_not_perform_if_before_enter_callback_fails
-    Switch.before_exit_state_off Proc.new {|record| record.callbacks << 'before_exit'; true}
-    Switch.before_enter_state_on Proc.new {|record| false}
-    Switch.after_exit_state_off Proc.new {|record| record.callbacks << 'after_exit'; true}
-    Switch.after_enter_state_on Proc.new {|record| record.callbacks << 'after_enter'; true}
-    
-    assert !@transition.perform(@record)
-    assert_equal %w(before_exit), @record.callbacks
+  def test_should_not_invoke_callback_if_from_state_not_included
+    Switch.before_transition_state lambda {|record| @invoked = true}, :from => 'on'
+    @transition.perform(@record)
+    assert !@invoked
   end
   
-  def test_should_perform_if_after_exit_callback_fails
-    Switch.before_exit_state_off Proc.new {|record| record.callbacks << 'before_exit'; true}
-    Switch.before_enter_state_on Proc.new {|record| record.callbacks << 'before_enter'; true}
-    Switch.after_exit_state_off Proc.new {|record| false}
-    Switch.after_enter_state_on Proc.new {|record| record.callbacks << 'after_enter'; true}
-    
-    assert @transition.perform(@record)
-    assert_equal %w(before_exit before_enter after_enter), @record.callbacks
+  def test_should_invoke_callback_if_except_from_state_not_included
+    Switch.before_transition_state lambda {|record| @invoked = true}, :except_from => 'on'
+    @transition.perform(@record)
+    assert @invoked
   end
   
-  def test_should_perform_if_after_enter_callback_fails
-    Switch.before_exit_state_off Proc.new {|record| record.callbacks << 'before_exit'; true}
-    Switch.before_enter_state_on Proc.new {|record| record.callbacks << 'before_enter'; true}
-    Switch.after_exit_state_off Proc.new {|record| record.callbacks << 'after_exit'; true}
-    Switch.after_enter_state_on Proc.new {|record| false}
-    
-    assert @transition.perform(@record)
-    assert_equal %w(before_exit before_enter after_exit), @record.callbacks
+  def test_should_not_invoke_callback_if_except_from_state_included
+    Switch.before_transition_state lambda {|record| @invoked = true}, :except_from => 'off'
+    @transition.perform(@record)
+    assert !@invoked
   end
   
-  def test_should_perform_if_all_callbacks_are_successful
-    Switch.before_exit_state_off Proc.new {|record| record.callbacks << 'before_exit'; true}
-    Switch.before_enter_state_on Proc.new {|record| record.callbacks << 'before_enter'; true}
-    Switch.after_exit_state_off Proc.new {|record| record.callbacks << 'after_exit'; true}
-    Switch.after_enter_state_on Proc.new {|record| record.callbacks << 'after_enter'; true}
-    
-    assert @transition.perform(@record)
-    assert_equal %w(before_exit before_enter after_exit after_enter), @record.callbacks
+  def test_should_invoke_callback_if_to_state_included
+    Switch.before_transition_state lambda {|record| @invoked = true}, :to => 'on'
+    @transition.perform(@record)
+    assert @invoked
   end
   
-  def test_should_stop_before_exit_callbacks_if_any_fail
-    Switch.before_exit_state_off Proc.new {|record| false}
-    Switch.before_exit_state_off Proc.new {|record| record.callbacks << 'before_exit'; true}
-    
-    assert !@transition.perform(@record)
-    assert_equal [], @record.callbacks
+  def test_should_not_invoke_callback_if_to_state_not_included
+    Switch.before_transition_state lambda {|record| @invoked = true}, :to => 'off'
+    @transition.perform(@record)
+    assert !@invoked
   end
   
-  def test_should_stop_before_enter_callbacks_if_any_fail
-    Switch.before_enter_state_on Proc.new {|record| false}
-    Switch.before_enter_state_on Proc.new {|record| record.callbacks << 'before_enter'; true}
-    
-    assert !@transition.perform(@record)
-    assert_equal [], @record.callbacks
+  def test_should_invoke_callback_if_except_to_state_not_included
+    Switch.before_transition_state lambda {|record| @invoked = true}, :except_to => 'off'
+    @transition.perform(@record)
+    assert @invoked
   end
   
-  def test_should_stop_after_exit_callbacks_if_any_fail
-    Switch.after_exit_state_off Proc.new {|record| false}
-    Switch.after_exit_state_off Proc.new {|record| record.callbacks << 'after_exit'; true}
-    
-    assert @transition.perform(@record)
-    assert_equal [], @record.callbacks
+  def test_should_not_invoke_callback_if_except_to_state_included
+    Switch.before_transition_state lambda {|record| @invoked = true}, :except_to => 'on'
+    @transition.perform(@record)
+    assert !@invoked
   end
   
-  def test_should_stop_after_enter_callbacks_if_any_fail
-    Switch.after_enter_state_on Proc.new {|record| false}
-    Switch.after_enter_state_on Proc.new {|record| record.callbacks << 'after_enter'; true}
-    
-    assert @transition.perform(@record)
-    assert_equal [], @record.callbacks
+  def test_should_invoke_callback_if_on_event_included
+    Switch.before_transition_state lambda {|record| @invoked = true}, :on => 'turn_on'
+    @transition.perform(@record)
+    assert @invoked
+  end
+  
+  def test_should_not_invoke_callback_if_on_event_not_included
+    Switch.before_transition_state lambda {|record| @invoked = true}, :on => 'turn_off'
+    @transition.perform(@record)
+    assert !@invoked
+  end
+  
+  def test_should_invoke_callback_if_except_on_event_not_included
+    Switch.before_transition_state lambda {|record| @invoked = true}, :except_on => 'turn_off'
+    @transition.perform(@record)
+    assert @invoked
+  end
+  
+  def test_should_not_invoke_callback_if_except_on_event_included
+    Switch.before_transition_state lambda {|record| @invoked = true}, :except_on => 'turn_on'
+    @transition.perform(@record)
+    assert !@invoked
+  end
+  
+  def test_should_skip_callbacks_that_do_not_match
+    Switch.before_transition_state lambda {|record| false}, :from => 'on'
+    Switch.before_transition_state lambda {|record| @invoked = true}, :from => 'off'
+    @transition.perform(@record)
+    assert @invoked
   end
   
   def teardown
     Switch.class_eval do
-      @before_exit_state_off_callbacks = nil
-      @before_enter_state_on_callbacks = nil
-      @after_exit_state_off_callbacks = nil
-      @after_enter_state_on_callbacks = nil
+      @before_transition_state_callbacks = nil
+      @after_transition_state_callbacks = nil
     end
   end
 end
 
-class TransitionWithLoopbackAndCallbacksTest < Test::Unit::TestCase
+class TransitionWithObserversTest < Test::Unit::TestCase
   def setup
-    @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state', :initial => 'off')
+    @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state')
     @event = PluginAWeek::StateMachine::Event.new(@machine, 'turn_on')
-    @transition = PluginAWeek::StateMachine::Transition.new(@event, :to => 'on', :from => 'on')
-    @record = create_switch(:state => 'on')
-    
-    Switch.define_callbacks :before_exit_state_off, :before_enter_state_on, :after_exit_state_off, :after_enter_state_on
-    Switch.before_exit_state_off Proc.new {|record| record.callbacks << 'before_exit'; true}
-    Switch.before_enter_state_on Proc.new {|record| record.callbacks << 'before_enter'; true}
-    Switch.after_exit_state_off Proc.new {|record| record.callbacks << 'after_exit'; true}
-    Switch.after_enter_state_on Proc.new {|record| record.callbacks << 'after_enter'; true}
+    @transition = PluginAWeek::StateMachine::Transition.new(@event, :to => 'on', :from => 'off')
+    @record = create_switch(:state => 'off')
     
-    assert @transition.perform(@record)
+    Switch.define_callbacks :before_transition_state, :after_transition_state
+    SwitchObserver.notifications = []
   end
   
-  def test_should_not_run_before_exit_callbacks
-    assert !@record.callbacks.include?('before_exit')
-  end
-  
-  def test_should_not_run_before_enter_callbacks
-    assert !@record.callbacks.include?('before_enter')
+  def test_should_notify_all_callbacks_if_successful
+    @transition.perform(@record)
+    
+    expected = [
+      ['before_turn_on', @record, 'off', 'on'],
+      ['before_transition', @record, 'state', 'turn_on', 'off', 'on'],
+      ['after_turn_on', @record, 'off', 'on'],
+      ['after_transition', @record, 'state', 'turn_on', 'off', 'on']
+    ]
+    
+    assert_equal expected, SwitchObserver.notifications
   end
   
-  def test_should_not_run_after_exit_callbacks
-    assert !@record.callbacks.include?('after_exit')
+  def test_should_notify_before_callbacks_if_before_callback_fails
+    Switch.before_transition_state lambda {|record| false}
+    @transition.perform(@record)
+    
+    expected = [
+      ['before_turn_on', @record, 'off', 'on'],
+      ['before_transition', @record, 'state', 'turn_on', 'off', 'on']
+    ]
+    
+    assert_equal expected, SwitchObserver.notifications
   end
   
-  def test_should_not_run_after_enter_callbacks
-    assert !@record.callbacks.include?('after_enter')
+  def test_should_notify_before_and_after_callbacks_if_after_callback_fails
+    Switch.after_transition_state lambda {|record| false}
+    @transition.perform(@record)
+    
+    expected = [
+      ['before_turn_on', @record, 'off', 'on'],
+      ['before_transition', @record, 'state', 'turn_on', 'off', 'on'],
+      ['after_turn_on', @record, 'off', 'on'],
+      ['after_transition', @record, 'state', 'turn_on', 'off', 'on']
+    ]
+    
+    assert_equal expected, SwitchObserver.notifications
   end
   
   def teardown
     Switch.class_eval do
-      @before_exit_state_off_callbacks = nil
-      @before_enter_state_on_callbacks = nil
-      @after_exit_state_off_callbacks = nil
-      @after_enter_state_on_callbacks = nil
+      @before_transition_state_callbacks = nil
+      @after_transition_state_callbacks = nil
     end
   end
 end