state_machines 0.5.0 → 0.10.0

data/test/unit/machine/machine_with_custom_initialize_test.rb

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

@@ -1,72 +0,0 @@
-require_relative '../../test_helper'
-require_relative '../../../test/files/models/vehicle'
-
-class MachineWithCustomIntegrationTest < StateMachinesTest
-  module Custom
-    include StateMachines::Integrations::Base
-
-    def self.matching_ancestors
-      [Vehicle]
-    end
-  end
-
-  def setup
-    StateMachines::Integrations.register(MachineWithCustomIntegrationTest::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?(MachineWithCustomIntegrationTest::Custom))
-  end
-
-  def test_should_not_be_extended_by_the_integration_if_implicit_but_not_available
-    MachineWithCustomIntegrationTest::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?(MachineWithCustomIntegrationTest::Custom))
-  end
-
-  def test_should_not_be_extended_by_the_integration_if_implicit_but_not_matched
-    MachineWithCustomIntegrationTest::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?(MachineWithCustomIntegrationTest::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?(MachineWithCustomIntegrationTest::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?(MachineWithCustomIntegrationTest::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?(MachineWithCustomIntegrationTest::Custom))
-  end
-
-  def teardown
-    StateMachines::Integrations.reset
-    MachineWithCustomIntegrationTest::Custom.class_eval do
-      class << self; remove_method :matching_ancestors; end
-      def self.matching_ancestors
-        [Vehicle]
-      end
-    end
-  end
-end

data/test/unit/machine/machine_with_custom_invalidation_test.rb

@@ -1,39 +0,0 @@
-require_relative '../../test_helper'
-
-class MachineWithCustomInvalidationTest < StateMachinesTest
-  module Custom
-    include StateMachines::Integrations::Base
-
-    def invalidate(object, _attribute, message, values = [])
-      object.error = generate_message(message, values)
-    end
-  end
-
-  def setup
-    StateMachines::Integrations.register(MachineWithCustomInvalidationTest::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
-  end
-end
-

data/test/unit/machine/machine_with_custom_name_test.rb

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

@@ -1,52 +0,0 @@
-require_relative '../../test_helper'
-
-class MachineWithCustomPluralTest < StateMachinesTest
-  def setup
-    @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)
-        MachineWithCustomPluralTest::Custom.with_scopes << name
-        lambda {}
-      end
-
-      def create_without_scope(name)
-        MachineWithCustomPluralTest::Custom.without_scopes << name
-        lambda {}
-      end
-    end
-
-    MachineWithCustomPluralTest.const_set('Custom', @integration)
-    StateMachines::Integrations.register(MachineWithCustomPluralTest::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
-    MachineWithCustomPluralTest.send(:remove_const, 'Custom')
-  end
-end
-

data/test/unit/machine/machine_with_dynamic_initial_state_test.rb

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

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

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

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

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

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

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

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

data/test/unit/machine/machine_with_existing_machines_with_same_attributes_on_owner_subclass_test.rb

@@ -1,31 +0,0 @@
-require_relative '../../test_helper'
-
-class MachineWithExistingMachinesWithSameAttributesOnOwnerSubclassTest < 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)
-
-    @subclass = Class.new(@klass)
-    @object = @subclass.new
-  end
-
-  def test_should_not_copy_sibling_machines_to_subclass_after_initialization
-    @subclass.state_machine(:state) {}
-    assert_equal @klass.state_machine(:public_state), @subclass.state_machine(:public_state)
-  end
-
-  def test_should_copy_sibling_machines_to_subclass_after_new_state
-    subclass_machine = @subclass.state_machine(:state) {}
-    subclass_machine.state :first_gear
-    refute_equal @klass.state_machine(:public_state), @subclass.state_machine(:public_state)
-  end
-
-  def test_should_copy_new_states_to_sibling_machines
-    subclass_machine = @subclass.state_machine(:state) {}
-    @first_gear = subclass_machine.state :first_gear
-
-    second_subclass_machine = @subclass.state_machine(:public_state)
-    assert_equal @first_gear, second_subclass_machine.state(:first_gear)
-  end
-end

data/test/unit/machine/machine_with_existing_state_test.rb

@@ -1,27 +0,0 @@
-require_relative '../../test_helper'
-
-class MachineWithExistingStateTest < StateMachinesTest
-  def setup
-    @klass = Class.new
-    @machine = StateMachines::Machine.new(@klass)
-    @state = @machine.state :parked
-    @same_state = @machine.state :parked, value: 1
-  end
-
-  def test_should_not_create_a_new_state
-    assert_same @state, @same_state
-  end
-
-  def test_should_update_attributes
-    assert_equal 1, @state.value
-  end
-
-  def test_should_no_longer_be_able_to_look_up_state_by_original_value
-    assert_nil @machine.states['parked', :value]
-  end
-
-  def test_should_be_able_to_look_up_state_by_new_value
-    assert_equal @state, @machine.states[1, :value]
-  end
-end
-

data/test/unit/machine/machine_with_failure_callbacks_test.rb

@@ -1,48 +0,0 @@
-require_relative '../../test_helper'
-
-class MachineWithFailureCallbacksTest < StateMachinesTest
-  def setup
-    @klass = Class.new do
-      attr_accessor :callbacks
-    end
-
-    @machine = StateMachines::Machine.new(@klass, initial: :parked)
-    @event = @machine.event :ignite
-
-    @object = @klass.new
-    @object.callbacks = []
-  end
-
-  def test_should_raise_exception_if_implicit_option_specified
-    exception = assert_raises(ArgumentError) { @machine.after_failure invalid: :valid, do: lambda {} }
-    assert_equal 'Unknown key: :invalid. Valid keys are: :on, :do, :if, :unless', exception.message
-  end
-
-  def test_should_raise_exception_if_method_not_specified
-    exception = assert_raises(ArgumentError) { @machine.after_failure on: :ignite }
-    assert_equal 'Method(s) for callback must be specified', exception.message
-  end
-
-  def test_should_invoke_callbacks_during_failed_transition
-    @machine.after_failure lambda { |object| object.callbacks << 'failure' }
-
-    @event.fire(@object)
-    assert_equal %w(failure), @object.callbacks
-  end
-
-  def test_should_allow_multiple_callbacks
-    @machine.after_failure lambda { |object| object.callbacks << 'failure1' }, lambda { |object| object.callbacks << 'failure2' }
-
-    @event.fire(@object)
-    assert_equal %w(failure1 failure2), @object.callbacks
-  end
-
-  def test_should_allow_multiple_callbacks_with_requirements
-    @machine.after_failure lambda { |object| object.callbacks << 'failure_ignite1' }, lambda { |object| object.callbacks << 'failure_ignite2' }, on: :ignite
-    @machine.after_failure lambda { |object| object.callbacks << 'failure_park1' }, lambda { |object| object.callbacks << 'failure_park2' }, on: :park
-
-    @event.fire(@object)
-    assert_equal %w(failure_ignite1 failure_ignite2), @object.callbacks
-  end
-end
-