state_machines 0.0.2 → 0.1.0

data/test/unit/state/state_after_being_copied_test.rb

@@ -0,0 +1,19 @@
+require_relative '../../test_helper'
+
+class StateAfterBeingCopiedTest < StateMachinesTest
+  def setup
+    @machine = StateMachines::Machine.new(Class.new)
+    @machine.states << @state = StateMachines::State.new(@machine, :parked)
+    @copied_state = @state.dup
+  end
+
+  def test_should_not_have_the_context
+    state_context = nil
+    @state.context { state_context = self }
+
+    copied_state_context = nil
+    @copied_state.context { copied_state_context = self }
+
+    refute_same state_context, copied_state_context
+  end
+end

data/test/unit/state/state_by_default_test.rb

@@ -0,0 +1,41 @@
+require_relative '../../test_helper'
+
+class StateByDefaultTest < StateMachinesTest
+  def setup
+    @machine = StateMachines::Machine.new(Class.new)
+    @machine.states << @state = StateMachines::State.new(@machine, :parked)
+  end
+
+  def test_should_have_a_machine
+    assert_equal @machine, @state.machine
+  end
+
+  def test_should_have_a_name
+    assert_equal :parked, @state.name
+  end
+
+  def test_should_have_a_qualified_name
+    assert_equal :parked, @state.qualified_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_not_be_initial
+    refute @state.initial
+  end
+
+  def test_should_not_have_a_matcher
+    assert_nil @state.matcher
+  end
+
+  def test_should_not_have_any_methods
+    expected = {}
+    assert_equal expected, @state.context_methods
+  end
+end

data/test/unit/state/state_final_test.rb

@@ -0,0 +1,28 @@
+require_relative '../../test_helper'
+
+class StateFinalTest < StateMachinesTest
+  def setup
+    @machine = StateMachines::Machine.new(Class.new)
+    @machine.states << @state = StateMachines::State.new(@machine, :parked)
+  end
+
+  def test_should_be_final_without_input_transitions
+    assert @state.final?
+  end
+
+  def test_should_be_final_with_input_transitions
+    @machine.event :park do
+      transition idling: :parked
+    end
+
+    assert @state.final?
+  end
+
+  def test_should_be_final_with_loopback
+    @machine.event :ignite do
+      transition parked: same
+    end
+
+    assert @state.final?
+  end
+end

data/test/unit/state/state_initial_test.rb

@@ -0,0 +1,13 @@
+require_relative '../../test_helper'
+
+class StateInitialTest < StateMachinesTest
+  def setup
+    @machine = StateMachines::Machine.new(Class.new)
+    @machine.states << @state = StateMachines::State.new(@machine, :parked, initial: true)
+  end
+
+  def test_should_be_initial
+    assert @state.initial
+    assert @state.initial?
+  end
+end

data/test/unit/state/state_not_final_test.rb

@@ -0,0 +1,32 @@
+require_relative '../../test_helper'
+
+class StateNotFinalTest < StateMachinesTest
+  def setup
+    @machine = StateMachines::Machine.new(Class.new)
+    @machine.states << @state = StateMachines::State.new(@machine, :parked)
+  end
+
+  def test_should_not_be_final_with_outgoing_whitelist_transitions
+    @machine.event :ignite do
+      transition parked: :idling
+    end
+
+    refute @state.final?
+  end
+
+  def test_should_not_be_final_with_outgoing_all_transitions
+    @machine.event :ignite do
+      transition all => :idling
+    end
+
+    refute @state.final?
+  end
+
+  def test_should_not_be_final_with_outgoing_blacklist_transitions
+    @machine.event :ignite do
+      transition all - :first_gear => :idling
+    end
+
+    refute @state.final?
+  end
+end

data/test/unit/state/state_not_initial_test.rb

@@ -0,0 +1,13 @@
+require_relative '../../test_helper'
+
+class StateNotInitialTest < StateMachinesTest
+  def setup
+    @machine = StateMachines::Machine.new(Class.new)
+    @machine.states << @state = StateMachines::State.new(@machine, :parked, initial: false)
+  end
+
+  def test_should_not_be_initial
+    refute @state.initial
+    refute @state.initial?
+  end
+end

data/test/unit/state/state_test.rb

