state_machines 0.0.2 → 0.1.0

data/test/unit/matcher/loopback_matcher_test.rb

@@ -0,0 +1,27 @@
+require_relative '../../test_helper'
+
+class LoopbackMatcherTest < StateMachinesTest
+  def setup
+    @matcher = StateMachines::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
+    refute @matcher.matches?(:parked, from: :idling)
+  end
+
+  def test_should_have_a_description
+    assert_equal 'same', @matcher.description
+  end
+end

data/test/unit/matcher/matcher_by_default_test.rb

@@ -0,0 +1,15 @@
+require_relative '../../test_helper'
+
+class MatcherByDefaultTest < StateMachinesTest
+  def setup
+    @matcher = StateMachines::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

data/test/unit/matcher/matcher_with_multiple_values_test.rb

@@ -0,0 +1,15 @@
+require_relative '../../test_helper'
+
+class MatcherWithMultipleValuesTest < StateMachinesTest
+  def setup
+    @matcher = StateMachines::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

data/test/unit/matcher/matcher_with_value_test.rb

@@ -0,0 +1,15 @@
+require_relative '../../test_helper'
+
+class MatcherWithValueTest < StateMachinesTest
+  def setup
+    @matcher = StateMachines::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

data/test/unit/matcher/whitelist_matcher_test.rb

@@ -0,0 +1,30 @@
+require_relative '../../test_helper'
+
+class WhitelistMatcherTest < StateMachinesTest
+  def setup
+    @matcher = StateMachines::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
+    refute @matcher.matches?(:first_gear)
+  end
+
+  def test_should_have_a_description
+    assert_equal '[:parked, :idling]', @matcher.description
+
+    matcher = StateMachines::WhitelistMatcher.new([:parked])
+    assert_equal ':parked', matcher.description
+  end
+end

data/test/unit/matcher_helpers/matcher_helpers_all_test.rb

@@ -0,0 +1,14 @@
+require_relative '../../test_helper'
+
+class MatcherHelpersAllTest < StateMachinesTest
+  include StateMachines::MatcherHelpers
+
+  def setup
+    @matcher = all
+  end
+
+  def test_should_build_an_all_matcher
+    assert_equal StateMachines::AllMatcher.instance, @matcher
+  end
+end
+

data/test/unit/matcher_helpers/matcher_helpers_any_test.rb

@@ -0,0 +1,14 @@
+require_relative '../../test_helper'
+
+class MatcherHelpersAnyTest < StateMachinesTest
+  include StateMachines::MatcherHelpers
+
+  def setup
+    @matcher = any
+  end
+
+  def test_should_build_an_all_matcher
+    assert_equal StateMachines::AllMatcher.instance, @matcher
+  end
+end
+

data/test/unit/matcher_helpers/matcher_helpers_same_test.rb

@@ -0,0 +1,13 @@
+require_relative '../../test_helper'
+
+class MatcherHelpersSameTest < StateMachinesTest
+  include StateMachines::MatcherHelpers
+
+  def setup
+    @matcher = same
+  end
+
+  def test_should_build_a_loopback_matcher
+    assert_equal StateMachines::LoopbackMatcher.instance, @matcher
+  end
+end

data/test/unit/node_collection/node_collection_after_being_copied_test/n.rb

@@ -0,0 +1,46 @@
+require_relative '../../test_helper'
+require_relative '../../files/node'
+
+class NodeCollectionAfterBeingCopiedTest < StateMachinesTest
+  def setup
+    machine = StateMachines::Machine.new(Class.new)
+    @collection = StateMachines::NodeCollection.new(machine)
+    @collection << @parked = Node.new(:parked)
+
+    @contexts_run = contexts_run = []
+    @collection.context([:parked]) { contexts_run << :parked }
+    @contexts_run.clear
+
+    @copied_collection = @collection.dup
+    @copied_collection << @idling = Node.new(:idling)
+    @copied_collection.context([:first_gear]) { contexts_run << :first_gear }
+  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
+    refute_same @parked, @copied_collection[:parked]
+  end
+
+  def test_should_not_run_contexts
+    assert_equal [], @contexts_run
+  end
+
+  def test_should_not_modify_contexts
+    @collection << Node.new(:first_gear)
+    assert_equal [], @contexts_run
+  end
+
+  def test_should_copy_contexts
+    @copied_collection << Node.new(:parked)
+    refute @contexts_run.empty?
+  end
+end

