state_machines 0.0.2 → 0.1.0

data/test/unit/machine/machine_after_being_copied_test.rb

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

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

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

data/test/unit/machine/machine_by_default_test.rb

@@ -0,0 +1,160 @@
+require_relative '../../test_helper'
+
+class MachineByDefaultTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass)
+    @object = @klass.new
+  end
+
+  def test_should_have_an_owner_class
+    assert_equal @klass, @machine.owner_class
+  end
+
+  def test_should_have_a_name
+    assert_equal :state, @machine.name
+  end
+
+  def test_should_have_an_attribute
+    assert_equal :state, @machine.attribute
+  end
+
+  def test_should_prefix_custom_attributes_with_attribute
+    assert_equal :state_event, @machine.attribute(:event)
+  end
+
+  def test_should_have_an_initial_state
+    refute_nil @machine.initial_state(@object)
+  end
+
+  def test_should_have_a_nil_initial_state
+    assert_nil @machine.initial_state(@object).value
+  end
+
+  def test_should_not_have_any_events
+    refute @machine.events.any?
+  end
+
+  def test_should_not_have_any_before_callbacks
+    assert @machine.callbacks[:before].empty?
+  end
+
+  def test_should_not_have_any_after_callbacks
+    assert @machine.callbacks[:after].empty?
+  end
+
+  def test_should_not_have_any_failure_callbacks
+    assert @machine.callbacks[:failure].empty?
+  end
+
+  def test_should_not_have_an_action
+    assert_nil @machine.action
+  end
+
+  def test_should_use_tranactions
+    assert_equal true, @machine.use_transactions
+  end
+
+  def test_should_not_have_a_namespace
+    assert_nil @machine.namespace
+  end
+
+  def test_should_have_a_nil_state
+    assert_equal [nil], @machine.states.keys
+  end
+
+  def test_should_set_initial_on_nil_state
+    assert @machine.state(nil).initial
+  end
+
+  def test_should_generate_default_messages
+    assert_equal 'is invalid', @machine.generate_message(:invalid)
+    assert_equal 'cannot transition when parked', @machine.generate_message(:invalid_event, [[:state, :parked]])
+    assert_equal 'cannot transition via "park"', @machine.generate_message(:invalid_transition, [[:event, :park]])
+  end
+
+  def test_should_define_a_reader_attribute_for_the_attribute
+    assert @object.respond_to?(:state)
+  end
+
+  def test_should_define_a_writer_attribute_for_the_attribute
+    assert @object.respond_to?(:state=)
+  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_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_not_define_an_event_attribute_reader
+    refute @object.respond_to?(:state_event)
+  end
+
+  def test_should_not_define_an_event_attribute_writer
+    refute @object.respond_to?(:state_event=)
+  end
+
+  def test_should_not_define_an_event_transition_attribute_reader
+    refute @object.respond_to?(:state_event_transition)
+  end
+
+  def test_should_not_define_an_event_transition_attribute_writer
+    refute @object.respond_to?(:state_event_transition=)
+  end
+
+  def test_should_define_a_human_attribute_name_reader_for_the_attribute
+    assert @klass.respond_to?(:human_state_name)
+  end
+
+  def test_should_define_a_human_event_name_reader_for_the_attribute
+    assert @klass.respond_to?(:human_state_event_name)
+  end
+
+  def test_should_not_define_singular_with_scope
+    refute @klass.respond_to?(:with_state)
+  end
+
+  def test_should_not_define_singular_without_scope
+    refute @klass.respond_to?(:without_state)
+  end
+
+  def test_should_not_define_plural_with_scope
+    refute @klass.respond_to?(:with_states)
+  end
+
+  def test_should_not_define_plural_without_scope
+    refute @klass.respond_to?(:without_states)
+  end
+
+  def test_should_extend_owner_class_with_class_methods
+    assert((class << @klass; ancestors; end).include?(StateMachines::ClassMethods))
+  end
+
+  def test_should_include_instance_methods_in_owner_class
+    assert @klass.included_modules.include?(StateMachines::InstanceMethods)
+  end
+
+  def test_should_define_state_machines_reader
+    expected = { state: @machine }
+    assert_equal expected, @klass.state_machines
+  end
+end

