state_machines-activemodel 0.9.0 → 0.31.0

data/test/human_name_preservation_test.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative 'test_helper'
+
+class HumanNamePreservationTest < BaseTestCase
+  def setup
+    @model = new_model do
+      include ActiveModel::Validations
+      attr_accessor :status
+    end
+  end
+
+  def test_should_preserve_custom_state_human_name_when_using_activemodel_integration
+    # This test specifically verifies that PR #38's fix works:
+    # Using ||= instead of = in add_states method
+
+    @model.class_eval do
+      state_machine :status, initial: :pending do
+        # Define a state with a custom human_name
+        state :pending, human_name: 'My Custom Pending'
+        state :approved
+      end
+    end
+
+    machine = @model.state_machine(:status)
+
+    # The custom human_name should be preserved, not overwritten by the integration
+    assert_equal 'My Custom Pending', machine.states[:pending].human_name(@model)
+  end
+
+  def test_should_preserve_custom_event_human_name_when_using_activemodel_integration
+    # This test verifies our additional fix for events:
+    # Using ||= instead of = in add_events method
+
+    @model.class_eval do
+      state_machine :status, initial: :pending do
+        event :approve, human_name: 'Grant Authorization' do
+          transition pending: :approved
+        end
+
+        event :reject do
+          transition pending: :rejected
+        end
+      end
+    end
+
+    machine = @model.state_machine(:status)
+
+    # The custom human_name should be preserved, not overwritten by the integration
+    assert_equal 'Grant Authorization', machine.events[:approve].human_name(@model)
+  end
+
+  def test_regression_issue_37_hard_coded_human_name_preserved
+    # This is the exact regression test for issue #37
+    # "Hard-coded human_name is being overwritten"
+
+    @model.class_eval do
+      state_machine :status do
+        state :pending, human_name: 'Pending Approval'
+        state :active, human_name: 'Active State'
+
+        event :activate, human_name: 'Activate Now' do
+          transition pending: :active
+        end
+      end
+    end
+
+    machine = @model.state_machine(:status)
+
+    # Both states and events should preserve their hard-coded human names
+    assert_equal 'Pending Approval', machine.states[:pending].human_name(@model)
+    assert_equal 'Active State', machine.states[:active].human_name(@model)
+    assert_equal 'Activate Now', machine.events[:activate].human_name(@model)
+  end
+end

data/test/integration_test.rb

@@ -1,4 +1,6 @@
-require_relative 'test_helper'
+# frozen_string_literal: true
+
+require 'test_helper'
 
 class IntegrationTest < BaseTestCase
   def test_should_be_registered

data/test/machine_by_default_test.rb

@@ -1,4 +1,6 @@
-require_relative 'test_helper'
+# frozen_string_literal: true
+
+require 'test_helper'
 
 class MachineByDefaultTest < BaseTestCase
   def setup

data/test/machine_errors_test.rb

@@ -1,4 +1,6 @@
-require_relative 'test_helper'
+# frozen_string_literal: true
+
+require 'test_helper'
 
 class MachineErrorsTest < BaseTestCase
   def setup

data/test/machine_initialization_compatibility_test.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative 'test_helper'
+
+class MachineInitializationCompatibilityTest < BaseTestCase
+  def setup
+    @model = new_model do
+      include ActiveModel::Validations
+      attr_accessor :state
+    end
+
+    @machine = StateMachines::Machine.new(@model, initial: :parked)
+    @machine.state :parked, :idling
+    @machine.event :ignite
+  end
+
+  def test_should_accept_positional_hash_argument
+    record = @model.new({ state: 'idling' })
+    assert_equal 'idling', record.state
+  end
+
+  def test_should_accept_keyword_arguments
+    record = @model.new(state: 'idling')
+    assert_equal 'idling', record.state
+  end
+
+  def test_should_accept_empty_initialization
+    record = @model.new
+    assert_equal 'parked', record.state
+  end
+
+  def test_should_handle_attribute_aliases
+    @model.class_eval do
+      def self.attribute_aliases
+        { 'status' => 'state' }
+      end
+    end
+
+    record = @model.new(status: 'idling')
+    assert_equal 'idling', record.state
+  end
+
+  def test_should_prefer_positional_hash_over_keywords_when_both_present
+    # If someone accidentally provides both, positional takes precedence
+    record = @model.new({ state: 'idling' }, state: 'parked')
+    assert_equal 'idling', record.state
+  end
+
+  def test_should_handle_empty_positional_hash
+    # Empty hash should still be treated as positional argument
+    record = @model.new({})
+    assert_equal 'parked', record.state # Gets default initial state
+  end
+
+  def test_should_use_keywords_when_empty_hash_and_keywords_present
+    # With the fix, keywords are ignored even with empty positional hash
+    record = @model.new({}, state: 'idling')
+    assert_equal 'parked', record.state # Empty hash takes precedence
+  end
+end

