state_machine 0.1.0

data/test/unit/event_test.rb

@@ -0,0 +1,234 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class EventTest < Test::Unit::TestCase
+  def setup
+    @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state', :initial => 'off')
+    @event = PluginAWeek::StateMachine::Event.new(@machine, 'turn_on')
+  end
+  
+  def test_should_have_a_machine
+    assert_equal @machine, @event.machine
+  end
+  
+  def test_should_have_a_name
+    assert_equal 'turn_on', @event.name
+  end
+  
+  def test_should_define_an_event_action_on_the_owner_class
+    switch = new_switch
+    assert switch.respond_to?(:turn_on!)
+  end
+  
+  def test_should_define_transition_callbacks
+    assert Switch.respond_to?(:transition_on_turn_on)
+  end
+  
+  def test_should_define_before_event_callbacks
+    assert Switch.respond_to?(:before_turn_on)
+  end
+  
+  def test_should_define_after_event_callbacks
+    assert Switch.respond_to?(:after_turn_on)
+  end
+end
+
+class EventWithInvalidOptionsTest < Test::Unit::TestCase
+  def setup
+    @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state', :initial => 'off')
+  end
+  
+  def test_should_raise_exception
+    assert_raise(ArgumentError) {PluginAWeek::StateMachine::Event.new(@machine, 'turn_on', :invalid => true)}
+  end
+end
+
+class EventWithTransitionsTest < Test::Unit::TestCase
+  def setup
+    @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state', :initial => 'off')
+    @event = PluginAWeek::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')}
+  end
+  
+  def test_should_not_raise_exception_if_from_option_not_specified
+    assert_nothing_raised {@event.transition(:to => 'on')}
+  end
+  
+  def test_should_allow_transitioning_from_a_single_state
+    assert_equal [%w(off on)], @event.transition(:to => 'on', :from => 'off').map {|t| [t.from_state, t.to_state]}
+  end
+  
+  def test_should_allow_transitioning_from_multiple_states
+    assert_equal [%w(off on), %w(on on)], @event.transition(:to => 'on', :from => %w(off on)).map {|t| [t.from_state, t.to_state]}
+  end
+  
+  def teardown
+    Switch.class_eval do
+      @transition_on_turn_on_callbacks = nil
+    end
+  end
+end
+
+class EventAfterBeingFiredWithNoTransitionsTest < 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')
+  end
+  
+  def test_should_not_fire
+    assert !@event.fire!(@switch)
+  end
+  
+  def test_should_not_change_the_current_state
+    @event.fire!(@switch)
+    assert_equal 'off', @switch.state
+  end
+end
+
+class EventAfterBeingFiredWithTransitionsTest < 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')
+  end
+  
+  def test_should_not_fire_if_no_transitions_are_matched
+    assert !@event.fire!(@switch)
+    assert_equal 'off', @switch.state
+  end
+  
+  def test_should_fire_if_transition_is_matched
+    @event.transition :to => 'on', :from => 'off'
+    assert @event.fire!(@switch)
+    assert_equal 'on', @switch.state
+  end
+  
+  def teardown
+    Switch.class_eval do
+      @transition_on_turn_on_callbacks = nil
+    end
+  end
+end
+
+class EventAfterBeingFiredWithConditionalTransitionsTest < 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 => 'if_not_evaluated', :from => 'off', :if => Proc.new {false}
+    @event.transition :to => 'unless_not_evaluated', :from => 'off', :unless => Proc.new {true}
+    @event.transition :to => 'no_record', :from => 'off', :if => Proc.new {|record, value| record.nil?}
+    @event.transition :to => 'no_arguments', :from => 'off', :if => Proc.new {|record, value| value.nil?}
+    
+    @switch = create_switch(:state => 'off')
+  end
+  
+  def test_should_not_fire_of_no_transitions_are_matched
+    assert !@event.fire!(@switch, 1)
+    assert_equal 'off', @switch.state
+  end
+  
+  def test_should_fire_if_transition_is_matched
+    @event.transition :to => 'on', :from => 'off', :if => Proc.new {|record, value| value == 1}
+    assert @event.fire!(@switch, 1)
+    assert_equal 'on', @switch.state
+  end
+  
+  def teardown
+    Switch.class_eval do
+      @transition_on_turn_on_callbacks = nil
+    end
+  end
+end
+
+class EventWithinTransactionTest < 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')
+    
+    Switch.define_callbacks :after_enter_state_on
+  end
+  
+  def test_should_save_all_records_within_transaction_if_performed
+    Switch.after_enter_state_on Proc.new {|record| Switch.create(:state => 'pending'); true}
+    assert @event.fire!(@switch)
+    assert_equal 'on', @switch.state
+    assert_equal 'pending', Switch.find(:all).last.state
+  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.after_enter_state_on Proc.new {|record| Switch.create(:state => 'pending'); false}
+    assert !@event.fire!(@switch)
+    assert_equal 1, Switch.count
+  ensure
+    Switch.destroy_all
+  end
+  
+  def teardown
+    Switch.class_eval do
+      @transition_on_turn_on_callbacks = nil
+      @after_enter_state_on_callbacks = nil
+    end
+  end
+end
+
+class EventWithCallbacksTest < Test::Unit::TestCase
+  def setup
+    @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state', :initial => 'off')
+    @event = PluginAWeek::StateMachine::Event.new(@machine, 'turn_on')
+    @event.transition :from => 'off', :to => 'on'
+    @record = create_switch(:state => 'off')
+    
+    Switch.define_callbacks :before_turn_on, :after_turn_on
+  end
+  
+  def test_should_not_perform_if_before_callback_fails
+    Switch.before_turn_on Proc.new {|record| false}
+    Switch.after_turn_on Proc.new {|record| record.callbacks << 'after'; true}
+    
+    assert !@event.fire!(@record)
+    assert_equal %w(), @record.callbacks
+  end
+  
+  def test_should_not_perform_if_after_callback_fails
+    Switch.before_turn_on Proc.new {|record| record.callbacks << 'before'; true}
+    Switch.after_turn_on Proc.new {|record| false}
+    
+    assert !@event.fire!(@record)
+    assert_equal %w(before), @record.callbacks
+  end
+  
+  def test_should_perform_if_all_callbacks_are_successful
+    Switch.before_turn_on Proc.new {|record| record.callbacks << 'before'; true}
+    Switch.after_turn_on Proc.new {|record| record.callbacks << 'after'; true}
+    
+    assert @event.fire!(@record)
+    assert_equal %w(before after), @record.callbacks
+  end
+  
+  def test_should_pass_additional_arguments_to_callbacks
+    Switch.before_turn_on Proc.new {|record, value| record.callbacks << "before-#{value}"; true}
+    Switch.after_turn_on Proc.new {|record, value| record.callbacks << "after-#{value}"; true}
+    
+    assert @event.fire!(@record, 'light')
+    assert_equal %w(before-light after-light), @record.callbacks
+  end
+  
+  def teardown
+    Switch.class_eval do
+      @before_turn_on_callbacks = nil
+      @after_turn_on_callbacks = nil
+      @transition_on_turn_on_callbacks = nil
+    end
+  end
+end

