shoulda-matchers 3.1.0 → 5.2.0

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

@@ -9,7 +9,7 @@ module Shoulda
       #     end
       #
       #     # RSpec
-      #     describe User do
+      #     RSpec.describe User, type: :model do
       #       it { should have_readonly_attribute(:password) }
       #     end
       #
@@ -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

@@ -0,0 +1,132 @@
+module Shoulda
+  module Matchers
+    module ActiveRecord
+      # The `have_secure_token` matcher tests usage of the
+      # `has_secure_token` macro.
+      #
+      #     class User < ActiveRecord
+      #       has_secure_token
+      #       has_secure_token :auth_token
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe User, type: :model do
+      #       it { should have_secure_token }
+      #       it { should have_secure_token(:auth_token) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class UserTest < ActiveSupport::TestCase
+      #       should have_secure_token
+      #       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]
+      #
+      def have_secure_token(token_attribute = :token)
+        HaveSecureTokenMatcher.new(token_attribute)
+      end
+
+      # @private
+      class HaveSecureTokenMatcher
+        attr_reader :token_attribute
+
+        def initialize(token_attribute)
+          @token_attribute = token_attribute
+          @options = { ignore_check_for_db_index: false }
+        end
+
+        def description
+          "have :#{token_attribute} as a secure token"
+        end
+
+        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
+
+        def matches?(subject)
+          @subject = subject
+          @errors = run_checks
+          @errors.empty?
+        end
+
+        def ignoring_check_for_db_index
+          @options[:ignore_check_for_db_index] = true
+          self
+        end
+
+        private
+
+        def run_checks
+          @errors = []
+          if !has_expected_instance_methods?
+            @errors << 'missing expected class and instance methods'
+          end
+          if !has_expected_db_column?
+            @errors << "missing correct column #{token_attribute}:string"
+          end
+          if !@options[:ignore_check_for_db_index] && !has_expected_db_index?
+            @errors << "missing unique index for #{table_and_column}"
+          end
+          @errors
+        end
+
+        def has_expected_instance_methods?
+          @subject.respond_to?(token_attribute.to_s) &&
+            @subject.respond_to?("#{token_attribute}=") &&
+            @subject.respond_to?("regenerate_#{token_attribute}") &&
+            @subject.class.respond_to?(:generate_unique_secure_token)
+        end
+
+        def has_expected_db_column?
+          matcher = HaveDbColumnMatcher.new(token_attribute).of_type(:string)
+          matcher.matches?(@subject)
+        end
+
+        def has_expected_db_index?
+          matcher = HaveDbIndexMatcher.new(token_attribute).unique(true)
+          matcher.matches?(@subject)
+        end
+
+        def table_and_column
+          "#{table_name}.#{token_attribute}"
+        end
+
+        def table_name
+          @subject.class.table_name
+        end
+      end
+    end
+  end
+end

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

@@ -8,7 +8,7 @@ module Shoulda
       #     end
       #
       #     # RSpec
-      #     describe Product do
+      #     RSpec.describe Product, type: :model do
       #       it { should serialize(:customizations) }
       #     end
       #
@@ -38,7 +38,7 @@ module Shoulda
       #     end
       #
       #     # RSpec
-      #     describe Product do
+      #     RSpec.describe Product, type: :model do
       #       it do
       #         should serialize(:specifications).
       #           as(ProductSpecsSerializer)
@@ -70,7 +70,7 @@ module Shoulda
       #     end
       #
       #     # RSpec
-      #     describe Product do
+      #     RSpec.describe Product, type: :model do
       #       it do
       #         should serialize(:options).
       #           as_instance_of(ProductOptionsSerializer)
@@ -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,22 +177,21 @@ 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
 
         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/uniqueness/test_model_creator.rb

@@ -1,5 +1,3 @@
-require 'thread'
-
 module Shoulda
   module Matchers
     module ActiveRecord
@@ -37,7 +35,7 @@ module Shoulda
           def new_model
             @_new_model ||= Model.next_unique_copy_of(
               model_name_without_namespace,
-              namespace
+              namespace,
             )
           end
 

data/lib/shoulda/matchers/active_record/uniqueness/test_models.rb

@@ -1,5 +1,3 @@
-require 'thread'
-
 module Shoulda
   module Matchers
     module ActiveRecord

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

@@ -1,6 +1,6 @@
 module Shoulda
   module Matchers
-    module ActiveModel
+    module ActiveRecord
       # @private
       module Uniqueness
       end