state_machines 0.0.2 → 0.1.0

data/test/unit/eval_helper/eval_helpers_symbol_tainted_method_test.rb

@@ -0,0 +1,18 @@
+require_relative '../../test_helper'
+require_relative '../../unit/eval_helper/eval_helpers_base_test'
+
+class EvalHelpersSymbolTaintedMethodTest < EvalHelpersBaseTest
+  def setup
+    class << (@object = Object.new)
+      def callback
+        true
+      end
+
+      taint
+    end
+  end
+
+  def test_should_not_raise_security_error
+    evaluate_method(@object, :callback, 1, 2, 3)
+  end
+end

data/test/unit/eval_helper/eval_helpers_symbol_test.rb

@@ -0,0 +1,16 @@
+require_relative '../../test_helper'
+require_relative '../../unit/eval_helper/eval_helpers_base_test'
+
+class EvalHelpersSymbolTest < EvalHelpersBaseTest
+  def setup
+    class << (@object = Object.new)
+      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_with_arguments_and_block_test.rb

@@ -0,0 +1,16 @@
+require_relative '../../test_helper'
+require_relative '../../unit/eval_helper/eval_helpers_base_test'
+
+class EvalHelpersSymbolWithArgumentsAndBlockTest < EvalHelpersBaseTest
+  def setup
+    class << (@object = Object.new)
+      def callback(*args)
+        args << yield
+      end
+    end
+  end
+
+  def test_should_call_method_on_object_with_all_arguments_and_block
+    assert_equal [1, 2, 3, true], evaluate_method(@object, :callback, 1, 2, 3) { true }
+  end
+end

data/test/unit/eval_helper/eval_helpers_symbol_with_arguments_test.rb

@@ -0,0 +1,16 @@
+require_relative '../../test_helper'
+require_relative '../../unit/eval_helper/eval_helpers_base_test'
+
+class EvalHelpersSymbolWithArgumentsTest < EvalHelpersBaseTest
+  def setup
+    class << (@object = Object.new)
+      def callback(*args)
+        args
+      end
+    end
+  end
+
+  def test_should_call_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_with_block_test.rb

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

data/test/unit/eval_helper/eval_helpers_test.rb

@@ -0,0 +1,13 @@
+require_relative '../../test_helper'
+require_relative '../../unit/eval_helper/eval_helpers_base_test'
+
+class EvalHelpersTest < EvalHelpersBaseTest
+  def setup
+    @object = Object.new
+  end
+
+  def test_should_raise_exception_if_method_is_not_symbol_string_or_proc
+    exception = assert_raises(ArgumentError) { evaluate_method(@object, 1) }
+    assert_match(/Methods must/, exception.message)
+  end
+end

data/test/unit/event/event_after_being_copied_test.rb

@@ -0,0 +1,17 @@
+require_relative '../../test_helper'
+
+class EventAfterBeingCopiedTest < StateMachinesTest
+  def setup
+    @machine = StateMachines::Machine.new(Class.new)
+    @machine.events << @event = StateMachines::Event.new(@machine, :ignite)
+    @copied_event = @event.dup
+  end
+
+  def test_should_not_have_the_same_collection_of_branches
+    refute_same @event.branches, @copied_event.branches
+  end
+
+  def test_should_not_have_the_same_collection_of_known_states
+    refute_same @event.known_states, @copied_event.known_states
+  end
+end

data/test/unit/event/event_by_default_test.rb

