state_machines 0.5.0 → 0.6.0

data/test/unit/node_collection/node_collection_after_being_copied_test.rb

@@ -1,46 +0,0 @@
-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.rb

@@ -1,36 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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.rb

@@ -1,42 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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.rb

@@ -1,46 +0,0 @@
-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.rb

@@ -1,24 +0,0 @@
-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.rb

@@ -1,22 +0,0 @@
-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.rb

@@ -1,23 +0,0 @@
-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.rb

@@ -1,20 +0,0 @@
-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.rb

@@ -1,20 +0,0 @@
-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.rb

@@ -1,30 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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
-

data/test/unit/path/path_with_available_transitions_test.rb

@@ -1,54 +0,0 @@
-require_relative '../../test_helper'
-
-class PathWithAvailableTransitionsTest < StateMachinesTest
-  def setup
-    @klass = Class.new
-    @machine = StateMachines::Machine.new(@klass)
-    @machine.state :parked, :idling, :first_gear
-    @machine.event :ignite
-    @machine.event :shift_up do
-      transition idling: :first_gear
-    end
-    @machine.event :park do
-      transition idling: :parked
-    end
-
-    @object = @klass.new
-    @object.state = 'parked'
-
-    @path = StateMachines::Path.new(@object, @machine)
-    @path.concat([
-                     @ignite_transition = StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling)
-                 ])
-  end
-
-  def test_should_not_be_complete
-    refute @path.complete?
-  end
-
-  def test_should_walk_each_available_transition
-    paths = []
-    @path.walk { |path| paths << path }
-
-    assert_equal [
-                     [@ignite_transition, StateMachines::Transition.new(@object, @machine, :shift_up, :idling, :first_gear)],
-                     [@ignite_transition, StateMachines::Transition.new(@object, @machine, :park, :idling, :parked)]
-                 ], paths
-  end
-
-  def test_should_yield_path_instances_when_walking
-    @path.walk do |path|
-      assert_instance_of StateMachines::Path, path
-    end
-  end
-
-  def test_should_not_modify_current_path_after_walking
-    @path.walk {}
-    assert_equal [@ignite_transition], @path
-  end
-
-  def test_should_not_modify_object_after_walking
-    @path.walk {}
-    assert_equal 'parked', @object.state
-  end
-end

data/test/unit/path/path_with_deep_target_reached_test.rb

@@ -1,50 +0,0 @@
-require_relative '../../test_helper'
-
-class PathWithDeepTargetReachedTest < 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),
-                     @shift_up_transition = StateMachines::Transition.new(@object, @machine, :shift_up, :parked, :first_gear),
-                     @park_transition_2 = StateMachines::Transition.new(@object, @machine, :park, :first_gear, :parked)
-                 ])
-  end
-
-  def test_should_be_complete
-    assert_equal true, @path.complete?
-  end
-
-  def test_should_not_be_able_to_walk
-    walked = false
-    @path.walk { walked = true }
-    assert_equal false, walked
-  end
-
-  def test_should_not_be_able_to_walk_with_available_transitions
-    @machine.event :park do
-      transition parked: same
-    end
-
-    walked = false
-    @path.walk { walked = true }
-    assert_equal false, walked
-  end
-end
-

data/test/unit/path/path_with_deep_target_test.rb

@@ -1,40 +0,0 @@
-require_relative '../../test_helper'
-
-class PathWithDeepTargetTest < 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),
-                     @shift_up_transition = StateMachines::Transition.new(@object, @machine, :shift_up, :parked, :first_gear)
-                 ])
-  end
-
-  def test_should_not_be_complete
-    assert_equal false, @path.complete?
-  end
-
-  def test_should_be_able_to_walk
-    paths = []
-    @path.walk { |path| paths << path }
-    assert_equal [
-                     [@ignite_transition, @park_transition, @shift_up_transition, StateMachines::Transition.new(@object, @machine, :park, :first_gear, :parked)]
-                 ], paths
-  end
-end

data/test/unit/path/path_with_duplicates_test.rb

@@ -1,32 +0,0 @@
-require_relative '../../test_helper'
-
-class PathWithDuplicatesTest < StateMachinesTest
-  def setup
-    @klass = Class.new
-    @machine = StateMachines::Machine.new(@klass)
-    @machine.state :parked, :idling
-    @machine.event :park, :ignite
-
-    @object = @klass.new
-    @object.state = 'parked'
-
-    @path = StateMachines::Path.new(@object, @machine)
-    @path.concat([
-                     @ignite_transition = StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling),
-                     @park_transition = StateMachines::Transition.new(@object, @machine, :park, :idling, :parked),
-                     @ignite_again_transition = StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling)
-                 ])
-  end
-
-  def test_should_not_include_duplicates_in_from_states
-    assert_equal [:parked, :idling], @path.from_states
-  end
-
-  def test_should_not_include_duplicates_in_to_states
-    assert_equal [:idling, :parked], @path.to_states
-  end
-
-  def test_should_not_include_duplicates_in_events
-    assert_equal [:ignite, :park], @path.events
-  end
-end