state_machines 0.4.0 → 0.6.0

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
-

data/test/unit/event/event_with_matching_enabled_transitions_test.rb

@@ -1,75 +0,0 @@
-require_relative '../../test_helper'
-
-class EventWithMatchingEnabledTransitionsTest < 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(EventWithMatchingEnabledTransitionsTest::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)
-
-    @object = @klass.new
-    @object.state = 'parked'
-  end
-
-  def test_should_be_able_to_fire
-    assert @event.can_fire?(@object)
-  end
-
-  def test_should_have_a_transition
-    transition = @event.transition_for(@object)
-    refute_nil transition
-    assert_equal 'parked', transition.from
-    assert_equal 'idling', transition.to
-    assert_equal :ignite, transition.event
-  end
-
-  def test_should_fire
-    assert @event.fire(@object)
-  end
-
-  def test_should_change_the_current_state
-    @event.fire(@object)
-    assert_equal 'idling', @object.state
-  end
-
-  def test_should_reset_existing_error
-    @object.errors = ['invalid']
-
-    @event.fire(@object)
-    assert_equal [], @object.errors
-  end
-
-  def test_should_not_invalidate_the_state
-    @event.fire(@object)
-    assert_equal [], @object.errors
-  end
-
-  def test_should_not_be_able_to_fire_on_reset
-    @event.reset
-    refute @event.can_fire?(@object)
-  end
-
-  def teardown
-    StateMachines::Integrations.reset
-  end
-end
-

data/test/unit/event/event_with_multiple_transitions_test.rb

@@ -1,61 +0,0 @@
-require_relative '../../test_helper'
-
-class EventWithMultipleTransitionsTest < 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(idling: :idling)
-    @event.transition(parked: :idling)
-    @event.transition(parked: :parked)
-
-    @object = @klass.new
-    @object.state = 'parked'
-  end
-
-  def test_should_be_able_to_fire
-    assert @event.can_fire?(@object)
-  end
-
-  def test_should_have_a_transition
-    transition = @event.transition_for(@object)
-    refute_nil transition
-    assert_equal 'parked', transition.from
-    assert_equal 'idling', transition.to
-    assert_equal :ignite, transition.event
-  end
-
-  def test_should_allow_specific_transition_selection_using_from
-    transition = @event.transition_for(@object, from: :idling)
-
-    refute_nil transition
-    assert_equal 'idling', transition.from
-    assert_equal 'idling', transition.to
-    assert_equal :ignite, transition.event
-  end
-
-  def test_should_allow_specific_transition_selection_using_to
-    transition = @event.transition_for(@object, from: :parked, to: :parked)
-
-    refute_nil transition
-    assert_equal 'parked', transition.from
-    assert_equal 'parked', transition.to
-    assert_equal :ignite, transition.event
-  end
-
-  def test_should_not_allow_specific_transition_selection_using_on
-    exception = assert_raises(ArgumentError) { @event.transition_for(@object, on: :park) }
-    assert_equal 'Unknown key: :on. Valid keys are: :from, :to, :guard', exception.message
-  end
-
-  def test_should_fire
-    assert @event.fire(@object)
-  end
-
-  def test_should_change_the_current_state
-    @event.fire(@object)
-    assert_equal 'idling', @object.state
-  end
-end

data/test/unit/event/event_with_namespace_test.rb

@@ -1,34 +0,0 @@
-require_relative '../../test_helper'
-
-class EventWithNamespaceTest < StateMachinesTest
-  def setup
-    @klass = Class.new
-    @machine = StateMachines::Machine.new(@klass, namespace: 'alarm')
-    @machine.events << @event = StateMachines::Event.new(@machine, :enable)
-    @object = @klass.new
-  end
-
-  def test_should_have_a_name
-    assert_equal :enable, @event.name
-  end
-
-  def test_should_have_a_qualified_name
-    assert_equal :enable_alarm, @event.qualified_name
-  end
-
-  def test_should_namespace_predicate
-    assert @object.respond_to?(:can_enable_alarm?)
-  end
-
-  def test_should_namespace_transition_accessor
-    assert @object.respond_to?(:enable_alarm_transition)
-  end
-
-  def test_should_namespace_action
-    assert @object.respond_to?(:enable_alarm)
-  end
-
-  def test_should_namespace_bang_action
-    assert @object.respond_to?(:enable_alarm!)
-  end
-end

