state_machines 0.5.0 → 0.6.0

data/test/unit/machine/machine_with_class_helpers_test.rb

@@ -1,179 +0,0 @@
-require_relative '../../test_helper'
-require 'stringio'
-
-class MachineWithClassHelpersTest < StateMachinesTest
-  def setup
-    @klass = Class.new
-    @machine = StateMachines::Machine.new(@klass)
-  end
-
-  def test_should_not_redefine_existing_public_methods
-    class << @klass
-      def states
-        []
-      end
-    end
-
-    @machine.define_helper(:class, :states) {}
-    assert_equal [], @klass.states
-  end
-
-  def test_should_not_redefine_existing_protected_methods
-    class << @klass
-      protected
-      def states
-        []
-      end
-    end
-
-    @machine.define_helper(:class, :states) {}
-    assert_equal [], @klass.send(:states)
-  end
-
-  def test_should_not_redefine_existing_private_methods
-    class << @klass
-      private
-      def states
-        []
-      end
-    end
-
-    @machine.define_helper(:class, :states) {}
-    assert_equal [], @klass.send(:states)
-  end
-
-  def test_should_warn_if_defined_in_superclass
-    @original_stderr, $stderr = $stderr, StringIO.new
-
-    superclass = Class.new do
-      def self.park
-      end
-    end
-    klass = Class.new(superclass)
-    machine = StateMachines::Machine.new(klass)
-
-    machine.define_helper(:class, :park) {}
-    assert_equal "Class method \"park\" is already defined in #{superclass}, use generic helper instead or set StateMachines::Machine.ignore_method_conflicts = true.\n", $stderr.string
-  ensure
-    $stderr = @original_stderr
-  end
-
-  def test_should_warn_if_defined_in_multiple_superclasses
-    @original_stderr, $stderr = $stderr, StringIO.new
-
-    superclass1 = Class.new do
-      def self.park
-      end
-    end
-    superclass2 = Class.new(superclass1) do
-      def self.park
-      end
-    end
-    klass = Class.new(superclass2)
-    machine = StateMachines::Machine.new(klass)
-
-    machine.define_helper(:class, :park) {}
-    assert_equal "Class method \"park\" is already defined in #{superclass1}, use generic helper instead or set StateMachines::Machine.ignore_method_conflicts = true.\n", $stderr.string
-  ensure
-    $stderr = @original_stderr
-  end
-
-  def test_should_warn_if_defined_in_module_prior_to_helper_module
-    @original_stderr, $stderr = $stderr, StringIO.new
-
-    mod = Module.new do
-      def park
-      end
-    end
-    klass = Class.new do
-      extend mod
-    end
-    machine = StateMachines::Machine.new(klass)
-
-    machine.define_helper(:class, :park) {}
-    assert_equal "Class method \"park\" is already defined in #{mod}, use generic helper instead or set StateMachines::Machine.ignore_method_conflicts = true.\n", $stderr.string
-  ensure
-    $stderr = @original_stderr
-  end
-
-  def test_should_not_warn_if_defined_in_module_after_helper_module
-    @original_stderr, $stderr = $stderr, StringIO.new
-
-    klass = Class.new
-    machine = StateMachines::Machine.new(klass)
-
-    mod = Module.new do
-      def park
-      end
-    end
-    klass.class_eval do
-      extend mod
-    end
-
-    machine.define_helper(:class, :park) {}
-    assert_equal '', $stderr.string
-  ensure
-    $stderr = @original_stderr
-  end
-
-  def test_should_define_if_ignoring_method_conflicts_and_defined_in_superclass
-    @original_stderr, $stderr = $stderr, StringIO.new
-    StateMachines::Machine.ignore_method_conflicts = true
-
-    superclass = Class.new do
-      def self.park
-      end
-    end
-    klass = Class.new(superclass)
-    machine = StateMachines::Machine.new(klass)
-
-    machine.define_helper(:class, :park) { true }
-    assert_equal '', $stderr.string
-    assert_equal true, klass.park
-  ensure
-    StateMachines::Machine.ignore_method_conflicts = false
-    $stderr = @original_stderr
-  end
-
-  def test_should_define_nonexistent_methods
-    @machine.define_helper(:class, :states) { [] }
-    assert_equal [], @klass.states
-  end
-
-  def test_should_warn_if_defined_multiple_times
-    @original_stderr, $stderr = $stderr, StringIO.new
-
-    @machine.define_helper(:class, :states) {}
-    @machine.define_helper(:class, :states) {}
-
-    assert_equal "Class method \"states\" is already defined in #{@klass} :state class helpers, use generic helper instead or set StateMachines::Machine.ignore_method_conflicts = true.\n", $stderr.string
-  ensure
-    $stderr = @original_stderr
-  end
-
-  def test_should_pass_context_as_arguments
-    helper_args = nil
-    @machine.define_helper(:class, :states) { |*args| helper_args = args }
-    @klass.states
-    assert_equal 2, helper_args.length
-    assert_equal [@machine, @klass], helper_args
-  end
-
-  def test_should_pass_method_arguments_through
-    helper_args = nil
-    @machine.define_helper(:class, :states) { |*args| helper_args = args }
-    @klass.states(1, 2, 3)
-    assert_equal 5, helper_args.length
-    assert_equal [@machine, @klass, 1, 2, 3], helper_args
-  end
-
-  def test_should_allow_string_evaluation
-    @machine.define_helper :class, <<-end_eval, __FILE__, __LINE__ + 1
-      def states
-        []
-      end
-    end_eval
-    assert_equal [], @klass.states
-  end
-end
-

