shoulda-matchers 5.1.0 → 6.4.0

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/association_matchers/model_reflection.rb

@@ -13,7 +13,11 @@ module Shoulda
           end
 
           def associated_class
-            reflection.klass
+            if polymorphic?
+              subject
+            else
+              reflection.klass
+            end
           end
 
           def polymorphic?
@@ -70,6 +74,10 @@ module Shoulda
             reflection.options[:through]
           end
 
+          def strict_loading?
+            reflection.options.fetch(:strict_loading, subject.strict_loading_by_default)
+          end
+
           protected
 
           attr_reader :reflection, :subject

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

@@ -8,6 +8,7 @@ module Shoulda
             :associated_class,
             :association_foreign_key,
             :foreign_key,
+            :foreign_type,
             :has_and_belongs_to_many_name,
             :join_table_name,
             :polymorphic?,

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

@@ -122,6 +122,10 @@ module Shoulda
             reflector.associated_class
           end
 
+          def actual_value_for_strict_loading
+            reflection.strict_loading?
+          end
+
           def actual_value_for_option(name)
             option_value = reflection.options[name]
 

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

@@ -22,44 +22,48 @@ module Shoulda
             if submatcher_passes?(subject)
               true
             else
-              @missing_option = 'and for the record '
+              @missing_option = build_missing_option
 
-              missing_option <<
+              false
+            end
+          end
+
+          private
+
+          attr_reader :attribute_name, :optional, :submatcher
+
+          def submatcher_passes?(subject)
+            if optional
+              submatcher.matches?(subject)
+            else
+              submatcher.does_not_match?(subject)
+            end
+          end
+
+          def build_missing_option
+            String.new('and for the record ').tap do |missing_option_string|
+              missing_option_string <<
                 if optional
                   'not to '
                 else
                   'to '
                 end
 
-              missing_option << (
+              missing_option_string << (
                 'fail validation if '\
                 ":#{attribute_name} is unset; i.e., either the association "\
                 'should have been defined with `optional: '\
                 "#{optional.inspect}`, or there "
               )
 
-              missing_option <<
+              missing_option_string <<
                 if optional
                   'should not '
                 else
                   'should '
                 end
 
-              missing_option << "be a presence validation on :#{attribute_name}"
-
-              false
-            end
-          end
-
-          private
-
-          attr_reader :attribute_name, :optional, :submatcher
-
-          def submatcher_passes?(subject)
-            if optional
-              submatcher.matches?(subject)
-            else
-              submatcher.does_not_match?(subject)
+              missing_option_string << "be a presence validation on :#{attribute_name}"
             end
           end
         end

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

@@ -23,50 +23,54 @@ module Shoulda
             if submatcher_passes?(subject)
               true
             else
-              @missing_option = 'and for the record '
+              @missing_option = build_missing_option
 
-              missing_option <<
+              false
+            end
+          end
+
+          private
+
+          attr_reader :attribute_name, :required, :submatcher
+
+          def submatcher_passes?(subject)
+            if required
+              submatcher.matches?(subject)
+            else
+              submatcher.does_not_match?(subject)
+            end
+          end
+
+          def validation_message_key
+            :required
+          end
+
+          def build_missing_option
+            String.new('and for the record ').tap do |missing_option_string|
+              missing_option_string <<
                 if required
                   'to '
                 else
                   'not to '
                 end
 
-              missing_option << (
+              missing_option_string << (
                 'fail validation if '\
                 ":#{attribute_name} is unset; i.e., either the association "\
                 'should have been defined with `required: '\
                 "#{required.inspect}`, or there "
               )
 
-              missing_option <<
+              missing_option_string <<
                 if required
                   'should '
                 else
                   'should not '
                 end
 
-              missing_option << "be a presence validation on :#{attribute_name}"
-
-              false
+              missing_option_string << "be a presence validation on :#{attribute_name}"
             end
           end
-
-          private
-
-          attr_reader :attribute_name, :required, :submatcher
-
-          def submatcher_passes?(subject)
-            if required
-              submatcher.matches?(subject)
-            else
-              submatcher.does_not_match?(subject)
-            end
-          end
-
-          def validation_message_key
-            :required
-          end
         end
       end
     end