RubyGems - state_machines - Versions diffs - 0.4.0 → 0.6.0 - Mend

state_machines 0.4.0 → 0.6.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (454) hide show

data/test/unit/machine/machine_with_class_helpers_test.rb DELETED Viewed

@@ -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 DELETED Viewed

@@ -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 DELETED Viewed

@@ -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 DELETED Viewed

@@ -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 DELETED Viewed

@@ -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