hsume2-state_machine 1.0.1

data/test/unit/matcher_helpers_test.rb

@@ -0,0 +1,37 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class MatcherHelpersAllTest < Test::Unit::TestCase
+  include StateMachine::MatcherHelpers
+  
+  def setup
+    @matcher = all
+  end
+  
+  def test_should_build_an_all_matcher
+    assert_equal StateMachine::AllMatcher.instance, @matcher
+  end
+end
+
+class MatcherHelpersAnyTest < Test::Unit::TestCase
+  include StateMachine::MatcherHelpers
+  
+  def setup
+    @matcher = any
+  end
+  
+  def test_should_build_an_all_matcher
+    assert_equal StateMachine::AllMatcher.instance, @matcher
+  end
+end
+
+class MatcherHelpersSameTest < Test::Unit::TestCase
+  include StateMachine::MatcherHelpers
+  
+  def setup
+    @matcher = same
+  end
+  
+  def test_should_build_a_loopback_matcher
+    assert_equal StateMachine::LoopbackMatcher.instance, @matcher
+  end
+end

data/test/unit/matcher_test.rb

@@ -0,0 +1,155 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class MatcherByDefaultTest < Test::Unit::TestCase
+  def setup
+    @matcher = StateMachine::Matcher.new
+  end
+  
+  def test_should_have_no_values
+    assert_equal [], @matcher.values
+  end
+  
+  def test_should_filter_all_values
+    assert_equal [], @matcher.filter([:parked, :idling])
+  end
+end
+
+class MatcherWithValueTest < Test::Unit::TestCase
+  def setup
+    @matcher = StateMachine::Matcher.new(nil)
+  end
+  
+  def test_should_have_values
+    assert_equal [nil], @matcher.values
+  end
+  
+  def test_should_filter_unknown_values
+    assert_equal [nil], @matcher.filter([nil, :parked])
+  end
+end
+
+class MatcherWithMultipleValuesTest < Test::Unit::TestCase
+  def setup
+    @matcher = StateMachine::Matcher.new([:parked, :idling])
+  end
+  
+  def test_should_have_values
+    assert_equal [:parked, :idling], @matcher.values
+  end
+  
+  def test_should_filter_unknown_values
+    assert_equal [:parked], @matcher.filter([:parked, :first_gear])
+  end
+end
+
+class AllMatcherTest < Test::Unit::TestCase
+  def setup
+    @matcher = StateMachine::AllMatcher.instance
+  end
+  
+  def test_should_have_no_values
+    assert_equal [], @matcher.values
+  end
+  
+  def test_should_always_match
+    [nil, :parked, :idling].each {|value| assert @matcher.matches?(value)}
+  end
+  
+  def test_should_not_filter_any_values
+    assert_equal [:parked, :idling], @matcher.filter([:parked, :idling])
+  end
+  
+  def test_should_generate_blacklist_matcher_after_subtraction
+    matcher = @matcher - [:parked, :idling]
+    assert_instance_of StateMachine::BlacklistMatcher, matcher
+    assert_equal [:parked, :idling], matcher.values
+  end
+  
+  def test_should_have_a_description
+    assert_equal 'all', @matcher.description
+  end
+end
+
+class WhitelistMatcherTest < Test::Unit::TestCase
+  def setup
+    @matcher = StateMachine::WhitelistMatcher.new([:parked, :idling])
+  end
+  
+  def test_should_have_values
+    assert_equal [:parked, :idling], @matcher.values
+  end
+  
+  def test_should_filter_unknown_values
+    assert_equal [:parked, :idling], @matcher.filter([:parked, :idling, :first_gear])
+  end
+  
+  def test_should_match_known_values
+    assert @matcher.matches?(:parked)
+  end
+  
+  def test_should_not_match_unknown_values
+    assert !@matcher.matches?(:first_gear)
+  end
+  
+  def test_should_have_a_description
+    assert_equal '[:parked, :idling]', @matcher.description
+    
+    matcher = StateMachine::WhitelistMatcher.new([:parked])
+    assert_equal ':parked', matcher.description
+  end
+end
+
+class BlacklistMatcherTest < Test::Unit::TestCase
+  def setup
+    @matcher = StateMachine::BlacklistMatcher.new([:parked, :idling])
+  end
+  
+  def test_should_have_values
+    assert_equal [:parked, :idling], @matcher.values
+  end
+  
+  def test_should_filter_known_values
+    assert_equal [:first_gear], @matcher.filter([:parked, :idling, :first_gear])
+  end
+  
+  def test_should_match_unknown_values
+    assert @matcher.matches?(:first_gear)
+  end
+  
+  def test_should_not_match_known_values
+    assert !@matcher.matches?(:parked)
+  end
+  
+  def test_should_have_a_description
+    assert_equal 'all - [:parked, :idling]', @matcher.description
+    
+    matcher = StateMachine::BlacklistMatcher.new([:parked])
+    assert_equal 'all - :parked', matcher.description
+  end
+end
+
+class LoopbackMatcherTest < Test::Unit::TestCase
+  def setup
+    @matcher = StateMachine::LoopbackMatcher.instance
+  end
+  
+  def test_should_have_no_values
+    assert_equal [], @matcher.values
+  end
+  
+  def test_should_filter_all_values
+    assert_equal [], @matcher.filter([:parked, :idling])
+  end
+  
+  def test_should_match_if_from_context_is_same
+    assert @matcher.matches?(:parked, :from => :parked)
+  end
+  
+  def test_should_not_match_if_from_context_is_different
+    assert !@matcher.matches?(:parked, :from => :idling)
+  end
+  
+  def test_should_have_a_description
+    assert_equal 'same', @matcher.description
+  end
+end