data/test/machine_multiple_test.rb

@@ -1,4 +1,6 @@
-require_relative 'test_helper'
+# frozen_string_literal: true
+
+require 'test_helper'
 
 class MachineMultipleTest < BaseTestCase
   def setup

data/test/machine_with_callbacks_test.rb

@@ -1,4 +1,6 @@
-require_relative 'test_helper'
+# frozen_string_literal: true
+
+require 'test_helper'
 
 class MachineWithCallbacksTest < BaseTestCase
   def setup

data/test/machine_with_dirty_attribute_and_custom_attributes_during_loopback_test.rb

@@ -1,4 +1,6 @@
-require_relative 'test_helper'
+# frozen_string_literal: true
+
+require 'test_helper'
 
 class MachineWithDirtyAttributeAndCustomAttributesDuringLoopbackTest < BaseTestCase
   def setup

data/test/machine_with_dirty_attribute_and_state_events_test.rb

@@ -1,4 +1,6 @@
-require_relative 'test_helper'
+# frozen_string_literal: true
+
+require 'test_helper'
 
 class MachineWithDirtyAttributeAndStateEventsTest < BaseTestCase
   def setup

data/test/machine_with_dirty_attributes_and_custom_attribute_test.rb

@@ -1,4 +1,6 @@
-require_relative 'test_helper'
+# frozen_string_literal: true
+
+require 'test_helper'
 
 class MachineWithDirtyAttributesAndCustomAttributeTest < BaseTestCase
   def setup

data/test/machine_with_dirty_attributes_during_loopback_test.rb

@@ -1,4 +1,6 @@
-require_relative 'test_helper'
+# frozen_string_literal: true
+
+require 'test_helper'
 
 class MachineWithDirtyAttributesDuringLoopbackTest < BaseTestCase
   def setup

data/test/machine_with_dirty_attributes_test.rb

@@ -1,4 +1,6 @@
-require_relative 'test_helper'
+# frozen_string_literal: true
+
+require 'test_helper'
 
 class MachineWithDirtyAttributesTest < BaseTestCase
   def setup

data/test/machine_with_dynamic_initial_state_test.rb

@@ -1,4 +1,6 @@
-require_relative 'test_helper'
+# frozen_string_literal: true
+
+require 'test_helper'
 
 class MachineWithDynamicInitialStateTest < BaseTestCase
   def setup

data/test/machine_with_events_test.rb

@@ -1,4 +1,6 @@
-require_relative 'test_helper'
+# frozen_string_literal: true
+
+require 'test_helper'
 
 class MachineWithEventsTest < BaseTestCase
   def setup

data/test/machine_with_failed_after_callbacks_test.rb

@@ -1,4 +1,6 @@
-require_relative 'test_helper'
+# frozen_string_literal: true
+
+require 'test_helper'
 
 class MachineWithFailedAfterCallbacksTest < BaseTestCase
   def setup

data/test/machine_with_failed_before_callbacks_test.rb

@@ -1,4 +1,6 @@
-require_relative 'test_helper'
+# frozen_string_literal: true
+
+require 'test_helper'
 
 class MachineWithFailedBeforeCallbacksTest < BaseTestCase
   def setup

data/test/machine_with_initialized_aliased_attribute_test.rb

@@ -1,4 +1,6 @@
-require_relative 'test_helper'
+# frozen_string_literal: true
+
+require 'test_helper'
 
 class MachineWithInitializedAliasedAttributeTest < BaseTestCase
   def test_should_match_original_attribute_value_with_attribute_methods