data/test/unit/machine_test.rb

@@ -0,0 +1,152 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class MachineByDefaultTest < Test::Unit::TestCase
+  def setup
+    @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state')
+  end
+  
+  def test_should_have_an_attribute
+    assert_equal 'state', @machine.attribute
+  end
+  
+  def test_should_not_have_an_initial_state
+    assert_nil @machine.initial_state(new_switch)
+  end
+  
+  def test_should_have_an_owner_class
+    assert_equal Switch, @machine.owner_class
+  end
+  
+  def test_should_not_have_any_events
+    assert @machine.events.empty?
+  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')
+  end
+  
+  def test_should_have_an_initial_state
+    assert_equal 'off', @machine.initial_state(new_switch)
+  end
+end
+
+class MachineWithDynamicInitialStateTest < Test::Unit::TestCase
+  def setup
+    @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state', :initial => Proc.new {|switch| switch.initial_state})
+  end
+  
+  def test_should_use_the_record_for_determining_the_initial_state
+    assert_equal 'off', @machine.initial_state(new_switch(:initial_state => 'off'))
+    assert_equal 'on', @machine.initial_state(new_switch(:initial_state => 'on'))
+  end
+end
+
+class MachineTest < Test::Unit::TestCase
+  def setup
+    @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state')
+  end
+  
+  def test_should_define_a_named_scope_for_the_attribute
+    on = create_switch(:state => 'on')
+    off = create_switch(:state => 'off')
+    
+    assert_equal [on], Switch.with_state('on')
+  end
+  
+  def test_should_define_a_pluralized_named_scope_for_the_attribute
+    on = create_switch(:state => 'on')
+    off = create_switch(:state => 'off')
+    
+    assert_equal [on, off], Switch.with_state('on', 'off')
+  end
+end
+
+class MachineWithConflictingNamedScopesTest < Test::Unit::TestCase
+  class Switch < ActiveRecord::Base
+    def self.with_state
+      :custom
+    end
+    
+    def self.with_states
+      :custom
+    end
+  end
+  
+  def setup
+    @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state')
+  end
+  
+  def test_should_not_define_a_named_scope_for_the_attribute
+    assert_equal :custom, Switch.with_state
+  end
+  
+  def test_should_not_define_a_pluralized_named_scope_for_the_attribute
+    assert_equal :custom, Switch.with_states
+  end
+end
+
+class MachineWithEventsTest < Test::Unit::TestCase
+  def setup
+    @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state')
+  end
+  
+  def test_should_create_event_with_given_name
+    event = @machine.event :turn_on do
+    end
+    assert_equal 'turn_on', event.name
+  end
+  
+  def test_should_evaluate_block_within_event_context
+    responded = false
+    @machine.event :turn_on do
+      responded = respond_to?(:transition)
+    end
+    
+    assert responded
+  end
+  
+  def test_should_store_the_event
+    @machine.event :turn_on do
+    end
+    assert_equal 1, @machine.events.size
+  end
+end
+
+class MachineWithStateCallbacksTest < Test::Unit::TestCase
+  def setup
+    @machine = PluginAWeek::StateMachine::Machine.new(Switch, 'state')
+    @machine.before_exit 'off', Proc.new {|switch, value| switch.callbacks << 'before_exit'; true}
+    @machine.before_enter 'on', Proc.new {|switch, value| switch.callbacks << 'before_enter'; true}
+    @machine.after_exit 'off', Proc.new {|switch, value| switch.callbacks << 'after_exit'; true}
+    @machine.after_enter 'on', Proc.new {|switch, value| switch.callbacks << 'after_enter'; true}
+    
+    @event = @machine.event :turn_on do
+      transition :to => 'on', :from => 'off'
+    end
+    
+    @switch = create_switch(:state => 'off')
+  end
+  
+  def test_should_invoke_callbacks_during_transition
+    @event.fire!(@switch)
+    assert_equal %w(before_exit before_enter after_exit after_enter), @switch.callbacks
+  end
+  
+  def teardown
+    Switch.class_eval do
+      @transition_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
+  end
+end