data/test/unit/node_collection_test.rb

@@ -0,0 +1,217 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class NodeCollectionByDefaultTest < Test::Unit::TestCase
+  def setup
+    @machine = StateMachine::Machine.new(Class.new)
+    @collection = StateMachine::NodeCollection.new(@machine)
+  end
+  
+  def test_should_not_have_any_nodes
+    assert_equal 0, @collection.length
+  end
+  
+  def test_should_have_a_machine
+    assert_equal @machine, @collection.machine
+  end
+  
+  def test_should_index_by_name
+    @collection << object = Struct.new(:name).new(:parked)
+    assert_equal object, @collection[:parked]
+  end
+end
+
+class NodeCollectionTest < Test::Unit::TestCase
+  def setup
+    @machine = StateMachine::Machine.new(Class.new)
+    @collection = StateMachine::NodeCollection.new(@machine)
+  end
+  
+  def test_should_raise_exception_if_invalid_option_specified
+    exception = assert_raise(ArgumentError) { StateMachine::NodeCollection.new(@machine, :invalid => true) }
+    assert_equal 'Invalid key(s): invalid', exception.message
+  end
+  
+  def test_should_raise_exception_on_lookup_if_invalid_index_specified
+    exception = assert_raise(ArgumentError) { @collection[:something, :invalid] }
+    assert_equal 'Invalid index: :invalid', exception.message
+  end
+  
+  def test_should_raise_exception_on_fetch_if_invalid_index_specified
+    exception = assert_raise(ArgumentError) { @collection.fetch(:something, :invalid) }
+    assert_equal 'Invalid index: :invalid', exception.message
+  end
+end
+
+class NodeCollectionAfterBeingCopiedTest < Test::Unit::TestCase
+  def setup
+    machine = StateMachine::Machine.new(Class.new)
+    @collection = StateMachine::NodeCollection.new(machine)
+    @collection << @parked = Struct.new(:name).new(:parked)
+    
+    @copied_collection = @collection.dup
+    @copied_collection << @idling = Struct.new(:name).new(:idling)
+  end
+  
+  def test_should_not_modify_the_original_list
+    assert_equal 1, @collection.length
+    assert_equal 2, @copied_collection.length
+  end
+  
+  def test_should_not_modify_the_indices
+    assert_nil @collection[:idling]
+    assert_equal @idling, @copied_collection[:idling]
+  end
+  
+  def test_should_copy_each_node
+    assert_not_same @parked, @copied_collection[:parked]
+  end
+end
+
+class NodeCollectionWithoutIndicesTest < Test::Unit::TestCase
+  def setup
+    machine = StateMachine::Machine.new(Class.new)
+    @collection = StateMachine::NodeCollection.new(machine, :index => {})
+  end
+  
+  def test_should_allow_adding_node
+    @collection << Object.new
+    assert_equal 1, @collection.length
+  end
+  
+  def test_should_not_allow_keys_retrieval
+    exception = assert_raise(ArgumentError) { @collection.keys }
+    assert_equal 'No indices configured', exception.message
+  end
+  
+  def test_should_not_allow_lookup
+    @collection << object = Object.new
+    exception = assert_raise(ArgumentError) { @collection[0] }
+    assert_equal 'No indices configured', exception.message
+  end
+  
+  def test_should_not_allow_fetching
+    @collection << object = Object.new
+    exception = assert_raise(ArgumentError) { @collection.fetch(0) }
+    assert_equal 'No indices configured', exception.message
+  end
+end
+
+class NodeCollectionWithIndicesTest < Test::Unit::TestCase
+  def setup
+    machine = StateMachine::Machine.new(Class.new)
+    @collection = StateMachine::NodeCollection.new(machine, :index => [:name, :value])
+    
+    @object = Struct.new(:name, :value).new(:parked, 1)
+    @collection << @object
+  end
+  
+  def test_should_use_first_index_by_default_on_key_retrieval
+    assert_equal [:parked], @collection.keys
+  end
+  
+  def test_should_allow_customizing_index_for_key_retrieval
+    assert_equal [1], @collection.keys(:value)
+  end
+  
+  def test_should_use_first_index_by_default_on_lookup
+    assert_equal @object, @collection[:parked]
+    assert_nil @collection[1]
+  end
+  
+  def test_should_allow_customizing_index_on_lookup
+    assert_equal @object, @collection[1, :value]
+    assert_nil @collection[:parked, :value]
+  end
+  
+  def test_should_use_first_index_by_default_on_fetch
+    assert_equal @object, @collection.fetch(:parked)
+    exception = assert_raise(IndexError) { @collection.fetch(1) }
+    assert_equal '1 is an invalid name', exception.message
+  end
+  
+  def test_should_allow_customizing_index_on_fetch
+    assert_equal @object, @collection.fetch(1, :value)
+    exception = assert_raise(IndexError) { @collection.fetch(:parked, :value) }
+    assert_equal ':parked is an invalid value', exception.message
+  end
+end
+
+class NodeCollectionWithNodesTest < Test::Unit::TestCase
+  def setup
+    @machine = StateMachine::Machine.new(Class.new)
+    @collection = StateMachine::NodeCollection.new(@machine)
+    
+    @klass = Struct.new(:name, :machine)
+    @parked = @klass.new(:parked, @machine)
+    @idling = @klass.new(:idling, @machine)
+    
+    @collection << @parked
+    @collection << @idling
+  end
+  
+  def test_should_be_able_to_enumerate
+    order = []
+    @collection.each {|object| order << object}
+    
+    assert_equal [@parked, @idling], order
+  end
+  
+  def test_should_be_able_to_concatenate_multiple_nodes
+    @first_gear = @klass.new(:first_gear, @machine)
+    @second_gear = @klass.new(:second_gear, @machine)
+    @collection.concat([@first_gear, @second_gear])
+    
+    order = []
+    @collection.each {|object| order << object}
+    assert_equal [@parked, @idling, @first_gear, @second_gear], order
+  end
+  
+  def test_should_be_able_to_access_by_index
+    assert_equal @parked, @collection.at(0)
+    assert_equal @idling, @collection.at(1)
+  end
+  
+  def test_should_deep_copy_machine_changes
+    new_machine = StateMachine::Machine.new(Class.new)
+    @collection.machine = new_machine
+    
+    assert_equal new_machine, @collection.machine
+    assert_equal new_machine, @parked.machine
+    assert_equal new_machine, @idling.machine
+  end
+end
+
+class NodeCollectionAfterUpdateTest < Test::Unit::TestCase
+  def setup
+    machine = StateMachine::Machine.new(Class.new)
+    @collection = StateMachine::NodeCollection.new(machine, :index => [:name, :value])
+    
+    @klass = Struct.new(:name, :value)
+    @parked = @klass.new(:parked, 1)
+    @idling = @klass.new(:idling, 2)
+    
+    @collection << @parked << @idling
+    
+    @parked.name = :parking
+    @parked.value = 0
+    @collection.update(@parked)
+  end
+  
+  def test_should_not_change_the_index
+    assert_equal @parked, @collection.at(0)
+  end
+  
+  def test_should_not_duplicate_in_the_collection
+    assert_equal 2, @collection.length
+  end
+  
+  def test_should_add_each_indexed_key
+    assert_equal @parked, @collection[:parking]
+    assert_equal @parked, @collection[0, :value]
+  end
+  
+  def test_should_remove_each_old_indexed_key
+    assert_nil @collection[:parked]
+    assert_nil @collection[1, :value]
+  end
+end

