state_machines 0.0.2 → 0.1.0

data/test/unit/machine_collection/machine_collection_fire_attributes_with_validations_test.rb

@@ -0,0 +1,72 @@
+require_relative '../../test_helper'
+
+class MachineCollectionFireWithValidationsTest < 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
+
+      def initialize
+        @errors = []
+        super
+      end
+    end
+
+    @machines = StateMachines::MachineCollection.new
+    @machines[:state] = @state = StateMachines::Machine.new(@klass, :state, initial: :parked, integration: :custom)
+    @state.event :ignite do
+      transition parked: :idling
+    end
+
+    @machines[:alarm_state] = @alarm_state = StateMachines::Machine.new(@klass, :alarm_state, initial: :active, namespace: 'alarm', integration: :custom)
+    @alarm_state.event :disable do
+      transition active: :off
+    end
+
+    @object = @klass.new
+  end
+
+  def test_should_not_invalidate_if_transitions_exist
+    assert @machines.fire_events(@object, :ignite, :disable_alarm)
+    assert_equal [], @object.errors
+  end
+
+  def test_should_invalidate_if_no_transitions_exist
+    @object.state = 'idling'
+    @object.alarm_state = 'off'
+
+    refute @machines.fire_events(@object, :ignite, :disable_alarm)
+    assert_equal ['cannot transition via "ignite"', 'cannot transition via "disable"'], @object.errors
+  end
+
+  def test_should_run_failure_callbacks_if_no_transitions_exist
+    @object.state = 'idling'
+    @object.alarm_state = 'off'
+    @state_failure_run = @alarm_state_failure_run = false
+
+    @machines[:state].after_failure { @state_failure_run = true }
+    @machines[:alarm_state].after_failure { @alarm_state_failure_run = true }
+
+    refute @machines.fire_events(@object, :ignite, :disable_alarm)
+    assert @state_failure_run
+    assert @alarm_state_failure_run
+  end
+
+  def teardown
+    StateMachines::Integrations.reset
+    StateMachines::Integrations.send(:remove_const, 'Custom')
+  end
+end
+

data/test/unit/machine_collection/machine_collection_fire_test.rb

@@ -0,0 +1,80 @@
+require_relative '../../test_helper'
+
+class MachineCollectionFireTest < StateMachinesTest
+  def setup
+    @machines = StateMachines::MachineCollection.new
+
+    @klass = Class.new do
+      attr_reader :saved
+
+      def save
+        @saved = true
+      end
+    end
+
+    # First machine
+    @machines[:state] = @state = StateMachines::Machine.new(@klass, :state, initial: :parked, action: :save)
+    @state.event :ignite do
+      transition parked: :idling
+    end
+    @state.event :park do
+      transition idling: :parked
+    end
+
+    # Second machine
+    @machines[:alarm_state] = @alarm_state = StateMachines::Machine.new(@klass, :alarm_state, initial: :active, action: :save, namespace: 'alarm')
+    @alarm_state.event :enable do
+      transition off: :active
+    end
+    @alarm_state.event :disable do
+      transition active: :off
+    end
+
+    @object = @klass.new
+  end
+
+  def test_should_raise_exception_if_invalid_event_specified
+    exception = assert_raises(StateMachines::InvalidEvent) { @machines.fire_events(@object, :invalid) }
+    assert_equal :invalid, exception.event
+
+    exception = assert_raises(StateMachines::InvalidEvent) { @machines.fire_events(@object, :ignite, :invalid) }
+    assert_equal :invalid, exception.event
+  end
+
+  def test_should_fail_if_any_event_cannot_transition
+    refute @machines.fire_events(@object, :park, :disable_alarm)
+    assert_equal 'parked', @object.state
+    assert_equal 'active', @object.alarm_state
+    refute @object.saved
+
+    refute @machines.fire_events(@object, :ignite, :enable_alarm)
+    assert_equal 'parked', @object.state
+    assert_equal 'active', @object.alarm_state
+    refute @object.saved
+  end
+
+  def test_should_run_failure_callbacks_if_any_event_cannot_transition
+    @state_failure_run = @alarm_state_failure_run = false
+
+    @machines[:state].after_failure { @state_failure_run = true }
+    @machines[:alarm_state].after_failure { @alarm_state_failure_run = true }
+
+    refute @machines.fire_events(@object, :park, :disable_alarm)
+    assert @state_failure_run
+    refute @alarm_state_failure_run
+  end
+
+  def test_should_be_successful_if_all_events_transition
+    assert @machines.fire_events(@object, :ignite, :disable_alarm)
+    assert_equal 'idling', @object.state
+    assert_equal 'off', @object.alarm_state
+    assert @object.saved
+  end
+
+  def test_should_not_save_if_skipping_action
+    assert @machines.fire_events(@object, :ignite, :disable_alarm, false)
+    assert_equal 'idling', @object.state
+    assert_equal 'off', @object.alarm_state
+    refute @object.saved
+  end
+end

