state_machines 0.5.0 → 0.6.0

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
-

data/test/unit/state_collection/state_collection_with_transition_callbacks_test.rb

@@ -1,40 +0,0 @@
-require_relative '../../test_helper'
-
-class StateCollectionWithTransitionCallbacksTest < 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.before_transition to: :idling, do: lambda {}
-  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_after_states_with_behaviors
-    @parked.context do
-      def speed
-        0
-      end
-    end
-    assert_equal [@parked, @idling], @states.by_priority
-  end
-
-  def test_should_order_states_after_other_states
-    assert_equal [@parked, @idling], @states.by_priority
-  end
-end
-

data/test/unit/state_context/state_context_proxy_test.rb

@@ -1,26 +0,0 @@
-require_relative '../../test_helper'
-
-class StateContextProxyTest < StateMachinesTest
-  def setup
-    @klass = Class.new(Validateable)
-    machine = StateMachines::Machine.new(@klass, initial: :parked)
-    state = machine.state :parked
-
-    @state_context = StateMachines::StateContext.new(state)
-  end
-
-  def test_should_call_class_with_same_arguments
-    options = {}
-    validation = @state_context.validate(:name, options)
-
-    assert_equal [:name, options], validation
-  end
-
-  def test_should_pass_block_through_to_class
-    options = {}
-    proxy_block = lambda {}
-    validation = @state_context.validate(:name, options, &proxy_block)
-
-    assert_equal [:name, options, proxy_block], validation
-  end
-end

data/test/unit/state_context/state_context_proxy_with_if_and_unless_conditions_test.rb

@@ -1,42 +0,0 @@
-require_relative '../../test_helper'
-
-class StateContextProxyWithIfAndUnlessConditionsTest < StateMachinesTest
-  def setup
-    @klass = Class.new(Validateable)
-    machine = StateMachines::Machine.new(@klass, initial: :parked)
-    state = machine.state :parked
-
-    @state_context = StateMachines::StateContext.new(state)
-    @object = @klass.new
-
-    @if_condition_result = nil
-    @unless_condition_result = nil
-    @options = @state_context.validate(if: lambda { @if_condition_result }, unless: lambda { @unless_condition_result })[0]
-  end
-
-  def test_should_be_false_if_if_condition_is_false
-    @if_condition_result = false
-    @unless_condition_result = false
-    refute @options[:if].call(@object)
-
-    @if_condition_result = false
-    @unless_condition_result = true
-    refute @options[:if].call(@object)
-  end
-
-  def test_should_be_false_if_unless_condition_is_true
-    @if_condition_result = false
-    @unless_condition_result = true
-    refute @options[:if].call(@object)
-
-    @if_condition_result = true
-    @unless_condition_result = true
-    refute @options[:if].call(@object)
-  end
-
-  def test_should_be_true_if_if_condition_is_true_and_unless_condition_is_false
-    @if_condition_result = true
-    @unless_condition_result = false
-    assert @options[:if].call(@object)
-  end
-end