data/test/unit/machine/machine_finder_custom_options_test.rb

@@ -0,0 +1,17 @@
+require_relative '../../test_helper'
+
+class MachineFinderCustomOptionsTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.find_or_create(@klass, :status, initial: :parked)
+    @object = @klass.new
+  end
+
+  def test_should_use_custom_attribute
+    assert_equal :status, @machine.attribute
+  end
+
+  def test_should_set_custom_initial_state
+    assert_equal :parked, @machine.initial_state(@object).name
+  end
+end

data/test/unit/machine/machine_finder_with_existing_machine_on_superclass_test.rb

@@ -0,0 +1,86 @@
+require_relative '../../test_helper'
+
+class MachineFinderWithExistingMachineOnSuperclassTest < StateMachinesTest
+  def setup
+    integration = Module.new do
+      include StateMachines::Integrations::Base
+
+      def self.matches?(_klass)
+        false
+      end
+    end
+    StateMachines::Integrations.const_set('Custom', integration)
+    StateMachines::Integrations.register(StateMachines::Integrations::Custom)
+
+    @base_class = Class.new
+    @base_machine = StateMachines::Machine.new(@base_class, :status, action: :save, integration: :custom)
+    @base_machine.event(:ignite) {}
+    @base_machine.before_transition(-> {})
+    @base_machine.after_transition(-> {})
+    @base_machine.around_transition(-> {})
+
+    @klass = Class.new(@base_class)
+    @machine = StateMachines::Machine.find_or_create(@klass, :status) {}
+  end
+
+  def test_should_accept_a_block
+    called = false
+    StateMachines::Machine.find_or_create(Class.new(@base_class)) do
+      called = respond_to?(:event)
+    end
+
+    assert called
+  end
+
+  def test_should_not_create_a_new_machine_if_no_block_or_options
+    machine = StateMachines::Machine.find_or_create(Class.new(@base_class), :status)
+
+    assert_same machine, @base_machine
+  end
+
+  def test_should_create_a_new_machine_if_given_options
+    machine = StateMachines::Machine.find_or_create(@klass, :status, initial: :parked)
+
+    refute_nil machine
+    refute_same machine, @base_machine
+  end
+
+  def test_should_create_a_new_machine_if_given_block
+    refute_nil @machine
+    refute_same @machine, @base_machine
+  end
+
+  def test_should_copy_the_base_attribute
+    assert_equal :status, @machine.attribute
+  end
+
+  def test_should_copy_the_base_configuration
+    assert_equal :save, @machine.action
+  end
+
+  def test_should_copy_events
+    # Can't assert equal arrays since their machines change
+    assert_equal 1, @machine.events.length
+  end
+
+  def test_should_copy_before_callbacks
+    assert_equal @base_machine.callbacks[:before], @machine.callbacks[:before]
+  end
+
+  def test_should_copy_after_transitions
+    assert_equal @base_machine.callbacks[:after], @machine.callbacks[:after]
+  end
+
+  def test_should_use_the_same_integration
+    class_ancestors = class << @machine
+      ancestors
+    end
+
+    assert(class_ancestors.include?(StateMachines::Integrations::Custom))
+  end
+
+  def teardown
+    StateMachines::Integrations.reset
+    StateMachines::Integrations.send(:remove_const, 'Custom')
+  end
+end

data/test/unit/machine/machine_finder_with_existing_on_same_class_test.rb

@@ -0,0 +1,23 @@
+require_relative '../../test_helper'
+
+class MachineFinderWithExistingOnSameClassTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @existing_machine = StateMachines::Machine.new(@klass)
+    @machine = StateMachines::Machine.find_or_create(@klass)
+  end
+
+  def test_should_accept_a_block
+    called = false
+    StateMachines::Machine.find_or_create(@klass) do
+      called = respond_to?(:event)
+    end
+
+    assert called
+  end
+
+  def test_should_not_create_a_new_machine
+    assert_same @machine, @existing_machine
+  end
+end
+

data/test/unit/machine/machine_finder_without_existing_machine_test.rb

