shoulda-matchers 6.2.0 → 6.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d549ac8f3629ad37bc56d0d09daf37416ec23d78374a8ed6a630ea23e5c9e487
-  data.tar.gz: f09bc94b6be181564cdde56729c2055192a4725adee4ba8b6b7f8e84429fe9a0
+  metadata.gz: 0a3a788cc37a73b615004a4e88dacb051413e00f9a752b78f00cfa8b529e4149
+  data.tar.gz: 99e5319049435d5ae107d068cecacd547bbd5135e1f1966bf8e15c40e5cde84f
 SHA512:
-  metadata.gz: 1f3ba08a6d15ad56cb583c0a8289e180854f5d89020b3182b2d6140289800d71bca467f187c9a4718ba26078cc2562f6377d77b00a0e84f2e683079d62ef60d3
-  data.tar.gz: 45d0141c79d9642439c9c03ffcd8e41d1aee993eafaea11fc72812456ead1dcf17d1698e9eb7f311c40945c54c77fc4e573a820ffa115fc344e9b0049ed69479
+  metadata.gz: 5f2b4708f133c2e0a790c99de4608d976d8dfe8704436adeea539e816a18bc6bca7612e7ff669bc4830f8f617550a0db7a70574f611a791dc27879d66f6ed09c
+  data.tar.gz: 460ac28a8c3833b30ec3171f62a5d5225712132837caeb1c620df49cdcc1fc2d92614a8a652ac93f7707b06d4fe24c5c9ee70fc9759b8b34a3929f845931a2b5

data/README.md

@@ -167,9 +167,9 @@ end
 Most of the matchers provided by this gem are useful in a Rails context, and as
 such, can be used for different parts of a Rails app:
 
