state_machines 0.0.2 → 0.1.0

data/test/unit/state/state_with_name_test.rb

@@ -0,0 +1,43 @@
+require_relative '../../test_helper'
+
+class StateWithNameTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass)
+    @machine.states << @state = StateMachines::State.new(@machine, :parked)
+  end
+
+  def test_should_have_a_name
+    assert_equal :parked, @state.name
+  end
+
+  def test_should_have_a_qualified_name
+    assert_equal :parked, @state.name
+  end
+
+  def test_should_have_a_human_name
+    assert_equal 'parked', @state.human_name
+  end
+
+  def test_should_use_stringify_the_name_as_the_value
+    assert_equal 'parked', @state.value
+  end
+
+  def test_should_match_stringified_name
+    assert @state.matches?('parked')
+    refute @state.matches?('idling')
+  end
+
+  def test_should_not_include_value_in_description
+    assert_equal 'parked', @state.description
+  end
+
+  def test_should_allow_using_human_name_in_description
+    @state.human_name = 'Parked'
+    assert_equal 'Parked', @state.description(human_name: true)
+  end
+
+  def test_should_define_predicate
+    assert @klass.new.respond_to?(:parked?)
+  end
+end

data/test/unit/state/state_with_namespace_test.rb

@@ -0,0 +1,22 @@
+require_relative '../../test_helper'
+
+class StateWithNamespaceTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass, namespace: 'alarm')
+    @machine.states << @state = StateMachines::State.new(@machine, :active)
+    @object = @klass.new
+  end
+
+  def test_should_have_a_name
+    assert_equal :active, @state.name
+  end
+
+  def test_should_have_a_qualified_name
+    assert_equal :alarm_active, @state.qualified_name
+  end
+
+  def test_should_namespace_predicate
+    assert @object.respond_to?(:alarm_active?)
+  end
+end

data/test/unit/state/state_with_nil_value_test.rb

@@ -0,0 +1,35 @@
+require_relative '../../test_helper'
+
+class StateWithNilValueTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass)
+    @machine.states << @state = StateMachines::State.new(@machine, :parked, value: nil)
+  end
+
+  def test_should_have_a_name
+    assert_equal :parked, @state.name
+  end
+
+  def test_should_have_a_nil_value
+    assert_nil @state.value
+  end
+
+  def test_should_match_nil_values
+    assert @state.matches?(nil)
+  end
+
+  def test_should_have_a_description
+    assert_equal 'parked (nil)', @state.description
+  end
+
+  def test_should_have_a_description_with_human_name
+    @state.human_name = 'Parked'
+    assert_equal 'Parked (nil)', @state.description(human_name: true)
+  end
+
+  def test_should_define_predicate
+    object = @klass.new
+    assert object.respond_to?(:parked?)
+  end
+end

data/test/unit/state/state_with_redefined_context_method_test.rb

@@ -0,0 +1,45 @@
+require_relative '../../test_helper'
+
+class StateWithRedefinedContextMethodTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass)
+    @machine.states << @state = StateMachines::State.new(@machine, 'on')
+
+    old_context = nil
+    old_speed_method = nil
+    @state.context do
+      old_context = self
+
+      def speed
+        0
+      end
+
+      old_speed_method = instance_method(:speed)
+    end
+    @old_context = old_context
+    @old_speed_method = old_speed_method
+
+    current_context = nil
+    current_speed_method = nil
+    @state.context do
+      current_context = self
+
+      def speed
+        'green'
+      end
+
+      current_speed_method = instance_method(:speed)
+    end
+    @current_context = current_context
+    @current_speed_method = current_speed_method
+  end
+
+  def test_should_track_latest_defined_method
+    assert_equal @current_speed_method, @state.context_methods[:"__state_on_speed_#{@current_context.object_id}__"]
+  end
+
+  def test_should_have_the_same_context
+    assert_equal @current_context, @old_context
+  end
+end

data/test/unit/state/state_with_symbolic_value_test.rb

@@ -0,0 +1,32 @@
+require_relative '../../test_helper'
+
+class StateWithSymbolicValueTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass)
+    @machine.states << @state = StateMachines::State.new(@machine, :parked, value: :parked)
+  end
+
+  def test_should_use_custom_value
+    assert_equal :parked, @state.value
+  end
+
+  def test_should_not_include_value_in_description
+    assert_equal 'parked', @state.description
+  end
+
+  def test_should_allow_human_name_in_description
+    @state.human_name = 'Parked'
+    assert_equal 'Parked', @state.description(human_name: true)
+  end
+
+  def test_should_match_symbolic_value
+    assert @state.matches?(:parked)
+    refute @state.matches?('parked')
+  end
+
+  def test_should_define_predicate
+    object = @klass.new
+    assert object.respond_to?(:parked?)
+  end
+end