data/test/unit/machine_collection/machine_collection_fire_with_transactions_test.rb

@@ -0,0 +1,54 @@
+require_relative '../../test_helper'
+
+class MachineCollectionFireAttributesWithValidationsTest < StateMachinesTest
+  def setup
+    @klass = Class.new do
+      attr_accessor :errors
+
+      def initialize
+        @errors = []
+        super
+      end
+    end
+
+    @machines = StateMachines::MachineCollection.new
+    @machines[:state] = @machine = StateMachines::Machine.new(@klass, :state, initial: :parked, action: :save)
+    @machine.event :ignite do
+      transition parked: :idling
+    end
+
+    class << @machine
+      def invalidate(object, _attribute, message, values = [])
+        (object.errors ||= []) << generate_message(message, values)
+      end
+
+      def reset(object)
+        object.errors = []
+      end
+    end
+
+    @object = @klass.new
+  end
+
+  def test_should_invalidate_if_event_is_invalid
+    @object.state_event = 'invalid'
+    @machines.transitions(@object, :save)
+
+    refute @object.errors.empty?
+  end
+
+  def test_should_invalidate_if_no_transition_exists
+    @object.state = 'idling'
+    @object.state_event = 'ignite'
+    @machines.transitions(@object, :save)
+
+    refute @object.errors.empty?
+  end
+
+  def test_should_not_invalidate_if_transition_exists
+    @object.state_event = 'ignite'
+    @machines.transitions(@object, :save)
+
+    assert @object.errors.empty?
+  end
+end

data/test/unit/machine_collection/machine_collection_fire_with_validations_test.rb

@@ -0,0 +1,76 @@
+require_relative '../../test_helper'
+
+module MachineCollectionFireWithValidationsIntegration
+  include StateMachines::Integrations::Base
+
+  def self.integration_name
+    :custom_validation
+  end
+
+  def invalidate(object, _attribute, message, values = [])
+    (object.errors ||= []) << generate_message(message, values)
+  end
+
+  def reset(object)
+    object.errors = []
+  end
+end
+
+class MachineCollectionFireWithValidationsTest < StateMachinesTest
+  def setup
+    StateMachines::Integrations.reset
+    StateMachines::Integrations.register(MachineCollectionFireWithValidationsIntegration)
+
+    @klass = Class.new do
+      attr_accessor :errors
+
+      def initialize
+        @errors = []
+        super
+      end
+    end
+
+    @machines = StateMachines::MachineCollection.new
+    @machines[:state] = @state = StateMachines::Machine.new(@klass, :state, initial: :parked, integration: :custom_validation)
+    @state.event :ignite do
+      transition parked: :idling
+    end
+
+    @machines[:alarm_state] = @alarm_state = StateMachines::Machine.new(@klass, :alarm_state, initial: :active, namespace: 'alarm', integration: :custom_validation)
+    @alarm_state.event :disable do
+      transition active: :off
+    end
+
+    @object = @klass.new
+  end
+
+  def test_should_not_invalidate_if_transitions_exist
+    assert @machines.fire_events(@object, :ignite, :disable_alarm)
+    assert_equal [], @object.errors
+  end
+
+  def test_should_invalidate_if_no_transitions_exist
+    @object.state = 'idling'
+    @object.alarm_state = 'off'
+
+    refute @machines.fire_events(@object, :ignite, :disable_alarm)
+    assert_equal ['cannot transition via "ignite"', 'cannot transition via "disable"'], @object.errors
+  end
+
+  def test_should_run_failure_callbacks_if_no_transitions_exist
+    @object.state = 'idling'
+    @object.alarm_state = 'off'
+    @state_failure_run = @alarm_state_failure_run = false
+
+    @machines[:state].after_failure { @state_failure_run = true }
+    @machines[:alarm_state].after_failure { @alarm_state_failure_run = true }
+
+    refute @machines.fire_events(@object, :ignite, :disable_alarm)
+    assert @state_failure_run
+    assert @alarm_state_failure_run
+  end
+
+  def teardown
+    StateMachines::Integrations.reset
+  end
+end

