shoulda-matchers 4.3.0 → 5.0.0.rc1

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

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

@@ -84,6 +84,8 @@ module Shoulda
 
       # @private
       class HaveDbColumnMatcher
+        OPTIONS = %i(precision limit default null scale primary).freeze
+
         def initialize(column)
           @column = column
           @options = {}
@@ -95,7 +97,8 @@ module Shoulda
         end
 
         def with_options(opts = {})
-          %w(precision limit default null scale primary).each do |attribute|
+          validate_options(opts)
+          OPTIONS.each do |attribute|
             if opts.key?(attribute.to_sym)
               @options[attribute.to_sym] = opts[attribute.to_sym]
             end
@@ -125,23 +128,38 @@ module Shoulda
 
         def description
           desc = "have db column named #{@column}"
-          desc << " of type #{@options[:column_type]}"    if @options.key?(:column_type)
-          desc << " of precision #{@options[:precision]}" if @options.key?(:precision)
-          desc << " of limit #{@options[:limit]}"         if @options.key?(:limit)
-          desc << " of default #{@options[:default]}"     if @options.key?(:default)
-          desc << " of null #{@options[:null]}"           if @options.key?(:null)
-          desc << " of primary #{@options[:primary]}"     if @options.key?(:primary)
-          desc << " of scale #{@options[:scale]}"         if @options.key?(:scale)
+          if @options.key?(:column_type)
+            desc << " of type #{@options[:column_type]}"
+          end
+          if @options.key?(:precision)
+            desc << " of precision #{@options[:precision]}"
+          end
+          desc << " of limit #{@options[:limit]}" if @options.key?(:limit)
+          desc << " of default #{@options[:default]}" if @options.key?(:default)
+          desc << " of null #{@options[:null]}" if @options.key?(:null)
+          desc << " of primary #{@options[:primary]}" if @options.key?(:primary)
+          desc << " of scale #{@options[:scale]}" if @options.key?(:scale)
           desc
         end
 
         protected
 
+        def validate_options(opts)
+          invalid_options = opts.keys.map(&:to_sym) - OPTIONS
+          if invalid_options.any?
+            raise(
+              ArgumentError,
+              "Unknown option(s): #{invalid_options.map(&:inspect).join(', ')}",
+            )
+          end
+        end
+
         def column_exists?
           if model_class.column_names.include?(@column.to_s)
             true
           else
-            @missing = "#{model_class} does not have a db column named #{@column}."
+            @missing =
+              "#{model_class} does not have a db column named #{@column}."
             false
           end
         end
@@ -152,8 +170,9 @@ module Shoulda
           if matched_column.type.to_s == @options[:column_type].to_s
             true
           else
-            @missing = "#{model_class} has a db column named #{@column} " <<
-                       "of type #{matched_column.type}, not #{@options[:column_type]}."
+            @missing =
+              "#{model_class} has a db column named #{@column} " <<
+              "of type #{matched_column.type}, not #{@options[:column_type]}."
             false
           end
         end
@@ -229,18 +248,21 @@ module Shoulda
             true
           else
             @missing = "#{model_class} has a db column named #{@column} "
-            if @options[:primary]
-              @missing << 'that is not primary, but should be'
-            else
-              @missing << 'that is primary, but should not be'
-            end
+            @missing <<
+              if @options[:primary]
+                'that is not primary, but should be'
+              else
+                'that is primary, but should not be'
+              end
             false
           end
         end
 
         def matched_column
           @_matched_column ||= begin
-            column = model_class.columns.detect { |each| each.name == @column.to_s }
+            column = model_class.columns.detect do |each|
+              each.name == @column.to_s
+            end
             DecoratedColumn.new(model_class, column)
           end
         end

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

@@ -156,7 +156,7 @@ module Shoulda
 
           description <<
             if qualifiers.include?(:unique)
-              Shoulda::Matchers::Util.a_or_an(index_type) + ' '
+              "#{Shoulda::Matchers::Util.a_or_an(index_type)} "
             else
               'an '
             end

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