data/test/unit/machine/machine_with_conflicting_helpers_after_definition_test.rb

@@ -1,244 +0,0 @@
-require_relative '../../test_helper'
-
-class MachineWithConflictingHelpersAfterDefinitionTest < StateMachinesTest
-  module Custom
-    include StateMachines::Integrations::Base
-
-    def create_with_scope(_name)
-      ->(_klass, _values) { [] }
-    end
-
-    def create_without_scope(_name)
-      ->(_klass, _values) { [] }
-    end
-  end
-  def setup
-    @original_stderr, $stderr = $stderr, StringIO.new
-    StateMachines::Integrations.register(MachineWithConflictingHelpersAfterDefinitionTest::Custom)
-    @klass = Class.new do
-      def self.with_state
-        :with_state
-      end
-
-      def self.with_states
-        :with_states
-      end
-
-      def self.without_state
-        :without_state
-      end
-
-      def self.without_states
-        :without_states
-      end
-
-      def self.human_state_name
-        :human_state_name
-      end
-
-      def self.human_state_event_name
-        :human_state_event_name
-      end
-
-      attr_accessor :status
-
-      def state
-        'parked'
-      end
-
-      def state=(value)
-        self.status = value
-      end
-
-      def state?
-        true
-      end
-
-      def state_name
-        :parked
-      end
-
-      def human_state_name
-        'parked'
-      end
-
-      def state_events
-        [:ignite]
-      end
-
-      def state_transitions
-        [{ parked: :idling }]
-      end
-
-      def state_paths
-        [[{ parked: :idling }]]
-      end
-
-      def fire_state_event
-        true
-      end
-    end
-
-
-
-    @machine = StateMachines::Machine.new(@klass, integration: :custom)
-    @machine.state :parked, :idling
-    @machine.event :ignite
-    @object = @klass.new
-  end
-
-  def test_should_not_redefine_singular_with_scope
-    assert_equal :with_state, @klass.with_state
-  end
-
-  def test_should_not_redefine_plural_with_scope
-    assert_equal :with_states, @klass.with_states
-  end
-
-  def test_should_not_redefine_singular_without_scope
-    assert_equal :without_state, @klass.without_state
-  end
-
-  def test_should_not_redefine_plural_without_scope
-    assert_equal :without_states, @klass.without_states
-  end
-
-  def test_should_not_redefine_human_attribute_name_reader
-    assert_equal :human_state_name, @klass.human_state_name
-  end
-
-  def test_should_not_redefine_human_event_name_reader
-    assert_equal :human_state_event_name, @klass.human_state_event_name
-  end
-
-  def test_should_not_redefine_attribute_reader
-    assert_equal 'parked', @object.state
-  end
-
-  def test_should_not_redefine_attribute_writer
-    @object.state = 'parked'
-    assert_equal 'parked', @object.status
-  end
-
-  def test_should_not_define_attribute_predicate
-    assert @object.state?
-  end
-
-  def test_should_not_redefine_attribute_name_reader
-    assert_equal :parked, @object.state_name
-  end
-
-  def test_should_not_redefine_attribute_human_name_reader
-    assert_equal 'parked', @object.human_state_name
-  end
-
-  def test_should_not_redefine_attribute_events_reader
-    assert_equal [:ignite], @object.state_events
-  end
-
-  def test_should_not_redefine_attribute_transitions_reader
-    assert_equal [{ parked: :idling }], @object.state_transitions
-  end
-
-  def test_should_not_redefine_attribute_paths_reader
-    assert_equal [[{ parked: :idling }]], @object.state_paths
-  end
-
-  def test_should_not_redefine_event_runner
-    assert_equal true, @object.fire_state_event
-  end
-
-  def test_should_allow_super_chaining
-    @klass.class_eval do
-      def self.with_state(*states)
-        super
-      end
-
-      def self.with_states(*states)
-        super
-      end
-
-      def self.without_state(*states)
-        super
-      end
-
-      def self.without_states(*states)
-        super
-      end
-
-      def self.human_state_name(state)
-        super
-      end
-
-      def self.human_state_event_name(event)
-        super
-      end
-
-      attr_accessor :status
-
-      def state
-        super
-      end
-
-      def state=(value)
-        super
-      end
-
-      def state?(state)
-        super
-      end
-
-      def state_name
-        super
-      end
-
-      def human_state_name
-        super
-      end
-
-      def state_events
-        super
-      end
-
-      def state_transitions
-        super
-      end
-
-      def state_paths
-        super
-      end
-
-      def fire_state_event(event)
-        super
-      end
-    end
-
-    assert_equal [], @klass.with_state
-    assert_equal [], @klass.with_states
-    assert_equal [], @klass.without_state
-    assert_equal [], @klass.without_states
-    assert_equal 'parked', @klass.human_state_name(:parked)
-    assert_equal 'ignite', @klass.human_state_event_name(:ignite)
-
-    assert_equal nil, @object.state
-    @object.state = 'idling'
-    assert_equal 'idling', @object.state
-    assert_equal nil, @object.status
-    assert_equal false, @object.state?(:parked)
-    assert_equal :idling, @object.state_name
-    assert_equal 'idling', @object.human_state_name
-    assert_equal [], @object.state_events
-    assert_equal [], @object.state_transitions
-    assert_equal [], @object.state_paths
-    assert_equal false, @object.fire_state_event(:ignite)
-  end
-
-  def test_should_not_output_warning
-    assert_equal '', $stderr.string
-  end
-
-  def teardown
-    $stderr = @original_stderr
-    StateMachines::Integrations.reset
-  end
-end

