state_machines 0.4.0 → 0.6.0

data/test/unit/machine_collection/machine_collection_fire_test.rb

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

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

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

@@ -1,111 +0,0 @@
-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: ->(_object) { :active })
-    @machines[:alarm_state].state :active, value: -> { '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_initialize_static_states_after_block
-    @machines.initialize_states(@object) do
-      @state_in_block = @object.state
-      @alarm_state_in_block = @object.alarm_state
-    end
-
-    assert_nil @state_in_block
-    assert_nil @alarm_state_in_block
-  end
-
-  def test_should_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_initialize_existing_static_states_by_default
-    @object.state = 'idling'
-    @machines.initialize_states(@object)
-    assert_equal 'parked', @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_initialize_existing_static_states_if_not_forced
-    @object.state = 'idling'
-    @machines.initialize_states(@object, static: true)
-    assert_equal 'parked', @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
-
-  def test_shouldnt_force_state_given_either_as_string_or_symbol
-    @object.state = 'notparked'
-
-    @machines.initialize_states(@object, {}, { state: "parked" })
-    assert_equal 'notparked', @object.state
-
-    @machines.initialize_states(@object, {}, { "state" => "parked" })
-    assert_equal 'notparked', @object.state
-  end
-end

data/test/unit/machine_collection/machine_collection_transitions_with_blank_events_test.rb

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

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

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

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

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

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

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

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

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

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

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

data/test/unit/matcher/loopback_matcher_test.rb

@@ -1,27 +0,0 @@
-require_relative '../../test_helper'
-
-class LoopbackMatcherTest < StateMachinesTest
-  def setup
-    @matcher = StateMachines::LoopbackMatcher.instance
-  end
-
-  def test_should_have_no_values
-    assert_equal [], @matcher.values
-  end
-
-  def test_should_filter_all_values
-    assert_equal [], @matcher.filter([:parked, :idling])
-  end
-
-  def test_should_match_if_from_context_is_same
-    assert @matcher.matches?(:parked, from: :parked)
-  end
-
-  def test_should_not_match_if_from_context_is_different
-    refute @matcher.matches?(:parked, from: :idling)
-  end
-
-  def test_should_have_a_description
-    assert_equal 'same', @matcher.description
-  end
-end

data/test/unit/matcher/matcher_by_default_test.rb

@@ -1,15 +0,0 @@
-require_relative '../../test_helper'
-
-class MatcherByDefaultTest < StateMachinesTest
-  def setup
-    @matcher = StateMachines::Matcher.new
-  end
-
-  def test_should_have_no_values
-    assert_equal [], @matcher.values
-  end
-
-  def test_should_filter_all_values
-    assert_equal [], @matcher.filter([:parked, :idling])
-  end
-end

data/test/unit/matcher/matcher_with_multiple_values_test.rb

@@ -1,15 +0,0 @@
-require_relative '../../test_helper'
-
-class MatcherWithMultipleValuesTest < StateMachinesTest
-  def setup
-    @matcher = StateMachines::Matcher.new([:parked, :idling])
-  end
-
-  def test_should_have_values
-    assert_equal [:parked, :idling], @matcher.values
-  end
-
-  def test_should_filter_unknown_values
-    assert_equal [:parked], @matcher.filter([:parked, :first_gear])
-  end
-end