shoulda-matchers 3.1.0 → 5.2.0

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

@@ -13,7 +13,7 @@ module Shoulda
       #     end
       #
       #     # RSpec
-      #     describe Phone do
+      #     RSpec.describe Phone, type: :model do
       #       it { should have_db_column(:supported_ios_version) }
       #     end
       #
@@ -37,7 +37,7 @@ module Shoulda
       #     end
       #
       #     # RSpec
-      #     describe Phone do
+      #     RSpec.describe Phone, type: :model do
       #       it do
       #         should have_db_column(:camera_aperture).of_type(:decimal)
       #       end
@@ -52,7 +52,7 @@ module Shoulda
       #
       # Use `with_options` to assert that a column has been defined with
       # certain options (`:precision`, `:limit`, `:default`, `:null`, `:scale`,
-      # or `:primary`).
+      # `:primary` or `:array`).
       #
       #     class CreatePhones < ActiveRecord::Migration
       #       def change
@@ -63,7 +63,7 @@ module Shoulda
       #     end
       #
       #     # RSpec
-      #     describe Phone do
+      #     RSpec.describe Phone, type: :model do
       #       it do
       #         should have_db_column(:camera_aperture).
       #           with_options(precision: 1, null: false)
@@ -84,6 +84,8 @@ module Shoulda
 
       # @private
       class HaveDbColumnMatcher
+        OPTIONS = %i(precision limit default null scale primary array).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
@@ -112,7 +115,8 @@ module Shoulda
             correct_default? &&
             correct_null? &&
             correct_scale? &&
-            correct_primary?
+            correct_primary? &&
+            correct_array?
         end
 
         def failure_message
@@ -125,23 +129,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 +171,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 +249,38 @@ 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 correct_array?
+          return true unless @options.key?(:array)
+
+          if matched_column.array? == @options[:array]
+            true
+          else
+            @missing = "#{model_class} has a db column named #{@column} "
+            @missing <<
+              if @options[:primary]
+                'that is not array, but should be'
+              else
+                'that is array, 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
@@ -269,7 +309,7 @@ module Shoulda
           end
 
           def type_cast_default
-            Shoulda::Matchers::RailsShim.type_cast_default_for(model, self)
+            model.column_defaults[name]
           end
 
           def primary?

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

@@ -2,7 +2,9 @@ module Shoulda
   module Matchers
     module ActiveRecord
       # The `have_db_index` matcher tests that the table that backs your model
-      # has a index on a specific column.
+      # has a specific index.
+      #
+      # You can specify one column:
       #
       #     class CreateBlogs < ActiveRecord::Migration
       #       def change
@@ -15,7 +17,7 @@ module Shoulda
       #     end
       #
       #     # RSpec
-      #     describe Blog do
+      #     RSpec.describe Blog, type: :model do
       #       it { should have_db_index(:user_id) }
       #     end
       #
@@ -24,43 +26,83 @@ module Shoulda
       #       should have_db_index(:user_id)
       #     end
       #
-      # #### Qualifiers
-      #
-      # ##### unique
-      #
-      # Use `unique` to assert that the index is unique.
+      # Or you can specify a group of columns:
       #
       #     class CreateBlogs < ActiveRecord::Migration
       #       def change
       #         create_table :blogs do |t|
+      #           t.integer :user_id
       #           t.string :name
       #         end
       #
-      #         add_index :blogs, :name, unique: true
+      #         add_index :blogs, :user_id, :name
       #       end
       #     end
       #
       #     # RSpec
-      #     describe Blog do
-      #       it { should have_db_index(:name).unique(true) }
+      #     RSpec.describe Blog, type: :model do
+      #       it { should have_db_index([:user_id, :name]) }
       #     end
       #
       #     # Minitest (Shoulda)
       #     class BlogTest < ActiveSupport::TestCase
-      #       should have_db_index(:name).unique(true)
+      #       should have_db_index([:user_id, :name])
+      #     end
+      #
+      # Finally, if you're using Rails 5 and PostgreSQL, you can also specify an
+      # expression:
+      #
+      #     class CreateLoggedErrors < ActiveRecord::Migration
+      #       def change
+      #         create_table :logged_errors do |t|
+      #           t.string :code
+      #           t.jsonb :content
+      #         end
+      #
+      #         add_index :logged_errors, 'lower(code)::text'
+      #       end
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe LoggedError, type: :model do
+      #       it { should have_db_index('lower(code)::text') }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class LoggedErrorTest < ActiveSupport::TestCase
+      #       should have_db_index('lower(code)::text')
       #     end
       #
-      # Since it only ever makes since for `unique` to be `true`, you can also
-      # leave off the argument to save some keystrokes:
+      # #### Qualifiers
+      #
+      # ##### unique
+      #
+      # Use `unique` to assert that the index is either unique or non-unique:
+      #
+      #     class CreateBlogs < ActiveRecord::Migration
+      #       def change
+      #         create_table :blogs do |t|
+      #           t.string :domain
+      #           t.integer :user_id
+      #         end
+      #
+      #         add_index :blogs, :domain, unique: true
+      #         add_index :blogs, :user_id
+      #       end
+      #     end
       #
       #     # RSpec