data/test/unit/machine_collection/machine_collection_state_initialization_test.rb

@@ -0,0 +1,101 @@
+require_relative '../../test_helper'
+
+class MachineCollectionStateInitializationTest < StateMachinesTest
+  def setup
+    @machines = StateMachines::MachineCollection.new
+
+    @klass = Class.new
+
+    @machines[:state] = StateMachines::Machine.new(@klass, :state, initial: :parked)
+    @machines[:alarm_state] = StateMachines::Machine.new(@klass, :alarm_state, initial: lambda { |_object| :active })
+    @machines[:alarm_state].state :active, value: lambda { 'active' }
+
+    # Prevent the auto-initialization hook from firing
+    @klass.class_eval do
+      def initialize
+      end
+    end
+
+    @object = @klass.new
+    @object.state = nil
+    @object.alarm_state = nil
+  end
+
+  def test_should_raise_exception_if_invalid_option_specified
+    assert_raises(ArgumentError) { @machines.initialize_states(@object, invalid: true) }
+  end
+
+  def test_should_only_initialize_static_states_prior_to_block
+    @machines.initialize_states(@object) do
+      @state_in_block = @object.state
+      @alarm_state_in_block = @object.alarm_state
+    end
+
+    assert_equal 'parked', @state_in_block
+    assert_nil @alarm_state_in_block
+  end
+
+  def test_should_only_initialize_dynamic_states_after_block
+    @machines.initialize_states(@object) do
+      @alarm_state_in_block = @object.alarm_state
+    end
+
+    assert_nil @alarm_state_in_block
+    assert_equal 'active', @object.alarm_state
+  end
+
+  def test_should_initialize_all_states_without_block
+    @machines.initialize_states(@object)
+
+    assert_equal 'parked', @object.state
+    assert_equal 'active', @object.alarm_state
+  end
+
+  def test_should_skip_static_states_if_disabled
+    @machines.initialize_states(@object, static: false)
+    assert_nil @object.state
+    assert_equal 'active', @object.alarm_state
+  end
+
+  def test_should_not_initialize_existing_static_states_by_default
+    @object.state = 'idling'
+    @machines.initialize_states(@object)
+    assert_equal 'idling', @object.state
+  end
+
+  def test_should_initialize_existing_static_states_if_forced
+    @object.state = 'idling'
+    @machines.initialize_states(@object, static: :force)
+    assert_equal 'parked', @object.state
+  end
+
+  def test_should_not_initialize_existing_static_states_if_not_forced
+    @object.state = 'idling'
+    @machines.initialize_states(@object, static: true)
+    assert_equal 'idling', @object.state
+  end
+
+  def test_should_skip_dynamic_states_if_disabled
+    @machines.initialize_states(@object, dynamic: false)
+    assert_equal 'parked', @object.state
+    assert_nil @object.alarm_state
+  end
+
+  def test_should_not_initialize_existing_dynamic_states_by_default
+    @object.alarm_state = 'inactive'
+    @machines.initialize_states(@object)
+    assert_equal 'inactive', @object.alarm_state
+  end
+
+  def test_should_initialize_existing_dynamic_states_if_forced
+    @object.alarm_state = 'inactive'
+    @machines.initialize_states(@object, dynamic: :force)
+    assert_equal 'active', @object.alarm_state
+  end
+
+  def test_should_not_initialize_existing_dynamic_states_if_not_forced
+    @object.alarm_state = 'inactive'
+    @machines.initialize_states(@object, dynamic: true)
+    assert_equal 'inactive', @object.alarm_state
+  end
+end

data/test/unit/machine_collection/machine_collection_transitions_with_blank_events_test.rb

@@ -0,0 +1,25 @@
+require_relative '../../test_helper'
+
+class MachineCollectionTransitionsWithBlankEventsTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+
+    @machines = StateMachines::MachineCollection.new
+    @machines[:state] = @machine = StateMachines::Machine.new(@klass, :state, initial: :parked, action: :save)
+    @machine.event :ignite do
+      transition parked: :idling
+    end
+
+    @object = @klass.new
+    @object.state_event = ''
+    @transitions = @machines.transitions(@object, :save)
+  end
+
+  def test_should_be_empty
+    assert @transitions.empty?
+  end
+
+  def test_should_perform
+    assert_equal true, @transitions.perform
+  end
+end

