state_machine_deuxito 0.0.1

data/test/unit/state_collection_test.rb

@@ -0,0 +1,352 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class StateCollectionByDefaultTest < Test::Unit::TestCase
+  def setup
+    @machine = StateMachine::Machine.new(Class.new)
+    @states = StateMachine::StateCollection.new(@machine)
+  end
+  
+  def test_should_not_have_any_nodes
+    assert_equal 0, @states.length
+  end
+  
+  def test_should_have_a_machine
+    assert_equal @machine, @states.machine
+  end
+  
+  def test_should_be_empty_by_priority
+    assert_equal [], @states.by_priority
+  end
+end
+
+class StateCollectionTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+    @states = StateMachine::StateCollection.new(@machine)
+    
+    @states << @nil = StateMachine::State.new(@machine, nil)
+    @states << @parked = StateMachine::State.new(@machine, :parked)
+    @states << @idling = StateMachine::State.new(@machine, :idling)
+    @machine.states.concat(@states)
+    
+    @object = @klass.new
+  end
+  
+  def test_should_index_by_name
+    assert_equal @parked, @states[:parked, :name]
+  end
+  
+  def test_should_index_by_name_by_default
+    assert_equal @parked, @states[:parked]
+  end
+  
+  def test_should_index_by_string_name
+    assert_equal @parked, @states['parked']
+  end
+  
+  def test_should_index_by_qualified_name
+    assert_equal @parked, @states[:parked, :qualified_name]
+  end
+  
+  def test_should_index_by_string_qualified_name
+    assert_equal @parked, @states['parked', :qualified_name]
+  end
+  
+  def test_should_index_by_value
+    assert_equal @parked, @states['parked', :value]
+  end
+  
+  def test_should_not_match_if_value_does_not_match
+    assert !@states.matches?(@object, :parked)
+    assert !@states.matches?(@object, :idling)
+  end
+  
+  def test_should_match_if_value_matches
+    assert @states.matches?(@object, nil)
+  end
+  
+  def test_raise_exception_if_matching_invalid_state
+    assert_raise(IndexError) { @states.matches?(@object, :invalid) }
+  end
+  
+  def test_should_find_state_for_object_if_value_is_known
+    @object.state = 'parked'
+    assert_equal @parked, @states.match(@object)
+  end
+  
+  def test_should_find_bang_state_for_object_if_value_is_known
+    @object.state = 'parked'
+    assert_equal @parked, @states.match!(@object)
+  end
+  
+  def test_should_not_find_state_for_object_with_unknown_value
+    @object.state = 'invalid'
+    assert_nil @states.match(@object)
+  end
+  
+  def test_should_raise_exception_if_finding_bang_state_for_object_with_unknown_value
+    @object.state = 'invalid'
+    exception = assert_raise(ArgumentError) { @states.match!(@object) }
+    assert_equal '"invalid" is not a known state value', exception.message
+  end
+end
+
+class StateCollectionStringTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+    @states = StateMachine::StateCollection.new(@machine)
+    
+    @states << @nil = StateMachine::State.new(@machine, nil)
+    @states << @parked = StateMachine::State.new(@machine, 'parked')
+    @machine.states.concat(@states)
+    
+    @object = @klass.new
+  end
+  
+  def test_should_index_by_name
+    assert_equal @parked, @states['parked', :name]
+  end
+  
+  def test_should_index_by_name_by_default
+    assert_equal @parked, @states['parked']
+  end
+  
+  def test_should_index_by_symbol_name
+    assert_equal @parked, @states[:parked]
+  end
+  
+  def test_should_index_by_qualified_name
+    assert_equal @parked, @states['parked', :qualified_name]
+  end
+  
+  def test_should_index_by_symbol_qualified_name
+    assert_equal @parked, @states[:parked, :qualified_name]
+  end
+end
+
+class StateCollectionWithNamespaceTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass, :namespace => 'vehicle')
+    @states = StateMachine::StateCollection.new(@machine)
+    
+    @states << @state = StateMachine::State.new(@machine, :parked)
+    @machine.states.concat(@states)
+  end
+  
+  def test_should_index_by_name
+    assert_equal @state, @states[:parked, :name]
+  end
+  
+  def test_should_index_by_qualified_name
+    assert_equal @state, @states[:vehicle_parked, :qualified_name]
+  end
+end
+
+class StateCollectionWithCustomStateValuesTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+    @states = StateMachine::StateCollection.new(@machine)
+    
+    @states << @state = StateMachine::State.new(@machine, :parked, :value => 1)
+    @machine.states.concat(@states)
+    
+    @object = @klass.new
+    @object.state = 1
+  end
+  
+  def test_should_match_if_value_matches
+    assert @states.matches?(@object, :parked)
+  end
+  
+  def test_should_not_match_if_value_does_not_match
+    @object.state = 2
+    assert !@states.matches?(@object, :parked)
+  end
+  
+  def test_should_find_state_for_object_if_value_is_known
+    assert_equal @state, @states.match(@object)
+  end
+end
+
+class StateCollectionWithStateMatchersTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+    @states = StateMachine::StateCollection.new(@machine)
+    
+    @states << @state = StateMachine::State.new(@machine, :parked, :if => lambda {|value| !value.nil?})
+    @machine.states.concat(@states)
+    
+    @object = @klass.new
+    @object.state = 1
+  end
+  
+  def test_should_match_if_value_matches
+    assert @states.matches?(@object, :parked)
+  end
+  
+  def test_should_not_match_if_value_does_not_match
+    @object.state = nil
+    assert !@states.matches?(@object, :parked)
+  end
+  
+  def test_should_find_state_for_object_if_value_is_known
+    assert_equal @state, @states.match(@object)
+  end
+end
+
+class StateCollectionWithInitialStateTest < Test::Unit::TestCase
+  def setup
+    @machine = StateMachine::Machine.new(Class.new)
+    @states = StateMachine::StateCollection.new(@machine)
+    
+    @states << @parked = StateMachine::State.new(@machine, :parked)
+    @states << @idling = StateMachine::State.new(@machine, :idling)
+    @machine.states.concat(@states)
+    
+    @parked.initial = true
+  end
+  
+  def test_should_order_state_before_transition_states
+    @machine.event :ignite do
+      transition :to => :idling
+    end
+    assert_equal [@parked, @idling], @states.by_priority
+  end
+  
+  def test_should_order_state_before_states_with_behaviors
+    @idling.context do
+      def speed
+        0
+      end
+    end
+    assert_equal [@parked, @idling], @states.by_priority
+  end
+  
+  def test_should_order_state_before_other_states
+    assert_equal [@parked, @idling], @states.by_priority
+  end
+  
+  def test_should_order_state_before_callback_states
+    @machine.before_transition :from => :idling, :do => lambda {}
+    assert_equal [@parked, @idling], @states.by_priority
+  end
+end
+
+class StateCollectionWithStateBehaviorsTest < Test::Unit::TestCase
+  def setup
+    @machine = StateMachine::Machine.new(Class.new)
+    @states = StateMachine::StateCollection.new(@machine)
+    
+    @states << @parked = StateMachine::State.new(@machine, :parked)
+    @states << @idling = StateMachine::State.new(@machine, :idling)
+    @machine.states.concat(@states)
+    
+    @idling.context do
+      def speed
+        0
+      end
+    end
+  end
+  
+  def test_should_order_states_after_initial_state
+    @parked.initial = true
+    assert_equal [@parked, @idling], @states.by_priority
+  end
+  
+  def test_should_order_states_after_transition_states
+    @machine.event :ignite do
+      transition :from => :parked
+    end
+    assert_equal [@parked, @idling], @states.by_priority
+  end
+  
+  def test_should_order_states_before_other_states
+    assert_equal [@idling, @parked], @states.by_priority
+  end
+  
+  def test_should_order_state_before_callback_states
+    @machine.before_transition :from => :parked, :do => lambda {}
+    assert_equal [@idling, @parked], @states.by_priority
+  end
+end
+
+class StateCollectionWithEventTransitionsTest < Test::Unit::TestCase
+  def setup
+    @machine = StateMachine::Machine.new(Class.new)
+    @states = StateMachine::StateCollection.new(@machine)
+    
+    @states << @parked = StateMachine::State.new(@machine, :parked)
+    @states << @idling = StateMachine::State.new(@machine, :idling)
+    @machine.states.concat(@states)
+    
+    @machine.event :ignite do
+      transition :to => :idling
+    end
+  end
+  
+  def test_should_order_states_after_initial_state
+    @parked.initial = true
+    assert_equal [@parked, @idling], @states.by_priority
+  end
+  
+  def test_should_order_states_before_states_with_behaviors
+    @parked.context do
+      def speed
+        0
+      end
+    end
+    assert_equal [@idling, @parked], @states.by_priority
+  end
+  
+  def test_should_order_states_before_other_states
+    assert_equal [@idling, @parked], @states.by_priority
+  end
+  
+  def test_should_order_state_before_callback_states
+    @machine.before_transition :from => :parked, :do => lambda {}
+    assert_equal [@idling, @parked], @states.by_priority
+  end
+end
+
+class StateCollectionWithTransitionCallbacksTest < Test::Unit::TestCase
+  def setup
+    @machine = StateMachine::Machine.new(Class.new)
+    @states = StateMachine::StateCollection.new(@machine)
+    
+    @states << @parked = StateMachine::State.new(@machine, :parked)
+    @states << @idling = StateMachine::State.new(@machine, :idling)
+    @machine.states.concat(@states)
+    
+    @machine.before_transition :to => :idling, :do => lambda {}
+  end
+  
+  def test_should_order_states_after_initial_state
+    @parked.initial = true
+    assert_equal [@parked, @idling], @states.by_priority
+  end
+  
+  def test_should_order_states_after_transition_states
+    @machine.event :ignite do
+      transition :from => :parked
+    end
+    assert_equal [@parked, @idling], @states.by_priority
+  end
+  
+  def test_should_order_states_after_states_with_behaviors
+    @parked.context do
+      def speed
+        0
+      end
+    end
+    assert_equal [@parked, @idling], @states.by_priority
+  end
+  
+  def test_should_order_states_after_other_states
+    assert_equal [@parked, @idling], @states.by_priority
+  end
+end

