state_machines 0.5.0 → 0.10.0

data/test/unit/event_collection/event_collection_with_custom_machine_attribute_test.rb

@@ -1,31 +0,0 @@
-require_relative '../../test_helper'
-
-class EventCollectionWithCustomMachineAttributeTest < StateMachinesTest
-  def setup
-    @klass = Class.new do
-      def save
-      end
-    end
-
-    @machine = StateMachines::Machine.new(@klass, :state, attribute: :state_id, 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_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
-end

data/test/unit/event_collection/event_collection_with_events_with_transitions_test.rb

@@ -1,76 +0,0 @@
-require_relative '../../test_helper'
-
-class EventCollectionWithEventsWithTransitionsTest < StateMachinesTest
-  def setup
-    @klass = Class.new
-    @machine = StateMachines::Machine.new(@klass, initial: :parked)
-    @events = StateMachines::EventCollection.new(@machine)
-
-    @machine.state :idling, :first_gear
-
-    @events << @ignite = StateMachines::Event.new(@machine, :ignite)
-    @ignite.transition parked: :idling
-
-    @events << @park = StateMachines::Event.new(@machine, :park)
-    @park.transition idling: :parked
-
-    @events << @shift_up = StateMachines::Event.new(@machine, :shift_up)
-    @shift_up.transition parked: :first_gear
-    @shift_up.transition idling: :first_gear, if: lambda { false }
-
-    @machine.events.concat(@events)
-
-    @object = @klass.new
-  end
-
-  def test_should_find_valid_events_based_on_current_state
-    assert_equal [@ignite, @shift_up], @events.valid_for(@object)
-  end
-
-  def test_should_filter_valid_events_by_from_state
-    assert_equal [@park], @events.valid_for(@object, from: :idling)
-  end
-
-  def test_should_filter_valid_events_by_to_state
-    assert_equal [@shift_up], @events.valid_for(@object, to: :first_gear)
-  end
-
-  def test_should_filter_valid_events_by_event
-    assert_equal [@ignite], @events.valid_for(@object, on: :ignite)
-  end
-
-  def test_should_filter_valid_events_by_multiple_requirements
-    assert_equal [], @events.valid_for(@object, from: :idling, to: :first_gear)
-  end
-
-  def test_should_allow_finding_valid_events_without_guards
-    assert_equal [@shift_up], @events.valid_for(@object, from: :idling, to: :first_gear, guard: false)
-  end
-
-  def test_should_find_valid_transitions_based_on_current_state
-    assert_equal [
-                     StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling),
-                     StateMachines::Transition.new(@object, @machine, :shift_up, :parked, :first_gear)
-                 ], @events.transitions_for(@object)
-  end
-
-  def test_should_filter_valid_transitions_by_from_state
-    assert_equal [StateMachines::Transition.new(@object, @machine, :park, :idling, :parked)], @events.transitions_for(@object, from: :idling)
-  end
-
-  def test_should_filter_valid_transitions_by_to_state
-    assert_equal [StateMachines::Transition.new(@object, @machine, :shift_up, :parked, :first_gear)], @events.transitions_for(@object, to: :first_gear)
-  end
-
-  def test_should_filter_valid_transitions_by_event
-    assert_equal [StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling)], @events.transitions_for(@object, on: :ignite)
-  end
-
-  def test_should_filter_valid_transitions_by_multiple_requirements
-    assert_equal [], @events.transitions_for(@object, from: :idling, to: :first_gear)
-  end
-
-  def test_should_allow_finding_valid_transitions_without_guards
-    assert_equal [StateMachines::Transition.new(@object, @machine, :shift_up, :idling, :first_gear)], @events.transitions_for(@object, from: :idling, to: :first_gear, guard: false)
-  end
-end

data/test/unit/event_collection/event_collection_with_multiple_events_test.rb