data/test/unit/machine_collection/machine_collection_transitions_with_custom_options_test.rb

@@ -0,0 +1,20 @@
+require_relative '../../test_helper'
+
+class MachineCollectionTransitionsWithCustomOptionsTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+
+    @machines = StateMachines::MachineCollection.new
+    @machines[:state] = @machine = StateMachines::Machine.new(@klass, :state, initial: :parked, action: :save)
+    @machine.event :ignite do
+      transition parked: :idling
+    end
+
+    @object = @klass.new
+    @transitions = @machines.transitions(@object, :save, after: false)
+  end
+
+  def test_should_use_custom_options
+    assert @transitions.skip_after
+  end
+end

data/test/unit/machine_collection/machine_collection_transitions_with_different_actions_test.rb

@@ -0,0 +1,26 @@
+require_relative '../../test_helper'
+
+class MachineCollectionTransitionsWithDifferentActionsTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+
+    @machines = StateMachines::MachineCollection.new
+    @machines[:state] = @state = StateMachines::Machine.new(@klass, :state, initial: :parked, action: :save)
+    @state.event :ignite do
+      transition parked: :idling
+    end
+    @machines[:status] = @status = StateMachines::Machine.new(@klass, :status, initial: :first_gear, action: :persist)
+    @status.event :shift_up do
+      transition first_gear: :second_gear
+    end
+
+    @object = @klass.new
+    @object.state_event = 'ignite'
+    @object.status_event = 'shift_up'
+    @transitions = @machines.transitions(@object, :save)
+  end
+
+  def test_should_only_select_matching_actions
+    assert_equal 1, @transitions.length
+  end
+end

data/test/unit/machine_collection/machine_collection_transitions_with_exisiting_transitions_test.rb

@@ -0,0 +1,25 @@
+require_relative '../../test_helper'
+
+class MachineCollectionTransitionsWithExisitingTransitionsTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+
+    @machines = StateMachines::MachineCollection.new
+    @machines[:state] = @machine = StateMachines::Machine.new(@klass, :state, initial: :parked, action: :save)
+    @machine.event :ignite do
+      transition parked: :idling
+    end
+
+    @object = @klass.new
+    @object.send(:state_event_transition=, StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling))
+    @transitions = @machines.transitions(@object, :save)
+  end
+
+  def test_should_not_be_empty
+    assert_equal 1, @transitions.length
+  end
+
+  def test_should_perform
+    assert_equal true, @transitions.perform
+  end
+end

data/test/unit/machine_collection/machine_collection_transitions_with_invalid_events_test.rb

@@ -0,0 +1,25 @@
+require_relative '../../test_helper'
+
+class MachineCollectionTransitionsWithInvalidEventsTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+
+    @machines = StateMachines::MachineCollection.new
+    @machines[:state] = @machine = StateMachines::Machine.new(@klass, :state, initial: :parked, action: :save)
+    @machine.event :ignite do
+      transition parked: :idling
+    end
+
+    @object = @klass.new
+    @object.state_event = 'invalid'
+    @transitions = @machines.transitions(@object, :save)
+  end
+
+  def test_should_be_empty
+    assert @transitions.empty?
+  end
+
+  def test_should_not_perform
+    assert_equal false, @transitions.perform
+  end
+end

data/test/unit/machine_collection/machine_collection_transitions_with_same_actions_test.rb

@@ -0,0 +1,31 @@
+require_relative '../../test_helper'
+
+class MachineCollectionTransitionsWithSameActionsTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+
+    @machines = StateMachines::MachineCollection.new
+    @machines[:state] = @machine = StateMachines::Machine.new(@klass, :state, initial: :parked, action: :save)
+    @machine.event :ignite do
+      transition parked: :idling
+    end
+    @machines[:status] = @machine = StateMachines::Machine.new(@klass, :status, initial: :first_gear, action: :save)
+    @machine.event :shift_up do
+      transition first_gear: :second_gear
+    end
+
+    @object = @klass.new
+    @object.state_event = 'ignite'
+    @object.status_event = 'shift_up'
+    @transitions = @machines.transitions(@object, :save)
+  end
+
+  def test_should_not_be_empty
+    assert_equal 2, @transitions.length
+  end
+
+  def test_should_perform
+    assert_equal true, @transitions.perform
+  end
+end
+

