state_machines 0.0.2 → 0.1.0

data/test/unit/callback/callback_with_bound_method_and_arguments_test.rb

@@ -0,0 +1,28 @@
+require_relative '../../test_helper'
+
+class CallbackWithBoundMethodAndArgumentsTest < StateMachinesTest
+  def setup
+    @object = Object.new
+  end
+
+  def test_should_include_single_argument_if_specified
+    context = nil
+    callback = StateMachines::Callback.new(:before, do: lambda { |arg1| context = [arg1] }, bind_to_object: true)
+    callback.call(@object, {}, 1)
+    assert_equal [1], context
+  end
+
+  def test_should_include_multiple_arguments_if_specified
+    context = nil
+    callback = StateMachines::Callback.new(:before, do: lambda { |arg1, arg2, arg3| context = [arg1, arg2, arg3] }, bind_to_object: true)
+    callback.call(@object, {}, 1, 2, 3)
+    assert_equal [1, 2, 3], context
+  end
+
+  def test_should_include_arguments_if_splat_used
+    context = nil
+    callback = StateMachines::Callback.new(:before, do: lambda { |*args| context = args }, bind_to_object: true)
+    callback.call(@object, {}, 1, 2, 3)
+    assert_equal [1, 2, 3], context
+  end
+end

data/test/unit/callback/callback_with_bound_method_test.rb

@@ -0,0 +1,35 @@
+require_relative '../../test_helper'
+
+class CallbackWithBoundMethodTest < StateMachinesTest
+  def setup
+    @object = Object.new
+  end
+
+  def test_should_call_method_within_the_context_of_the_object_for_block_methods
+    context = nil
+    callback = StateMachines::Callback.new(:before, do: lambda { |*args| context = [self] + args }, bind_to_object: true)
+    callback.call(@object, {}, 1, 2, 3)
+
+    assert_equal [@object, 1, 2, 3], context
+  end
+
+  def test_should_ignore_option_for_symbolic_methods
+    class << @object
+      attr_reader :context
+
+      def after_ignite(*args)
+        @context = args
+      end
+    end
+
+    callback = StateMachines::Callback.new(:before, do: :after_ignite, bind_to_object: true)
+    callback.call(@object)
+
+    assert_equal [], @object.context
+  end
+
+  def test_should_ignore_option_for_string_methods
+    callback = StateMachines::Callback.new(:before, do: '[1, 2, 3]', bind_to_object: true)
+    assert callback.call(@object)
+  end
+end

data/test/unit/callback/callback_with_do_method_test.rb

@@ -0,0 +1,18 @@
+require_relative '../../test_helper'
+
+class CallbackWithDoMethodTest < StateMachinesTest
+  def setup
+    @callback = StateMachines::Callback.new(:before, do: lambda { |*args| @args = args })
+
+    @object = Object.new
+    @result = @callback.call(@object)
+  end
+
+  def test_should_be_successful
+    assert @result
+  end
+
+  def test_should_call_with_empty_context
+    assert_equal [@object], @args
+  end
+end

data/test/unit/callback/callback_with_explicit_requirements_test.rb

@@ -0,0 +1,32 @@
+require_relative '../../test_helper'
+
+class CallbackWithExplicitRequirementsTest < StateMachinesTest
+  def setup
+    @object = Object.new
+    @callback = StateMachines::Callback.new(:before, from: :parked, to: :idling, on: :ignite, do: lambda {})
+  end
+
+  def test_should_call_with_empty_context
+    assert @callback.call(@object, {})
+  end
+
+  def test_should_not_call_if_from_not_included
+    refute @callback.call(@object, from: :idling)
+  end
+
+  def test_should_not_call_if_to_not_included
+    refute @callback.call(@object, to: :parked)
+  end
+
+  def test_should_not_call_if_on_not_included
+    refute @callback.call(@object, on: :park)
+  end
+
+  def test_should_call_if_all_requirements_met
+    assert @callback.call(@object, from: :parked, to: :idling, on: :ignite)
+  end
+
+  def test_should_include_in_known_states
+    assert_equal [:parked, :idling], @callback.known_states
+  end
+end

data/test/unit/callback/callback_with_if_condition_test.rb

