state_machines 0.0.2 → 0.1.0

data/test/unit/machine/machine_with_custom_attribute_test.rb

@@ -0,0 +1,103 @@
+require_relative '../../test_helper'
+
+module MachineWithCustomAttributeIntegration
+  include StateMachines::Integrations::Base
+
+  def self.integration_name
+    :custom_attribute
+  end
+
+  @defaults = { action: :save, use_transactions: false }
+
+  def create_with_scope(_name)
+    -> {}
+  end
+
+  def create_without_scope(_name)
+    -> {}
+  end
+end
+
+class MachineWithCustomAttributeTest < StateMachinesTest
+  def setup
+    StateMachines::Integrations.register(MachineWithCustomAttributeIntegration)
+
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass, :state, attribute: :state_id, initial: :active, integration: :custom_attribute) do
+      event :ignite do
+        transition parked: :idling
+      end
+    end
+    @object = @klass.new
+  end
+
+  def test_should_define_a_reader_attribute_for_the_attribute
+    assert @object.respond_to?(:state_id)
+  end
+
+  def test_should_define_a_writer_attribute_for_the_attribute
+    assert @object.respond_to?(:state_id=)
+  end
+
+  def test_should_define_a_predicate_for_the_attribute
+    assert @object.respond_to?(:state?)
+  end
+
+  def test_should_define_a_name_reader_for_the_attribute
+    assert @object.respond_to?(:state_name)
+  end
+
+  def test_should_define_a_human_name_reader_for_the_attribute
+    assert @object.respond_to?(:state_name)
+  end
+
+  def test_should_define_an_event_reader_for_the_attribute
+    assert @object.respond_to?(:state_events)
+  end
+
+  def test_should_define_a_transition_reader_for_the_attribute
+    assert @object.respond_to?(:state_transitions)
+  end
+
+  def test_should_define_a_path_reader_for_the_attribute
+    assert @object.respond_to?(:state_paths)
+  end
+
+  def test_should_define_an_event_runner_for_the_attribute
+    assert @object.respond_to?(:fire_state_event)
+  end
+
+  def test_should_define_a_human_attribute_name_reader
+    assert @klass.respond_to?(:human_state_name)
+  end
+
+  def test_should_define_a_human_event_name_reader
+    assert @klass.respond_to?(:human_state_event_name)
+  end
+
+  def test_should_define_singular_with_scope
+    assert @klass.respond_to?(:with_state)
+  end
+
+  def test_should_define_singular_without_scope
+    assert @klass.respond_to?(:without_state)
+  end
+
+  def test_should_define_plural_with_scope
+    assert @klass.respond_to?(:with_states)
+  end
+
+  def test_should_define_plural_without_scope
+    assert @klass.respond_to?(:without_states)
+  end
+
+  def test_should_define_state_machines_reader
+    expected = { state: @machine }
+    assert_equal expected, @klass.state_machines
+  end
+
+  def teardown
+    StateMachines::Integrations.reset
+  end
+end
+

data/test/unit/machine/machine_with_custom_initialize_test.rb

@@ -0,0 +1,24 @@
+require_relative '../../test_helper'
+
+class MachineWithCustomInitializeTest < StateMachinesTest
+  def setup
+    @klass = Class.new do
+      def initialize(state = nil, options = {})
+        @state = state
+        initialize_state_machines(options)
+      end
+    end
+    @machine = StateMachines::Machine.new(@klass, initial: :parked)
+    @object = @klass.new
+  end
+
+  def test_should_initialize_state
+    assert_equal 'parked', @object.state
+  end
+
+  def test_should_allow_custom_options
+    @machine.state :idling
+    @object = @klass.new('idling', static: :force)
+    assert_equal 'parked', @object.state
+  end
+end

data/test/unit/machine/machine_with_custom_integration_test.rb

