shoulda-matchers 4.1.1 → 4.4.1

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

@@ -269,7 +269,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_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 => error
+          @failure_message = Shoulda::Matchers.word_wrap(
+            "Expected #{model.name} to #{expectation}, " +
+            "but that could not be proved: #{error.message}."
+          )
+          false
+        rescue PrimaryCheckFailedError => error
+          @failure_message = Shoulda::Matchers.word_wrap(
+            "Expected #{model.name} to #{expectation}, but #{error.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_rich_text_matcher.rb

@@ -0,0 +1,79 @@
+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 { is_expected.to have_rich_text(:content) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class PostTest < ActiveSupport::TestCase
+      #       should have_rich_text(:content)
+      #     end
+      #
+      # @return [HaveRichText]
+      #
+      def have_rich_text(rich_text_attribute)
+        HaveRichText.new(rich_text_attribute)
+      end
+
+      # @private
+      class HaveRichText
+        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?
+          @subject.send(rich_text_attribute).class.name == '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
@@ -65,6 +79,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 +94,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

@@ -183,15 +183,11 @@ module Shoulda
         end
 
         def attribute_is_serialized?
-          serialized_attributes.include?(@name)
+          !!serialization_coder
         end
 
         def serialization_coder
-          serialized_attributes[@name]
-        end
-
-        def serialized_attributes
-          Shoulda::Matchers::RailsShim.serialized_attributes_for(model)
+          RailsShim.attribute_serialization_coder_for(model, @name)
         end
 
         def model

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

@@ -396,7 +396,7 @@ module Shoulda
         end
 
         def validations
-          model._validators[@attribute].select do |validator|
+          model.validators_on(@attribute).select do |validator|
             validator.is_a?(::ActiveRecord::Validations::UniquenessValidator)
           end
         end
@@ -820,7 +820,7 @@ module Shoulda
           elsif previous_value.respond_to?(:next)
             previous_value.next
           elsif previous_value.respond_to?(:to_datetime)
-            previous_value.to_datetime.next
+            previous_value.to_datetime.in(60).next
           elsif boolean_value?(previous_value)
             !previous_value
           else

data/lib/shoulda/matchers/independent.rb

@@ -1,5 +1,4 @@
 require 'shoulda/matchers/independent/delegate_method_matcher'
-require 'shoulda/matchers/independent/delegate_method_matcher/stubbed_target'
 require 'shoulda/matchers/independent/delegate_method_matcher/target_not_defined_error'
 
 module Shoulda

data/lib/shoulda/matchers/rails_shim.rb

@@ -3,10 +3,6 @@ module Shoulda
     # @private
     module RailsShim
       class << self
-        def action_pack_gte_4_1?
-          Gem::Requirement.new('>= 4.1').satisfied_by?(action_pack_version)
-        end
-
         def action_pack_gte_5?
           Gem::Requirement.new('>= 5').satisfied_by?(action_pack_version)
         end
@@ -25,6 +21,10 @@ module Shoulda
           Gem::Requirement.new('>= 5').satisfied_by?(active_record_version)
         end
 
+        def active_record_gte_6?
+          Gem::Requirement.new('>= 6').satisfied_by?(active_record_version)
+        end
+
         def active_record_version
           Gem::Version.new(::ActiveRecord::VERSION::STRING)
         rescue NameError
@@ -69,30 +69,20 @@ module Shoulda
         end
 
         def serialized_attributes_for(model)
-          if defined?(::ActiveRecord::Type::Serialized)
-            # Rails 5+
-            serialized_columns = model.columns.select do |column|
-              model.type_for_attribute(column.name).is_a?(
-                ::ActiveRecord::Type::Serialized,
-              )
-            end
-
-            serialized_columns.inject({}) do |hash, column|
-              hash[column.name.to_s] = model.type_for_attribute(column.name).coder
-              hash
+          attribute_types_for(model).
+            inject({}) do |hash, (attribute_name, attribute_type)|
+              if attribute_type.is_a?(::ActiveRecord::Type::Serialized)
+                hash.merge(attribute_name => attribute_type.coder)
+              else
+                hash
+              end
             end
-          else
-            model.serialized_attributes
-          end
+        rescue NotImplementedError
+          {}
         end
 
-        def type_cast_default_for(model, column)
-          if model.respond_to?(:column_defaults)
-            # Rails 4.2
-            model.column_defaults[column.name]
-          else
-            column.default
-          end
+        def attribute_serialization_coder_for(model, attribute_name)
+          serialized_attributes_for(model)[attribute_name.to_s]
         end
 
         def tables_and_views(connection)
@@ -104,11 +94,7 @@ module Shoulda
         end
 
         def verb_for_update
-          if action_pack_gte_4_1?
-            :patch
-          else
-            :put
-          end
+          :patch
         end
 
         def validation_message_key_for_association_required_option
@@ -156,14 +142,35 @@ module Shoulda
           nil
         end
 
+        def attribute_types_for(model)
+          if model.respond_to?(:attribute_types)
+            model.attribute_types
+          elsif model.respond_to?(:type_for_attribute)
+            model.columns.inject({}) do |hash, column|
+              key = column.name.to_s
+              value = model.type_for_attribute(column.name)
+              hash.merge(key => value)
+            end
+          else
+            raise NotImplementedError
+          end
+        end
+
         def attribute_type_for(model, attribute_name)
-          if supports_full_attributes_api?(model)
-            model.attribute_types[attribute_name.to_s]
+          attribute_types_for(model)[attribute_name.to_s]
+        rescue NotImplementedError
+          if model.respond_to?(:type_for_attribute)
+            model.type_for_attribute(attribute_name)
           else
-            LegacyAttributeType.new(model, attribute_name)
+            FakeAttributeType.new(model, attribute_name)
           end
         end
 
+        def supports_full_attributes_api?(model)
+          defined?(::ActiveModel::Attributes) &&
+            model.respond_to?(:attribute_types)
+        end
+
         private
 
         def simply_generate_validation_message(
@@ -188,23 +195,14 @@ module Shoulda
           I18n.translate(primary_translation_key, translate_options)
         end
 
-        def supports_full_attributes_api?(model)
-          defined?(::ActiveModel::Attributes) &&
-            model.respond_to?(:attribute_types)
-        end
-
-        class LegacyAttributeType
+        class FakeAttributeType
           def initialize(model, attribute_name)
             @model = model
             @attribute_name = attribute_name
           end
 
           def coder
-            if model.respond_to?(:serialized_attributes)
-              ActiveSupport::Deprecation.silence do
-                model.serialized_attributes[attribute_name.to_s]
-              end
-            end
+            nil
           end
 
           private