@@ -0,0 +1,17 @@
+require_relative '../../test_helper'
+
+class CallbackWithIfConditionTest < StateMachinesTest
+  def setup
+    @object = Object.new
+  end
+
+  def test_should_call_if_true
+    callback = StateMachines::Callback.new(:before, if: lambda { true }, do: lambda {})
+    assert callback.call(@object)
+  end
+
+  def test_should_not_call_if_false
+    callback = StateMachines::Callback.new(:before, if: lambda { false }, do: lambda {})
+    refute callback.call(@object)
+  end
+end

data/test/unit/callback/callback_with_implicit_requirements_test.rb

@@ -0,0 +1,32 @@
+require_relative '../../test_helper'
+
+class CallbackWithImplicitRequirementsTest < StateMachinesTest
+  def setup
+    @object = Object.new
+    @callback = StateMachines::Callback.new(:before, parked: :idling, on: :ignite, do: lambda {})
+  end
+
+  def test_should_call_with_empty_context
+    assert @callback.call(@object, {})
+  end
+
+  def test_should_not_call_if_from_not_included
+    refute @callback.call(@object, from: :idling)
+  end
+
+  def test_should_not_call_if_to_not_included
+    refute @callback.call(@object, to: :parked)
+  end
+
+  def test_should_not_call_if_on_not_included
+    refute @callback.call(@object, on: :park)
+  end
+
+  def test_should_call_if_all_requirements_met
+    assert @callback.call(@object, from: :parked, to: :idling, on: :ignite)
+  end
+
+  def test_should_include_in_known_states
+    assert_equal [:parked, :idling], @callback.known_states
+  end
+end

data/test/unit/callback/callback_with_method_argument_test.rb

@@ -0,0 +1,18 @@
+require_relative '../../test_helper'
+
+class CallbackWithMethodArgumentTest < StateMachinesTest
+  def setup
+    @callback = StateMachines::Callback.new(:before, lambda { |*args| @args = args })
+
+    @object = Object.new
+    @result = @callback.call(@object)
+  end
+
+  def test_should_be_successful
+    assert @result
+  end
+
+  def test_should_call_with_empty_context
+    assert_equal [@object], @args
+  end
+end

data/test/unit/callback/callback_with_mixed_methods_test.rb

@@ -0,0 +1,31 @@
+require_relative '../../test_helper'
+
+class CallbackWithMixedMethodsTest < StateMachinesTest
+  def setup
+    @callback = StateMachines::Callback.new(:before, :run_argument, do: :run_do) do |object|
+      object.callbacks << :block
+    end
+
+    class << @object = Object.new
+      attr_accessor :callbacks
+
+      def run_argument
+        (@callbacks ||= []) << :argument
+      end
+
+      def run_do
+        (@callbacks ||= []) << :do
+      end
+    end
+
+    @result = @callback.call(@object)
+  end
+
+  def test_should_be_successful
+    assert @result
+  end
+
+  def test_should_call_each_callback_in_order
+    assert_equal [:argument, :do, :block], @object.callbacks
+  end
+end

data/test/unit/callback/callback_with_multiple_bound_methods_test.rb

@@ -0,0 +1,21 @@
+require_relative '../../test_helper'
+
+class CallbackWithMultipleBoundMethodsTest < StateMachinesTest
+  def setup
+    @object = Object.new
+
+    first_context = nil
+    second_context = nil
+
+    @callback = StateMachines::Callback.new(:before, do: [lambda { first_context = self }, lambda { second_context = self }], bind_to_object: true)
+    @callback.call(@object)
+
+    @first_context = first_context
+    @second_context = second_context
+  end
+
+  def test_should_call_each_method_within_the_context_of_the_object
+    assert_equal @object, @first_context
+    assert_equal @object, @second_context
+  end
+end

data/test/unit/callback/callback_with_multiple_do_methods_test.rb

@@ -0,0 +1,29 @@
+require_relative '../../test_helper'
+
+class CallbackWithMultipleDoMethodsTest < StateMachinesTest
+  def setup
+    @callback = StateMachines::Callback.new(:before, do: [:run_1, :run_2])
+
+    class << @object = Object.new
+      attr_accessor :callbacks
+
+      def run_1
+        (@callbacks ||= []) << :run_1
+      end
+
+      def run_2
+        (@callbacks ||= []) << :run_2
+      end
+    end
+
+    @result = @callback.call(@object)
+  end
+
+  def test_should_be_successful
+    assert @result
+  end
+
+  def test_should_call_each_callback_in_order
+    assert_equal [:run_1, :run_2], @object.callbacks
+  end
+end