data/test/unit/state/state_with_valid_inherited_method_call_for_current_state_test.rb

@@ -0,0 +1,40 @@
+require_relative '../../test_helper'
+
+class StateWithValidInheritedMethodCallForCurrentStateTest < StateMachinesTest
+  def setup
+    @superclass = Class.new do
+      def speed(arg = nil)
+        [arg]
+      end
+    end
+    @klass = Class.new(@superclass)
+    @machine = StateMachines::Machine.new(@klass, initial: :idling)
+    @ancestors = @klass.ancestors
+    @state = @machine.state(:idling)
+    @state.context do
+      def speed(arg = nil)
+        [arg] + super(2)
+      end
+    end
+
+    @object = @klass.new
+  end
+
+  def test_should_not_raise_an_exception
+    @state.call(@object, :speed, method_missing: lambda { fail })
+  end
+
+  def test_should_be_able_to_call_super
+    assert_equal [1, 2], @state.call(@object, :speed, 1)
+  end
+
+  def test_should_allow_redefinition
+    @state.context do
+      def speed(arg = nil)
+        [arg] + super(3)
+      end
+    end
+
+    assert_equal [1, 3], @state.call(@object, :speed, 1)
+  end
+end

data/test/unit/state/state_with_valid_method_call_for_current_state_test.rb

@@ -0,0 +1,33 @@
+require_relative '../../test_helper'
+
+class StateWithValidMethodCallForCurrentStateTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass, initial: :idling)
+    @ancestors = @klass.ancestors
+    @state = @machine.state(:idling)
+    @state.context do
+      def speed(arg = nil)
+        block_given? ? [arg, yield] : arg
+      end
+    end
+
+    @object = @klass.new
+  end
+
+  def test_should_not_raise_an_exception
+    @state.call(@object, :speed, method_missing: lambda { fail })
+  end
+
+  def test_should_pass_arguments_through
+    assert_equal 1, @state.call(@object, :speed, 1, method_missing: lambda {})
+  end
+
+  def test_should_pass_blocks_through
+    assert_equal [nil, 1], @state.call(@object, :speed) { 1 }
+  end
+
+  def test_should_pass_both_arguments_and_blocks_through
+    assert_equal [1, 2], @state.call(@object, :speed, 1, method_missing: lambda {}) { 2 }
+  end
+end

data/test/unit/state/state_with_valid_method_call_for_different_state_test.rb

@@ -0,0 +1,41 @@
+require_relative '../../test_helper'
+
+class StateWithValidMethodCallForDifferentStateTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass)
+    @ancestors = @klass.ancestors
+    @machine.states << @state = StateMachines::State.new(@machine, :idling)
+    @state.context do
+      def speed
+        0
+      end
+    end
+
+    @object = @klass.new
+  end
+
+  def test_should_call_method_missing_arg
+    assert_equal 1, @state.call(@object, :speed, method_missing: lambda { 1 })
+  end
+
+  def test_should_raise_invalid_context_on_no_method_error
+    exception = assert_raises(StateMachines::InvalidContext) do
+      @state.call(@object, :speed, method_missing: lambda { fail NoMethodError.new('Invalid', :speed, []) })
+    end
+    assert_equal @object, exception.object
+    assert_equal 'State nil for :state is not a valid context for calling #speed', exception.message
+  end
+
+  def test_should_raise_original_error_on_no_method_error_with_different_arguments
+    assert_raises(NoMethodError) do
+      @state.call(@object, :speed, method_missing: lambda { fail NoMethodError.new('Invalid', :speed, [1]) })
+    end
+  end
+
+  def test_should_raise_original_error_on_no_method_error_for_different_method
+    assert_raises(NoMethodError) do
+      @state.call(@object, :speed, method_missing: lambda { fail NoMethodError.new('Invalid', :rpm, []) })
+    end
+  end
+end

data/test/unit/state/state_without_cached_lambda_value_test.rb

@@ -0,0 +1,25 @@
+require_relative '../../test_helper'
+
+class StateWithoutCachedLambdaValueTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass)
+    @dynamic_value = -> { 'value' }
+    @machine.states << @state = StateMachines::State.new(@machine, :parked, value: @dynamic_value)
+  end
+
+  def test_should_not_be_caching
+    refute @state.cache
+  end
+
+  def test_should_evaluate_value_each_time
+    value = @state.value
+    refute_same value, @state.value
+  end
+
+  def test_should_not_update_value_index_for_state_collection
+    @state.value
+    assert_nil @machine.states['value', :value]
+    assert_equal @state, @machine.states[@dynamic_value, :value]
+  end
+end