data/test/unit/machine_collection/machine_collection_transitions_with_transition_test.rb

@@ -0,0 +1,26 @@
+require_relative '../../test_helper'
+
+class MachineCollectionTransitionsWithTransitionTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+
+    @machines = StateMachines::MachineCollection.new
+    @machines[:state] = @machine = StateMachines::Machine.new(@klass, :state, initial: :parked, action: :save)
+    @machine.event :ignite do
+      transition parked: :idling
+    end
+
+    @object = @klass.new
+    @object.state_event = 'ignite'
+    @transitions = @machines.transitions(@object, :save)
+  end
+
+  def test_should_not_be_empty
+    assert_equal 1, @transitions.length
+  end
+
+  def test_should_perform
+    assert_equal true, @transitions.perform
+  end
+end
+

data/test/unit/machine_collection/machine_collection_transitions_without_events_test.rb

@@ -0,0 +1,25 @@
+require_relative '../../test_helper'
+
+class MachineCollectionTransitionsWithoutEventsTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+
+    @machines = StateMachines::MachineCollection.new
+    @machines[:state] = @machine = StateMachines::Machine.new(@klass, :state, initial: :parked, action: :save)
+    @machine.event :ignite do
+      transition parked: :idling
+    end
+
+    @object = @klass.new
+    @object.state_event = nil
+    @transitions = @machines.transitions(@object, :save)
+  end
+
+  def test_should_be_empty
+    assert @transitions.empty?
+  end
+
+  def test_should_perform
+    assert_equal true, @transitions.perform
+  end
+end

data/test/unit/machine_collection/machine_collection_transitions_without_transition_test.rb

@@ -0,0 +1,27 @@
+require_relative '../../test_helper'
+
+class MachineCollectionTransitionsWithoutTransitionTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+
+    @machines = StateMachines::MachineCollection.new
+    @machines[:state] = @machine = StateMachines::Machine.new(@klass, :state, initial: :parked, action: :save)
+    @machine.event :ignite do
+      transition parked: :idling
+    end
+
+    @object = @klass.new
+    @object.state = 'idling'
+    @object.state_event = 'ignite'
+    @transitions = @machines.transitions(@object, :save)
+  end
+
+  def test_should_be_empty
+    assert @transitions.empty?
+  end
+
+  def test_should_not_perform
+    assert_equal false, @transitions.perform
+  end
+end
+

data/test/unit/matcher/all_matcher_test.rb

@@ -0,0 +1,29 @@
+require_relative '../../test_helper'
+
+class AllMatcherTest < StateMachinesTest
+  def setup
+    @matcher = StateMachines::AllMatcher.instance
+  end
+
+  def test_should_have_no_values
+    assert_equal [], @matcher.values
+  end
+
+  def test_should_always_match
+    [nil, :parked, :idling].each { |value| assert @matcher.matches?(value) }
+  end
+
+  def test_should_not_filter_any_values
+    assert_equal [:parked, :idling], @matcher.filter([:parked, :idling])
+  end
+
+  def test_should_generate_blacklist_matcher_after_subtraction
+    matcher = @matcher - [:parked, :idling]
+    assert_instance_of StateMachines::BlacklistMatcher, matcher
+    assert_equal [:parked, :idling], matcher.values
+  end
+
+  def test_should_have_a_description
+    assert_equal 'all', @matcher.description
+  end
+end

data/test/unit/matcher/blacklist_matcher_test.rb

@@ -0,0 +1,30 @@
+require_relative '../../test_helper'
+
+class BlacklistMatcherTest < StateMachinesTest
+  def setup
+    @matcher = StateMachines::BlacklistMatcher.new([:parked, :idling])
+  end
+
+  def test_should_have_values
+    assert_equal [:parked, :idling], @matcher.values
+  end
+
+  def test_should_filter_known_values
+    assert_equal [:first_gear], @matcher.filter([:parked, :idling, :first_gear])
+  end
+
+  def test_should_match_unknown_values
+    assert @matcher.matches?(:first_gear)
+  end
+
+  def test_should_not_match_known_values
+    refute @matcher.matches?(:parked)
+  end
+
+  def test_should_have_a_description
+    assert_equal 'all - [:parked, :idling]', @matcher.description
+
+    matcher = StateMachines::BlacklistMatcher.new([:parked])
+    assert_equal 'all - :parked', matcher.description
+  end
+end