shoulda-matchers 3.1.0 → 5.2.0

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

@@ -19,7 +19,10 @@ module Shoulda
           def matches?(subject)
             self.subject = ModelReflector.new(subject, name)
 
-            if option_verifier.correct_for_string?(:counter_cache, counter_cache)
+            if option_verifier.correct_for_string?(
+              :counter_cache,
+              counter_cache,
+            )
               true
             else
               self.missing_option = "#{name} should have #{description}"
@@ -32,7 +35,7 @@ module Shoulda
           attr_accessor :subject, :counter_cache, :name
 
           def option_verifier
-            @option_verifier ||= OptionVerifier.new(subject)
+            @_option_verifier ||= OptionVerifier.new(subject)
           end
         end
       end

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

@@ -34,7 +34,7 @@ module Shoulda
           private
 
           def option_verifier
-            @option_verifier ||= OptionVerifier.new(subject)
+            @_option_verifier ||= OptionVerifier.new(subject)
           end
 
           def option_matches?
@@ -43,8 +43,8 @@ module Shoulda
 
           def option_type
             case dependent
-              when true, false then :boolean
-              else :string
+            when true, false then :boolean
+            else :string
             end
           end
 
@@ -52,7 +52,7 @@ module Shoulda
             [
               "#{name} should have",
               (dependent == true ? 'a' : dependent),
-              'dependency'
+              'dependency',
             ].join(' ')
           end
         end

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

@@ -32,7 +32,7 @@ module Shoulda
           attr_accessor :subject, :inverse_of, :name
 
           def option_verifier
-            @option_verifier ||= OptionVerifier.new(subject)
+            @_option_verifier ||= OptionVerifier.new(subject)
           end
         end
       end

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

@@ -18,7 +18,7 @@ module Shoulda
             @reflector = reflector
           end
 
-          def matches?(subject)
+          def matches?(_subject)
             join_table_option_correct? &&
               join_table_exists? &&
               join_table_has_correct_columns?
@@ -26,10 +26,14 @@ module Shoulda
 
           def join_table_option_correct?
             if options.key?(:join_table_name)
-              if option_verifier.correct_for_string?(:join_table, options[:join_table_name])
+              if option_verifier.correct_for_string?(
+                :join_table,
+                options[:join_table_name],
+              )
                 true
               else
-                @failure_message = "#{name} should use '#{options[:join_table_name]}' for :join_table option"
+                @failure_message = "#{name} should use"\
+                  " #{options[:join_table_name].inspect} for :join_table option"
                 false
               end
             else
@@ -38,7 +42,8 @@ module Shoulda
           end
 
           def join_table_exists?
-            if connection.tables.include?(join_table_name)
+            if connection.data_sources.
+                include?(join_table_name.to_s)
               true
             else
               @failure_message = missing_table_message
@@ -64,8 +69,8 @@ module Shoulda
           delegate :foreign_key, :association_foreign_key, to: :reflector
 
           def missing_columns
-            @missing_columns ||= expected_join_table_columns.select do |key|
-              !actual_join_table_columns.include?(key.to_s)
+            @_missing_columns ||= expected_join_table_columns.reject do |key|
+              actual_join_table_columns.include?(key.to_s)
             end
           end
 

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

@@ -26,21 +26,16 @@ module Shoulda
 
           def join_table_name
             join_table_name =
-              if has_and_belongs_to_many_name_table_name
-                has_and_belongs_to_many_name_table_name
-              else
-                reflection.join_table
-              end
-
+              has_and_belongs_to_many_name_table_name || reflection.join_table
             join_table_name.to_s
           end
 
-          def association_relation
+          def association_relation(related_instance)
             relation = associated_class.all
 
             if reflection.scope
               # Source: AR::Associations::AssociationScope#eval_scope
-              relation.instance_exec(subject, &reflection.scope)
+              relation.instance_exec(related_instance, &reflection.scope)
             else
               relation
             end
@@ -65,20 +60,24 @@ module Shoulda
             end
           end
 
+          def validate_inverse_of_through_association!
+            if through?
+              reflection.check_validity!
+            end
+          end
+
+          def has_and_belongs_to_many_name
+            reflection.options[:through]
+          end
+
           protected
 
           attr_reader :reflection, :subject
 
           private
 
-          def has_and_belongs_to_many_name
-            reflection.options[:through]
-          end
-
           def has_and_belongs_to_many_name_table_name