-      #     describe Blog do
+      #     RSpec.describe Blog, type: :model do
       #       it { should have_db_index(:name).unique }
+      #       it { should have_db_index(:name).unique(true) }   # if you want to be explicit
+      #       it { should have_db_index(:user_id).unique(false) }
       #     end
       #
       #     # Minitest (Shoulda)
       #     class BlogTest < ActiveSupport::TestCase
       #       should have_db_index(:name).unique
+      #       should have_db_index(:name).unique(true)   # if you want to be explicit
+      #       should have_db_index(:user_id).unique(false)
       #     end
       #
       # @return [HaveDbIndexMatcher]
@@ -72,12 +114,12 @@ module Shoulda
       # @private
       class HaveDbIndexMatcher
         def initialize(columns)
-          @columns = normalize_columns_to_array(columns)
-          @options = {}
+          @expected_columns = normalize_columns_to_array(columns)
+          @qualifiers = {}
         end
 
         def unique(unique = true)
-          @options[:unique] = unique
+          @qualifiers[:unique] = unique
           self
         end
 
@@ -87,72 +129,146 @@ module Shoulda
         end
 
         def failure_message
-          "Expected #{expectation} (#{@missing})"
+          message =
+            "Expected #{described_table_name} to #{positive_expectation}"
+
+          message <<
+            if index_exists?
+              ". The index does exist, but #{reason}."
+            elsif reason
+              ", but #{reason}."
+            else
+              ', but it does not.'
+            end
+
+          Shoulda::Matchers.word_wrap(message)
         end
 
         def failure_message_when_negated
-          "Did not expect #{expectation}"
+          Shoulda::Matchers.word_wrap(
+            "Expected #{described_table_name} not to " +
+            "#{negative_expectation}, but it does.",
+          )
         end
 
         def description
-          if @options.key?(:unique)
-            "have a #{index_type} index on columns #{@columns.join(' and ')}"
-          else
-            "have an index on columns #{@columns.join(' and ')}"
-          end
-        end
+          description = 'have '
 
-        protected
+          description <<
+            if qualifiers.include?(:unique)
+              "#{Shoulda::Matchers::Util.a_or_an(index_type)} "
+            else
+              'an '
+            end
 
-        def index_exists?
-          ! matched_index.nil?
+          description << 'index on '
+
+          description << inspected_expected_columns
         end
 
-        def correct_unique?
-          return true unless @options.key?(:unique)
+        private
 
-          is_unique = matched_index.unique
+        attr_reader :expected_columns, :qualifiers, :subject, :reason
 
-          is_unique = !is_unique unless @options[:unique]
+        def normalize_columns_to_array(columns)
+          Array.wrap(columns).map(&:to_s)
+        end
 
-          unless is_unique
-            @missing = "#{table_name} has an index named #{matched_index.name} " <<
-            "of unique #{matched_index.unique}, not #{@options[:unique]}."
-          end
+        def index_exists?
+          !matched_index.nil?
+        end
 
-          is_unique
+        def correct_unique?
+          if qualifiers.include?(:unique)
+            if qualifiers[:unique] && !matched_index.unique
+              @reason = 'it is not unique'
+              false
+            elsif !qualifiers[:unique] && matched_index.unique
+              @reason = 'it is unique'
+              false
+            else
+              true
+            end
+          else
+            true
+          end
         end
 
         def matched_index
-          indexes.detect { |each| each.columns == @columns }
+          @_matched_index ||=
+            if expected_columns.one?
+              actual_indexes.detect do |index|
+                Array.wrap(index.columns) == expected_columns
+              end
+            else
+              actual_indexes.detect do |index|
+                index.columns == expected_columns
+              end
+            end
         end
 
-        def model_class
-          @subject.class
+        def actual_indexes
+          model.connection.indexes(table_name)
+        end
+
+        def described_table_name
+          if model
+            "the #{table_name} table"
+          else
+            'a table'
+          end
         end
 
         def table_name
-          model_class.table_name
+          model.table_name
+        end
+
+        def positive_expectation
+          if index_exists?
+            expectation = "have an index on #{inspected_expected_columns}"
+
+            if qualifiers.include?(:unique)
+              expectation << " and for it to be #{index_type}"
+            end
+
+            expectation
+          else
+            description
+          end
         end
 
-        def indexes
-          ::ActiveRecord::Base.connection.indexes(table_name)
+        def negative_expectation
+          description
         end
 
-        def expectation
-          "#{model_class.name} to #{description}"
+        def inspected_expected_columns
+          if formatted_expected_columns.one?
+            formatted_expected_columns.first.inspect
+          else
+            formatted_expected_columns.inspect
+          end
         end
 
         def index_type
-          if @options[:unique]
+          if qualifiers[:unique]
             'unique'
           else
             'non-unique'
           end
         end
 
-        def normalize_columns_to_array(columns)
-          Array.wrap(columns).map(&:to_s)
+        def formatted_expected_columns
+          expected_columns.map do |column|
+            if column.match?(/^\w+$/)
+              column.to_sym
+            else
+              column
+            end
+          end
+        end
+
+        def model
+          subject&.class
         end
       end
     end