@@ -0,0 +1,44 @@
+require_relative '../../test_helper'
+
+class StateTest < StateMachinesTest
+  def setup
+    @machine = StateMachines::Machine.new(Class.new)
+    @machine.states << @state = StateMachines::State.new(@machine, :parked)
+  end
+
+  def test_should_raise_exception_if_invalid_option_specified
+    exception = assert_raises(ArgumentError) { StateMachines::State.new(@machine, :parked, invalid: true) }
+    assert_equal 'Unknown key: :invalid. Valid keys are: :initial, :value, :cache, :if, :human_name', exception.message
+  end
+
+  def test_should_allow_changing_machine
+    new_machine = StateMachines::Machine.new(Class.new)
+    @state.machine = new_machine
+    assert_equal new_machine, @state.machine
+  end
+
+  def test_should_allow_changing_value
+    @state.value = 1
+    assert_equal 1, @state.value
+  end
+
+  def test_should_allow_changing_initial
+    @state.initial = true
+    assert @state.initial
+  end
+
+  def test_should_allow_changing_matcher
+    matcher = lambda {}
+    @state.matcher = matcher
+    assert_equal matcher, @state.matcher
+  end
+
+  def test_should_allow_changing_human_name
+    @state.human_name = 'stopped'
+    assert_equal 'stopped', @state.human_name
+  end
+
+  def test_should_use_pretty_inspect
+    assert_equal '#<StateMachines::State name=:parked value="parked" initial=false>', @state.inspect
+  end
+end

data/test/unit/state/state_with_cached_lambda_value_test.rb

@@ -0,0 +1,29 @@
+require_relative '../../test_helper'
+
+class StateWithCachedLambdaValueTest < 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, cache: true)
+  end
+
+  def test_should_be_caching
+    assert @state.cache
+  end
+
+  def test_should_evaluate_value
+    assert_equal 'value', @state.value
+  end
+
+  def test_should_only_evaluate_value_once
+    value = @state.value
+    assert_same value, @state.value
+  end
+
+  def test_should_update_value_index_for_state_collection
+    @state.value
+    assert_equal @state, @machine.states['value', :value]
+    assert_nil @machine.states[@dynamic_value, :value]
+  end
+end

data/test/unit/state/state_with_conflicting_helpers_after_definition_test.rb

@@ -0,0 +1,38 @@
+require_relative '../../test_helper'
+
+class StateWithConflictingHelpersAfterDefinitionTest < StateMachinesTest
+  def setup
+    @original_stderr, $stderr = $stderr, StringIO.new
+
+    @klass = Class.new do
+      def parked?
+        0
+      end
+    end
+    @machine = StateMachines::Machine.new(@klass)
+    @machine.state :parked
+    @object = @klass.new
+  end
+
+  def test_should_not_override_state_predicate
+    assert_equal 0, @object.parked?
+  end
+
+  def test_should_still_allow_super_chaining
+    @klass.class_eval do
+      def parked?
+        super
+      end
+    end
+
+    assert_equal false, @object.parked?
+  end
+
+  def test_should_not_output_warning
+    assert_equal '', $stderr.string
+  end
+
+  def teardown
+    $stderr = @original_stderr
+  end
+end

data/test/unit/state/state_with_conflicting_helpers_before_definition_test.rb

@@ -0,0 +1,29 @@
+require_relative '../../test_helper'
+
+class StateWithConflictingHelpersBeforeDefinitionTest < StateMachinesTest
+  def setup
+    @original_stderr, $stderr = $stderr, StringIO.new
+
+    @superclass = Class.new do
+      def parked?
+        0
+      end
+    end
+    @klass = Class.new(@superclass)
+    @machine = StateMachines::Machine.new(@klass)
+    @machine.state :parked
+    @object = @klass.new
+  end
+
+  def test_should_not_override_state_predicate
+    assert_equal 0, @object.parked?
+  end
+
+  def test_should_output_warning
+    assert_equal "Instance method \"parked?\" is already defined in #{@superclass}, use generic helper instead or set StateMachines::Machine.ignore_method_conflicts = true.\n", $stderr.string
+  end
+
+  def teardown
+    $stderr = @original_stderr
+  end
+end

data/test/unit/state/state_with_conflicting_machine_name_test.rb

@@ -0,0 +1,20 @@
+require_relative '../../test_helper'
+require 'stringio'
+
+class StateWithConflictingMachineNameTest < StateMachinesTest
+  def setup
+    @original_stderr, $stderr = $stderr, StringIO.new
+
+    @klass = Class.new
+    @state_machine = StateMachines::Machine.new(@klass, :state)
+  end
+
+  def test_should_output_warning_if_name_conflicts
+    StateMachines::State.new(@state_machine, :state)
+    assert_equal "Instance method \"state?\" is already defined in #{@klass} :state instance helpers, use generic helper instead or set StateMachines::Machine.ignore_method_conflicts = true.\n", $stderr.string
+  end
+
+  def teardown
+    $stderr = @original_stderr
+  end
+end