-            if has_and_belongs_to_many_reflection
-              has_and_belongs_to_many_reflection.table_name
-            end
+            has_and_belongs_to_many_reflection&.table_name
           end
 
           def has_and_belongs_to_many_reflection

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

@@ -4,17 +4,34 @@ module Shoulda
       module AssociationMatchers
         # @private
         class ModelReflector
-          delegate :associated_class, :through?, :join_table_name,
-            :association_relation, :polymorphic?, :foreign_key,
-            :association_foreign_key, to: :reflection
+          delegate(
+            :associated_class,
+            :association_foreign_key,
+            :foreign_key,
+            :has_and_belongs_to_many_name,
+            :join_table_name,
+            :polymorphic?,
+            :validate_inverse_of_through_association!,
+            to: :reflection,
+          )
+
+          delegate(
+            :through?,
+            to: :reflection,
+            allow_nil: true,
+          )
 
           def initialize(subject, name)
             @subject = subject
             @name = name
           end
 
+          def association_relation
+            reflection.association_relation(subject)
+          end
+
           def reflection
-            @reflection ||= reflect_on_association(name)
+            @_reflection ||= reflect_on_association(name)
           end
 
           def reflect_on_association(name)
@@ -31,9 +48,12 @@ module Shoulda
 
           def build_relation_with_clause(name, value)
             case name
-              when :conditions then associated_class.where(value)
-              when :order      then associated_class.order(value)
-              else                  raise ArgumentError, "Unknown clause '#{name}'"
+            when :conditions
+              associated_class.where(value)
+            when :order
+              associated_class.order(value)
+            else
+              raise ArgumentError, "Unknown clause '#{name}'"
             end
           end
 
@@ -42,7 +62,9 @@ module Shoulda
             when :conditions
               relation.where_values_hash
             when :order
-              relation.order_values.map { |value| value_as_sql(value) }.join(', ')
+              relation.order_values.map do |value|
+                value_as_sql(value)
+              end.join(', ')
             else
               raise ArgumentError, "Unknown clause '#{name}'"
             end

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

@@ -6,7 +6,12 @@ module Shoulda
         class OptionVerifier
           delegate :reflection, to: :reflector
 
-          RELATION_OPTIONS = [:conditions, :order]
+          DEFAULT_VALUE_OF_OPTIONS = {
+            has_many: {
+              validate: true,
+            },
+          }.freeze
+          RELATION_OPTIONS = [:conditions, :order].freeze
 
           def initialize(reflector)
             @reflector = reflector
@@ -34,15 +39,16 @@ module Shoulda
 
           def correct_for?(*args)
             expected_value, name, type = args.reverse
+
             if expected_value.nil?
               true
             else
-              expected_value = type_cast(
+              type_cast_expected_value = type_cast(
                 type,
-                expected_value_for(type, name, expected_value)
+                expected_value_for(type, name, expected_value),
               )
               actual_value = type_cast(type, actual_value_for(name))
-              expected_value == actual_value
+              type_cast_expected_value == actual_value
             end
           end
 
@@ -54,7 +60,7 @@ module Shoulda
               if respond_to?(method_name, true)
                 __send__(method_name)
               else
-                reflection.options[name]
+                actual_value_for_option(name)
               end
             end
           end
@@ -65,10 +71,14 @@ module Shoulda
 
           def type_cast(type, value)
             case type
-              when :string, :relation_clause then value.to_s
-              when :boolean                  then !!value
-              when :hash                     then Hash(value).stringify_keys
-              else                                value
+            when :string, :relation_clause
+              value.to_s
+            when :boolean
+              !!value
+            when :hash
+              Hash(value).stringify_keys
+            else
+              value
             end
           end
 
@@ -89,7 +99,7 @@ module Shoulda
 
           def expected_value_for_constant(name)
             namespace = Shoulda::Matchers::Util.deconstantize(
-              reflector.model_class.to_s
+              reflector.model_class.to_s,
             )
 
             ["#{namespace}::#{name}", name].each do |path|
@@ -102,12 +112,25 @@ module Shoulda
           end
 
           def actual_value_for_relation_clause(name)
-            reflector.extract_relation_clause_from(reflector.association_relation, name)
+            reflector.extract_relation_clause_from(
+              reflector.association_relation,
+              name,
+            )
           end
 
           def actual_value_for_class_name
             reflector.associated_class
           end
+
+          def actual_value_for_option(name)
+            option_value = reflection.options[name]
+
+            if option_value.nil?
+              DEFAULT_VALUE_OF_OPTIONS.dig(reflection.macro, name)
+            else
+              option_value
+            end
+          end
         end
       end
     end

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

@@ -0,0 +1,69 @@
+module Shoulda
+  module Matchers
+    module ActiveRecord
+      module AssociationMatchers
+        # @private
+        class OptionalMatcher
+          attr_reader :missing_option
+
+          def initialize(attribute_name, optional)
+            @attribute_name = attribute_name
+            @optional = optional
+            @submatcher = ActiveModel::AllowValueMatcher.new(nil).
+              for(attribute_name)
+            @missing_option = ''
+          end
+
+          def description
+            "optional: #{optional}"
+          end
+
+          def matches?(subject)
+            if submatcher_passes?(subject)
+              true
+            else
+              @missing_option = 'and for the record '
+
+              missing_option <<
+                if optional
+                  'not to '
+                else
+                  'to '
+                end
+
+              missing_option << (
+                'fail validation if '\
+                ":#{attribute_name} is unset; i.e., either the association "\
+                'should have been defined with `optional: '\
+                "#{optional.inspect}`, or there "
+              )
+
+              missing_option <<
+                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)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -32,7 +32,7 @@ module Shoulda
           attr_accessor :subject, :order, :name
 
           def option_verifier