data/test/machine_with_initialized_state_test.rb

@@ -1,4 +1,6 @@
-require_relative 'test_helper'
+# frozen_string_literal: true
+
+require 'test_helper'
 
 class MachineWithInitializedStateTest < BaseTestCase
   def setup

data/test/machine_with_internationalization_test.rb

@@ -1,4 +1,6 @@
-require_relative 'test_helper'
+# frozen_string_literal: true
+
+require 'test_helper'
 require 'i18n'
 
 class MachineWithInternationalizationTest < BaseTestCase
@@ -54,7 +56,7 @@ class MachineWithInternationalizationTest < BaseTestCase
 
     machine = StateMachines::Machine.new(@model)
     machine.state :parked
-    assert_equal 'shutdown', machine.state(:parked).human_name
+    assert_equal 'shutdown', machine.state(:parked).human_name(@model)
   end
 
   def test_should_allow_customized_state_key_scoped_to_class
@@ -65,7 +67,7 @@ class MachineWithInternationalizationTest < BaseTestCase
     machine = StateMachines::Machine.new(@model)
     machine.state :parked
 
-    assert_equal 'shutdown', machine.state(:parked).human_name
+    assert_equal 'shutdown', machine.state(:parked).human_name(@model)
   end
 
   def test_should_allow_customized_state_key_scoped_to_machine
@@ -76,7 +78,7 @@ class MachineWithInternationalizationTest < BaseTestCase
     machine = StateMachines::Machine.new(@model)
     machine.state :parked
 
-    assert_equal 'shutdown', machine.state(:parked).human_name
+    assert_equal 'shutdown', machine.state(:parked).human_name(@model)
   end
 
   def test_should_allow_customized_state_key_unscoped
@@ -87,7 +89,7 @@ class MachineWithInternationalizationTest < BaseTestCase
     machine = StateMachines::Machine.new(@model)
     machine.state :parked
 
-    assert_equal 'shutdown', machine.state(:parked).human_name
+    assert_equal 'shutdown', machine.state(:parked).human_name(@model)
   end
 
   def test_should_support_nil_state_key
@@ -97,7 +99,7 @@ class MachineWithInternationalizationTest < BaseTestCase
 
     machine = StateMachines::Machine.new(@model)
 
-    assert_equal 'empty', machine.state(nil).human_name
+    assert_equal 'empty', machine.state(nil).human_name(@model)
   end
 
   def test_should_allow_customized_event_key_scoped_to_class_and_machine
@@ -108,7 +110,7 @@ class MachineWithInternationalizationTest < BaseTestCase
     machine = StateMachines::Machine.new(@model)
     machine.event :park
 
-    assert_equal 'stop', machine.event(:park).human_name
+    assert_equal 'stop', machine.event(:park).human_name(@model)
   end
 
   def test_should_allow_customized_event_key_scoped_to_class
@@ -119,7 +121,7 @@ class MachineWithInternationalizationTest < BaseTestCase
     machine = StateMachines::Machine.new(@model)
     machine.event :park
 
-    assert_equal 'stop', machine.event(:park).human_name
+    assert_equal 'stop', machine.event(:park).human_name(@model)
   end
 
   def test_should_allow_customized_event_key_scoped_to_machine
@@ -130,7 +132,7 @@ class MachineWithInternationalizationTest < BaseTestCase
     machine = StateMachines::Machine.new(@model)
     machine.event :park
 
-    assert_equal 'stop', machine.event(:park).human_name
+    assert_equal 'stop', machine.event(:park).human_name(@model)
   end
 
   def test_should_allow_customized_event_key_unscoped
@@ -141,7 +143,7 @@ class MachineWithInternationalizationTest < BaseTestCase
     machine = StateMachines::Machine.new(@model)
     machine.event :park
 
-    assert_equal 'stop', machine.event(:park).human_name
+    assert_equal 'stop', machine.event(:park).human_name(@model)
   end
 
   def test_should_have_locale_once_in_load_path

data/test/machine_with_model_state_attribute_test.rb

@@ -1,4 +1,6 @@
-require_relative 'test_helper'
+# frozen_string_literal: true
+
+require 'test_helper'
 
 class MachineWithModelStateAttributeTest < BaseTestCase
   def setup

