shoulda-matchers 4.1.2 → 4.5.0

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 RailsShim.tables_and_views(connection).include?(join_table_name)
+            if RailsShim.tables_and_views(connection).
+                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
@@ -40,7 +45,7 @@ module Shoulda
             else
               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))
               type_cast_expected_value == actual_value
@@ -55,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
@@ -94,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|
@@ -107,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

@@ -32,9 +32,9 @@ module Shoulda
                 end
 
               missing_option << (
-                'fail validation if ' +
-                ":#{attribute_name} is unset; i.e., either the association " +
-                'should have been defined with `optional: ' +
+                'fail validation if '\
+                ":#{attribute_name} is unset; i.e., either the association "\
+                'should have been defined with `optional: '\
                 "#{optional.inspect}`, or there "
               )
 

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

@@ -33,9 +33,9 @@ module Shoulda
                 end
 
               missing_option << (
-                'fail validation if ' +
-                ":#{attribute_name} is unset; i.e., either the association " +
-                'should have been defined with `required: ' +
+                'fail validation if '\
+                ":#{attribute_name} is unset; i.e., either the association "\
+                'should have been defined with `required: '\
                 "#{required.inspect}`, or there "
               )
 

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

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

@@ -237,7 +237,7 @@ module Shoulda
               "Expected #{model} to #{expectation}, but "
             end
 
-          message << failure_message_continuation + '.'
+          message << "#{failure_message_continuation}."
 
           Shoulda::Matchers.word_wrap(message)
         end
@@ -252,7 +252,7 @@ module Shoulda
         attr_reader :attribute_name, :options, :record,
           :failure_message_continuation
 
-        def expectation
+        def expectation # rubocop:disable Metrics/MethodLength
           if enum_defined?
             expectation = "#{simple_description} backed by "
             expectation << Shoulda::Matchers::Util.a_or_an(expected_column_type)
@@ -358,8 +358,8 @@ module Shoulda
             true
           else
             @failure_message_continuation =
-              "However, #{attribute_name.inspect} is " +
-              Shoulda::Matchers::Util.a_or_an(column.type) +
+              "However, #{attribute_name.inspect} is "\
+              "#{Shoulda::Matchers::Util.a_or_an(column.type)}"\
               ' column'
             false
           end
@@ -421,9 +421,9 @@ module Shoulda
         def expected_prefix
           if options.include?(:prefix)
             if options[:prefix] == true
-              attribute_name#.to_sym
+              attribute_name
             else
-              options[:prefix]#.to_sym
+              options[:prefix]
             end
           end
         end
@@ -431,9 +431,9 @@ module Shoulda
         def expected_suffix
           if options.include?(:suffix)
             if options[:suffix] == true
-              attribute_name#.to_sym
+              attribute_name
             else
-              options[:suffix]#.to_sym
+              options[:suffix]
             end
           end
         end

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

@@ -0,0 +1,185 @@
+module Shoulda
+  module Matchers
+    module ActiveRecord
+      # The `have_one_attached` matcher tests usage of the
+      # `has_one_attached` macro.
+      #
+      # #### Example
+      #
+      #     class User < ApplicationRecord
+      #       has_one_attached :avatar
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe User, type: :model do
+      #       it { should have_one_attached(:avatar) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class UserTest < ActiveSupport::TestCase
+      #       should have_one_attached(:avatar)
+      #     end
+      #
+      # @return [HaveAttachedMatcher]
+      #
+      def have_one_attached(name)
+        HaveAttachedMatcher.new(:one, name)
+      end
+
+      # The `have_many_attached` matcher tests usage of the
+      # `has_many_attached` macro.
+      #
+      # #### Example
+      #
+      #     class Message < ApplicationRecord
+      #       has_many_attached :images
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Message, type: :model do
+      #       it { should have_many_attached(:images) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class MessageTest < ActiveSupport::TestCase
+      #       should have_many_attached(:images)
+      #     end
+      #
+      # @return [HaveAttachedMatcher]
+      #
+      def have_many_attached(name)
+        HaveAttachedMatcher.new(:many, name)
+      end
+
+      # @private
+      class HaveAttachedMatcher
+        attr_reader :name
+
+        def initialize(macro, name)
+          @macro = macro
+          @name = name
+        end
+
+        def description
+          "have a has_#{macro}_attached called #{name}"
+        end
+
+        def failure_message
+          <<-MESSAGE
+Expected #{expectation}, but this could not be proved.
+  #{@failure}
+          MESSAGE
+        end
+
+        def failure_message_when_negated
+          <<-MESSAGE
+Did not expect #{expectation}, but it does.
+          MESSAGE
+        end
+
+        def expectation
+          "#{model_class.name} to #{description}"
+        end
+
+        def matches?(subject)
+          @subject = subject
+          reader_attribute_exists? &&
+            writer_attribute_exists? &&
+            attachments_association_exists? &&
+            blobs_association_exists? &&
+            eager_loading_scope_exists?
+        end
+
+        private
+
+        attr_reader :subject, :macro
+
+        def reader_attribute_exists?
+          if subject.respond_to?(name)
+            true
+          else
+            @failure = "#{model_class.name} does not have a :#{name} method."
+            false
+          end
+        end
+
+        def writer_attribute_exists?
+          if subject.respond_to?("#{name}=")
+            true
+          else
+            @failure = "#{model_class.name} does not have a :#{name}= method."
+            false
+          end
+        end
+
+        def attachments_association_exists?
+          if attachments_association_matcher.matches?(subject)
+            true
+          else
+            @failure = attachments_association_matcher.failure_message
+            false
+          end
+        end
+
+        def attachments_association_matcher
+          @_attachments_association_matcher ||=
+            AssociationMatcher.new(
+              :"has_#{macro}",
+              attachments_association_name,
+            ).
+              conditions(name: name).
+              class_name('ActiveStorage::Attachment').
+              inverse_of(:record)
+        end
+
+        def attachments_association_name
+          case macro
+          when :one then "#{name}_attachment"
+          when :many then "#{name}_attachments"
+          end
+        end
+
+        def blobs_association_exists?
+          if blobs_association_matcher.matches?(subject)
+            true
+          else
+            @failure = blobs_association_matcher.failure_message
+            false
+          end
+        end
+
+        def blobs_association_matcher
+          @_blobs_association_matcher ||=
+            AssociationMatcher.new(
+              :"has_#{macro}",
+              blobs_association_name,
+            ).
+              through(attachments_association_name).
+              class_name('ActiveStorage::Blob').
+              source(:blob)
+        end
+
+        def blobs_association_name
+          case macro
+          when :one then "#{name}_blob"
+          when :many then "#{name}_blobs"
+          end
+        end
+
+        def eager_loading_scope_exists?
+          if model_class.respond_to?("with_attached_#{name}")
+            true
+          else
+            @failure = "#{model_class.name} does not have a " \
+                       ":with_attached_#{name} scope."
+            false
+          end
+        end
+
+        def model_class
+          subject.class
+        end
+      end
+    end
+  end
+end