@@ -0,0 +1,69 @@
+require_relative '../../test_helper'
+require_relative '../../../test/files/models/vehicle'
+
+class MachineWithCustomIntegrationTest < StateMachinesTest
+  def setup
+    StateMachines::Integrations.reset
+    integration = Module.new do
+      include StateMachines::Integrations::Base
+
+      def self.matching_ancestors
+        ['Vehicle']
+      end
+    end
+
+    StateMachines::Integrations.const_set('Custom', integration)
+    StateMachines::Integrations.register(StateMachines::Integrations::Custom)
+
+    @klass = Vehicle
+  end
+
+  def test_should_be_extended_by_the_integration_if_explicit
+    machine = StateMachines::Machine.new(@klass, integration: :custom)
+    assert((class << machine; ancestors; end).include?(StateMachines::Integrations::Custom))
+  end
+
+  def test_should_not_be_extended_by_the_integration_if_implicit_but_not_available
+    StateMachines::Integrations::Custom.class_eval do
+      class << self; remove_method :matching_ancestors; end
+      def self.matching_ancestors
+        []
+      end
+    end
+
+    machine = StateMachines::Machine.new(@klass)
+    assert(!(class << machine; ancestors; end).include?(StateMachines::Integrations::Custom))
+  end
+
+  def test_should_not_be_extended_by_the_integration_if_implicit_but_not_matched
+    StateMachines::Integrations::Custom.class_eval do
+      class << self; remove_method :matching_ancestors; end
+      def self.matching_ancestors
+        []
+      end
+    end
+
+    machine = StateMachines::Machine.new(@klass)
+    assert(!(class << machine; ancestors; end).include?(StateMachines::Integrations::Custom))
+  end
+
+  def test_should_be_extended_by_the_integration_if_implicit_and_available_and_matches
+    machine = StateMachines::Machine.new(@klass)
+    assert((class << machine; ancestors; end).include?(StateMachines::Integrations::Custom))
+  end
+
+  def test_should_not_be_extended_by_the_integration_if_nil
+    machine = StateMachines::Machine.new(@klass, integration: nil)
+    assert(!(class << machine; ancestors; end).include?(StateMachines::Integrations::Custom))
+  end
+
+  def test_should_not_be_extended_by_the_integration_if_false
+    machine = StateMachines::Machine.new(@klass, integration: false)
+    assert(!(class << machine; ancestors; end).include?(StateMachines::Integrations::Custom))
+  end
+
+  def teardown
+    StateMachines::Integrations.reset
+    StateMachines::Integrations.send(:remove_const, 'Custom')
+  end
+end

data/test/unit/machine/machine_with_custom_invalidation_test.rb

@@ -0,0 +1,40 @@
+require_relative '../../test_helper'
+
+class MachineWithCustomInvalidationTest < StateMachinesTest
+  def setup
+    @integration = Module.new do
+      include StateMachines::Integrations::Base
+
+      def invalidate(object, _attribute, message, values = [])
+        object.error = generate_message(message, values)
+      end
+    end
+    StateMachines::Integrations.const_set('Custom', @integration)
+    StateMachines::Integrations.register(StateMachines::Integrations::Custom)
+
+    @klass = Class.new do
+      attr_accessor :error
+    end
+
+    @machine = StateMachines::Machine.new(@klass, integration: :custom, messages: { invalid_transition: 'cannot %s' })
+    @machine.state :parked
+
+    @object = @klass.new
+    @object.state = 'parked'
+  end
+
+  def test_generate_custom_message
+    assert_equal 'cannot park', @machine.generate_message(:invalid_transition, [[:event, :park]])
+  end
+
+  def test_use_custom_message
+    @machine.invalidate(@object, :state, :invalid_transition, [[:event, 'park']])
+    assert_equal 'cannot park', @object.error
+  end
+
+  def teardown
+    StateMachines::Integrations.reset
+    StateMachines::Integrations.send(:remove_const, 'Custom')
+  end
+end
+

data/test/unit/machine/machine_with_custom_name_test.rb

@@ -0,0 +1,57 @@
+require_relative '../../test_helper'
+
+class MachineWithCustomNameTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass, :status)
+    @object = @klass.new
+  end
+
+  def test_should_use_custom_name
+    assert_equal :status, @machine.name
+  end
+
+  def test_should_use_custom_name_for_attribute
+    assert_equal :status, @machine.attribute
+  end
+
+  def test_should_prefix_custom_attributes_with_custom_name
+    assert_equal :status_event, @machine.attribute(:event)
+  end
+
+  def test_should_define_a_reader_attribute_for_the_attribute
+    assert @object.respond_to?(:status)
+  end
+
+  def test_should_define_a_writer_attribute_for_the_attribute
+    assert @object.respond_to?(:status=)
+  end
+
+  def test_should_define_a_predicate_for_the_attribute
+    assert @object.respond_to?(:status?)
+  end
+
+  def test_should_define_a_name_reader_for_the_attribute
+    assert @object.respond_to?(:status_name)
+  end
+
+  def test_should_define_an_event_reader_for_the_attribute
+    assert @object.respond_to?(:status_events)
+  end
+
+  def test_should_define_a_transition_reader_for_the_attribute
+    assert @object.respond_to?(:status_transitions)
+  end
+
+  def test_should_define_an_event_runner_for_the_attribute
+    assert @object.respond_to?(:fire_status_event)
+  end
+
+  def test_should_define_a_human_attribute_name_reader_for_the_attribute
+    assert @klass.respond_to?(:human_status_name)
+  end
+
+  def test_should_define_a_human_event_name_reader_for_the_attribute
+    assert @klass.respond_to?(:human_status_event_name)
+  end
+end