data/test/machine_with_non_model_state_attribute_undefined_test.rb

@@ -1,4 +1,6 @@
-require_relative 'test_helper'
+# frozen_string_literal: true
+
+require 'test_helper'
 
 class MachineWithNonModelStateAttributeUndefinedTest < BaseTestCase
   def setup

data/test/machine_with_state_driven_validations_test.rb

@@ -1,4 +1,6 @@
-require_relative 'test_helper'
+# frozen_string_literal: true
+
+require 'test_helper'
 
 class MachineWithStateDrivenValidationsTest < BaseTestCase
   def setup
@@ -9,7 +11,7 @@ class MachineWithStateDrivenValidationsTest < BaseTestCase
 
     @machine = StateMachines::Machine.new(@model)
     @machine.state :first_gear, :second_gear do
-      validates_presence_of :seatbelt
+      validates :seatbelt, presence: true
     end
     @machine.other_states :parked
   end

data/test/machine_with_states_test.rb

@@ -1,4 +1,6 @@
-require_relative 'test_helper'
+# frozen_string_literal: true
+
+require 'test_helper'
 
 class MachineWithStatesTest < BaseTestCase
   def setup

data/test/machine_with_static_initial_state_test.rb

@@ -1,4 +1,6 @@
-require_relative 'test_helper'
+# frozen_string_literal: true
+
+require 'test_helper'
 
 class MachineWithStaticInitialStateTest < BaseTestCase
   def setup

data/test/machine_with_validations_and_custom_attribute_test.rb

@@ -1,4 +1,6 @@
-require_relative 'test_helper'
+# frozen_string_literal: true
+
+require 'test_helper'
 
 class MachineWithValidationsAndCustomAttributeTest < BaseTestCase
   def setup

data/test/machine_with_validations_test.rb

@@ -1,4 +1,6 @@
-require_relative 'test_helper'
+# frozen_string_literal: true
+
+require 'test_helper'
 
 class MachineWithValidationsTest < BaseTestCase
   def setup