data/test/unit/callback/callback_with_multiple_method_arguments_test.rb

@@ -0,0 +1,29 @@
+require_relative '../../test_helper'
+
+class CallbackWithMultipleMethodArgumentsTest < StateMachinesTest
+  def setup
+    @callback = StateMachines::Callback.new(:before, :run_1, :run_2)
+
+    class << @object = Object.new
+      attr_accessor :callbacks
+
+      def run_1
+        (@callbacks ||= []) << :run_1
+      end
+
+      def run_2
+        (@callbacks ||= []) << :run_2
+      end
+    end
+
+    @result = @callback.call(@object)
+  end
+
+  def test_should_be_successful
+    assert @result
+  end
+
+  def test_should_call_each_callback_in_order
+    assert_equal [:run_1, :run_2], @object.callbacks
+  end
+end

data/test/unit/callback/callback_with_terminator_test.rb

@@ -0,0 +1,22 @@
+require_relative '../../test_helper'
+
+class CallbackWithTerminatorTest < StateMachinesTest
+  def setup
+    @object = Object.new
+  end
+
+  def test_should_not_halt_if_terminator_does_not_match
+    callback = StateMachines::Callback.new(:before, do: lambda { false }, terminator: lambda { |result| result == true })
+    callback.call(@object)
+  end
+
+  def test_should_halt_if_terminator_matches
+    callback = StateMachines::Callback.new(:before, do: lambda { false }, terminator: lambda { |result| result == false })
+    assert_throws(:halt) { callback.call(@object) }
+  end
+
+  def test_should_halt_if_terminator_matches_any_method
+    callback = StateMachines::Callback.new(:before, do: [lambda { true }, lambda { false }], terminator: lambda { |result| result == false })
+    assert_throws(:halt) { callback.call(@object) }
+  end
+end

data/test/unit/callback/callback_with_unbound_method_test.rb

@@ -0,0 +1,14 @@
+require_relative '../../test_helper'
+
+class CallbackWithUnboundMethodTest < StateMachinesTest
+  def setup
+    @callback = StateMachines::Callback.new(:before, do: lambda { |*args| @context = args.unshift(self) })
+
+    @object = Object.new
+    @callback.call(@object, {}, 1, 2, 3)
+  end
+
+  def test_should_call_method_outside_the_context_of_the_object
+    assert_equal [self, @object, 1, 2, 3], @context
+  end
+end

data/test/unit/callback/callback_with_unless_condition_test.rb

@@ -0,0 +1,17 @@
+require_relative '../../test_helper'
+
+class CallbackWithUnlessConditionTest < StateMachinesTest
+  def setup
+    @object = Object.new
+  end
+
+  def test_should_call_if_false
+    callback = StateMachines::Callback.new(:before, unless: lambda { false }, do: lambda {})
+    assert callback.call(@object)
+  end
+
+  def test_should_not_call_if_true
+    callback = StateMachines::Callback.new(:before, unless: lambda { true }, do: lambda {})
+    refute callback.call(@object)
+  end
+end

data/test/unit/callback/callback_without_arguments_test.rb

@@ -0,0 +1,14 @@
+require_relative '../../test_helper'
+
+class CallbackWithoutArgumentsTest < StateMachinesTest
+  def setup
+    @callback = StateMachines::Callback.new(:before, do: lambda { |object| @arg = object })
+
+    @object = Object.new
+    @callback.call(@object, {}, 1, 2, 3)
+  end
+
+  def test_should_call_method_with_object_as_argument
+    assert_equal @object, @arg
+  end
+end

data/test/unit/callback/callback_without_terminator_test.rb

@@ -0,0 +1,12 @@
+require_relative '../../test_helper'
+
+class CallbackWithoutTerminatorTest < StateMachinesTest
+  def setup
+    @object = Object.new
+  end
+
+  def test_should_not_halt_if_result_is_false
+    callback = StateMachines::Callback.new(:before, do: lambda { false }, terminator: nil)
+    callback.call(@object)
+  end
+end

data/test/unit/error/error_by_default_test.rb

@@ -0,0 +1,21 @@
+require_relative '../../test_helper'
+
+class ErrorByDefaultTest < 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 = Struct.new(:name).new(:parked)
+    assert_equal object, @collection[:parked]
+  end
+end

data/test/unit/error/error_with_message_test.rb