data/test/unit/machine/machine_with_custom_plural_test.rb

@@ -0,0 +1,53 @@
+require_relative '../../test_helper'
+
+class MachineWithCustomPluralTest < StateMachinesTest
+  def setup
+    StateMachines::Integrations.reset
+    @integration = Module.new do
+      include StateMachines::Integrations::Base
+
+      class << self; attr_accessor :with_scopes, :without_scopes; end
+      @with_scopes = []
+      @without_scopes = []
+
+      def create_with_scope(name)
+        StateMachines::Integrations::Custom.with_scopes << name
+        lambda {}
+      end
+
+      def create_without_scope(name)
+        StateMachines::Integrations::Custom.without_scopes << name
+        lambda {}
+      end
+    end
+
+    StateMachines::Integrations.const_set('Custom', @integration)
+    StateMachines::Integrations.register(StateMachines::Integrations::Custom)
+  end
+
+  def test_should_define_a_singular_and_plural_with_scope
+    StateMachines::Machine.new(Class.new, integration: :custom, plural: 'staties')
+    assert_equal %w(with_state with_staties), @integration.with_scopes
+  end
+
+  def test_should_define_a_singular_and_plural_without_scope
+    StateMachines::Machine.new(Class.new, integration: :custom, plural: 'staties')
+    assert_equal %w(without_state without_staties), @integration.without_scopes
+  end
+
+  def test_should_define_single_with_scope_if_singular_same_as_plural
+    StateMachines::Machine.new(Class.new, integration: :custom, plural: 'state')
+    assert_equal %w(with_state), @integration.with_scopes
+  end
+
+  def test_should_define_single_without_scope_if_singular_same_as_plural
+    StateMachines::Machine.new(Class.new, integration: :custom, plural: 'state')
+    assert_equal %w(without_state), @integration.without_scopes
+  end
+
+  def teardown
+    StateMachines::Integrations.reset
+    StateMachines::Integrations.send(:remove_const, 'Custom')
+  end
+end
+

data/test/unit/machine/machine_with_dynamic_initial_state_test.rb

@@ -0,0 +1,65 @@
+require_relative '../../test_helper'
+
+class MachineWithDynamicInitialStateTest < StateMachinesTest
+  def setup
+    @klass = Class.new do
+      attr_accessor :initial_state
+    end
+    @machine = StateMachines::Machine.new(@klass, initial: lambda { |object| object.initial_state || :default })
+    @machine.state :parked, :idling, :default
+    @object = @klass.new
+  end
+
+  def test_should_have_dynamic_initial_state
+    assert @machine.dynamic_initial_state?
+  end
+
+  def test_should_use_the_record_for_determining_the_initial_state
+    @object.initial_state = :parked
+    assert_equal :parked, @machine.initial_state(@object).name
+
+    @object.initial_state = :idling
+    assert_equal :idling, @machine.initial_state(@object).name
+  end
+
+  def test_should_write_to_attribute_when_initializing_state
+    object = @klass.allocate
+    object.initial_state = :parked
+    @machine.initialize_state(object)
+    assert_equal 'parked', object.state
+  end
+
+  def test_should_set_initial_state_on_created_object
+    assert_equal 'default', @object.state
+  end
+
+  def test_should_not_set_initial_state_even_if_not_empty
+    @klass.class_eval do
+      def initialize(_attributes = {})
+        self.state = 'parked'
+        super()
+      end
+    end
+    object = @klass.new
+    assert_equal 'parked', object.state
+  end
+
+  def test_should_set_initial_state_after_initialization
+    base = Class.new do
+      attr_accessor :state_on_init
+
+      def initialize
+        self.state_on_init = state
+      end
+    end
+    klass = Class.new(base)
+    machine = StateMachines::Machine.new(klass, initial: lambda { |_object| :parked })
+    machine.state :parked
+
+    assert_nil klass.new.state_on_init
+  end
+
+  def test_should_not_be_included_in_known_states
+    assert_equal [:parked, :idling, :default], @machine.states.map { |state| state.name }
+  end
+end