@@ -1,27 +0,0 @@
-require_relative '../../test_helper'
-
-class EventCollectionWithMultipleEventsTest < StateMachinesTest
-  def setup
-    @klass = Class.new
-    @machine = StateMachines::Machine.new(@klass, initial: :parked)
-    @events = StateMachines::EventCollection.new(@machine)
-
-    @machine.state :first_gear
-    @park, @shift_down = @machine.event :park, :shift_down
-
-    @events << @park
-    @park.transition first_gear: :parked
-
-    @events << @shift_down
-    @shift_down.transition first_gear: :parked
-
-    @machine.events.concat(@events)
-  end
-
-  def test_should_only_include_all_valid_events_for_an_object
-    object = @klass.new
-    object.state = 'first_gear'
-    assert_equal [@park, @shift_down], @events.valid_for(object)
-  end
-end
-

data/test/unit/event_collection/event_collection_with_validations_test.rb

@@ -1,74 +0,0 @@
-require_relative '../../test_helper'
-
-class EventCollectionWithValidationsTest < 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(EventCollectionWithValidationsTest::Custom)
-
-    @klass = Class.new do
-      attr_accessor :errors
-
-      def initialize
-        @errors = []
-        super
-      end
-    end
-
-    @machine = StateMachines::Machine.new(@klass, initial: :parked, action: :save, integration: :custom)
-    @events = StateMachines::EventCollection.new(@machine)
-
-    @parked, @idling = @machine.state :parked, :idling
-    @events << @ignite = StateMachines::Event.new(@machine, :ignite)
-    @machine.events.concat(@events)
-
-    @object = @klass.new
-  end
-
-  def test_should_invalidate_if_invalid_event_specified
-    @object.state_event = 'invalid'
-    @events.attribute_transition_for(@object, true)
-
-    assert_equal ['is invalid'], @object.errors
-  end
-
-  def test_should_invalidate_if_event_cannot_be_fired
-    @object.state = 'idling'
-    @object.state_event = 'ignite'
-    @events.attribute_transition_for(@object, true)
-
-    assert_equal ['cannot transition when idling'], @object.errors
-  end
-
-  def test_should_invalidate_with_human_name_if_invalid_event_specified
-    @idling.human_name = 'waiting'
-    @object.state = 'idling'
-    @object.state_event = 'ignite'
-    @events.attribute_transition_for(@object, true)
-
-    assert_equal ['cannot transition when waiting'], @object.errors
-  end
-
-  def test_should_not_invalidate_event_can_be_fired
-    @ignite.transition parked: :idling
-    @object.state_event = 'ignite'
-    @events.attribute_transition_for(@object, true)
-
-    assert_equal [], @object.errors
-  end
-
-  def teardown
-    StateMachines::Integrations.reset
-  end
-end
-

data/test/unit/event_collection/event_collection_without_machine_action_test.rb

@@ -1,18 +0,0 @@
-require_relative '../../test_helper'
-
-class EventCollectionWithoutMachineActionTest < StateMachinesTest
-  def setup
-    @klass = Class.new
-    @machine = StateMachines::Machine.new(@klass, initial: :parked)
-    @events = StateMachines::EventCollection.new(@machine)
-    @events << StateMachines::Event.new(@machine, :ignite)
-    @machine.events.concat(@events)
-
-    @object = @klass.new
-  end
-
-  def test_should_not_have_an_attribute_transition
-    assert_nil @events.attribute_transition_for(@object)
-  end
-end
-

data/test/unit/event_collection/event_string_collection_test.rb

@@ -1,31 +0,0 @@
-require_relative '../../test_helper'
-
-class EventStringCollectionTest < StateMachinesTest
-  def setup
-    machine = StateMachines::Machine.new(Class.new, namespace: 'alarm')
-    @events = StateMachines::EventCollection.new(machine)
-
-    @events << @open = StateMachines::Event.new(machine, 'enable')
-    machine.events.concat(@events)
-  end
-
-  def test_should_index_by_name
-    assert_equal @open, @events['enable', :name]
-  end
-
-  def test_should_index_by_name_by_default
-    assert_equal @open, @events['enable']
-  end
-
-  def test_should_index_by_symbol_name
-    assert_equal @open, @events[:enable]
-  end
-
-  def test_should_index_by_qualified_name
-    assert_equal @open, @events['enable_alarm', :qualified_name]
-  end
-
-  def test_should_index_by_symbol_qualified_name
-    assert_equal @open, @events[:enable_alarm, :qualified_name]
-  end
-end