data/test/unit/node_collection/node_collection_after_update_test/n.rb

@@ -0,0 +1,36 @@
+require_relative '../../test_helper'
+require_relative '../../files/node'
+
+class NodeCollectionAfterUpdateTest < StateMachinesTest
+  def setup
+    machine = StateMachines::Machine.new(Class.new)
+    @collection = StateMachines::NodeCollection.new(machine, index: [:name, :value])
+
+    @parked = Node.new(:parked, 1)
+    @idling = Node.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/node_collection/node_collection_by_default_test.rb

@@ -0,0 +1,22 @@
+require_relative '../../test_helper'
+require_relative '../../files/node'
+
+class NodeCollectionByDefaultTest < StateMachinesTest
+  def setup
+    @machine = StateMachines::Machine.new(Class.new)
+    @collection = StateMachines::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 = Node.new(:parked)
+    assert_equal object, @collection[:parked]
+  end
+end

data/test/unit/node_collection/node_collection_test.rb

@@ -0,0 +1,23 @@
+require_relative '../../test_helper'
+
+class NodeCollectionTest < StateMachinesTest
+  def setup
+    @machine = StateMachines::Machine.new(Class.new)
+    @collection = StateMachines::NodeCollection.new(@machine)
+  end
+
+  def test_should_raise_exception_if_invalid_option_specified
+    exception = assert_raises(ArgumentError) { StateMachines::NodeCollection.new(@machine, invalid: true) }
+    assert_equal 'Unknown key: :invalid. Valid keys are: :index', exception.message
+  end
+
+  def test_should_raise_exception_on_lookup_if_invalid_index_specified
+    exception = assert_raises(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_raises(ArgumentError) { @collection.fetch(:something, :invalid) }
+    assert_equal 'Invalid index: :invalid', exception.message
+  end
+end

data/test/unit/node_collection/node_collection_with_indices_test/n.rb

@@ -0,0 +1,42 @@
+require_relative '../../test_helper'
+require_relative '../../files/node'
+
+class NodeCollectionWithIndicesTest < StateMachinesTest
+  def setup
+    machine = StateMachines::Machine.new(Class.new)
+    @collection = StateMachines::NodeCollection.new(machine, index: [:name, :value])
+
+    @object = Node.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_raises(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_raises(IndexError) { @collection.fetch(:parked, :value) }
+    assert_equal ':parked is an invalid value', exception.message
+  end
+end

data/test/unit/node_collection/node_collection_with_matcher_contexts_test.rb

@@ -0,0 +1,25 @@
+require_relative '../../test_helper'
+require_relative '../../files/node'
+
+class NodeCollectionWithMatcherContextsTest < StateMachinesTest
+  def setup
+    machine = StateMachines::Machine.new(Class.new)
+    @collection = StateMachines::NodeCollection.new(machine)
+    @collection << Node.new(:parked)
+  end
+
+  def test_should_always_run_all_matcher_context
+    contexts_run = []
+    @collection.context([StateMachines::AllMatcher.instance]) { contexts_run << :all }
+    assert_equal [:all], contexts_run
+  end
+
+  def test_should_only_run_blacklist_matcher_if_not_matched
+    contexts_run = []
+    @collection.context([StateMachines::BlacklistMatcher.new([:parked])]) { contexts_run << :blacklist }
+    assert_equal [], contexts_run
+
+    @collection << Node.new(:idling)
+    assert_equal [:blacklist], contexts_run
+  end
+end

data/test/unit/node_collection/node_collection_with_nodes_test/n.rb

@@ -0,0 +1,46 @@
+require_relative '../../test_helper'
+require_relative '../../files/node'
+
+class NodeCollectionWithNodesTest < StateMachinesTest
+  def setup
+    @machine = StateMachines::Machine.new(Class.new)
+    @collection = StateMachines::NodeCollection.new(@machine)
+
+    @parked = Node.new(:parked, nil, @machine)
+    @idling = Node.new(:idling, nil, @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 = Node.new(:first_gear, nil, @machine)
+    @second_gear = Node.new(:second_gear, nil, @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 = StateMachines::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

data/test/unit/node_collection/node_collection_with_numeric_index_test/n.rb

@@ -0,0 +1,24 @@
+require_relative '../../test_helper'
+require_relative '../../files/node'
+
+class NodeCollectionWithNumericIndexTest < StateMachinesTest
+  def setup
+    machine = StateMachines::Machine.new(Class.new)
+    @collection = StateMachines::NodeCollection.new(machine, index: [:name, :value])
+
+    @parked = Node.new(10, 1)
+    @collection << @parked
+  end
+
+  def test_should_index_by_name
+    assert_equal @parked, @collection[10]
+  end
+
+  def test_should_index_by_string_name
+    assert_equal @parked, @collection['10']
+  end
+
+  def test_should_index_by_symbol_name
+    assert_equal @parked, @collection[:'10']
+  end
+end

data/test/unit/node_collection/node_collection_with_postdefined_contexts_test/n.rb

@@ -0,0 +1,22 @@
+require_relative '../../test_helper'
+require_relative '../../files/node'
+
+class NodeCollectionWithPostdefinedContextsTest < StateMachinesTest
+  def setup
+    machine = StateMachines::Machine.new(Class.new)
+    @collection = StateMachines::NodeCollection.new(machine)
+    @collection << Node.new(:parked)
+  end
+
+  def test_should_run_context_if_matched
+    contexts_run = []
+    @collection.context([:parked]) { contexts_run << :parked }
+    assert_equal [:parked], contexts_run
+  end
+
+  def test_should_not_run_contexts_if_not_matched
+    contexts_run = []
+    @collection.context([:idling]) { contexts_run << :idling }
+    assert_equal [], contexts_run
+  end
+end

data/test/unit/node_collection/node_collection_with_predefined_contexts_test/n.rb

@@ -0,0 +1,23 @@
+require_relative '../../test_helper'
+require_relative '../../files/node'
+
+class NodeCollectionWithPredefinedContextsTest < StateMachinesTest
+  def setup
+    machine = StateMachines::Machine.new(Class.new)
+    @collection = StateMachines::NodeCollection.new(machine)
+
+    @contexts_run = contexts_run = []
+    @collection.context([:parked]) { contexts_run << :parked }
+    @collection.context([:parked]) { contexts_run << :second_parked }
+  end
+
+  def test_should_run_contexts_in_the_order_defined
+    @collection << Node.new(:parked)
+    assert_equal [:parked, :second_parked], @contexts_run
+  end
+
+  def test_should_not_run_contexts_if_not_matched
+    @collection << Node.new(:idling)
+    assert_equal [], @contexts_run
+  end
+end

data/test/unit/node_collection/node_collection_with_string_index_test/n.rb

@@ -0,0 +1,20 @@
+require_relative '../../test_helper'
+require_relative '../../files/node'
+
+class NodeCollectionWithStringIndexTest < StateMachinesTest
+  def setup
+    machine = StateMachines::Machine.new(Class.new)
+    @collection = StateMachines::NodeCollection.new(machine, index: [:name, :value])
+
+    @parked = Node.new(:parked, 1)
+    @collection << @parked
+  end
+
+  def test_should_index_by_name
+    assert_equal @parked, @collection[:parked]
+  end
+
+  def test_should_index_by_string_name
+    assert_equal @parked, @collection['parked']
+  end
+end

data/test/unit/node_collection/node_collection_with_symbol_index_test/n.rb

@@ -0,0 +1,20 @@
+require_relative '../../test_helper'
+require_relative '../../files/node'
+
+class NodeCollectionWithSymbolIndexTest < StateMachinesTest
+  def setup
+    machine = StateMachines::Machine.new(Class.new)
+    @collection = StateMachines::NodeCollection.new(machine, index: [:name, :value])
+
+    @parked = Node.new('parked', 1)
+    @collection << @parked
+  end
+
+  def test_should_index_by_name
+    assert_equal @parked, @collection['parked']
+  end
+
+  def test_should_index_by_symbol_name
+    assert_equal @parked, @collection[:parked]
+  end
+end

data/test/unit/node_collection/node_collection_without_indices_test/n.rb

@@ -0,0 +1,30 @@
+require_relative '../../test_helper'
+
+class NodeCollectionWithoutIndicesTest < StateMachinesTest
+  def setup
+    machine = StateMachines::Machine.new(Class.new)
+    @collection = StateMachines::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_raises(ArgumentError) { @collection.keys }
+    assert_equal 'No indices configured', exception.message
+  end
+
+  def test_should_not_allow_lookup
+    @collection << Object.new
+    exception = assert_raises(ArgumentError) { @collection[0] }
+    assert_equal 'No indices configured', exception.message
+  end
+
+  def test_should_not_allow_fetching
+    @collection << Object.new
+    exception = assert_raises(ArgumentError) { @collection.fetch(0) }
+    assert_equal 'No indices configured', exception.message
+  end
+end

data/test/unit/path/path_by_default_test.rb

@@ -0,0 +1,54 @@
+require_relative '../../test_helper'
+
+class PathByDefaultTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass)
+    @object = @klass.new
+
+    @path = StateMachines::Path.new(@object, @machine)
+  end
+
+  def test_should_have_an_object
+    assert_equal @object, @path.object
+  end
+
+  def test_should_have_a_machine
+    assert_equal @machine, @path.machine
+  end
+
+  def test_should_not_have_walked_anywhere
+    assert_equal [], @path
+  end
+
+  def test_should_not_have_a_from_name
+    assert_nil @path.from_name
+  end
+
+  def test_should_have_no_from_states
+    assert_equal [], @path.from_states
+  end
+
+  def test_should_not_have_a_to_name
+    assert_nil @path.to_name
+  end
+
+  def test_should_have_no_to_states
+    assert_equal [], @path.to_states
+  end
+
+  def test_should_have_no_events
+    assert_equal [], @path.events
+  end
+
+  def test_should_not_be_able_to_walk_anywhere
+    walked = false
+    @path.walk { walked = true }
+    assert_equal false, walked
+  end
+
+  def test_should_not_be_complete
+    assert_equal false, @path.complete?
+  end
+end
+

data/test/unit/path/path_test.rb

@@ -0,0 +1,14 @@
+require_relative '../../test_helper'
+
+class PathTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass)
+    @object = @klass.new
+  end
+
+  def test_should_raise_exception_if_invalid_option_specified
+    exception = assert_raises(ArgumentError) { StateMachines::Path.new(@object, @machine, invalid: true) }
+    assert_equal 'Unknown key: :invalid. Valid keys are: :target, :guard', exception.message
+  end
+end

data/test/unit/path/path_with_available_transitions_after_reaching_target_test.rb

@@ -0,0 +1,40 @@
+require_relative '../../test_helper'
+
+class PathWithAvailableTransitionsAfterReachingTargetTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass)
+    @machine.state :parked, :idling
+    @machine.event :ignite do
+      transition parked: :idling
+    end
+    @machine.event :shift_up do
+      transition parked: :first_gear
+    end
+    @machine.event :park do
+      transition [:idling, :first_gear] => :parked
+    end
+
+    @object = @klass.new
+    @object.state = 'parked'
+
+    @path = StateMachines::Path.new(@object, @machine, target: :parked)
+    @path.concat([
+                     @ignite_transition = StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling),
+                     @park_transition = StateMachines::Transition.new(@object, @machine, :park, :idling, :parked)
+                 ])
+  end
+
+  def test_should_be_complete
+    assert_equal true, @path.complete?
+  end
+
+  def test_should_be_able_to_walk
+    paths = []
+    @path.walk { |path| paths << path }
+    assert_equal [
+                     [@ignite_transition, @park_transition, StateMachines::Transition.new(@object, @machine, :shift_up, :parked, :first_gear)]
+                 ], paths
+  end
+end
+