data/test/unit/machine/machine_with_event_matchers_test.rb

@@ -0,0 +1,41 @@
+require_relative '../../test_helper'
+
+class MachineWithEventMatchersTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass)
+  end
+
+  def test_should_empty_array_for_all_matcher
+    assert_equal [], @machine.event(StateMachines::AllMatcher.instance)
+  end
+
+  def test_should_return_referenced_events_for_blacklist_matcher
+    assert_instance_of StateMachines::Event, @machine.event(StateMachines::BlacklistMatcher.new([:park]))
+  end
+
+  def test_should_not_allow_configurations
+    exception = assert_raises(ArgumentError) { @machine.event(StateMachines::BlacklistMatcher.new([:park]), human_name: 'Park') }
+    assert_equal 'Cannot configure events when using matchers (using {:human_name=>"Park"})', exception.message
+  end
+
+  def test_should_track_referenced_events
+    @machine.event(StateMachines::BlacklistMatcher.new([:park]))
+    assert_equal [:park], @machine.events.map { |event| event.name }
+  end
+
+  def test_should_eval_context_for_matching_events
+    contexts_run = []
+    @machine.event(StateMachines::BlacklistMatcher.new([:park])) { contexts_run << name }
+
+    @machine.event :park
+    assert_equal [], contexts_run
+
+    @machine.event :ignite
+    assert_equal [:ignite], contexts_run
+
+    @machine.event :shift_up, :shift_down
+    assert_equal [:ignite, :shift_up, :shift_down], contexts_run
+  end
+end
+

data/test/unit/machine/machine_with_events_test.rb

@@ -0,0 +1,52 @@
+require_relative '../../test_helper'
+
+class MachineWithEventsTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass)
+  end
+
+  def test_should_return_the_created_event
+    assert_instance_of StateMachines::Event, @machine.event(:ignite)
+  end
+
+  def test_should_create_event_with_given_name
+    event = @machine.event(:ignite) {}
+    assert_equal :ignite, event.name
+  end
+
+  def test_should_evaluate_block_within_event_context
+    responded = false
+    @machine.event :ignite do
+      responded = respond_to?(:transition)
+    end
+
+    assert responded
+  end
+
+  def test_should_be_aliased_as_on
+    event = @machine.on(:ignite) {}
+    assert_equal :ignite, event.name
+  end
+
+  def test_should_have_events
+    event = @machine.event(:ignite)
+    assert_equal [event], @machine.events.to_a
+  end
+
+  def test_should_allow_human_state_name_lookup
+    @machine.event(:ignite)
+    assert_equal 'ignite', @klass.human_state_event_name(:ignite)
+  end
+
+  def test_should_raise_exception_on_invalid_human_state_event_name_lookup
+    exception = assert_raises(IndexError) { @klass.human_state_event_name(:invalid) }
+    assert_equal ':invalid is an invalid name', exception.message
+  end
+
+  def test_should_raise_exception_if_conflicting_type_used_for_name
+    @machine.event :park
+    exception = assert_raises(ArgumentError) {  @machine.event 'ignite' }
+    assert_equal '"ignite" event defined as String, :park defined as Symbol; all events must be consistent', exception.message
+  end
+end

data/test/unit/machine/machine_with_events_with_custom_human_names_test.rb

@@ -0,0 +1,18 @@
+require_relative '../../test_helper'
+
+class MachineWithEventsWithCustomHumanNamesTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass)
+    @event = @machine.event(:ignite, human_name: 'start')
+  end
+
+  def test_should_use_custom_human_name
+    assert_equal 'start', @event.human_name
+  end
+
+  def test_should_allow_human_state_name_lookup
+    assert_equal 'start', @klass.human_state_event_name(:ignite)
+  end
+end
+

data/test/unit/machine/machine_with_events_with_transitions_test.rb