data/test/unit/helper_module_test.rb

@@ -1,17 +0,0 @@
-require_relative '../test_helper'
-
-class HelperModuleTest < StateMachinesTest
-  def setup
-    @klass = Class.new
-    @machine = StateMachines::Machine.new(@klass)
-    @helper_module = StateMachines::HelperModule.new(@machine, :instance)
-  end
-
-  def test_should_not_have_a_name
-    assert_equal '', @helper_module.name.to_s
-  end
-
-  def test_should_provide_human_readable_to_s
-    assert_equal "#{@klass} :state instance helpers", @helper_module.to_s
-  end
-end

data/test/unit/integrations/integration_finder_test.rb

@@ -1,16 +0,0 @@
-require_relative '../../test_helper'
-
-class IntegrationFinderTest < StateMachinesTest
-  def setup
-    StateMachines::Integrations.reset
-  end
-
-  def test_should_raise_an_exception_if_invalid
-    exception = assert_raises(StateMachines::IntegrationNotFound) { StateMachines::Integrations.find_by_name(:invalid) }
-    assert_equal ':invalid is an invalid integration. No integrations registered', exception.message
-  end
-
-  def test_should_have_no_integrations
-    assert_equal([], StateMachines::Integrations.list)
-  end
-end

data/test/unit/integrations/integration_matcher_test.rb

@@ -1,29 +0,0 @@
-require_relative '../../test_helper'
-require_relative '../../files/models/vehicle'
-require_relative '../../files/integrations/vehicle'
-
-class IntegrationMatcherTest < StateMachinesTest
-  def setup
-    StateMachines::Integrations.reset
-  end
-
-  def test_should_return_nil_if_no_match_found
-    assert_nil StateMachines::Integrations.match(Vehicle)
-  end
-
-  def test_should_return_integration_class_if_match_found
-    StateMachines::Integrations.register(VehicleIntegration)
-    assert_equal VehicleIntegration, StateMachines::Integrations.match(Vehicle)
-  end
-
-  def test_should_return_nil_if_no_match_found_with_ancestors
-    fake = Class.new
-    assert_nil StateMachines::Integrations.match_ancestors([fake])
-  end
-
-  def test_should_return_integration_class_if_match_found_with_ancestors
-    fake = Class.new
-    StateMachines::Integrations.register(VehicleIntegration)
-    assert_equal VehicleIntegration, StateMachines::Integrations.match_ancestors([fake, Vehicle])
-  end
-end

data/test/unit/invalid_transition/invalid_parallel_transition_test.rb

@@ -1,18 +0,0 @@
-require_relative '../../test_helper'
-
-class InvalidParallelTransitionTest < StateMachinesTest
-  def setup
-    @object = Object.new
-    @events = [:ignite, :disable_alarm]
-
-    @invalid_transition = StateMachines::InvalidParallelTransition.new(@object, @events)
-  end
-
-  def test_should_have_an_object
-    assert_equal @object, @invalid_transition.object
-  end
-
-  def test_should_have_events
-    assert_equal @events, @invalid_transition.events
-  end
-end

data/test/unit/invalid_transition/invalid_transition_test.rb