@@ -0,0 +1,25 @@
+require_relative '../../test_helper'
+
+class MachineFinderWithoutExistingMachineTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.find_or_create(@klass)
+  end
+
+  def test_should_accept_a_block
+    called = false
+    StateMachines::Machine.find_or_create(Class.new) do
+      called = respond_to?(:event)
+    end
+
+    assert called
+  end
+
+  def test_should_create_a_new_machine
+    refute_nil @machine
+  end
+
+  def test_should_use_default_state
+    assert_equal :state, @machine.attribute
+  end
+end

data/test/unit/machine/machine_persistence_test.rb

@@ -0,0 +1,52 @@
+require_relative '../../test_helper'
+
+class MachinePersistenceTest < StateMachinesTest
+  def setup
+    @klass = Class.new do
+      attr_accessor :state_event
+    end
+    @machine = StateMachines::Machine.new(@klass, initial: :parked)
+    @object = @klass.new
+  end
+
+  def test_should_allow_reading_state
+    assert_equal 'parked', @machine.read(@object, :state)
+  end
+
+  def test_should_allow_reading_custom_attributes
+    assert_nil @machine.read(@object, :event)
+
+    @object.state_event = 'ignite'
+    assert_equal 'ignite', @machine.read(@object, :event)
+  end
+
+  def test_should_allow_reading_custom_instance_variables
+    @klass.class_eval do
+      attr_writer :state_value
+    end
+
+    @object.state_value = 1
+    assert_raises(NoMethodError) { @machine.read(@object, :value) }
+    assert_equal 1, @machine.read(@object, :value, true)
+  end
+
+  def test_should_allow_writing_state
+    @machine.write(@object, :state, 'idling')
+    assert_equal 'idling', @object.state
+  end
+
+  def test_should_allow_writing_custom_attributes
+    @machine.write(@object, :event, 'ignite')
+    assert_equal 'ignite', @object.state_event
+  end
+
+  def test_should_allow_writing_custom_instance_variables
+    @klass.class_eval do
+      attr_reader :state_value
+    end
+
+    assert_raises(NoMethodError) { @machine.write(@object, :value, 1) }
+    assert_equal 1, @machine.write(@object, :value, 1, true)
+    assert_equal 1, @object.state_value
+  end
+end

data/test/unit/machine/machine_state_initialization_test.rb

@@ -0,0 +1,56 @@
+require_relative '../../test_helper'
+
+class MachineStateInitializationTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass, :state, initial: :parked, initialize: false)
+
+    @object = @klass.new
+    @object.state = nil
+  end
+
+  def test_should_set_states_if_nil
+    @machine.initialize_state(@object)
+
+    assert_equal 'parked', @object.state
+  end
+
+  def test_should_set_states_if_empty
+    @object.state = ''
+    @machine.initialize_state(@object)
+
+    assert_equal 'parked', @object.state
+  end
+
+  def test_should_not_set_states_if_not_empty
+    @object.state = 'idling'
+    @machine.initialize_state(@object)
+
+    assert_equal 'idling', @object.state
+  end
+
+  def test_should_set_states_if_not_empty_and_forced
+    @object.state = 'idling'
+    @machine.initialize_state(@object, force: true)
+
+    assert_equal 'parked', @object.state
+  end
+
+  def test_should_not_set_state_if_nil_and_nil_is_valid_state
+    @machine.state :initial, value: nil
+    @machine.initialize_state(@object)
+
+    assert_nil @object.state
+  end
+
+  def test_should_write_to_hash_if_specified
+    @machine.initialize_state(@object, to: hash = {})
+    assert_equal({ 'state' => 'parked' }, hash)
+  end
+
+  def test_should_not_write_to_object_if_writing_to_hash
+    @machine.initialize_state(@object, to: {})
+    assert_nil @object.state
+  end
+end
+

data/test/unit/machine/machine_test.rb