@@ -0,0 +1,23 @@
+require_relative '../../test_helper'
+
+class ErrorWithMessageTest < 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/eval_helper/eval_helpers_base_test.rb

@@ -0,0 +1,8 @@
+require_relative '../../test_helper'
+
+class EvalHelpersBaseTest < StateMachinesTest
+  include StateMachines::EvalHelpers
+
+  def default_test
+  end
+end

data/test/unit/eval_helper/eval_helpers_proc_block_and_explicit_arguments_test.rb

@@ -0,0 +1,14 @@
+require_relative '../../test_helper'
+require_relative '../../unit/eval_helper/eval_helpers_base_test'
+
+class EvalHelpersProcBlockAndExplicitArgumentsTest < EvalHelpersBaseTest
+  def setup
+    @object = Object.new
+    @proc = lambda { |object, arg1, arg2, arg3, block| [object, arg1, arg2, arg3, block] }
+  end
+
+  def test_should_call_method_on_object_with_all_arguments_and_block
+    block = lambda { true }
+    assert_equal [@object, 1, 2, 3, block], evaluate_method(@object, @proc, 1, 2, 3, &block)
+  end
+end

data/test/unit/eval_helper/eval_helpers_proc_block_and_implicit_arguments_test.rb

@@ -0,0 +1,14 @@
+require_relative '../../test_helper'
+require_relative '../../unit/eval_helper/eval_helpers_base_test'
+
+class EvalHelpersProcBlockAndImplicitArgumentsTest < EvalHelpersBaseTest
+  def setup
+    @object = Object.new
+    @proc = lambda { |*args| args }
+  end
+
+  def test_should_call_method_on_object_with_all_arguments_and_block
+    block = lambda { true }
+    assert_equal [@object, 1, 2, 3, block], evaluate_method(@object, @proc, 1, 2, 3, &block)
+  end
+end

data/test/unit/eval_helper/eval_helpers_proc_test.rb

@@ -0,0 +1,13 @@
+require_relative '../../test_helper'
+require_relative '../../unit/eval_helper/eval_helpers_base_test'
+
+class EvalHelpersProcTest < EvalHelpersBaseTest
+  def setup
+    @object = Object.new
+    @proc = ->(obj) { obj }
+  end
+
+  def test_should_call_proc_with_object_as_argument
+    assert_equal @object, evaluate_method(@object, @proc, 1, 2, 3)
+  end
+end

data/test/unit/eval_helper/eval_helpers_proc_with_arguments_test.rb

@@ -0,0 +1,13 @@
+require_relative '../../test_helper'
+require_relative '../../unit/eval_helper/eval_helpers_base_test'
+
+class EvalHelpersProcWithArgumentsTest < EvalHelpersBaseTest
+  def setup
+    @object = Object.new
+    @proc = lambda { |*args| args }
+  end
+
+  def test_should_call_method_with_all_arguments
+    assert_equal [@object, 1, 2, 3], evaluate_method(@object, @proc, 1, 2, 3)
+  end
+end

data/test/unit/eval_helper/eval_helpers_proc_with_block_test.rb

@@ -0,0 +1,13 @@
+require_relative '../../test_helper'
+require_relative '../../unit/eval_helper/eval_helpers_base_test'
+
+class EvalHelpersProcWithBlockTest < EvalHelpersBaseTest
+  def setup
+    @object = Object.new
+    @proc = lambda { |_obj, block| block.call }
+  end
+
+  def test_should_call_method_on_object_with_block
+    assert_equal true, evaluate_method(@object, @proc, 1, 2, 3) { true }
+  end
+end

data/test/unit/eval_helper/eval_helpers_proc_with_block_without_arguments_test.rb

@@ -0,0 +1,18 @@
+require_relative '../../test_helper'
+require_relative '../../unit/eval_helper/eval_helpers_base_test'
+
+class EvalHelpersProcWithoutArgumentsTest < EvalHelpersBaseTest
+  def setup
+    @object = Object.new
+    @proc = lambda { |*args| args }
+    class << @proc
+      def arity
+        0
+      end
+    end
+  end
+
+  def test_should_call_proc_with_no_arguments
+    assert_equal [], evaluate_method(@object, @proc, 1, 2, 3)
+  end
+end

data/test/unit/eval_helper/eval_helpers_proc_with_block_without_object_test.rb