-            @option_verifier ||= OptionVerifier.new(subject)
+            @_option_verifier ||= OptionVerifier.new(subject)
           end
         end
       end

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

@@ -0,0 +1,74 @@
+module Shoulda
+  module Matchers
+    module ActiveRecord
+      module AssociationMatchers
+        # @private
+        class RequiredMatcher
+          attr_reader :missing_option
+
+          def initialize(attribute_name, required)
+            @attribute_name = attribute_name
+            @required = required
+            @submatcher = ActiveModel::DisallowValueMatcher.new(nil).
+              for(attribute_name).
+              with_message(validation_message_key)
+            @missing_option = ''
+          end
+
+          def description
+            "required: #{required}"
+          end
+
+          def matches?(subject)
+            if submatcher_passes?(subject)
+              true
+            else
+              @missing_option = 'and for the record '
+
+              missing_option <<
+                if required
+                  'to '
+                else
+                  'not to '
+                end
+
+              missing_option << (
+                'fail validation if '\
+                ":#{attribute_name} is unset; i.e., either the association "\
+                'should have been defined with `required: '\
+                "#{required.inspect}`, or there "
+              )
+
+              missing_option <<
+                if required
+                  'should '
+                else
+                  'should not '
+                end
+
+              missing_option << "be a presence validation on :#{attribute_name}"
+
+              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
+        end
+      end
+    end
+  end
+end

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

@@ -22,7 +22,8 @@ module Shoulda
             if option_verifier.correct_for_string?(:source, source)
               true
             else
-              self.missing_option = "#{name} should have #{source} as source option"
+              self.missing_option =
+                "#{name} should have #{source} as source option"
               false
             end
           end
@@ -32,7 +33,7 @@ module Shoulda
           attr_accessor :subject, :source, :name
 
           def option_verifier
-            @option_verifier ||= OptionVerifier.new(subject)
+            @_option_verifier ||= OptionVerifier.new(subject)
           end
         end
       end

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

@@ -29,13 +29,14 @@ module Shoulda
             if through_reflection.present?
               true
             else
-              self.missing_option = "#{name} does not have any relationship to #{through}"
+              self.missing_option =
+                "#{name} does not have any relationship to #{through}"
               false
             end
           end
 
           def through_reflection
-            @through_reflection ||= subject.reflect_on_association(through)
+            @_through_reflection ||= subject.reflect_on_association(through)
           end
 
           def through_association_correct?
@@ -43,8 +44,9 @@ module Shoulda
               true
             else
               self.missing_option =
-                "Expected #{name} to have #{name} through #{through}, " +
-                "but got it through #{option_verifier.actual_value_for(:through)}"
+                "Expected #{name} to have #{name} through #{through}, "\
+                'but got it through ' +
+                option_verifier.actual_value_for(:through).to_s
               false
             end
           end
@@ -54,7 +56,7 @@ module Shoulda
           attr_accessor :through, :name, :subject
 
           def option_verifier
-            @option_verifier ||= OptionVerifier.new(subject)
+            @_option_verifier ||= OptionVerifier.new(subject)
           end
         end
       end