data/test/unit/state/state_with_conflicting_machine_test.rb

@@ -0,0 +1,37 @@
+require_relative '../../test_helper'
+require 'stringio'
+
+class StateWithConflictingMachineTest < StateMachinesTest
+  def setup
+    @original_stderr, $stderr = $stderr, StringIO.new
+
+    @klass = Class.new
+    @state_machine = StateMachines::Machine.new(@klass, :state)
+    @state_machine.states << @state = StateMachines::State.new(@state_machine, :parked)
+  end
+
+  def test_should_output_warning_if_using_different_attribute
+    @status_machine = StateMachines::Machine.new(@klass, :status)
+    @status_machine.states << @state = StateMachines::State.new(@status_machine, :parked)
+
+    assert_equal "State :parked for :status is already defined in :state\n", $stderr.string
+  end
+
+  def test_should_not_output_warning_if_using_same_attribute
+    @status_machine = StateMachines::Machine.new(@klass, :status, attribute: :state)
+    @status_machine.states << @state = StateMachines::State.new(@status_machine, :parked)
+
+    assert_equal '', $stderr.string
+  end
+
+  def test_should_not_output_warning_if_using_different_namespace
+    @status_machine = StateMachines::Machine.new(@klass, :status, namespace: 'alarm')
+    @status_machine.states << @state = StateMachines::State.new(@status_machine, :parked)
+
+    assert_equal '', $stderr.string
+  end
+
+  def teardown
+    $stderr = @original_stderr
+  end
+end

data/test/unit/state/state_with_context_test.rb

@@ -0,0 +1,60 @@
+require_relative '../../test_helper'
+
+class StateWithContextTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass)
+    @ancestors = @klass.ancestors
+    @machine.states << @state = StateMachines::State.new(@machine, :idling)
+
+    context = nil
+    speed_method = nil
+    rpm_method = nil
+    @result = @state.context do
+      context = self
+
+      def speed
+        0
+      end
+
+      speed_method = instance_method(:speed)
+
+      def rpm
+        1000
+      end
+
+      rpm_method = instance_method(:rpm)
+    end
+
+    @context = context
+    @speed_method = speed_method
+    @rpm_method = rpm_method
+  end
+
+  def test_should_return_true
+    assert_equal true, @result
+  end
+
+  def test_should_include_new_module_in_owner_class
+    refute_equal @ancestors, @klass.ancestors
+    assert_equal [@context], @klass.ancestors - @ancestors
+  end
+
+  def test_should_define_each_context_method_in_owner_class
+    %w(speed rpm).each { |method| assert @klass.method_defined?(method) }
+  end
+
+  def test_should_define_aliased_context_method_in_owner_class
+    %w(speed rpm).each { |method| assert @klass.method_defined?("__state_idling_#{method}_#{@context.object_id}__") }
+  end
+
+  def test_should_not_use_context_methods_as_owner_class_methods
+    refute_equal @speed_method, @state.context_methods[:speed]
+    refute_equal @rpm_method, @state.context_methods[:rpm]
+  end
+
+  def test_should_use_context_methods_as_aliased_owner_class_methods
+    assert_equal @speed_method, @state.context_methods[:"__state_idling_speed_#{@context.object_id}__"]
+    assert_equal @rpm_method, @state.context_methods[:"__state_idling_rpm_#{@context.object_id}__"]
+  end
+end

data/test/unit/state/state_with_dynamic_human_name_test.rb

@@ -0,0 +1,25 @@
+require_relative '../../test_helper'
+
+class StateWithDynamicHumanNameTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass)
+    @machine.states << @state = StateMachines::State.new(@machine, :parked, human_name: lambda { |_state, object| ['stopped', object] })
+  end
+
+  def test_should_use_custom_human_name
+    human_name, klass = @state.human_name
+    assert_equal 'stopped', human_name
+    assert_equal @klass, klass
+  end
+
+  def test_should_allow_custom_class_to_be_passed_through
+    human_name, klass = @state.human_name(1)
+    assert_equal 'stopped', human_name
+    assert_equal 1, klass
+  end
+
+  def test_should_not_cache_value
+    refute_same @state.human_name, @state.human_name
+  end
+end

data/test/unit/state/state_with_existing_context_method_test.rb