@@ -1,47 +0,0 @@
-require_relative '../../test_helper'
-
-class InvalidTransitionTest < StateMachinesTest
-  def setup
-    @klass = Class.new
-    @machine = StateMachines::Machine.new(@klass)
-    @state = @machine.state :parked
-    @machine.event :ignite
-
-    @object = @klass.new
-    @object.state = 'parked'
-
-    @invalid_transition = StateMachines::InvalidTransition.new(@object, @machine, :ignite)
-  end
-
-  def test_should_have_an_object
-    assert_equal @object, @invalid_transition.object
-  end
-
-  def test_should_have_a_machine
-    assert_equal @machine, @invalid_transition.machine
-  end
-
-  def test_should_have_an_event
-    assert_equal :ignite, @invalid_transition.event
-  end
-
-  def test_should_have_a_qualified_event
-    assert_equal :ignite, @invalid_transition.qualified_event
-  end
-
-  def test_should_have_a_from_value
-    assert_equal 'parked', @invalid_transition.from
-  end
-
-  def test_should_have_a_from_name
-    assert_equal :parked, @invalid_transition.from_name
-  end
-
-  def test_should_have_a_qualified_from_name
-    assert_equal :parked, @invalid_transition.qualified_from_name
-  end
-
-  def test_should_generate_a_message
-    assert_equal 'Cannot transition state via :ignite from :parked', @invalid_transition.message
-  end
-end

data/test/unit/invalid_transition/invalid_transition_with_integration_test.rb

@@ -1,45 +0,0 @@
-require_relative '../../test_helper'
-
-class InvalidTransitionWithIntegrationTest < StateMachinesTest
-  module Custom
-    include StateMachines::Integrations::Base
-
-    def errors_for(object)
-      object.errors
-    end
-  end
-
-  def setup
-    StateMachines::Integrations.register(InvalidTransitionWithIntegrationTest::Custom)
-
-    @klass = Class.new do
-      attr_accessor :errors
-    end
-    @machine = StateMachines::Machine.new(@klass, integration: :custom)
-    @machine.state :parked
-    @machine.event :ignite
-
-    @object = @klass.new
-    @object.state = 'parked'
-  end
-
-  def fix_test
-    skip
-  end
-
-  def test_should_generate_a_message_without_reasons_if_empty
-    @object.errors = ''
-    invalid_transition = StateMachines::InvalidTransition.new(@object, @machine, :ignite)
-    assert_equal 'Cannot transition state via :ignite from :parked', invalid_transition.message
-  end
-
-  def test_should_generate_a_message_with_error_reasons_if_errors_found
-    @object.errors = 'Id is invalid, Name is invalid'
-    invalid_transition = StateMachines::InvalidTransition.new(@object, @machine, :ignite)
-    assert_equal 'Cannot transition state via :ignite from :parked (Reason(s): Id is invalid, Name is invalid)', invalid_transition.message
-  end
-
-  def teardown
-    StateMachines::Integrations.reset
-  end
-end

data/test/unit/invalid_transition/invalid_transition_with_namespace_test.rb

@@ -1,32 +0,0 @@
-require_relative '../../test_helper'
-
-class InvalidTransitionWithNamespaceTest < StateMachinesTest
-  def setup
-    @klass = Class.new
-    @machine = StateMachines::Machine.new(@klass, namespace: 'alarm')
-    @state = @machine.state :active
-    @machine.event :disable
-
-    @object = @klass.new
-    @object.state = 'active'
-
-    @invalid_transition = StateMachines::InvalidTransition.new(@object, @machine, :disable)
-  end
-
-  def test_should_have_an_event
-    assert_equal :disable, @invalid_transition.event
-  end
-
-  def test_should_have_a_qualified_event
-    assert_equal :disable_alarm, @invalid_transition.qualified_event
-  end
-
-  def test_should_have_a_from_name
-    assert_equal :active, @invalid_transition.from_name
-  end
-
-  def test_should_have_a_qualified_from_name
-    assert_equal :alarm_active, @invalid_transition.qualified_from_name
-  end
-end
-

data/test/unit/machine/machine_after_being_copied_test.rb