data/test/unit/state/state_without_name_test.rb

@@ -0,0 +1,39 @@
+require_relative '../../test_helper'
+
+class StateWithoutNameTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass)
+    @machine.states << @state = StateMachines::State.new(@machine, nil)
+  end
+
+  def test_should_have_a_nil_name
+    assert_nil @state.name
+  end
+
+  def test_should_have_a_nil_qualified_name
+    assert_nil @state.qualified_name
+  end
+
+  def test_should_have_an_empty_human_name
+    assert_equal 'nil', @state.human_name
+  end
+
+  def test_should_have_a_nil_value
+    assert_nil @state.value
+  end
+
+  def test_should_not_redefine_nil_predicate
+    object = @klass.new
+    refute object.nil?
+    refute object.respond_to?('?')
+  end
+
+  def test_should_have_a_description
+    assert_equal 'nil', @state.description
+  end
+
+  def test_should_have_a_description_using_human_name
+    assert_equal 'nil', @state.description(human_name: true)
+  end
+end

data/test/unit/state_collection/state_collection_by_default_test.rb

@@ -0,0 +1,21 @@
+require_relative '../../test_helper'
+
+class StateCollectionByDefaultTest < StateMachinesTest
+  def setup
+    @machine = StateMachines::Machine.new(Class.new)
+    @states = StateMachines::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
+

data/test/unit/state_collection/state_collection_string_test.rb

@@ -0,0 +1,35 @@
+require_relative '../../test_helper'
+
+class StateCollectionStringTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass)
+    @states = StateMachines::StateCollection.new(@machine)
+
+    @states << @nil = StateMachines::State.new(@machine, nil)
+    @states << @parked = StateMachines::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

data/test/unit/state_collection/state_collection_test.rb

@@ -0,0 +1,74 @@
+require_relative '../../test_helper'
+
+class StateCollectionTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass)
+    @states = StateMachines::StateCollection.new(@machine)
+
+    @states << @nil = StateMachines::State.new(@machine, nil)
+    @states << @parked = StateMachines::State.new(@machine, :parked)
+    @states << @idling = StateMachines::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
+    refute @states.matches?(@object, :parked)
+    refute @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_raises(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_raises(ArgumentError) { @states.match!(@object) }
+    assert_equal '"invalid" is not a known state value', exception.message
+  end
+end

data/test/unit/state_collection/state_collection_with_custom_state_values_test.rb

@@ -0,0 +1,29 @@
+require_relative '../../test_helper'
+
+class StateCollectionWithCustomStateValuesTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass)
+    @states = StateMachines::StateCollection.new(@machine)
+
+    @states << @state = StateMachines::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
+    refute @states.matches?(@object, :parked)
+  end
+
+  def test_should_find_state_for_object_if_value_is_known
+    assert_equal @state, @states.match(@object)
+  end
+end
+

data/test/unit/state_collection/state_collection_with_event_transitions_test.rb

@@ -0,0 +1,39 @@
+require_relative '../../test_helper'
+
+class StateCollectionWithEventTransitionsTest < StateMachinesTest
+  def setup
+    @machine = StateMachines::Machine.new(Class.new)
+    @states = StateMachines::StateCollection.new(@machine)
+
+    @states << @parked = StateMachines::State.new(@machine, :parked)
+    @states << @idling = StateMachines::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

data/test/unit/state_collection/state_collection_with_initial_state_test.rb

@@ -0,0 +1,40 @@
+require_relative '../../test_helper'
+
+class StateCollectionWithInitialStateTest < StateMachinesTest
+  def setup
+    @machine = StateMachines::Machine.new(Class.new)
+    @states = StateMachines::StateCollection.new(@machine)
+
+    @states << @parked = StateMachines::State.new(@machine, :parked)
+    @states << @idling = StateMachines::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
+

data/test/unit/state_collection/state_collection_with_namespace_test.rb

@@ -0,0 +1,21 @@
+require_relative '../../test_helper'
+
+class StateCollectionWithNamespaceTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass, namespace: 'vehicle')
+    @states = StateMachines::StateCollection.new(@machine)
+
+    @states << @state = StateMachines::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
+

data/test/unit/state_collection/state_collection_with_state_behaviors_test.rb

@@ -0,0 +1,40 @@
+require_relative '../../test_helper'
+
+class StateCollectionWithStateBehaviorsTest < StateMachinesTest
+  def setup
+    @machine = StateMachines::Machine.new(Class.new)
+    @states = StateMachines::StateCollection.new(@machine)
+
+    @states << @parked = StateMachines::State.new(@machine, :parked)
+    @states << @idling = StateMachines::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
+