data/test/unit/machine/machine_with_conflicting_helpers_before_definition_test.rb

@@ -1,175 +0,0 @@
-require_relative '../../test_helper'
-
-class MachineWithConflictingHelpersBeforeDefinitionTest < StateMachinesTest
-  module Custom
-    include StateMachines::Integrations::Base
-
-    def create_with_scope(_name)
-      lambda { |_klass, _values| [] }
-    end
-
-    def create_without_scope(_name)
-      lambda { |_klass, _values| [] }
-    end
-  end
-
-  def setup
-    @original_stderr, $stderr = $stderr, StringIO.new
-
-    StateMachines::Integrations.register(MachineWithConflictingHelpersBeforeDefinitionTest::Custom)
-
-    @superclass = Class.new do
-      def self.with_state
-        :with_state
-      end
-
-      def self.with_states
-        :with_states
-      end
-
-      def self.without_state
-        :without_state
-      end
-
-      def self.without_states
-        :without_states
-      end
-
-      def self.human_state_name
-        :human_state_name
-      end
-
-      def self.human_state_event_name
-        :human_state_event_name
-      end
-
-      attr_accessor :status
-
-      def state
-        'parked'
-      end
-
-      def state=(value)
-        self.status = value
-      end
-
-      def state?
-        true
-      end
-
-      def state_name
-        :parked
-      end
-
-      def human_state_name
-        'parked'
-      end
-
-      def state_events
-        [:ignite]
-      end
-
-      def state_transitions
-        [{ parked: :idling }]
-      end
-
-      def state_paths
-        [[{ parked: :idling }]]
-      end
-
-      def fire_state_event
-        true
-      end
-    end
-    @klass = Class.new(@superclass)
-    @machine = StateMachines::Machine.new(@klass, integration: :custom)
-    @machine.state :parked, :idling
-    @machine.event :ignite
-    @object = @klass.new
-  end
-
-  def test_should_not_redefine_singular_with_scope
-    assert_equal :with_state, @klass.with_state
-  end
-
-  def test_should_not_redefine_plural_with_scope
-    assert_equal :with_states, @klass.with_states
-  end
-
-  def test_should_not_redefine_singular_without_scope
-    assert_equal :without_state, @klass.without_state
-  end
-
-  def test_should_not_redefine_plural_without_scope
-    assert_equal :without_states, @klass.without_states
-  end
-
-  def test_should_not_redefine_human_attribute_name_reader
-    assert_equal :human_state_name, @klass.human_state_name
-  end
-
-  def test_should_not_redefine_human_event_name_reader
-    assert_equal :human_state_event_name, @klass.human_state_event_name
-  end
-
-  def test_should_not_redefine_attribute_reader
-    assert_equal 'parked', @object.state
-  end
-
-  def test_should_not_redefine_attribute_writer
-    @object.state = 'parked'
-    assert_equal 'parked', @object.status
-  end
-
-  def test_should_not_define_attribute_predicate
-    assert @object.state?
-  end
-
-  def test_should_not_redefine_attribute_name_reader
-    assert_equal :parked, @object.state_name
-  end
-
-  def test_should_not_redefine_attribute_human_name_reader
-    assert_equal 'parked', @object.human_state_name
-  end
-
-  def test_should_not_redefine_attribute_events_reader
-    assert_equal [:ignite], @object.state_events
-  end
-
-  def test_should_not_redefine_attribute_transitions_reader
-    assert_equal [{ parked: :idling }], @object.state_transitions
-  end
-
-  def test_should_not_redefine_attribute_paths_reader
-    assert_equal [[{ parked: :idling }]], @object.state_paths
-  end
-
-  def test_should_not_redefine_event_runner
-    assert_equal true, @object.fire_state_event
-  end
-
-  def test_should_output_warning
-    expected = [
-        'Instance method "state_events"',
-        'Instance method "state_transitions"',
-        'Instance method "fire_state_event"',
-        'Instance method "state_paths"',
-        'Class method "human_state_name"',
-        'Class method "human_state_event_name"',
-        'Instance method "state_name"',
-        'Instance method "human_state_name"',
-        'Class method "with_state"',
-        'Class method "with_states"',
-        'Class method "without_state"',
-        'Class method "without_states"'
-    ].map { |method| "#{method} is already defined in #{@superclass}, use generic helper instead or set StateMachines::Machine.ignore_method_conflicts = true.\n" }.join
-
-    assert_equal expected, $stderr.string
-  end
-
-  def teardown
-    $stderr = @original_stderr
-  end
-end
-

data/test/unit/machine/machine_with_custom_action_test.rb

@@ -1,11 +0,0 @@
-require_relative '../../test_helper'
-
-class MachineWithCustomActionTest < StateMachinesTest
-  def setup
-    @machine = StateMachines::Machine.new(Class.new, action: :save)
-  end
-
-  def test_should_use_the_custom_action
-    assert_equal :save, @machine.action
-  end
-end

data/test/unit/machine/machine_with_custom_attribute_test.rb

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