@@ -0,0 +1,106 @@
+module Shoulda
+  module Matchers
+    module ActiveRecord
+      # The `have_implicit_order_column` matcher tests that the model has `implicit_order_column`
+      # assigned to one of the table columns. (Rails 6+ only)
+      #
+      #     class Product < ApplicationRecord
+      #       self.implicit_order_column = :created_at
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Product, type: :model do
+      #       it { should have_implicit_order_column(:created_at) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class ProductTest < ActiveSupport::TestCase
+      #       should have_implicit_order_column(:created_at)
+      #     end
+      #
+      # @return [HaveImplicitOrderColumnMatcher]
+      #
+      if RailsShim.active_record_gte_6?
+        def have_implicit_order_column(column_name)
+          HaveImplicitOrderColumnMatcher.new(column_name)
+        end
+      end
+
+      # @private
+      class HaveImplicitOrderColumnMatcher
+        attr_reader :failure_message
+
+        def initialize(column_name)
+          @column_name = column_name
+        end
+
+        def matches?(subject)
+          @subject = subject
+          check_column_exists!
+          check_implicit_order_column_matches!
+          true
+        rescue SecondaryCheckFailedError => e
+          @failure_message = Shoulda::Matchers.word_wrap(
+            "Expected #{model.name} to #{expectation}, " +
+            "but that could not be proved: #{e.message}.",
+          )
+          false
+        rescue PrimaryCheckFailedError => e
+          @failure_message = Shoulda::Matchers.word_wrap(
+            "Expected #{model.name} to #{expectation}, but #{e.message}.",
+          )
+          false
+        end
+
+        def failure_message_when_negated
+          Shoulda::Matchers.word_wrap(
+            "Expected #{model.name} not to #{expectation}, but it did.",
+          )
+        end
+
+        def description
+          expectation
+        end
+
+        private
+
+        attr_reader :column_name, :subject
+
+        def check_column_exists!
+          matcher = HaveDbColumnMatcher.new(column_name)
+
+          if !matcher.matches?(@subject)
+            raise SecondaryCheckFailedError.new(
+              "The :#{model.table_name} table does not have a " +
+              ":#{column_name} column",
+            )
+          end
+        end
+
+        def check_implicit_order_column_matches!
+          if model.implicit_order_column.to_s != column_name.to_s
+            message =
+              if model.implicit_order_column.nil?
+                'implicit_order_column is not set'
+              else
+                "it is :#{model.implicit_order_column}"
+              end
+
+            raise PrimaryCheckFailedError.new(message)
+          end
+        end
+
+        def model
+          subject.class
+        end
+
+        def expectation
+          "have an implicit_order_column of :#{column_name}"
+        end
+
+        class SecondaryCheckFailedError < StandardError; end
+        class PrimaryCheckFailedError < StandardError; end
+      end
+    end
+  end
+end

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

@@ -35,17 +35,19 @@ module Shoulda
         def matches?(subject)
           @subject = subject
           if readonly_attributes.include?(@attribute)
-            @failure_message_when_negated = "Did not expect #{@attribute} to be read-only"
+            @failure_message_when_negated = "Did not expect #{@attribute}"\
+            ' to be read-only'
             true
           else
-            if readonly_attributes.empty?
-              @failure_message = "#{class_name} attribute #{@attribute} " <<
-                'is not read-only'
-            else
-              @failure_message = "#{class_name} is making " <<
-                "#{readonly_attributes.to_a.to_sentence} " <<
-                "read-only, but not #{@attribute}."
-            end
+            @failure_message =
+              if readonly_attributes.empty?
+                "#{class_name} attribute #{@attribute} " <<
+                  'is not read-only'
+              else
+                "#{class_name} is making " <<
+                  "#{readonly_attributes.to_a.to_sentence} " <<
+                  "read-only, but not #{@attribute}."
+              end
             false
           end
         end
@@ -57,7 +59,7 @@ module Shoulda
         private
 
         def readonly_attributes
-          @readonly_attributes ||= (@subject.class.readonly_attributes || [])
+          @_readonly_attributes ||= (@subject.class.readonly_attributes || [])
         end
 
         def class_name

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

@@ -12,7 +12,7 @@ module Shoulda
       #
       #     # RSpec
       #     RSpec.describe Post, type: :model do
-      #       it { is_expected.to have_rich_text(:content) }
+      #       it { should have_rich_text(:content) }
       #     end
       #
       #     # Minitest (Shoulda)
@@ -20,20 +20,21 @@ module Shoulda
       #       should have_rich_text(:content)
       #     end
       #
-      # @return [HaveRichText]
+      # @return [HaveRichTextMatcher]
       #
       def have_rich_text(rich_text_attribute)
-        HaveRichText.new(rich_text_attribute)
+        HaveRichTextMatcher.new(rich_text_attribute)
       end
 
       # @private
-      class HaveRichText
+      class HaveRichTextMatcher
         def initialize(rich_text_attribute)
           @rich_text_attribute = rich_text_attribute
         end
 
         def description
-          "have configured :#{rich_text_attribute} as a ActionText::RichText association"
+          "have configured :#{rich_text_attribute} as a "\
+          'ActionText::RichText association'
         end
 
         def failure_message
@@ -41,7 +42,8 @@ module Shoulda
         end
 
         def failure_message_when_negated
-          "Did not expect #{subject.class} to have ActionText::RichText :#{rich_text_attribute}"
+          "Did not expect #{subject.class} to have ActionText::RichText"\
+          " :#{rich_text_attribute}"
         end
 
         def matches?(subject)
@@ -67,7 +69,9 @@ module Shoulda
         end
 
         def has_expected_action_text?
-          @subject.send(rich_text_attribute).class.name == 'ActionText::RichText'
+          defined?(ActionText::RichText) &&
+            @subject.send(rich_text_attribute).
+              instance_of?(ActionText::RichText)
         end
 
         def error_description