-* [database models backed by ActiveRecord](#activemodel-matchers)
+* [database models backed by ActiveRecord](#activerecord-matchers)
 * [non-database models, form objects, etc. backed by
-  ActiveModel](#activerecord-matchers)
+  ActiveModel](#activemodel-matchers)
 * [controllers](#actioncontroller-matchers)
 * [routes](#routing-matchers) (RSpec only)
 * [Rails-specific features like `delegate`](#independent-matchers)
@@ -527,7 +527,6 @@ The names and logos for thoughtbot are trademarks of thoughtbot, inc.
 
 We love open source software!
 See [our other projects][community].
-
 We are [available for hire][hire].
 
 [community]: https://thoughtbot.com/community?utm_source=github

data/lib/shoulda/matchers/action_controller/respond_with_matcher.rb

@@ -133,7 +133,7 @@ module Shoulda
           when :missing  then 404
           when :error    then 500..599
           when Symbol
-            ::Rack::Utils::SYMBOL_TO_STATUS_CODE[potential_symbol]
+            ::Rack::Utils.status_code(potential_symbol)
           else
             potential_symbol
           end

data/lib/shoulda/matchers/active_record/association_matchers/counter_cache_matcher.rb

@@ -19,10 +19,7 @@ module Shoulda
           def matches?(subject)
             self.subject = ModelReflector.new(subject, name)
 
-            if option_verifier.correct_for_string?(
-              :counter_cache,
-              counter_cache,
-            )
+            if correct_value?
               true
             else
               self.missing_option = "#{name} should have #{description}"
@@ -34,9 +31,42 @@ module Shoulda
 
           attr_accessor :subject, :counter_cache, :name
 
+          def correct_value?
+            expected = normalize_value
+
+            if expected.is_a?(Hash)
+              option_verifier.correct_for_hash?(
+                :counter_cache,
+                expected,
+              )
+            else
+              option_verifier.correct_for_string?(
+                :counter_cache,
+                expected,
+              )
+            end
+          end
+
           def option_verifier
             @_option_verifier ||= OptionVerifier.new(subject)
           end
+
+          def normalize_value
+            if Rails::VERSION::STRING >= '7.2'
+              case counter_cache
+              when true
+                { active: true, column: nil }
+              when String, Symbol
+                { active: true, column: counter_cache.to_s }
+              when Hash
+                { active: true, column: nil }.merge(counter_cache)
+              else
+                raise ArgumentError, 'Invalid counter_cache option'
+              end
+            else
+              counter_cache
+            end
+          end
         end
       end
     end

data/lib/shoulda/matchers/active_record/define_enum_for_matcher.rb

@@ -187,8 +187,95 @@ module Shoulda
       #         without_scopes
       #     end
       #
-      # @return [DefineEnumForMatcher]
+      # ##### with_default
+      #
+      # Use `with_default` to test that the enum is defined with a
+      # default value. A proc can also be passed, and will be called once each
+      # time a new value is needed. (If using Time or Date, it's recommended to
+      # freeze time or date to avoid flaky tests):
+      #
+      #     class Issue < ActiveRecord::Base
+      #       enum status: [:open, :closed], default: :closed
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Issue, type: :model do
+      #       it do
+      #         should define_enum_for(:status).
+      #           with_default(:closed)
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class ProcessTest < ActiveSupport::TestCase
+      #       should define_enum_for(:status).
+      #         with_default(:closed)
+      #     end
+      #
+      # ##### validating
+      #
+      # Use `validating` to test that the enum is being validated.
+      # Can take a boolean value and an allowing_nil keyword argument:
+      #
+      #     class Issue < ActiveRecord::Base
+      #       enum status: [:open, :closed], validate: true
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Issue, type: :model do
+      #       it do
+      #         should define_enum_for(:status).
+      #           validating
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class ProcessTest < ActiveSupport::TestCase
+      #       should define_enum_for(:status).
+      #         validating
+      #     end
+      #
+      #     class Issue < ActiveRecord::Base
+      #       enum status: [:open, :closed], validate: { allow_nil: true }
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Issue, type: :model do
+      #       it do
+      #         should define_enum_for(:status).
+      #           validating(allowing_nil: true)
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class ProcessTest < ActiveSupport::TestCase
+      #       should define_enum_for(:status).
+      #         validating(allowing_nil: true)
+      #     end
+      #
+      # ##### without_instance_methods
+      #
+      # Use `without_instance_methods` to exclude the check for instance methods.
+      #
+      #     class Issue < ActiveRecord::Base
+      #       enum status: [:open, :closed], instance_methods: false
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Issue, type: :model do
+      #       it do
+      #         should define_enum_for(:status).
+      #           without_instance_methods
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class ProcessTest < ActiveSupport::TestCase
+      #       should define_enum_for(:status).
+      #         without_instance_methods
+      #     end
       #
+      # @return [DefineEnumForMatcher]
       def define_enum_for(attribute_name)
         DefineEnumForMatcher.new(attribute_name)
       end
@@ -197,7 +284,7 @@ module Shoulda
       class DefineEnumForMatcher
         def initialize(attribute_name)
           @attribute_name = attribute_name
-          @options = { expected_enum_values: [], scopes: true }
+          @options = { expected_enum_values: [], scopes: true, instance_methods: true }
         end
 
         def description
@@ -222,6 +309,12 @@ module Shoulda
           description
         end
 
+        def validating(value = true, allowing_nil: false)
+          options[:validating] = value
+          options[:allowing_nil] = allowing_nil
+          self
+        end
+
         def with_values(expected_enum_values)
           options[:expected_enum_values] = expected_enum_values
           self
@@ -247,6 +340,16 @@ module Shoulda
           self
         end
 
+        def without_instance_methods
+          options[:instance_methods] = false
+          self
+        end
+
+        def with_default(default_value)
+          options[:default] = default_value
+          self
+        end
+
         def matches?(subject)
           @record = subject
 
@@ -254,7 +357,9 @@ module Shoulda
             enum_values_match? &&
             column_type_matches? &&
             enum_value_methods_exist? &&
-            scope_presence_matches?
+            scope_presence_matches? &&
+            default_value_matches? &&
+            validating_matches?
         end
 
         def failure_message
@@ -277,6 +382,30 @@ module Shoulda
 
         private
 
+        def validating_matches?
+          return true if options[:validating].nil?
+
+          validator = find_enum_validator
+
+          if expected_validating? == !!validator
+            if validator&.options&.dig(:allow_nil).present? == expected_allowing_nil?
+              true
+            else
+              @failure_message_continuation =
+                "However, #{attribute_name.inspect} is allowing nil values"
+              false
+            end
+          else
+            @failure_message_continuation =
+              if expected_validating?
+                "However, #{attribute_name.inspect} is not being validated"
+              else
+                "However, #{attribute_name.inspect} is being validated"
+              end
+            false
+          end
+        end
+
         attr_reader :attribute_name, :options, :record,
           :failure_message_continuation
 
@@ -292,6 +421,21 @@ module Shoulda
               )
             end
 
+            if options[:default].present?
+              expectation << ', with a default value of '
+              expectation << Shoulda::Matchers::Util.inspect_value(expected_default_value)
+            end
+
+            if expected_validating?
+              expectation << ', and being validated '
+              expectation <<
+                if expected_allowing_nil?
+                  'allowing nil values'
+                else
+                  'not allowing nil values'
+                end
+            end
+
             if expected_prefix
               expectation <<
                 if expected_suffix
@@ -413,16 +557,24 @@ module Shoulda
         end
 
         def enum_value_methods_exist?
-          if instance_methods_exist?
-            true
-          else
+          if options[:instance_methods]
+            return true if instance_methods_exist?
+
             message = missing_methods_message
+            message << " (we can't tell which)" if [expected_prefix, expected_suffix].any?
 
-            message << " (we can't tell which)"
+            @failure_message_continuation = message
+
+            false
+          elsif instance_methods_exist?
+            message = "#{attribute_name.inspect} does map to these values"
+            message << ' with instance methods, but expected no instance methods'
 
             @failure_message_continuation = message
 
             false
+          else
+            true
           end
         end
 
@@ -471,11 +623,61 @@ module Shoulda
           elsif expected_suffix
             message << 'configured with either a different suffix or no '
             message << 'suffix at all'
+          elsif expected_instance_methods?
+            message << 'configured with no instance methods'
           else
             ''
           end
         end
 
+        def default_value_matches?
+          return true if options[:default].blank?
+
+          if actual_default_value.nil?
+            @failure_message_continuation = 'However, no default value was set'
+            return false
+          end
+
+          if actual_default_value == expected_default_value
+            true
+          else
+            String.new.tap do |message|
+              message << 'However, the default value is '
+              message << Shoulda::Matchers::Util.inspect_value(actual_default_value)
+              @failure_message_continuation = message
+            end
+            false
+          end
+        end
+
+        def expected_default_value
+          options[:default].respond_to?(:call) ? options[:default].call : options[:default]
+        end
+
+        def actual_default_value
+          attribute_schema = if model.respond_to?(:_default_attributes)
+                               model._default_attributes[attribute_name.to_s]
+                             else
+                               model.attributes_to_define_after_schema_loads[attribute_name.to_s]
+                             end
+
+          if Kernel.const_defined?('ActiveModel::Attribute::UserProvidedDefault') &&
+             attribute_schema.is_a?(::ActiveModel::Attribute::UserProvidedDefault)
+            attribute_schema = attribute_schema.marshal_dump
+          end
+
+          value = case attribute_schema
+                  in [_, { default: default_value } ]
+                    default_value
+                  in [_, default_value, *]
+                    default_value
+                  in [_, default_value]
+                    default_value
+                  end
+
+          value.respond_to?(:call) ? value.call : value
+        end
+
         def singleton_methods_exist?
           expected_singleton_methods.all? do |method|
             model.singleton_methods.include?(method)
@@ -509,6 +711,10 @@ module Shoulda
           end
         end
 
+        def expected_instance_methods?
+          options[:instance_methods]
+        end
+
         def expected_prefix
           if options.include?(:prefix)
             if options[:prefix] == true
@@ -529,6 +735,22 @@ module Shoulda
           end
         end
 
+        def expected_validating?
+          options[:validating].present?
+        end
+
+        def expected_allowing_nil?
+          options[:allowing_nil].present?
+        end
+
+        def find_enum_validator
+          record.class.validators.detect do |validator|
+            validator.kind == :inclusion &&
+              validator.attributes.include?(attribute_name.to_s) &&
+              validator.options[:in] == expected_enum_value_names
+          end
+        end
+
         def exclude_scopes?
           !options[:scopes]
         end

data/lib/shoulda/matchers/active_record/uniqueness/model.rb

@@ -29,7 +29,19 @@ module Shoulda
           end
 
           def symlink_to(parent)
-            namespace.set(name, Class.new(parent))
+            table_name = parent.table_name
+
+            new_class = Class.new(parent) do
+              define_singleton_method :table_name do
+                table_name
+              end
+
+              define_singleton_method :base_class do
+                self
+              end
+            end
+
+            namespace.set(name, new_class)
           end
 
           def to_s

data/lib/shoulda/matchers/doublespeak.rb

@@ -1,5 +1,4 @@
 require 'forwardable'
-require 'logger'
 
 module Shoulda
   module Matchers

data/lib/shoulda/matchers/version.rb

@@ -1,6 +1,6 @@
 module Shoulda
   module Matchers
     # @private
-    VERSION = '6.2.0'.freeze
+    VERSION = '6.4.0'.freeze
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: shoulda-matchers
 version: !ruby/object:Gem::Version
-  version: 6.2.0
+  version: 6.4.0
 platform: ruby
 authors:
 - Tammer Saleh
@@ -14,7 +14,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-03-15 00:00:00.000000000 Z
+date: 2024-08-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -198,7 +198,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.6
+rubygems_version: 3.5.3
 signing_key:
 specification_version: 4
 summary: Simple one-liner tests for common Rails functionality