@@ -0,0 +1,60 @@
+require_relative '../../test_helper'
+
+
+class EventByDefaultTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass)
+    @machine.events << @event = StateMachines::Event.new(@machine, :ignite)
+
+    @object = @klass.new
+  end
+
+  def test_should_have_a_machine
+    assert_equal @machine, @event.machine
+  end
+
+  def test_should_have_a_name
+    assert_equal :ignite, @event.name
+  end
+
+  def test_should_have_a_qualified_name
+    assert_equal :ignite, @event.qualified_name
+  end
+
+  def test_should_have_a_human_name
+    assert_equal 'ignite', @event.human_name
+  end
+
+  def test_should_not_have_any_branches
+    assert @event.branches.empty?
+  end
+
+  def test_should_have_no_known_states
+    assert @event.known_states.empty?
+  end
+
+  def test_should_not_be_able_to_fire
+    refute @event.can_fire?(@object)
+  end
+
+  def test_should_not_have_a_transition
+    assert_nil @event.transition_for(@object)
+  end
+
+  def test_should_define_a_predicate
+    assert @object.respond_to?(:can_ignite?)
+  end
+
+  def test_should_define_a_transition_accessor
+    assert @object.respond_to?(:ignite_transition)
+  end
+
+  def test_should_define_an_action
+    assert @object.respond_to?(:ignite)
+  end
+
+  def test_should_define_a_bang_action
+    assert @object.respond_to?(:ignite!)
+  end
+end

data/test/unit/event/event_context_test.rb

@@ -0,0 +1,16 @@
+require_relative '../../test_helper'
+
+class EventContextTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass)
+    @machine.events << @event = StateMachines::Event.new(@machine, :ignite, human_name: 'start')
+  end
+
+  def test_should_evaluate_within_the_event
+    scope = nil
+    @event.context { scope = self }
+    assert_equal @event, scope
+  end
+end
+

data/test/unit/event/event_on_failure_test.rb

@@ -0,0 +1,44 @@
+require_relative '../../test_helper'
+require_relative '../../files/integrations/event_on_failure_integration'
+
+class EventOnFailureTest < StateMachinesTest
+  def setup
+    StateMachines::Integrations.reset
+    StateMachines::Integrations.register(EventOnFailureIntegration)
+    @klass = Class.new do
+      attr_accessor :errors
+    end
+
+    @machine = StateMachines::Machine.new(@klass, integration: :event_on_failure_integration)
+    @machine.state :parked
+    @machine.events << @event = StateMachines::Event.new(@machine, :ignite)
+
+    @object = @klass.new
+    @object.state = 'parked'
+  end
+
+  def test_should_invalidate_the_state
+    @event.fire(@object)
+    assert_equal ['cannot transition via "ignite"'], @object.errors
+  end
+
+  def test_should_run_failure_callbacks
+    callback_args = nil
+    @machine.after_failure { |*args| callback_args = args }
+
+    @event.fire(@object)
+
+    object, transition = callback_args
+    assert_equal @object, object
+    refute_nil transition
+    assert_equal @object, transition.object
+    assert_equal @machine, transition.machine
+    assert_equal :ignite, transition.event
+    assert_equal :parked, transition.from_name
+    assert_equal :parked, transition.to_name
+  end
+
+  def teardown
+    StateMachines::Integrations.reset
+  end
+end

data/test/unit/event/event_test.rb

@@ -0,0 +1,34 @@
+require_relative '../../test_helper'
+
+class EventTest < StateMachinesTest
+  def setup
+    @machine = StateMachines::Machine.new(Class.new)
+    @machine.events << @event = StateMachines::Event.new(@machine, :ignite)
+    @event.transition parked: :idling
+  end
+
+  def test_should_allow_changing_machine
+    new_machine = StateMachines::Machine.new(Class.new)
+    @event.machine = new_machine
+    assert_equal new_machine, @event.machine
+  end
+
+  def test_should_allow_changing_human_name
+    @event.human_name = 'Stop'
+    assert_equal 'Stop', @event.human_name
+  end
+
+  def test_should_provide_matcher_helpers_during_initialization
+    matchers = []
+
+    @event.instance_eval do
+      matchers = [all, any, same]
+    end
+
+    assert_equal [StateMachines::AllMatcher.instance, StateMachines::AllMatcher.instance, StateMachines::LoopbackMatcher.instance], matchers
+  end
+
+  def test_should_use_pretty_inspect
+    assert_match '#<StateMachines::Event name=:ignite transitions=[:parked => :idling]>', @event.inspect
+  end
+end

data/test/unit/event/event_transitions_test.rb

