state_machines 0.4.0 → 0.6.0

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
-

data/test/unit/machine/machine_by_default_test.rb

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

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

@@ -1,85 +0,0 @@
-require_relative '../../test_helper'
-
-class MachineFinderWithExistingMachineOnSuperclassTest < StateMachinesTest
-  module Custom
-    include StateMachines::Integrations::Base
-
-    def self.matches?(_klass)
-      false
-    end
-  end
-
-  def setup
-    StateMachines::Integrations.register(MachineFinderWithExistingMachineOnSuperclassTest::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?(MachineFinderWithExistingMachineOnSuperclassTest::Custom))
-  end
-
-  def teardown
-    StateMachines::Integrations.reset
-  end
-end

data/test/unit/machine/machine_finder_with_existing_on_same_class_test.rb

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

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

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

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

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

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

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

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

data/test/unit/machine/machine_with_action_defined_in_superclass_test.rb

@@ -1,43 +0,0 @@
-require_relative '../../test_helper'
-
-class MachineWithActionDefinedInSuperclassTest < StateMachinesTest
-  def setup
-    @superclass = Class.new do
-      def save
-      end
-    end
-    @klass = Class.new(@superclass)
-
-    @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, @superclass].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
-

data/test/unit/machine/machine_with_action_undefined_test.rb

@@ -1,33 +0,0 @@
-require_relative '../../test_helper'
-
-class MachineWithActionUndefinedTest < StateMachinesTest
-  def setup
-    @klass = Class.new
-    @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 @object.respond_to?(:save)
-  end
-
-  def test_should_not_mark_action_hook_as_defined
-    refute @machine.action_hook?
-  end
-end

data/test/unit/machine/machine_with_cached_state_test.rb

@@ -1,20 +0,0 @@
-require_relative '../../test_helper'
-
-class MachineWithCachedStateTest < StateMachinesTest
-  def setup
-    @klass = Class.new
-    @machine = StateMachines::Machine.new(@klass, initial: :parked)
-    @state = @machine.state :parked, value: -> { Object.new }, cache: true
-
-    @object = @klass.new
-  end
-
-  def test_should_use_evaluated_value
-    assert_instance_of Object, @object.state
-  end
-
-  def test_use_same_value_across_multiple_objects
-    assert_equal @object.state, @klass.new.state
-  end
-end
-