@@ -0,0 +1,30 @@
+require_relative '../../test_helper'
+
+class MachineTest < StateMachinesTest
+  def test_should_raise_exception_if_invalid_option_specified
+    assert_raises(ArgumentError) { StateMachines::Machine.new(Class.new, invalid: true) }
+  end
+
+  def test_should_not_raise_exception_if_custom_messages_specified
+    StateMachines::Machine.new(Class.new, messages: { invalid_transition: 'custom' })
+  end
+
+  def test_should_evaluate_a_block_during_initialization
+    called = true
+    StateMachines::Machine.new(Class.new) do
+      called = respond_to?(:event)
+    end
+
+    assert called
+  end
+
+  def test_should_provide_matcher_helpers_during_initialization
+    matchers = []
+
+    StateMachines::Machine.new(Class.new) do
+      matchers = [all, any, same]
+    end
+
+    assert_equal [StateMachines::AllMatcher.instance, StateMachines::AllMatcher.instance, StateMachines::LoopbackMatcher.instance], matchers
+  end
+end

data/test/unit/machine/machine_with_action_already_overridden_test.rb

@@ -0,0 +1,23 @@
+require_relative '../../test_helper'
+
+class MachineWithActionAlreadyOverriddenTest < StateMachinesTest
+  def setup
+    @superclass = Class.new do
+      def save
+      end
+    end
+    @klass = Class.new(@superclass)
+
+    StateMachines::Machine.new(@klass, action: :save)
+    @machine = StateMachines::Machine.new(@klass, :status, action: :save)
+    @object = @klass.new
+  end
+
+  def test_should_not_redefine_action
+    assert_equal 1, @klass.ancestors.select { |ancestor| ![@klass, @superclass].include?(ancestor) && ancestor.method_defined?(:save) }.length
+  end
+
+  def test_should_mark_action_hook_as_defined
+    assert @machine.action_hook?
+  end
+end

data/test/unit/machine/machine_with_action_defined_in_class_test.rb

@@ -0,0 +1,37 @@
+require_relative '../../test_helper'
+
+class MachineWithActionDefinedInClassTest < StateMachinesTest
+  def setup
+    @klass = Class.new do
+      def save
+      end
+    end
+
+    @machine = StateMachines::Machine.new(@klass, action: :save)
+    @object = @klass.new
+  end
+
+  def test_should_define_an_event_attribute_reader
+    assert @object.respond_to?(:state_event)
+  end
+
+  def test_should_define_an_event_attribute_writer
+    assert @object.respond_to?(:state_event=)
+  end
+
+  def test_should_define_an_event_transition_attribute_reader
+    assert @object.respond_to?(:state_event_transition, true)
+  end
+
+  def test_should_define_an_event_transition_attribute_writer
+    assert @object.respond_to?(:state_event_transition=, true)
+  end
+
+  def test_should_not_define_action
+    refute @klass.ancestors.any? { |ancestor| ancestor != @klass && ancestor.method_defined?(:save) }
+  end
+
+  def test_should_not_mark_action_hook_as_defined
+    refute @machine.action_hook?
+  end
+end

data/test/unit/machine/machine_with_action_defined_in_included_module_test.rb

@@ -0,0 +1,46 @@
+require_relative '../../test_helper'
+
+class MachineWithActionDefinedInIncludedModuleTest < StateMachinesTest
+  def setup
+    @mod = mod = Module.new do
+      def save
+      end
+    end
+
+    @klass = Class.new do
+      include mod
+    end
+
+    @machine = StateMachines::Machine.new(@klass, action: :save)
+    @object = @klass.new
+  end
+
+  def test_should_define_an_event_attribute_reader
+    assert @object.respond_to?(:state_event)
+  end
+
+  def test_should_define_an_event_attribute_writer
+    assert @object.respond_to?(:state_event=)
+  end
+
+  def test_should_define_an_event_transition_attribute_reader
+    assert @object.respond_to?(:state_event_transition, true)
+  end
+
+  def test_should_define_an_event_transition_attribute_writer
+    assert @object.respond_to?(:state_event_transition=, true)
+  end
+
+  def test_should_define_action
+    assert @klass.ancestors.any? { |ancestor| ![@klass, @mod].include?(ancestor) && ancestor.method_defined?(:save) }
+  end
+
+  def test_should_keep_action_public
+    assert @klass.public_method_defined?(:save)
+  end
+
+  def test_should_mark_action_hook_as_defined
+    assert @machine.action_hook?
+  end
+end
+