state_machines 0.0.2 → 0.1.0

data/test/unit/machine/machine_with_action_defined_in_superclass_test.rb

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

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

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

data/test/unit/machine/machine_with_class_helpers_test.rb

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

@@ -0,0 +1,243 @@
+require_relative '../../test_helper'
+
+class MachineWithConflictingHelpersAfterDefinitionTest < StateMachinesTest
+  def setup
+    @original_stderr, $stderr = $stderr, StringIO.new
+
+    @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
+
+    StateMachines::Integrations.const_set('Custom', Module.new do
+                                                    include StateMachines::Integrations::Base
+
+                                                    def create_with_scope(_name)
+                                                      lambda { |_klass, _values| [] }
+                                                    end
+
+                                                    def create_without_scope(_name)
+                                                      lambda { |_klass, _values| [] }
+                                                    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.send(:remove_const, 'Custom')
+  end
+end

data/test/unit/machine/machine_with_conflicting_helpers_before_definition_test.rb

@@ -0,0 +1,175 @@
+require_relative '../../test_helper'
+
+class MachineWithConflictingHelpersBeforeDefinitionTest < StateMachinesTest
+  def setup
+    @original_stderr, $stderr = $stderr, StringIO.new
+
+    @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)
+
+    StateMachines::Integrations.const_set('Custom', Module.new do
+                                                    include StateMachines::Integrations::Base
+
+                                                    def create_with_scope(_name)
+                                                      lambda { |_klass, _values| [] }
+                                                    end
+
+                                                    def create_without_scope(_name)
+                                                      lambda { |_klass, _values| [] }
+                                                    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_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
+    StateMachines::Integrations.send(:remove_const, 'Custom')
+  end
+end
+

data/test/unit/machine/machine_with_custom_action_test.rb

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