data/test/unit/event/event_with_transition_with_blacklisted_to_state_test.rb

@@ -1,60 +0,0 @@
-require_relative '../../test_helper'
-class EventWithTransitionWithBlacklistedToStateTest < StateMachinesTest
-  def setup
-    @klass = Class.new
-    @machine = StateMachines::Machine.new(@klass, initial: :parked)
-    @machine.state :parked, :idling, :first_gear, :second_gear
-
-    @machine.events << @event = StateMachines::Event.new(@machine, :ignite)
-    @event.transition(from: :parked, to: StateMachines::BlacklistMatcher.new([:parked, :idling]))
-
-    @object = @klass.new
-    @object.state = 'parked'
-  end
-
-  def test_should_be_able_to_fire
-    assert @event.can_fire?(@object)
-  end
-
-  def test_should_have_a_transition
-    transition = @event.transition_for(@object)
-    refute_nil transition
-    assert_equal 'parked', transition.from
-    assert_equal 'first_gear', transition.to
-    assert_equal :ignite, transition.event
-  end
-
-  def test_should_allow_loopback_first_when_possible
-    @event.transition(from: :second_gear, to: StateMachines::BlacklistMatcher.new([:parked, :idling]))
-    @object.state = 'second_gear'
-
-    transition = @event.transition_for(@object)
-    refute_nil transition
-    assert_equal 'second_gear', transition.from
-    assert_equal 'second_gear', transition.to
-    assert_equal :ignite, transition.event
-  end
-
-  def test_should_allow_specific_transition_selection_using_to
-    transition = @event.transition_for(@object, from: :parked, to: :second_gear)
-
-    refute_nil transition
-    assert_equal 'parked', transition.from
-    assert_equal 'second_gear', transition.to
-    assert_equal :ignite, transition.event
-  end
-
-  def test_should_not_allow_transition_selection_if_not_matching
-    transition = @event.transition_for(@object, from: :parked, to: :parked)
-    assert_nil transition
-  end
-
-  def test_should_fire
-    assert @event.fire(@object)
-  end
-
-  def test_should_change_the_current_state
-    @event.fire(@object)
-    assert_equal 'first_gear', @object.state
-  end
-end

data/test/unit/event/event_with_transition_with_loopback_state_test.rb

@@ -1,36 +0,0 @@
-require_relative '../../test_helper'
-
-class EventWithTransitionWithLoopbackStateTest < StateMachinesTest
-  def setup
-    @klass = Class.new
-    @machine = StateMachines::Machine.new(@klass)
-    @machine.state :parked
-
-    @machine.events << @event = StateMachines::Event.new(@machine, :park)
-    @event.transition(from: :parked, to: StateMachines::LoopbackMatcher.instance)
-
-    @object = @klass.new
-    @object.state = 'parked'
-  end
-
-  def test_should_be_able_to_fire
-    assert @event.can_fire?(@object)
-  end
-
-  def test_should_have_a_transition
-    transition = @event.transition_for(@object)
-    refute_nil transition
-    assert_equal 'parked', transition.from
-    assert_equal 'parked', transition.to
-    assert_equal :park, transition.event
-  end
-
-  def test_should_fire
-    assert @event.fire(@object)
-  end
-
-  def test_should_not_change_the_current_state
-    @event.fire(@object)
-    assert_equal 'parked', @object.state
-  end
-end

data/test/unit/event/event_with_transition_with_nil_to_state_test.rb

@@ -1,36 +0,0 @@
-require_relative '../../test_helper'
-
-class EventWithTransitionWithNilToStateTest < StateMachinesTest
-  def setup
-    @klass = Class.new
-    @machine = StateMachines::Machine.new(@klass)
-    @machine.state nil, :idling
-
-    @machine.events << @event = StateMachines::Event.new(@machine, :park)
-    @event.transition(idling: nil)
-
-    @object = @klass.new
-    @object.state = 'idling'
-  end
-
-  def test_should_be_able_to_fire
-    assert @event.can_fire?(@object)
-  end
-
-  def test_should_have_a_transition
-    transition = @event.transition_for(@object)
-    refute_nil transition
-    assert_equal 'idling', transition.from
-    assert_equal nil, transition.to
-    assert_equal :park, transition.event
-  end
-
-  def test_should_fire
-    assert @event.fire(@object)
-  end
-
-  def test_should_not_change_the_current_state
-    @event.fire(@object)
-    assert_equal nil, @object.state
-  end
-end