@@ -0,0 +1,14 @@
+require_relative '../../test_helper'
+require_relative '../../unit/eval_helper/eval_helpers_base_test'
+
+class EvalHelpersProcWithBlockWithoutObjectTest < EvalHelpersBaseTest
+  def setup
+    @object = Object.new
+    @proc = lambda { |block| [block] }
+  end
+
+  def test_should_call_proc_with_block_only
+    block = lambda { true }
+    assert_equal [block], evaluate_method(@object, @proc, 1, 2, 3, &block)
+  end
+end

data/test/unit/eval_helper/eval_helpers_proc_without_arguments_test.rb

@@ -0,0 +1,19 @@
+require_relative '../../test_helper'
+require_relative '../../unit/eval_helper/eval_helpers_base_test'
+
+class EvalHelpersProcWithBlockWithoutArgumentsTest < EvalHelpersBaseTest
+  def setup
+    @object = Object.new
+    @proc = lambda { |*args| args }
+    class << @proc
+      def arity
+        0
+      end
+    end
+  end
+
+  def test_should_call_proc_without_arguments
+    block = lambda { true }
+    assert_equal [], evaluate_method(@object, @proc, 1, 2, 3, &block)
+  end
+end

data/test/unit/eval_helper/eval_helpers_string_test.rb

@@ -0,0 +1,25 @@
+require_relative '../../test_helper'
+require_relative '../../unit/eval_helper/eval_helpers_base_test.rb'
+
+class EvalHelpersStringTest < EvalHelpersBaseTest
+  def setup
+    @object = Object.new
+  end
+
+  def test_should_evaluate_string
+    assert_equal 1, evaluate_method(@object, '1')
+  end
+
+  def test_should_evaluate_string_within_object_context
+    @object.instance_variable_set('@value', 1)
+    assert_equal 1, evaluate_method(@object, '@value')
+  end
+
+  def test_should_ignore_additional_arguments
+    assert_equal 1, evaluate_method(@object, '1', 2, 3, 4)
+  end
+end
+
+
+
+

data/test/unit/eval_helper/eval_helpers_string_with_block_test.rb

@@ -0,0 +1,12 @@
+require_relative '../../test_helper'
+require_relative '../../unit/eval_helper/eval_helpers_base_test'
+
+class EvalHelpersStringWithBlockTest < EvalHelpersBaseTest
+  def setup
+    @object = Object.new
+  end
+
+  def test_should_call_method_on_object_with_block
+    assert_equal 1, evaluate_method(@object, 'yield') { 1 }
+  end
+end

data/test/unit/eval_helper/eval_helpers_symbol_method_missing_test.rb

@@ -0,0 +1,20 @@
+require_relative '../../test_helper'
+require_relative '../../unit/eval_helper/eval_helpers_base_test'
+
+class EvalHelpersSymbolMethodMissingTest < EvalHelpersBaseTest
+  def setup
+    class << (@object = Object.new)
+      def method_missing(symbol, *args)
+        send("method_missing_#{symbol}", *args)
+      end
+
+      def method_missing_callback(*args)
+        args
+      end
+    end
+  end
+
+  def test_should_call_dynamic_method_with_all_arguments
+    assert_equal [1, 2, 3], evaluate_method(@object, :callback, 1, 2, 3)
+  end
+end

data/test/unit/eval_helper/eval_helpers_symbol_private_test.rb

@@ -0,0 +1,17 @@
+require_relative '../../test_helper'
+require_relative '../../unit/eval_helper/eval_helpers_base_test'
+
+class EvalHelpersSymbolPrivateTest < EvalHelpersBaseTest
+  def setup
+    class << (@object = Object.new)
+      private
+      def callback
+        true
+      end
+    end
+  end
+
+  def test_should_call_method_on_object_with_no_arguments
+    assert_equal true, evaluate_method(@object, :callback, 1, 2, 3)
+  end
+end

data/test/unit/eval_helper/eval_helpers_symbol_protected_test.rb

@@ -0,0 +1,17 @@
+require_relative '../../test_helper'
+require_relative '../../unit/eval_helper/eval_helpers_base_test'
+
+class EvalHelpersSymbolProtectedTest < EvalHelpersBaseTest
+  def setup
+    class << (@object = Object.new)
+      protected
+      def callback
+        true
+      end
+    end
+  end
+
+  def test_should_call_method_on_object_with_no_arguments
+    assert_equal true, evaluate_method(@object, :callback, 1, 2, 3)
+  end
+end