data/test/unit/path_collection_test.rb

@@ -0,0 +1,266 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class PathCollectionByDefaultTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+    @machine.state :parked
+    
+    @object = @klass.new
+    @object.state = 'parked'
+    
+    @paths = StateMachine::PathCollection.new(@object, @machine)
+  end
+  
+  def test_should_have_an_object
+    assert_equal @object, @paths.object
+  end
+  
+  def test_should_have_a_machine
+    assert_equal @machine, @paths.machine
+  end
+  
+  def test_should_have_a_from_name
+    assert_equal :parked, @paths.from_name
+  end
+  
+  def test_should_not_have_a_to_name
+    assert_nil @paths.to_name
+  end
+  
+  def test_should_have_no_from_states
+    assert_equal [], @paths.from_states
+  end
+  
+  def test_should_have_no_to_states
+    assert_equal [], @paths.to_states
+  end
+  
+  def test_should_have_no_events
+    assert_equal [], @paths.events
+  end
+  
+  def test_should_have_no_paths
+    assert @paths.empty?
+  end
+end
+
+class PathCollectionTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+    @object = @klass.new
+  end
+  
+  def test_should_raise_exception_if_invalid_option_specified
+    exception = assert_raise(ArgumentError) {StateMachine::PathCollection.new(@object, @machine, :invalid => true)}
+    assert_equal 'Invalid key(s): invalid', exception.message
+  end
+  
+  def test_should_raise_exception_if_invalid_from_state_specified
+    exception = assert_raise(IndexError) {StateMachine::PathCollection.new(@object, @machine, :from => :invalid)}
+    assert_equal ':invalid is an invalid name', exception.message
+  end
+  
+  def test_should_raise_exception_if_invalid_to_state_specified
+    exception = assert_raise(IndexError) {StateMachine::PathCollection.new(@object, @machine, :to => :invalid)}
+    assert_equal ':invalid is an invalid name', exception.message
+  end
+end
+
+class PathCollectionWithPathsTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+    @machine.state :parked, :idling, :first_gear
+    @machine.event :ignite do
+      transition :parked => :idling
+    end
+    @machine.event :shift_up do
+      transition :idling => :first_gear
+    end
+    
+    @object = @klass.new
+    @object.state = 'parked'
+    
+    @paths = StateMachine::PathCollection.new(@object, @machine)
+  end
+  
+  def test_should_enumerate_paths
+    assert_equal [[
+      StateMachine::Transition.new(@object, @machine, :ignite, :parked, :idling),
+      StateMachine::Transition.new(@object, @machine, :shift_up, :idling, :first_gear)
+    ]], @paths
+  end
+  
+  def test_should_have_a_from_name
+    assert_equal :parked, @paths.from_name
+  end
+  
+  def test_should_not_have_a_to_name
+    assert_nil @paths.to_name
+  end
+  
+  def test_should_have_from_states
+    assert_equal [:parked, :idling], @paths.from_states
+  end
+  
+  def test_should_have_to_states
+    assert_equal [:idling, :first_gear], @paths.to_states
+  end
+  
+  def test_should_have_no_events
+    assert_equal [:ignite, :shift_up], @paths.events
+  end
+end
+
+class PathWithGuardedPathsTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+    @machine.state :parked, :idling, :first_gear
+    @machine.event :ignite do
+      transition :parked => :idling, :if => lambda {false}
+    end
+    
+    @object = @klass.new
+    @object.state = 'parked'
+  end
+  
+  def test_should_not_enumerate_paths_if_guard_enabled
+    assert_equal [], StateMachine::PathCollection.new(@object, @machine)
+  end
+  
+  def test_should_enumerate_paths_if_guard_disabled
+    paths = StateMachine::PathCollection.new(@object, @machine, :guard => false)
+    assert_equal [[
+      StateMachine::Transition.new(@object, @machine, :ignite, :parked, :idling)
+    ]], paths
+  end
+end
+
+class PathCollectionWithDuplicateNodesTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+    @machine.state :parked, :idling
+    @machine.event :shift_up do
+      transition :parked => :idling, :idling => :first_gear
+    end
+    @machine.event :park do
+      transition :first_gear => :idling
+    end
+    @object = @klass.new
+    @object.state = 'parked'
+    
+    @paths = StateMachine::PathCollection.new(@object, @machine)
+  end
+  
+  def test_should_not_include_duplicates_in_from_states
+    assert_equal [:parked, :idling, :first_gear], @paths.from_states
+  end
+  
+  def test_should_not_include_duplicates_in_to_states
+    assert_equal [:idling, :first_gear], @paths.to_states
+  end
+  
+  def test_should_not_include_duplicates_in_events
+    assert_equal [:shift_up, :park], @paths.events
+  end
+end
+
+class PathCollectionWithFromStateTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+    @machine.state :parked, :idling, :first_gear
+    @machine.event :park do
+      transition :idling => :parked
+    end
+    
+    @object = @klass.new
+    @object.state = 'parked'
+    
+    @paths = StateMachine::PathCollection.new(@object, @machine, :from => :idling)
+  end
+  
+  def test_should_generate_paths_from_custom_from_state
+    assert_equal [[
+      StateMachine::Transition.new(@object, @machine, :park, :idling, :parked)
+    ]], @paths
+  end
+  
+  def test_should_have_a_from_name
+    assert_equal :idling, @paths.from_name
+  end
+end
+
+class PathCollectionWithToStateTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+    @machine.state :parked, :idling
+    @machine.event :ignite do
+      transition :parked => :idling
+    end
+    @machine.event :shift_up do
+      transition :parked => :idling, :idling => :first_gear
+    end
+    @machine.event :shift_down do
+      transition :first_gear => :idling
+    end
+    @object = @klass.new
+    @object.state = 'parked'
+    
+    @paths = StateMachine::PathCollection.new(@object, @machine, :to => :idling)
+  end
+  
+  def test_should_stop_paths_once_target_state_reached
+    assert_equal [
+      [StateMachine::Transition.new(@object, @machine, :ignite, :parked, :idling)],
+      [StateMachine::Transition.new(@object, @machine, :shift_up, :parked, :idling)]
+    ], @paths
+  end
+end
+
+class PathCollectionWithDeepPathsTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+    @machine.state :parked, :idling
+    @machine.event :ignite do
+      transition :parked => :idling
+    end
+    @machine.event :shift_up do
+      transition :parked => :idling, :idling => :first_gear
+    end
+    @machine.event :shift_down do
+      transition :first_gear => :idling
+    end
+    @object = @klass.new
+    @object.state = 'parked'
+    
+    @paths = StateMachine::PathCollection.new(@object, @machine, :to => :idling, :deep => true)
+  end
+  
+  def test_should_allow_target_to_be_reached_more_than_once_per_path
+    assert_equal [
+      [
+        StateMachine::Transition.new(@object, @machine, :ignite, :parked, :idling)
+      ],
+      [
+        StateMachine::Transition.new(@object, @machine, :ignite, :parked, :idling),
+        StateMachine::Transition.new(@object, @machine, :shift_up, :idling, :first_gear),
+        StateMachine::Transition.new(@object, @machine, :shift_down, :first_gear, :idling)
+      ],
+      [
+        StateMachine::Transition.new(@object, @machine, :shift_up, :parked, :idling)
+      ],
+      [
+        StateMachine::Transition.new(@object, @machine, :shift_up, :parked, :idling),
+        StateMachine::Transition.new(@object, @machine, :shift_up, :idling, :first_gear),
+        StateMachine::Transition.new(@object, @machine, :shift_down, :first_gear, :idling)
+      ]
+    ], @paths
+  end
+end