state_machines 0.4.0 → 0.6.0

data/test/unit/state/state_with_namespace_test.rb

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

data/test/unit/state_collection/state_collection_with_state_matchers_test.rb

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