state_machines 0.0.2 → 0.1.0

data/test/unit/event_collection/event_collection_attribute_with_machine_action_test.rb

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

data/test/unit/event_collection/event_collection_attribute_with_namespaced_machine_test.rb

@@ -0,0 +1,36 @@
+require_relative '../../test_helper'
+
+class EventCollectionAttributeWithNamespacedMachineTest < StateMachinesTest
+  def setup
+    @klass = Class.new do
+      def save
+      end
+    end
+
+    @machine = StateMachines::Machine.new(@klass, namespace: 'alarm', initial: :active, action: :save)
+    @events = StateMachines::EventCollection.new(@machine)
+
+    @machine.state :active, :off
+    @events << @disable = StateMachines::Event.new(@machine, :disable)
+    @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_invalid_transition_if_event_cannot_be_fired
+    @object.state_event = 'disable'
+    assert_equal false, @events.attribute_transition_for(@object)
+  end
+
+  def test_should_have_valid_transition_if_event_can_be_fired
+    @disable.transition active: :off
+    @object.state_event = 'disable'
+
+    assert_instance_of StateMachines::Transition, @events.attribute_transition_for(@object)
+  end
+end

data/test/unit/event_collection/event_collection_by_default_test.rb

@@ -0,0 +1,26 @@
+require_relative '../../test_helper'
+
+class EventCollectionByDefaultTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass)
+    @events = StateMachines::EventCollection.new(@machine)
+    @object = @klass.new
+  end
+
+  def test_should_not_have_any_nodes
+    assert_equal 0, @events.length
+  end
+
+  def test_should_have_a_machine
+    assert_equal @machine, @events.machine
+  end
+
+  def test_should_not_have_any_valid_events_for_an_object
+    assert @events.valid_for(@object).empty?
+  end
+
+  def test_should_not_have_any_transitions_for_an_object
+    assert @events.transitions_for(@object).empty?
+  end
+end

data/test/unit/event_collection/event_collection_test.rb

@@ -0,0 +1,39 @@
+require_relative '../../test_helper'
+
+class EventCollectionTest < 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_string_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_string_qualified_name
+    assert_equal @open, @events['enable_alarm', :qualified_name]
+  end
+end
+
+
+
+
+
+
+
+

data/test/unit/event_collection/event_collection_with_custom_machine_attribute_test.rb

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

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

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

@@ -0,0 +1,75 @@
+require_relative '../../test_helper'
+
+class EventCollectionWithValidationsTest < 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
+
+    @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
+    StateMachines::Integrations.send(:remove_const, 'Custom')
+  end
+end
+

data/test/unit/event_collection/event_collection_without_machine_action_test.rb

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

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

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

@@ -0,0 +1,16 @@
+require_relative '../../test_helper'
+
+class IntegrationFinderTest < StateMachinesTest
+  def setup
+    StateMachines::Integrations.reset
+  end
+
+  def test_should_find_base
+    assert_equal StateMachines::Integrations::Base, StateMachines::Integrations.find_by_name(:base)
+  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. Valid integrations are: base ', exception.message
+  end
+end

data/test/unit/integrations/integration_matcher_test.rb

@@ -0,0 +1,27 @@
+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
+    assert_nil StateMachines::Integrations.match_ancestors(['Fake'])
+  end
+
+  def test_should_return_integration_class_if_match_found_with_ancestors
+    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

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

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

@@ -0,0 +1,47 @@
+require_relative '../../test_helper'
+
+class InvalidTransitionWithIntegrationTest < StateMachinesTest
+  def setup
+    StateMachines::Integrations.const_set('Custom', Module.new do
+                                                    include StateMachines::Integrations::Base
+
+                                                    def errors_for(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
+    @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
+    StateMachines::Integrations.send(:remove_const, 'Custom')
+  end
+end

data/test/unit/invalid_transition/invalid_transition_with_namespace_test.rb

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