data/test/unit/state_machine_test.rb

@@ -0,0 +1,102 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class StateMachineTest < Test::Unit::TestCase
+  def test_should_track_all_state_machines
+    @machine = Switch.state_machine(:state)
+    assert_equal @machine, Switch.state_machines['state']
+  end
+  
+  def test_should_allow_multiple_state_machines
+    @machine = Switch.state_machine(:state)
+    @second_machine = Switch.state_machine(:kind)
+    assert_equal 2, Switch.state_machines.size
+  end
+  
+  def test_should_evaluate_block_within_event_context
+    responded = false
+    Switch.state_machine(:state) do
+      responded = respond_to?(:event)
+    end
+    
+    assert responded
+  end
+  
+  def teardown
+    Switch.write_inheritable_attribute(:state_machines, {})
+  end
+end
+
+class StateMachineAfterInitializedTest < Test::Unit::TestCase
+  def setup
+    Switch.state_machine(:state, :initial => 'off')
+  end
+  
+  def test_should_set_the_initial_state
+    assert_equal 'off', Switch.new.state
+  end
+  
+  def teardown
+    Switch.write_inheritable_attribute(:state_machines, {})
+  end
+end
+
+class StateMachineAfterInitializedWithDynamicInitialStateTest < Test::Unit::TestCase
+  def setup
+    Switch.state_machine(:state, :initial => Proc.new {|record| record.initial_state})
+  end
+  
+  def test_should_set_the_initial_state_based_on_the_record
+    assert_equal 'off', Switch.new(:initial_state => 'off').state
+    assert_equal 'on', Switch.new(:initial_state => 'on').state
+  end
+  
+  def teardown
+    Switch.write_inheritable_attribute(:state_machines, {})
+  end
+end
+
+class StateMachineAfterCreatedTest < Test::Unit::TestCase
+  def setup
+    machine = Switch.state_machine(:state, :initial => 'off')
+    
+    machine.before_exit 'off', Proc.new {|switch, value| switch.callbacks << 'before_exit'; true}
+    machine.before_enter 'off', Proc.new {|switch, value| switch.callbacks << 'before_enter'; true}
+    machine.after_exit 'off', Proc.new {|switch, value| switch.callbacks << 'after_exit'; true}
+    machine.after_enter 'off', Proc.new {|switch, value| switch.callbacks << 'after_enter'; true}
+    
+    @switch = create_switch
+  end
+  
+  def test_should_invoke_after_enter_callbacks_for_initial_state
+    assert_equal %w(after_enter), @switch.callbacks
+  end
+  
+  def teardown
+    Switch.write_inheritable_attribute(:state_machines, {})
+    
+    Switch.class_eval do
+      @transition_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
+  end
+end
+
+class StateMachineWithSubclassTest < Test::Unit::TestCase
+  def setup
+    Switch.state_machine(:state, :initial => 'on')
+    ToggleSwitch.state_machine(:state, :initial => 'off')
+  end
+  
+  def test_should_be_able_to_override_initial_state
+    assert_equal 'on', Switch.new.state
+    assert_equal 'off', ToggleSwitch.new.state
+  end
+  
+  def teardown
+    Switch.write_inheritable_attribute(:state_machines, {})
+    ToggleSwitch.write_inheritable_attribute(:state_machines, {})
+  end
+end