@@ -0,0 +1,62 @@
+require_relative '../../test_helper'
+
+class EventTransitionsTest < StateMachinesTest
+  def setup
+    @machine = StateMachines::Machine.new(Class.new)
+    @machine.events << @event = StateMachines::Event.new(@machine, :ignite)
+  end
+
+  def test_should_not_raise_exception_if_implicit_option_specified
+    @event.transition(invalid: :valid)
+  end
+
+  def test_should_not_allow_on_option
+    exception = assert_raises(ArgumentError) { @event.transition(on: :ignite) }
+    assert_equal 'Unknown key: :on. Valid keys are: :from, :to, :except_from, :except_to, :if, :unless', exception.message
+  end
+
+  def test_should_automatically_set_on_option
+    branch = @event.transition(to: :idling)
+    assert_instance_of StateMachines::WhitelistMatcher, branch.event_requirement
+    assert_equal [:ignite], branch.event_requirement.values
+  end
+
+  def test_should_not_allow_except_on_option
+    exception = assert_raises(ArgumentError) { @event.transition(except_on: :ignite) }
+    assert_equal 'Unknown key: :except_on. Valid keys are: :from, :to, :except_from, :except_to, :if, :unless', exception.message
+  end
+
+  def test_should_allow_transitioning_without_a_to_state
+    @event.transition(from: :parked)
+  end
+
+  def test_should_allow_transitioning_without_a_from_state
+    @event.transition(to: :idling)
+  end
+
+  def test_should_allow_except_from_option
+    @event.transition(except_from: :idling)
+  end
+
+  def test_should_allow_except_to_option
+    @event.transition(except_to: :idling)
+  end
+
+  def test_should_allow_transitioning_from_a_single_state
+    assert @event.transition(parked: :idling)
+  end
+
+  def test_should_allow_transitioning_from_multiple_states
+    assert @event.transition([:parked, :idling] => :idling)
+  end
+
+  def test_should_allow_transitions_to_multiple_states
+    assert @event.transition(parked: [:parked, :idling])
+  end
+
+  def test_should_have_transitions
+    branch = @event.transition(to: :idling)
+    assert_equal [branch], @event.branches
+  end
+end
+

data/test/unit/event/event_with_conflicting_helpers_after_definition_test.rb

@@ -0,0 +1,79 @@
+require_relative '../../test_helper'
+require 'stringio'
+
+class EventWithConflictingHelpersAfterDefinitionTest < StateMachinesTest
+  def setup
+    @original_stderr, $stderr = $stderr, StringIO.new
+
+    @klass = Class.new do
+      def can_ignite?
+        0
+      end
+
+      def ignite_transition
+        0
+      end
+
+      def ignite
+        0
+      end
+
+      def ignite!
+        0
+      end
+    end
+    @machine = StateMachines::Machine.new(@klass)
+    @machine.events << @event = StateMachines::Event.new(@machine, :ignite)
+    @object = @klass.new
+  end
+
+  def test_should_not_redefine_predicate
+    assert_equal 0, @object.can_ignite?
+  end
+
+  def test_should_not_redefine_transition_accessor
+    assert_equal 0, @object.ignite_transition
+  end
+
+  def test_should_not_redefine_action
+    assert_equal 0, @object.ignite
+  end
+
+  def test_should_not_redefine_bang_action
+    assert_equal 0, @object.ignite!
+  end
+
+  def test_should_allow_super_chaining
+    @klass.class_eval do
+      def can_ignite?
+        super
+      end
+
+      def ignite_transition
+        super
+      end
+
+      def ignite
+        super
+      end
+
+      def ignite!
+        super
+      end
+    end
+
+    assert_equal false, @object.can_ignite?
+    assert_equal nil, @object.ignite_transition
+    assert_equal false, @object.ignite
+    assert_raises(StateMachines::InvalidTransition) { @object.ignite! }
+  end
+
+  def test_should_not_output_warning
+    assert_equal '', $stderr.string
+  end
+
+  def teardown
+    $stderr = @original_stderr
+  end
+end
+