data/test/unit/state_context_test.rb

@@ -0,0 +1,441 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class Validateable
+  class << self
+    def validate(*args, &block)
+      args << block if block_given?
+      args
+    end
+  end
+end
+
+class StateContextTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new(Validateable)
+    @machine = StateMachine::Machine.new(@klass, :initial => :parked)
+    @state = @machine.state :parked
+    
+    @state_context = StateMachine::StateContext.new(@state)
+  end
+  
+  def test_should_have_a_machine
+    assert_equal @machine, @state_context.machine
+  end
+  
+  def test_should_have_a_state
+    assert_equal @state, @state_context.state
+  end
+end
+
+class StateContextTransitionTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass, :initial => :parked)
+    @state = @machine.state :parked
+    
+    @state_context = StateMachine::StateContext.new(@state)
+  end
+  
+  def test_should_not_allow_except_to
+    exception = assert_raise(ArgumentError) { @state_context.transition(:except_to => :idling) }
+    assert_equal 'Invalid key(s): except_to', exception.message
+  end
+  
+  def test_should_not_allow_except_from
+    exception = assert_raise(ArgumentError) { @state_context.transition(:except_from => :idling) }
+    assert_equal 'Invalid key(s): except_from', exception.message
+  end
+  
+  def test_should_not_allow_implicit_transitions
+    exception = assert_raise(ArgumentError) { @state_context.transition(:parked => :idling) }
+    assert_equal 'Invalid key(s): parked', exception.message
+  end
+  
+  def test_should_not_allow_except_on
+    exception = assert_raise(ArgumentError) { @state_context.transition(:except_on => :park) }
+    assert_equal 'Invalid key(s): except_on', exception.message
+  end
+  
+  def test_should_require_on_event
+    exception = assert_raise(ArgumentError) { @state_context.transition(:to => :idling) }
+    assert_equal 'Must specify :on event', exception.message
+  end
+  
+  def test_should_not_allow_missing_from_and_to
+    exception = assert_raise(ArgumentError) { @state_context.transition(:on => :ignite) }
+    assert_equal 'Must specify either :to or :from state', exception.message
+  end
+  
+  def test_should_not_allow_from_and_to
+    exception = assert_raise(ArgumentError) { @state_context.transition(:on => :ignite, :from => :parked, :to => :idling) }
+    assert_equal 'Must specify either :to or :from state', exception.message
+  end
+  
+  def test_should_allow_to_state_if_missing_from_state
+    assert_nothing_raised { @state_context.transition(:on => :park, :from => :parked) }
+  end
+  
+  def test_should_allow_from_state_if_missing_to_state
+    assert_nothing_raised { @state_context.transition(:on => :ignite, :to => :idling) }
+  end
+  
+  def test_should_automatically_set_to_option_with_from_state
+    branch = @state_context.transition(:from => :idling, :on => :park)
+    assert_instance_of StateMachine::Branch, branch
+    
+    state_requirements = branch.state_requirements
+    assert_equal 1, state_requirements.length
+    
+    from_requirement = state_requirements[0][:to]
+    assert_instance_of StateMachine::WhitelistMatcher, from_requirement
+    assert_equal [:parked], from_requirement.values
+  end
+  
+  def test_should_automatically_set_from_option_with_to_state
+    branch = @state_context.transition(:to => :idling, :on => :ignite)
+    assert_instance_of StateMachine::Branch, branch
+    
+    state_requirements = branch.state_requirements
+    assert_equal 1, state_requirements.length
+    
+    from_requirement = state_requirements[0][:from]
+    assert_instance_of StateMachine::WhitelistMatcher, from_requirement
+    assert_equal [:parked], from_requirement.values
+  end
+  
+  def test_should_allow_if_condition
+    assert_nothing_raised {@state_context.transition(:to => :idling, :on => :park, :if => :seatbelt_on?)}
+  end
+  
+  def test_should_allow_unless_condition
+    assert_nothing_raised {@state_context.transition(:to => :idling, :on => :park, :unless => :seatbelt_off?)}
+  end
+  
+  def test_should_include_all_transition_states_in_machine_states
+    @state_context.transition(:to => :idling, :on => :ignite)
+    
+    assert_equal [:parked, :idling], @machine.states.map {|state| state.name}
+  end
+  
+  def test_should_include_all_transition_events_in_machine_events
+    @state_context.transition(:to => :idling, :on => :ignite)
+    
+    assert_equal [:ignite], @machine.events.map {|event| event.name}
+  end
+  
+  def test_should_allow_multiple_events
+    @state_context.transition(:to => :idling, :on => [:ignite, :shift_up])
+    
+    assert_equal [:ignite, :shift_up], @machine.events.map {|event| event.name}
+  end
+end
+
+class StateContextWithMatchingTransitionTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass, :initial => :parked)
+    @state = @machine.state :parked
+    
+    @state_context = StateMachine::StateContext.new(@state)
+    @state_context.transition(:to => :idling, :on => :ignite)
+    
+    @event = @machine.event(:ignite)
+    @object = @klass.new
+  end
+  
+  def test_should_be_able_to_fire
+    assert @event.can_fire?(@object)
+  end
+  
+  def test_should_have_a_transition
+    transition = @event.transition_for(@object)
+    assert_not_nil transition
+    assert_equal 'parked', transition.from
+    assert_equal 'idling', transition.to
+    assert_equal :ignite, transition.event
+  end
+end
+
+class StateContextProxyTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new(Validateable)
+    machine = StateMachine::Machine.new(@klass, :initial => :parked)
+    state = machine.state :parked
+    
+    @state_context = StateMachine::StateContext.new(state)
+  end
+  
+  def test_should_call_class_with_same_arguments
+    options = {}
+    validation = @state_context.validate(:name, options)
+    
+    assert_equal [:name, options], validation
+  end
+  
+  def test_should_pass_block_through_to_class
+    options = {}
+    proxy_block = lambda {}
+    validation = @state_context.validate(:name, options, &proxy_block)
+    
+    assert_equal [:name, options, proxy_block], validation
+  end
+end
+
+class StateContextProxyWithoutConditionsTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new(Validateable)
+    machine = StateMachine::Machine.new(@klass, :initial => :parked)
+    state = machine.state :parked
+    
+    @state_context = StateMachine::StateContext.new(state)
+    @object = @klass.new
+    
+    @options = @state_context.validate[0]
+  end
+  
+  def test_should_have_options_configuration
+    assert_instance_of Hash, @options
+  end
+  
+  def test_should_have_if_option
+    assert_not_nil @options[:if]
+  end
+  
+  def test_should_be_false_if_state_is_different
+    @object.state = nil
+    assert !@options[:if].call(@object)
+  end
+  
+  def test_should_be_true_if_state_matches
+    assert @options[:if].call(@object)
+  end
+end
+
+class StateContextProxyWithIfConditionTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new(Validateable)
+    machine = StateMachine::Machine.new(@klass, :initial => :parked)
+    state = machine.state :parked
+    
+    @state_context = StateMachine::StateContext.new(state)
+    @object = @klass.new
+    
+    @condition_result = nil
+    @options = @state_context.validate(:if => lambda {@condition_result})[0]
+  end
+  
+  def test_should_have_if_option
+    assert_not_nil @options[:if]
+  end
+  
+  def test_should_be_false_if_state_is_different
+    @object.state = nil
+    assert !@options[:if].call(@object)
+  end
+  
+  def test_should_be_false_if_original_condition_is_false
+    @condition_result = false
+    assert !@options[:if].call(@object)
+  end
+  
+  def test_should_be_true_if_state_matches_and_original_condition_is_true
+    @condition_result = true
+    assert @options[:if].call(@object)
+  end
+  
+  def test_should_evaluate_symbol_condition
+    @klass.class_eval do
+      attr_accessor :callback
+    end
+    
+    options = @state_context.validate(:if => :callback)[0]
+    
+    object = @klass.new
+    object.callback = false
+    assert !options[:if].call(object)
+    
+    object.callback = true
+    assert options[:if].call(object)
+  end
+  
+  def test_should_evaluate_string_condition
+    @klass.class_eval do
+      attr_accessor :callback
+    end
+    
+    options = @state_context.validate(:if => '@callback')[0]
+    
+    object = @klass.new
+    object.callback = false
+    assert !options[:if].call(object)
+    
+    object.callback = true
+    assert options[:if].call(object)
+  end
+end
+
+class StateContextProxyWithMultipleIfConditionsTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new(Validateable)
+    machine = StateMachine::Machine.new(@klass, :initial => :parked)
+    state = machine.state :parked
+    
+    @state_context = StateMachine::StateContext.new(state)
+    @object = @klass.new
+    
+    @first_condition_result = nil
+    @second_condition_result = nil
+    @options = @state_context.validate(:if => [lambda {@first_condition_result}, lambda {@second_condition_result}])[0]
+  end
+  
+  def test_should_be_true_if_all_conditions_are_true
+    @first_condition_result = true
+    @second_condition_result = true
+    assert @options[:if].call(@object)
+  end
+  
+  def test_should_be_false_if_any_condition_is_false
+    @first_condition_result = true
+    @second_condition_result = false
+    assert !@options[:if].call(@object)
+    
+    @first_condition_result = false
+    @second_condition_result = true
+    assert !@options[:if].call(@object)
+  end
+end
+
+class StateContextProxyWithUnlessConditionTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new(Validateable)
+    machine = StateMachine::Machine.new(@klass, :initial => :parked)
+    state = machine.state :parked
+    
+    @state_context = StateMachine::StateContext.new(state)
+    @object = @klass.new
+    
+    @condition_result = nil
+    @options = @state_context.validate(:unless => lambda {@condition_result})[0]
+  end
+  
+  def test_should_have_if_option
+    assert_not_nil @options[:if]
+  end
+  
+  def test_should_be_false_if_state_is_different
+    @object.state = nil
+    assert !@options[:if].call(@object)
+  end
+  
+  def test_should_be_false_if_original_condition_is_true
+    @condition_result = true
+    assert !@options[:if].call(@object)
+  end
+  
+  def test_should_be_true_if_state_matches_and_original_condition_is_false
+    @condition_result = false
+    assert @options[:if].call(@object)
+  end
+  
+  def test_should_evaluate_symbol_condition
+    @klass.class_eval do
+      attr_accessor :callback
+    end
+    
+    options = @state_context.validate(:unless => :callback)[0]
+    
+    object = @klass.new
+    object.callback = true
+    assert !options[:if].call(object)
+    
+    object.callback = false
+    assert options[:if].call(object)
+  end
+  
+  def test_should_evaluate_string_condition
+    @klass.class_eval do
+      attr_accessor :callback
+    end
+    
+    options = @state_context.validate(:unless => '@callback')[0]
+    
+    object = @klass.new
+    object.callback = true
+    assert !options[:if].call(object)
+    
+    object.callback = false
+    assert options[:if].call(object)
+  end
+end
+
+class StateContextProxyWithMultipleUnlessConditionsTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new(Validateable)
+    machine = StateMachine::Machine.new(@klass, :initial => :parked)
+    state = machine.state :parked
+    
+    @state_context = StateMachine::StateContext.new(state)
+    @object = @klass.new
+    
+    @first_condition_result = nil
+    @second_condition_result = nil
+    @options = @state_context.validate(:unless => [lambda {@first_condition_result}, lambda {@second_condition_result}])[0]
+  end
+  
+  def test_should_be_true_if_all_conditions_are_false
+    @first_condition_result = false
+    @second_condition_result = false
+    assert @options[:if].call(@object)
+  end
+  
+  def test_should_be_false_if_any_condition_is_true
+    @first_condition_result = true
+    @second_condition_result = false
+    assert !@options[:if].call(@object)
+    
+    @first_condition_result = false
+    @second_condition_result = true
+    assert !@options[:if].call(@object)
+  end
+end
+
+class StateContextProxyWithIfAndUnlessConditionsTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new(Validateable)
+    machine = StateMachine::Machine.new(@klass, :initial => :parked)
+    state = machine.state :parked
+    
+    @state_context = StateMachine::StateContext.new(state)
+    @object = @klass.new
+    
+    @if_condition_result = nil
+    @unless_condition_result = nil
+    @options = @state_context.validate(:if => lambda {@if_condition_result}, :unless => lambda {@unless_condition_result})[0]
+  end
+  
+  def test_should_be_false_if_if_condition_is_false
+    @if_condition_result = false
+    @unless_condition_result = false
+    assert !@options[:if].call(@object)
+    
+    @if_condition_result = false
+    @unless_condition_result = true
+    assert !@options[:if].call(@object)
+  end
+  
+  def test_should_be_false_if_unless_condition_is_true
+    @if_condition_result = false
+    @unless_condition_result = true
+    assert !@options[:if].call(@object)
+    
+    @if_condition_result = true
+    @unless_condition_result = true
+    assert !@options[:if].call(@object)
+  end
+  
+  def test_should_be_true_if_if_condition_is_true_and_unless_condition_is_false
+    @if_condition_result = true
+    @unless_condition_result = false
+    assert @options[:if].call(@object)
+  end
+end