@@ -0,0 +1,24 @@
+require_relative '../../test_helper'
+
+class StateWithExistingContextMethodTest < StateMachinesTest
+  def setup
+    @klass = Class.new do
+      def speed
+        60
+      end
+    end
+    @original_speed_method = @klass.instance_method(:speed)
+
+    @machine = StateMachines::Machine.new(@klass)
+    @machine.states << @state = StateMachines::State.new(@machine, :idling)
+    @state.context do
+      def speed
+        0
+      end
+    end
+  end
+
+  def test_should_not_override_method
+    assert_equal @original_speed_method, @klass.instance_method(:speed)
+  end
+end

data/test/unit/state/state_with_human_name_test.rb

@@ -0,0 +1,13 @@
+require_relative '../../test_helper'
+
+class StateWithHumanNameTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass)
+    @machine.states << @state = StateMachines::State.new(@machine, :parked, human_name: 'stopped')
+  end
+
+  def test_should_use_custom_human_name
+    assert_equal 'stopped', @state.human_name
+  end
+end

data/test/unit/state/state_with_integer_value_test.rb

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

data/test/unit/state/state_with_invalid_method_call_test.rb

@@ -0,0 +1,21 @@
+require_relative '../../test_helper'
+
+class StateWithInvalidMethodCallTest < 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, :invalid, method_missing: -> { 1 })
+  end
+end

data/test/unit/state/state_with_lambda_value_test.rb

@@ -0,0 +1,37 @@
+require_relative '../../test_helper'
+
+class StateWithLambdaValueTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @args = nil
+    @machine = StateMachines::Machine.new(@klass)
+    @value = ->(*args) { @args = args; :parked }
+    @machine.states << @state = StateMachines::State.new(@machine, :parked, value: @value)
+  end
+
+  def test_should_use_evaluated_value_by_default
+    assert_equal :parked, @state.value
+  end
+
+  def test_should_allow_access_to_original_value
+    assert_equal @value, @state.value(false)
+  end
+
+  def test_should_include_masked_value_in_description
+    assert_equal 'parked (*)', @state.description
+  end
+
+  def test_should_not_pass_in_any_arguments
+    @state.value
+    assert_equal [], @args
+  end
+
+  def test_should_define_predicate
+    object = @klass.new
+    assert object.respond_to?(:parked?)
+  end
+
+  def test_should_match_evaluated_value
+    assert @state.matches?(:parked)
+  end
+end

data/test/unit/state/state_with_matcher_test.rb

@@ -0,0 +1,18 @@
+require_relative '../../test_helper'
+
+class StateWithMatcherTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @args = nil
+    @machine = StateMachines::Machine.new(@klass)
+    @machine.states << @state = StateMachines::State.new(@machine, :parked, if: lambda { |value| value == 1 })
+  end
+
+  def test_should_not_match_actual_value
+    refute @state.matches?('parked')
+  end
+
+  def test_should_match_evaluated_block
+    assert @state.matches?(1)
+  end
+end

data/test/unit/state/state_with_multiple_contexts_test.rb

@@ -0,0 +1,57 @@
+require_relative '../../test_helper'
+
+class StateWithMultipleContextsTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass)
+    @ancestors = @klass.ancestors
+    @machine.states << @state = StateMachines::State.new(@machine, :idling)
+
+    context = nil
+    speed_method = nil
+    @state.context do
+      context = self
+
+      def speed
+        0
+      end
+
+      speed_method = instance_method(:speed)
+    end
+    @context = context
+    @speed_method = speed_method
+
+    rpm_method = nil
+    @state.context do
+      def rpm
+        1000
+      end
+
+      rpm_method = instance_method(:rpm)
+    end
+    @rpm_method = rpm_method
+  end
+
+  def test_should_include_new_module_in_owner_class
+    refute_equal @ancestors, @klass.ancestors
+    assert_equal [@context], @klass.ancestors - @ancestors
+  end
+
+  def test_should_define_each_context_method_in_owner_class
+    %w(speed rpm).each { |method| assert @klass.method_defined?(method) }
+  end
+
+  def test_should_define_aliased_context_method_in_owner_class
+    %w(speed rpm).each { |method| assert @klass.method_defined?("__state_idling_#{method}_#{@context.object_id}__") }
+  end
+
+  def test_should_not_use_context_methods_as_owner_class_methods
+    refute_equal @speed_method, @state.context_methods[:speed]
+    refute_equal @rpm_method, @state.context_methods[:rpm]
+  end
+
+  def test_should_use_context_methods_as_aliased_owner_class_methods
+    assert_equal @speed_method, @state.context_methods[:"__state_idling_speed_#{@context.object_id}__"]
+    assert_equal @rpm_method, @state.context_methods[:"__state_idling_rpm_#{@context.object_id}__"]
+  end
+end