data/test/unit/event/event_with_conflicting_helpers_before_definition_test.rb

@@ -0,0 +1,58 @@
+require_relative '../../test_helper'
+require 'stringio'
+
+class EventWithConflictingHelpersBeforeDefinitionTest < StateMachinesTest
+  def setup
+    @original_stderr, $stderr = $stderr, StringIO.new
+
+    @superclass = Class.new do
+      def can_ignite?
+        0
+      end
+
+      def ignite_transition
+        0
+      end
+
+      def ignite
+        0
+      end
+
+      def ignite!
+        0
+      end
+    end
+    @klass = Class.new(@superclass)
+    @machine = StateMachines::Machine.new(@klass)
+    @machine.events << @event = StateMachines::Event.new(@machine, :ignite)
+    @object = @klass.new
+  end
+
+  def test_should_not_redefine_predicate
+    assert_equal 0, @object.can_ignite?
+  end
+
+  def test_should_not_redefine_transition_accessor
+    assert_equal 0, @object.ignite_transition
+  end
+
+  def test_should_not_redefine_action
+    assert_equal 0, @object.ignite
+  end
+
+  def test_should_not_redefine_bang_action
+    assert_equal 0, @object.ignite!
+  end
+
+  def test_should_output_warning
+    expected = %w(can_ignite? ignite_transition ignite ignite!).map do |method|
+      "Instance method \"#{method}\" is already defined in #{@superclass}, use generic helper instead or set StateMachines::Machine.ignore_method_conflicts = true.\n"
+    end.join
+
+    assert_equal expected, $stderr.string
+  end
+
+  def teardown
+    $stderr = @original_stderr
+  end
+end

data/test/unit/event/event_with_conflicting_machine_test.rb

@@ -0,0 +1,48 @@
+require_relative '../../test_helper'
+require 'stringio'
+
+class EventWithConflictingMachineTest < StateMachinesTest
+  def setup
+    @original_stderr, $stderr = $stderr, StringIO.new
+
+    @klass = Class.new
+    @state_machine = StateMachines::Machine.new(@klass, :state)
+    @state_machine.state :parked, :idling
+    @state_machine.events << @state_event = StateMachines::Event.new(@state_machine, :ignite)
+  end
+
+  def test_should_not_overwrite_first_event
+    @status_machine = StateMachines::Machine.new(@klass, :status)
+    @status_machine.state :first_gear, :second_gear
+    @status_machine.events << @status_event = StateMachines::Event.new(@status_machine, :ignite)
+
+    @object = @klass.new
+    @object.state = 'parked'
+    @object.status = 'first_gear'
+
+    @state_event.transition(parked: :idling)
+    @status_event.transition(parked: :first_gear)
+
+    @object.ignite
+    assert_equal 'idling', @object.state
+    assert_equal 'first_gear', @object.status
+  end
+
+  def test_should_output_warning
+    @status_machine = StateMachines::Machine.new(@klass, :status)
+    @status_machine.events << @status_event = StateMachines::Event.new(@status_machine, :ignite)
+
+    assert_equal "Event :ignite for :status is already defined in :state\n", $stderr.string
+  end
+
+  def test_should_not_output_warning_if_using_different_namespace
+    @status_machine = StateMachines::Machine.new(@klass, :status, namespace: 'alarm')
+    @status_machine.events << @status_event = StateMachines::Event.new(@status_machine, :ignite)
+
+    assert_equal '', $stderr.string
+  end
+
+  def teardown
+    $stderr = @original_stderr
+  end
+end

data/test/unit/event/event_with_dynamic_human_name_test.rb

@@ -0,0 +1,26 @@
+require_relative '../../test_helper'
+
+class EventWithDynamicHumanNameTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass)
+    @machine.events << @event = StateMachines::Event.new(@machine, :ignite, human_name: lambda { |_event, object| ['start', object] })
+  end
+
+  def test_should_use_custom_human_name
+    human_name, klass = @event.human_name
+    assert_equal 'start', human_name
+    assert_equal @klass, klass
+  end
+
+  def test_should_allow_custom_class_to_be_passed_through
+    human_name, klass = @event.human_name(1)
+    assert_equal 'start', human_name
+    assert_equal 1, klass
+  end
+
+  def test_should_not_cache_value
+    refute_same @event.human_name, @event.human_name
+  end
+end
+