@@ -1,62 +0,0 @@
-require_relative '../../test_helper'
-
-class MachineAfterBeingCopiedTest < StateMachinesTest
-  def setup
-    @machine = StateMachines::Machine.new(Class.new, :state, initial: :parked)
-    @machine.event(:ignite) {}
-    @machine.before_transition(lambda {})
-    @machine.after_transition(lambda {})
-    @machine.around_transition(lambda {})
-    @machine.after_failure(lambda {})
-
-    @copied_machine = @machine.clone
-  end
-
-  def test_should_not_have_the_same_collection_of_states
-    refute_same @copied_machine.states, @machine.states
-  end
-
-  def test_should_copy_each_state
-    refute_same @copied_machine.states[:parked], @machine.states[:parked]
-  end
-
-  def test_should_update_machine_for_each_state
-    assert_equal @copied_machine, @copied_machine.states[:parked].machine
-  end
-
-  def test_should_not_update_machine_for_original_state
-    assert_equal @machine, @machine.states[:parked].machine
-  end
-
-  def test_should_not_have_the_same_collection_of_events
-    refute_same @copied_machine.events, @machine.events
-  end
-
-  def test_should_copy_each_event
-    refute_same @copied_machine.events[:ignite], @machine.events[:ignite]
-  end
-
-  def test_should_update_machine_for_each_event
-    assert_equal @copied_machine, @copied_machine.events[:ignite].machine
-  end
-
-  def test_should_not_update_machine_for_original_event
-    assert_equal @machine, @machine.events[:ignite].machine
-  end
-
-  def test_should_not_have_the_same_callbacks
-    refute_same @copied_machine.callbacks, @machine.callbacks
-  end
-
-  def test_should_not_have_the_same_before_callbacks
-    refute_same @copied_machine.callbacks[:before], @machine.callbacks[:before]
-  end
-
-  def test_should_not_have_the_same_after_callbacks
-    refute_same @copied_machine.callbacks[:after], @machine.callbacks[:after]
-  end
-
-  def test_should_not_have_the_same_failure_callbacks
-    refute_same @copied_machine.callbacks[:failure], @machine.callbacks[:failure]
-  end
-end

data/test/unit/machine/machine_after_changing_initial_state.rb

@@ -1,28 +0,0 @@
-require_relative '../../test_helper'
-
-class MachineAfterChangingInitialState < StateMachinesTest
-  def setup
-    @klass = Class.new
-    @machine = StateMachines::Machine.new(@klass, initial: :parked)
-    @machine.initial_state = :idling
-
-    @object = @klass.new
-  end
-
-  def test_should_change_the_initial_state
-    assert_equal :idling, @machine.initial_state(@object).name
-  end
-
-  def test_should_include_in_known_states
-    assert_equal [:parked, :idling], @machine.states.map { |state| state.name }
-  end
-
-  def test_should_reset_original_initial_state
-    refute @machine.state(:parked).initial
-  end
-
-  def test_should_set_new_state_to_initial
-    assert @machine.state(:idling).initial
-  end
-end
-

data/test/unit/machine/machine_after_changing_owner_class_test.rb

@@ -1,31 +0,0 @@
-require_relative '../../test_helper'
-
-class MachineAfterChangingOwnerClassTest < StateMachinesTest
-  def setup
-    @original_class = Class.new
-    @machine = StateMachines::Machine.new(@original_class)
-
-    @new_class = Class.new(@original_class)
-    @new_machine = @machine.clone
-    @new_machine.owner_class = @new_class
-
-    @object = @new_class.new
-  end
-
-  def test_should_update_owner_class
-    assert_equal @new_class, @new_machine.owner_class
-  end
-
-  def test_should_not_change_original_owner_class
-    assert_equal @original_class, @machine.owner_class
-  end
-
-  def test_should_change_the_associated_machine_in_the_new_class
-    assert_equal @new_machine, @new_class.state_machines[:state]
-  end
-
-  def test_should_not_change_the_associated_machine_in_the_original_class
-    assert_equal @machine, @original_class.state_machines[:state]
-  end
-end
-