data/test/unit/event/event_with_transition_with_whitelisted_to_state_test.rb

@@ -1,51 +0,0 @@
-require_relative '../../test_helper'
-
-class EventWithTransitionWithWhitelistedToStateTest < StateMachinesTest
-  def setup
-    @klass = Class.new
-    @machine = StateMachines::Machine.new(@klass, initial: :parked)
-    @machine.state :parked, :idling, :first_gear, :second_gear
-
-    @machine.events << @event = StateMachines::Event.new(@machine, :ignite)
-    @event.transition(from: :parked, to: StateMachines::WhitelistMatcher.new([:first_gear, :second_gear]))
-
-    @object = @klass.new
-    @object.state = 'parked'
-  end
-
-  def test_should_be_able_to_fire
-    assert @event.can_fire?(@object)
-  end
-
-  def test_should_have_a_transition
-    transition = @event.transition_for(@object)
-    refute_nil transition
-    assert_equal 'parked', transition.from
-    assert_equal 'first_gear', transition.to
-    assert_equal :ignite, transition.event
-  end
-
-  def test_should_allow_specific_transition_selection_using_to
-    transition = @event.transition_for(@object, from: :parked, to: :second_gear)
-
-    refute_nil transition
-    assert_equal 'parked', transition.from
-    assert_equal 'second_gear', transition.to
-    assert_equal :ignite, transition.event
-  end
-
-  def test_should_not_allow_transition_selection_if_not_matching
-    transition = @event.transition_for(@object, from: :parked, to: :parked)
-    assert_nil transition
-  end
-
-  def test_should_fire
-    assert @event.fire(@object)
-  end
-
-  def test_should_change_the_current_state
-    @event.fire(@object)
-    assert_equal 'first_gear', @object.state
-  end
-end
-

data/test/unit/event/event_with_transition_without_to_state_test.rb

@@ -1,36 +0,0 @@
-require_relative '../../test_helper'
-
-class EventWithTransitionWithoutToStateTest < StateMachinesTest
-  def setup
-    @klass = Class.new
-    @machine = StateMachines::Machine.new(@klass)
-    @machine.state :parked
-
-    @machine.events << @event = StateMachines::Event.new(@machine, :park)
-    @event.transition(from: :parked)
-
-    @object = @klass.new
-    @object.state = 'parked'
-  end
-
-  def test_should_be_able_to_fire
-    assert @event.can_fire?(@object)
-  end
-
-  def test_should_have_a_transition
-    transition = @event.transition_for(@object)
-    refute_nil transition
-    assert_equal 'parked', transition.from
-    assert_equal 'parked', transition.to
-    assert_equal :park, transition.event
-  end
-
-  def test_should_fire
-    assert @event.fire(@object)
-  end
-
-  def test_should_not_change_the_current_state
-    @event.fire(@object)
-    assert_equal 'parked', @object.state
-  end
-end

data/test/unit/event/event_with_transitions_test.rb

@@ -1,32 +0,0 @@
-require_relative '../../test_helper'
-
-class EventWithTransitionsTest < StateMachinesTest
-  def setup
-    @klass = Class.new
-    @machine = StateMachines::Machine.new(@klass)
-    @machine.events << @event = StateMachines::Event.new(@machine, :ignite)
-    @event.transition(parked: :idling)
-    @event.transition(first_gear: :idling)
-  end
-
-  def test_should_include_all_transition_states_in_known_states
-    assert_equal [:parked, :idling, :first_gear], @event.known_states
-  end
-
-  def test_should_include_new_transition_states_after_calling_known_states
-    @event.known_states
-    @event.transition(stalled: :idling)
-
-    assert_equal [:parked, :idling, :first_gear, :stalled], @event.known_states
-  end
-
-  def test_should_clear_known_states_on_reset
-    @event.reset
-    assert_equal [], @event.known_states
-  end
-
-  def test_should_use_pretty_inspect
-    assert_match '#<StateMachines::Event name=:ignite transitions=[:parked => :idling, :first_gear => :idling]>', @event.inspect
-  end
-end
-