data/test/unit/event/event_with_human_name_test.rb

@@ -0,0 +1,13 @@
+require_relative '../../test_helper'
+
+class EventWithHumanNameTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass)
+    @machine.events << @event = StateMachines::Event.new(@machine, :ignite, human_name: 'start')
+  end
+
+  def test_should_use_custom_human_name
+    assert_equal 'start', @event.human_name
+  end
+end

data/test/unit/event/event_with_invalid_current_state_test.rb

@@ -0,0 +1,30 @@
+require_relative '../../test_helper'
+
+class EventWithInvalidCurrentStateTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass)
+    @machine.state :parked, :idling
+
+    @machine.events << @event = StateMachines::Event.new(@machine, :ignite)
+    @event.transition(parked: :idling)
+
+    @object = @klass.new
+    @object.state = 'invalid'
+  end
+
+  def test_should_raise_exception_when_checking_availability
+    exception = assert_raises(ArgumentError) { @event.can_fire?(@object) }
+    assert_equal '"invalid" is not a known state value', exception.message
+  end
+
+  def test_should_raise_exception_when_finding_transition
+    exception = assert_raises(ArgumentError) { @event.transition_for(@object) }
+    assert_equal '"invalid" is not a known state value', exception.message
+  end
+
+  def test_should_raise_exception_when_firing
+    exception = assert_raises(ArgumentError) { @event.fire(@object) }
+    assert_equal '"invalid" is not a known state value', exception.message
+  end
+end

data/test/unit/event/event_with_machine_action_test.rb

@@ -0,0 +1,33 @@
+require_relative '../../test_helper'
+
+class EventWithMachineActionTest < StateMachinesTest
+  def setup
+    @klass = Class.new do
+      attr_reader :saved
+
+      def save
+        @saved = true
+      end
+    end
+
+    @machine = StateMachines::Machine.new(@klass, action: :save)
+    @machine.state :parked, :idling
+
+    @machine.events << @event = StateMachines::Event.new(@machine, :ignite)
+    @event.transition(parked: :idling)
+
+    @object = @klass.new
+    @object.state = 'parked'
+  end
+
+  def test_should_run_action_on_fire
+    @event.fire(@object)
+    assert @object.saved
+  end
+
+  def test_should_not_run_action_if_configured_to_skip
+    @event.fire(@object, false)
+    refute @object.saved
+  end
+end
+

data/test/unit/event/event_with_marshalling_test.rb

@@ -0,0 +1,47 @@
+require_relative '../../test_helper'
+
+class EventWithMarshallingTest < StateMachinesTest
+  def setup
+    @klass = Class.new do
+      def save
+        true
+      end
+    end
+    self.class.const_set('Example', @klass)
+
+    @machine = StateMachines::Machine.new(@klass, action: :save)
+    @machine.state :parked, :idling
+
+    @machine.events << @event = StateMachines::Event.new(@machine, :ignite)
+    @event.transition(parked: :idling)
+
+    @object = @klass.new
+    @object.state = 'parked'
+  end
+
+  def test_should_marshal_during_before_callbacks
+    @machine.before_transition { |object, _transition| Marshal.dump(object) }
+    @event.fire(@object)
+  end
+
+  def test_should_marshal_during_action
+    @klass.class_eval do
+      remove_method :save
+
+      def save
+        Marshal.dump(self)
+      end
+    end
+
+    @event.fire(@object)
+  end
+
+  def test_should_marshal_during_after_callbacks
+    @machine.after_transition { |object, _transition| Marshal.dump(object) }
+    @event.fire(@object)
+  end
+
+  def teardown
+    self.class.send(:remove_const, 'Example')
+  end
+end