data/test/state_human_name_test.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require_relative 'test_helper'
+
+class StateHumanNameTest < BaseTestCase
+  def setup
+    @model = new_model do
+      include ActiveModel::Validations
+      attr_accessor :status
+    end
+  end
+
+  def test_should_allow_custom_human_name_on_state
+    machine = StateMachines::Machine.new(@model, :status, initial: :pending) do
+      state :pending, human_name: 'Awaiting Approval'
+      state :approved
+      state :rejected, human_name: 'Denied'
+    end
+
+    assert_equal 'Awaiting Approval', machine.states[:pending].human_name(@model)
+    assert_equal 'Denied', machine.states[:rejected].human_name(@model)
+  end
+
+  def test_should_not_override_custom_human_name_with_translation
+    # Set up I18n translations
+    I18n.backend.store_translations(:en, {
+                                      activemodel: {
+                                        state_machines: {
+                                          states: {
+                                            pending: 'Translation for Pending',
+                                            approved: 'Translation for Approved',
+                                            rejected: 'Translation for Rejected'
+                                          }
+                                        }
+                                      }
+                                    })
+
+    machine = StateMachines::Machine.new(@model, :status, initial: :pending) do
+      state :pending, human_name: 'Custom Pending Name'
+      state :approved
+      state :rejected, human_name: 'Custom Rejected Name'
+    end
+
+    # Custom human names should be preserved
+    assert_equal 'Custom Pending Name', machine.states[:pending].human_name(@model)
+    assert_equal 'Custom Rejected Name', machine.states[:rejected].human_name(@model)
+
+    # State without custom human_name gets default behavior (which might not use translations in this test setup)
+    # The key test is that custom human names are preserved, not overwritten
+    refute_equal 'Custom Pending Name', machine.states[:approved].human_name(@model)
+  end
+
+  def test_should_allow_custom_human_name_as_string
+    machine = StateMachines::Machine.new(@model, :status) do
+      state :active, human_name: 'Currently Active'
+    end
+
+    assert_equal 'Currently Active', machine.states[:active].human_name(@model)
+  end
+
+  def test_should_allow_custom_human_name_as_lambda
+    machine = StateMachines::Machine.new(@model, :status) do
+      state :processing, human_name: ->(state, klass) { "#{klass.name} is #{state.name.to_s.upcase}" }
+    end
+
+    assert_equal 'Foo is PROCESSING', machine.states[:processing].human_name(@model)
+  end
+
+  def test_should_use_default_translation_when_no_custom_human_name
+    machine = StateMachines::Machine.new(@model, :status) do
+      state :idle
+    end
+
+    # Should fall back to humanized version when no translation exists
+    assert_equal 'idle', machine.states[:idle].human_name(@model)
+  end
+
+  def test_should_handle_nil_human_name
+    machine = StateMachines::Machine.new(@model, :status) do
+      state :waiting
+    end
+
+    # Explicitly set to nil (should still get default behavior)
+    machine.states[:waiting].human_name = nil
+
+    # When human_name is nil, State#human_name returns nil
+    assert_nil machine.states[:waiting].human_name(@model)
+  end
+
+  def test_should_preserve_human_name_through_multiple_state_definitions
+    machine = StateMachines::Machine.new(@model, :status)
+
+    # First define state with custom human name
+    machine.state :draft, human_name: 'Work in Progress'
+
+    # Redefine the same state (this should not override the human_name)
+    machine.state :draft do
+      # Add some behavior
+    end
+
+    assert_equal 'Work in Progress', machine.states[:draft].human_name(@model)
+  end
+
+  def test_should_work_with_state_machine_helper_method
+    @model.class_eval do
+      state_machine :status, initial: :pending do
+        state :pending, human_name: 'Awaiting Review'
+        state :reviewed
+      end
+    end
+
+    machine = @model.state_machine(:status)
+    assert_equal 'Awaiting Review', machine.states[:pending].human_name(@model)
+  end
+
+  def test_should_handle_complex_i18n_lookup_with_custom_human_name
+    # Set up complex I18n structure
+    I18n.backend.store_translations(:en, {
+                                      activemodel: {
+                                        state_machines: {
+                                          foo: {
+                                            status: {
+                                              states: {
+                                                pending: 'Model Specific Pending'
+                                              }
+                                            }
+                                          },
+                                          status: {
+                                            states: {
+                                              pending: 'Machine Specific Pending'
+                                            }
+                                          },
+                                          states: {
+                                            pending: 'Generic Pending'
+                                          }
+                                        }
+                                      }
+                                    })
+
+    machine = StateMachines::Machine.new(@model, :status) do
+      state :pending, human_name: 'Overridden Pending'
+    end
+
+    # Should use the custom human_name, not any of the I18n translations
+    assert_equal 'Overridden Pending', machine.states[:pending].human_name(@model)
+  end
+
+  def teardown
+    # Clear I18n translations after each test
+    I18n.backend.reload!
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'debug'
+
+require 'state_machines-activemodel'
+require 'minitest/autorun'
+require 'minitest/reporters'
+require 'active_support/all'
+Minitest::Reporters.use! [Minitest::Reporters::ProgressReporter.new]
+I18n.enforce_available_locales = true
+
+class BaseTestCase < ActiveSupport::TestCase
+  protected
+  # Creates a new ActiveModel model (and the associated table)
+  def new_model(&block)
+    # Simple ActiveModel superclass
+    parent = Class.new do
+      def self.model_attribute(name)
+        define_method(name) { instance_variable_defined?(:"@#{name}") ? instance_variable_get(:"@#{name}") : nil }
+        define_method("#{name}=") do |value|
+          send(:"#{name}_will_change!") if self.class <= ActiveModel::Dirty && value != send(name)
+          instance_variable_set("@#{name}", value)
+        end
+      end
+
+      def self.create
+        object = new
+        object.save
+        object
+      end
+
+      def initialize(attrs = {})
+        attrs.each { |attr, value| send("#{attr}=", value) }
+      end
+
+      def attributes
+        @attributes ||= {}
+      end
+
+      def save
+        true
+      end
+    end
+
+    model = Class.new(parent) do
+      def self.name
+        'Foo'
+      end
+
+      model_attribute :state
+    end
+    model.class_eval(&block) if block_given?
+    model
+  end
+end