shoulda-matchers 4.1.2 → 4.5.0

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
@@ -269,7 +291,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

@@ -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

@@ -0,0 +1,83 @@
+module Shoulda
+  module Matchers
+    module ActiveRecord
+      # The `have_rich_text` matcher tests usage of the
+      # `has_rich_text` macro.
+      #
+      # #### Example
+      #
+      #     class Post < ActiveRecord
+      #       has_rich_text :content
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Post, type: :model do
+      #       it { should have_rich_text(:content) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class PostTest < ActiveSupport::TestCase
+      #       should have_rich_text(:content)
+      #     end
+      #
+      # @return [HaveRichTextMatcher]
+      #
+      def have_rich_text(rich_text_attribute)
+        HaveRichTextMatcher.new(rich_text_attribute)
+      end
+
+      # @private
+      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'
+        end
+
+        def failure_message
+          "Expected #{subject.class} to #{error_description}"
+        end
+
+        def failure_message_when_negated
+          "Did not expect #{subject.class} to have ActionText::RichText"\
+          " :#{rich_text_attribute}"
+        end
+
+        def matches?(subject)
+          @subject = subject
+          @error = run_checks
+          @error.nil?
+        end
+
+        private
+
+        attr_reader :error, :rich_text_attribute, :subject
+
+        def run_checks
+          if !has_attribute?
+            ":#{rich_text_attribute} does not exist"
+          elsif !has_expected_action_text?
+            :default
+          end
+        end
+
+        def has_attribute?
+          @subject.respond_to?(rich_text_attribute.to_s)
+        end
+
+        def has_expected_action_text?
+          defined?(ActionText::RichText) &&
+            @subject.send(rich_text_attribute).
+              instance_of?(ActionText::RichText)
+        end
+
+        def error_description
+          error == :default ? description : "#{description} but #{error}"
+        end
+      end
+    end
+  end
+end

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

@@ -4,12 +4,7 @@ module Shoulda
       # The `have_secure_token` matcher tests usage of the
       # `has_secure_token` macro.
       #
-      # #### Example
-      #
       #     class User < ActiveRecord
-      #       attr_accessor :token
-      #       attr_accessor :auth_token
-      #
       #       has_secure_token
       #       has_secure_token :auth_token
       #     end
@@ -26,14 +21,32 @@ module Shoulda
       #       should have_secure_token(:auth_token)
       #     end
       #
+      # #### Qualifiers
+      #
+      # ##### ignoring_check_for_db_index
+      #
+      # By default, this matcher tests that an index is defined on your token
+      # column. Use `ignoring_check_for_db_index` if this is not the case.
+      #
+      #     class User < ActiveRecord
+      #       has_secure_token :auth_token
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe User, type: :model do
+      #       it { should have_secure_token(:auth_token).ignoring_check_for_db_index }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class UserTest < ActiveSupport::TestCase
+      #       should have_secure_token(:auth_token).ignoring_check_for_db_index
+      #     end
+      #
       # @return [HaveSecureToken]
       #
-
-      # rubocop:disable Style/PredicateName
       def have_secure_token(token_attribute = :token)
         HaveSecureTokenMatcher.new(token_attribute)
       end
-      # rubocop:enable Style/PredicateName
 
       # @private
       class HaveSecureTokenMatcher
@@ -41,6 +54,7 @@ module Shoulda
 
         def initialize(token_attribute)
           @token_attribute = token_attribute
+          @options = { ignore_check_for_db_index: false }
         end
 
         def description
@@ -49,12 +63,14 @@ module Shoulda
 
         def failure_message
           return if !@errors
+
           "Expected #{@subject.class} to #{description} but the following " \
           "errors were found: #{@errors.join(', ')}"
         end
 
         def failure_message_when_negated
           return if !@errors
+
           "Did not expect #{@subject.class} to have secure token " \
           ":#{token_attribute}"
         end
@@ -65,6 +81,11 @@ module Shoulda
           @errors.empty?
         end
 
+        def ignoring_check_for_db_index
+          @options[:ignore_check_for_db_index] = true
+          self
+        end
+
         private
 
         def run_checks
@@ -75,7 +96,7 @@ module Shoulda
           if !has_expected_db_column?
             @errors << "missing correct column #{token_attribute}:string"
           end
-          if !has_expected_db_index?
+          if !@options[:ignore_check_for_db_index] && !has_expected_db_index?
             @errors << "missing unique index for #{table_and_column}"
           end
           @errors

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

@@ -121,7 +121,9 @@ module Shoulda
 
         def description
           description = "serialize :#{@name}"
-          description += " class_name => #{@options[:type]}" if @options.key?(:type)
+          if @options.key?(:type)
+            description += " class_name => #{@options[:type]}"
+          end
           description
         end
 
@@ -141,13 +143,12 @@ module Shoulda
             klass = serialization_coder
             if klass == @options[:type]
               true
+            elsif klass.respond_to?(:object_class) &&
+                  klass.object_class == @options[:type]
+              true
             else
-              if klass.respond_to?(:object_class) && klass.object_class == @options[:type]
-                true
-              else
-                @missing = ":#{@name} should be a type of #{@options[:type]}"
-                false
-              end
+              @missing = ":#{@name} should be a type of #{@options[:type]}"
+              false
             end
           else
             true
@@ -176,9 +177,12 @@ module Shoulda
         end
 
         def expectation
-          expectation = "#{model_class.name} to serialize the attribute called :#{@name}"
+          expectation = "#{model_class.name} to serialize the attribute called"\
+            " :#{@name}"
           expectation += " with a type of #{@options[:type]}" if @options[:type]
-          expectation += " with an instance of #{@options[:instance_type]}" if @options[:instance_type]
+          if @options[:instance_type]
+            expectation += " with an instance of #{@options[:instance_type]}"
+          end
           expectation
         end