state_machines 0.0.2 → 0.1.0

data/test/unit/event/event_with_matching_disabled_transitions_test.rb

@@ -0,0 +1,115 @@
+require_relative '../../test_helper'
+
+class EventWithMatchingDisabledTransitionsTest < StateMachinesTest
+  def setup
+    StateMachines::Integrations.const_set('Custom', Module.new do
+                                                    include StateMachines::Integrations::Base
+
+                                                    def invalidate(object, _attribute, message, values = [])
+                                                      (object.errors ||= []) << generate_message(message, values)
+                                                    end
+
+                                                    def reset(object)
+                                                      object.errors = []
+                                                    end
+                                                  end)
+    StateMachines::Integrations.register(StateMachines::Integrations::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
+    StateMachines::Integrations.send(:remove_const, 'Custom')
+  end
+end
+

data/test/unit/event/event_with_matching_enabled_transitions_test.rb

@@ -0,0 +1,75 @@
+require_relative '../../test_helper'
+
+class EventWithMatchingEnabledTransitionsTest < StateMachinesTest
+  def setup
+    StateMachines::Integrations.const_set('Custom', Module.new do
+                                                    include StateMachines::Integrations::Base
+
+                                                    def invalidate(object, _attribute, message, values = [])
+                                                      (object.errors ||= []) << generate_message(message, values)
+                                                    end
+
+                                                    def reset(object)
+                                                      object.errors = []
+                                                    end
+                                                  end)
+    StateMachines::Integrations.register(StateMachines::Integrations::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
+    StateMachines::Integrations.send(:remove_const, 'Custom')
+  end
+end
+

data/test/unit/event/event_with_multiple_transitions_test.rb

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,28 @@
+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/{spec/state_machines/invalid_event_spec.rb → test/unit/event/invalid_event_test.rb}

@@ -1,19 +1,20 @@
-require 'spec_helper'
-describe StateMachines::InvalidEvent do
-  before(:each) do
+require_relative '../../test_helper'
+
+class InvalidEventTest < StateMachinesTest
+  def setup
     @object = Object.new
     @invalid_event = StateMachines::InvalidEvent.new(@object, :invalid)
   end
 
-  it 'should_have_an_object' do
+  def test_should_have_an_object
     assert_equal @object, @invalid_event.object
   end
 
-  it 'should_have_an_event' do
+  def test_should_have_an_event
     assert_equal :invalid, @invalid_event.event
   end
 
-  it 'should_generate_a_message' do
+  def test_should_generate_a_message
     assert_equal ':invalid is an unknown state machine event', @invalid_event.message
   end
-end
+end