@@ -0,0 +1,37 @@
+require_relative '../../test_helper'
+
+class MachineWithEventsWithTransitionsTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass, initial: :parked)
+    @event = @machine.event(:ignite) do
+      transition parked: :idling
+      transition stalled: :idling
+    end
+  end
+
+  def test_should_have_events
+    assert_equal [@event], @machine.events.to_a
+  end
+
+  def test_should_track_states_defined_in_event_transitions
+    assert_equal [:parked, :idling, :stalled], @machine.states.map { |state| state.name }
+  end
+
+  def test_should_not_duplicate_states_defined_in_multiple_event_transitions
+    @machine.event :park do
+      transition idling: :parked
+    end
+
+    assert_equal [:parked, :idling, :stalled], @machine.states.map { |state| state.name }
+  end
+
+  def test_should_track_state_from_new_events
+    @machine.event :shift_up do
+      transition idling: :first_gear
+    end
+
+    assert_equal [:parked, :idling, :stalled, :first_gear], @machine.states.map { |state| state.name }
+  end
+end
+

data/test/unit/machine/machine_with_existing_event_test.rb

@@ -0,0 +1,17 @@
+require_relative '../../test_helper'
+
+class MachineWithExistingEventTest < StateMachinesTest
+  def setup
+    @machine = StateMachines::Machine.new(Class.new)
+    @event = @machine.event(:ignite)
+    @same_event = @machine.event(:ignite)
+  end
+
+  def test_should_not_create_new_event
+    assert_same @event, @same_event
+  end
+
+  def test_should_allow_accessing_event_without_block
+    assert_equal @event, @machine.event(:ignite)
+  end
+end

data/test/unit/machine/machine_with_existing_machines_on_owner_class_test.rb

@@ -0,0 +1,20 @@
+require_relative '../../test_helper'
+
+class MachineWithExistingMachinesOnOwnerClassTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass, initial: :parked)
+    @second_machine = StateMachines::Machine.new(@klass, :status, initial: :idling)
+    @object = @klass.new
+  end
+
+  def test_should_track_each_state_machine
+    expected = { state: @machine, status: @second_machine }
+    assert_equal expected, @klass.state_machines
+  end
+
+  def test_should_initialize_state_for_both_machines
+    assert_equal 'parked', @object.state
+    assert_equal 'idling', @object.status
+  end
+end

data/test/unit/machine/machine_with_existing_machines_with_same_attributes_on_owner_class_test.rb

@@ -0,0 +1,71 @@
+require_relative '../../test_helper'
+
+class MachineWithExistingMachinesWithSameAttributesOnOwnerClassTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass, initial: :parked)
+    @second_machine = StateMachines::Machine.new(@klass, :public_state, initial: :idling, attribute: :state)
+    @object = @klass.new
+  end
+
+  def test_should_track_each_state_machine
+    expected = { state: @machine, public_state: @second_machine }
+    assert_equal expected, @klass.state_machines
+  end
+
+  def test_should_write_to_state_only_once
+    @klass.class_eval do
+      attr_reader :write_count
+
+      def state=(_value)
+        @write_count ||= 0
+        @write_count += 1
+      end
+    end
+    object = @klass.new
+
+    assert_equal 1, object.write_count
+  end
+
+  def test_should_initialize_based_on_first_machine
+    assert_equal 'parked', @object.state
+  end
+
+  def test_should_not_allow_second_machine_to_initialize_state
+    @object.state = nil
+    @second_machine.initialize_state(@object)
+    assert_nil @object.state
+  end
+
+  def test_should_allow_transitions_on_both_machines
+    @machine.event :ignite do
+      transition parked: :idling
+    end
+
+    @second_machine.event :park do
+      transition idling: :parked
+    end
+
+    @object.ignite
+    assert_equal 'idling', @object.state
+
+    @object.park
+    assert_equal 'parked', @object.state
+  end
+
+  def test_should_copy_new_states_to_sibling_machines
+    @first_gear = @machine.state :first_gear
+    assert_equal @first_gear, @second_machine.state(:first_gear)
+
+    @second_gear = @second_machine.state :second_gear
+    assert_equal @second_gear, @machine.state(:second_gear)
+  end
+
+  def test_should_copy_all_existing_states_to_new_machines
+    third_machine = StateMachines::Machine.new(@klass, :protected_state, attribute: :state)
+
+    assert_equal @machine.state(:parked), third_machine.state(:parked)
+    assert_equal @machine.state(:idling), third_machine.state(:idling)
+  end
+end
+