state_machines 0.5.0 → 0.10.0

data/test/unit/event/event_by_default_test.rb

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

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

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

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

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

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

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

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

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

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

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

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

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

data/test/unit/event/event_with_matching_disabled_transitions_test.rb

@@ -1,115 +0,0 @@
-require_relative '../../test_helper'
-
-class EventWithMatchingDisabledTransitionsTest < StateMachinesTest
-  module Custom
-    include StateMachines::Integrations::Base
-
-    def invalidate(object, _attribute, message, values = [])
-      (object.errors ||= []) << generate_message(message, values)
-    end
-
-    def reset(object)
-      object.errors = []
-    end
-  end
-
-  def setup
-    StateMachines::Integrations.register(EventWithMatchingDisabledTransitionsTest::Custom)
-
-    @klass = Class.new do
-      attr_accessor :errors
-    end
-
-    @machine = StateMachines::Machine.new(@klass, integration: :custom)
-    @machine.state :parked, :idling
-
-    @machine.events << @event = StateMachines::Event.new(@machine, :ignite)
-    @event.transition(parked: :idling, if: lambda { false })
-
-    @object = @klass.new
-    @object.state = 'parked'
-  end
-
-  def test_should_not_be_able_to_fire
-    refute @event.can_fire?(@object)
-  end
-
-  def test_should_be_able_to_fire_with_disabled_guards
-    assert @event.can_fire?(@object, guard: false)
-  end
-
-  def test_should_not_have_a_transition
-    assert_nil @event.transition_for(@object)
-  end
-
-  def test_should_have_a_transition_with_disabled_guards
-    refute_nil @event.transition_for(@object, guard: false)
-  end
-
-  def test_should_not_fire
-    refute @event.fire(@object)
-  end
-
-  def test_should_not_change_the_current_state
-    @event.fire(@object)
-    assert_equal 'parked', @object.state
-  end
-
-  def test_should_invalidate_the_state
-    @event.fire(@object)
-    assert_equal ['cannot transition via "ignite"'], @object.errors
-  end
-
-  def test_should_invalidate_with_human_event_name
-    @event.human_name = 'start'
-    @event.fire(@object)
-    assert_equal ['cannot transition via "start"'], @object.errors
-  end
-
-  def test_should_invalid_with_human_state_name_if_specified
-    klass = Class.new do
-      attr_accessor :errors
-    end
-
-    machine = StateMachines::Machine.new(klass, integration: :custom, messages: { invalid_transition: 'cannot transition via "%s" from "%s"' })
-    parked, _idling = machine.state :parked, :idling
-    parked.human_name = 'stopped'
-
-    machine.events << event = StateMachines::Event.new(machine, :ignite)
-    event.transition(parked: :idling, if: lambda { false })
-
-    object = @klass.new
-    object.state = 'parked'
-
-    event.fire(object)
-    assert_equal ['cannot transition via "ignite" from "stopped"'], object.errors
-  end
-
-  def test_should_reset_existing_error
-    @object.errors = ['invalid']
-
-    @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
-