data/test/unit/event/event_without_matching_transitions_test.rb

@@ -1,41 +0,0 @@
-require_relative '../../test_helper'
-
-class EventWithoutMatchingTransitionsTest < 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 = 'idling'
-  end
-
-  def test_should_not_be_able_to_fire
-    refute @event.can_fire?(@object)
-  end
-
-  def test_should_be_able_to_fire_with_custom_from_state
-    assert @event.can_fire?(@object, from: :parked)
-  end
-
-  def test_should_not_have_a_transition
-    assert_nil @event.transition_for(@object)
-  end
-
-  def test_should_have_a_transition_with_custom_from_state
-    refute_nil @event.transition_for(@object, from: :parked)
-  end
-
-  def test_should_not_fire
-    refute @event.fire(@object)
-  end
-
-  def test_should_not_change_the_current_state
-    @event.fire(@object)
-    assert_equal 'idling', @object.state
-  end
-end
-

data/test/unit/event/event_without_transitions_test.rb

@@ -1,28 +0,0 @@
-require_relative '../../test_helper'
-
-class EventWithoutTransitionsTest < 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_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_not_fire
-    refute @event.fire(@object)
-  end
-
-  def test_should_not_change_the_current_state
-    @event.fire(@object)
-    assert_nil @object.state
-  end
-end
-

data/test/unit/event/invalid_event_test.rb

@@ -1,20 +0,0 @@
-require_relative '../../test_helper'
-
-class InvalidEventTest < StateMachinesTest
-  def setup
-    @object = Object.new
-    @invalid_event = StateMachines::InvalidEvent.new(@object, :invalid)
-  end
-
-  def test_should_have_an_object
-    assert_equal @object, @invalid_event.object
-  end
-
-  def test_should_have_an_event
-    assert_equal :invalid, @invalid_event.event
-  end
-
-  def test_should_generate_a_message
-    assert_equal ':invalid is an unknown state machine event', @invalid_event.message
-  end
-end

data/test/unit/event_collection/event_collection_attribute_with_machine_action_test.rb

@@ -1,62 +0,0 @@
-require_relative '../../test_helper'
-
-class EventCollectionAttributeWithMachineActionTest < StateMachinesTest
-  def setup
-    @klass = Class.new do
-      def save
-      end
-    end
-
-    @machine = StateMachines::Machine.new(@klass, initial: :parked, action: :save)
-    @events = StateMachines::EventCollection.new(@machine)
-
-    @machine.state :parked, :idling
-    @events << @ignite = StateMachines::Event.new(@machine, :ignite)
-    @machine.events.concat(@events)
-
-    @object = @klass.new
-  end
-
-  def test_should_not_have_transition_if_nil
-    @object.state_event = nil
-    assert_nil @events.attribute_transition_for(@object)
-  end
-
-  def test_should_not_have_transition_if_empty
-    @object.state_event = ''
-    assert_nil @events.attribute_transition_for(@object)
-  end
-
-  def test_should_have_invalid_transition_if_invalid_event_specified
-    @object.state_event = 'invalid'
-    assert_equal false, @events.attribute_transition_for(@object)
-  end
-
-  def test_should_have_invalid_transition_if_event_cannot_be_fired
-    @object.state_event = 'ignite'
-    assert_equal false, @events.attribute_transition_for(@object)
-  end
-
-  def test_should_have_valid_transition_if_event_can_be_fired
-    @ignite.transition parked: :idling
-    @object.state_event = 'ignite'
-
-    assert_instance_of StateMachines::Transition, @events.attribute_transition_for(@object)
-  end
-
-  def test_should_have_valid_transition_if_already_defined_in_transition_cache
-    @ignite.transition parked: :idling
-    @object.state_event = nil
-    @object.send(:state_event_transition=, transition = @ignite.transition_for(@object))
-
-    assert_equal transition, @events.attribute_transition_for(@object)
-  end
-
-  def test_should_use_transition_cache_if_both_event_and_transition_are_present
-    @ignite.transition parked: :idling
-    @object.state_event = 'ignite'
-    @object.send(:state_event_transition=, transition = @ignite.transition_for(@object))
-
-    assert_equal transition, @events.attribute_transition_for(@object)
-  end
-end