shoulda-matchers 5.3.0 → 6.2.0

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

@@ -0,0 +1,151 @@
+module Shoulda
+  module Matchers
+    module ActiveRecord
+      # The `normalize` matcher is used to ensure attribute normalizations
+      # are transforming attribute values as expected.
+      #
+      # Take this model for example:
+      #
+      #     class User < ActiveRecord::Base
+      #       normalizes :email, with: -> email { email.strip.downcase }
+      #     end
+      #
+      # You can use `normalize` providing an input and defining the expected
+      # normalization output:
+      #
+      #     # RSpec
+      #     RSpec.describe User, type: :model do
+      #       it do
+      #         should normalize(:email).from(" ME@XYZ.COM\n").to("me@xyz.com")
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class User < ActiveSupport::TestCase
+      #       should normalize(:email).from(" ME@XYZ.COM\n").to("me@xyz.com")
+      #     end
+      #
+      # You can use `normalize` to test multiple attributes at once:
+      #
+      #     class User < ActiveRecord::Base
+      #       normalizes :email, :handle, with: -> value { value.strip.downcase }
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe User, type: :model do
+      #       it do
+      #         should normalize(:email, :handle).from(" Example\n").to("example")
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class User < ActiveSupport::TestCase
+      #       should normalize(:email, :handle).from(" Example\n").to("example")
+      #     end
+      #
+      # If the normalization accepts nil values with the `apply_to_nil` option,
+      # you just need to use `.from(nil).to("Your expected value here")`.
+      #
+      #     class User < ActiveRecord::Base
+      #       normalizes :name, with: -> name { name&.titleize || 'Untitled' },
+      #         apply_to_nil: true
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe User, type: :model do
+      #       it { should normalize(:name).from("jane doe").to("Jane Doe") }
+      #       it { should normalize(:name).from(nil).to("Untitled") }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class User < ActiveSupport::TestCase
+      #       should normalize(:name).from("jane doe").to("Jane Doe")
+      #       should normalize(:name).from(nil).to("Untitled")
+      #     end
+      #
+      # @return [NormalizeMatcher]
+      #
+      def normalize(*attributes)
+        if attributes.empty?
+          raise ArgumentError, 'need at least one attribute'
+        else
+          NormalizeMatcher.new(*attributes)
+        end
+      end
+
+      # @private
+      class NormalizeMatcher
+        attr_reader :attributes, :from_value, :to_value, :failure_message,
+          :failure_message_when_negated
+
+        def initialize(*attributes)
+          @attributes = attributes
+        end
+
+        def description
+          %(
+            normalize #{attributes.to_sentence(last_word_connector: ' and ')} from
+            ‹#{from_value.inspect}› to ‹#{to_value.inspect}›
+          ).squish
+        end
+
+        def from(value)
+          @from_value = value
+
+          self
+        end
+
+        def to(value)
+          @to_value = value
+
+          self
+        end
+
+        def matches?(subject)
+          attributes.all? { |attribute| attribute_matches?(subject, attribute) }
+        end
+
+        def does_not_match?(subject)
+          attributes.all? { |attribute| attribute_does_not_match?(subject, attribute) }
+        end
+
+        private
+
+        def attribute_matches?(subject, attribute)
+          return true if normalize_attribute?(subject, attribute)
+
+          @failure_message = build_failure_message(
+            attribute,
+            subject.class.normalize_value_for(attribute, from_value),
+          )
+          false
+        end
+
+        def attribute_does_not_match?(subject, attribute)
+          return true unless normalize_attribute?(subject, attribute)
+
+          @failure_message_when_negated = build_failure_message_when_negated(attribute)
+          false
+        end
+
+        def normalize_attribute?(subject, attribute)
+          subject.class.normalize_value_for(attribute, from_value) == to_value
+        end
+
+        def build_failure_message(attribute, attribute_value)
+          %(
+            Expected to normalize #{attribute.inspect} from ‹#{from_value.inspect}› to
+            ‹#{to_value.inspect}› but it was normalized to ‹#{attribute_value.inspect}›
+          ).squish
+        end
+
+        def build_failure_message_when_negated(attribute)
+          %(
+            Expected to not normalize #{attribute.inspect} from ‹#{from_value.inspect}› to
+            ‹#{to_value.inspect}› but it was normalized
+          ).squish
+        end
+      end
+    end
+  end
+end

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

@@ -29,7 +29,7 @@ module Shoulda
           end
 
           def symlink_to(parent)
-            namespace.set(name, parent.dup)
+            namespace.set(name, Class.new(parent))
           end
 
           def to_s

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

@@ -411,9 +411,29 @@ module Shoulda
           if scopes_match?
             true
           else
-            @failure_reason = 'Expected the validation '
+            @failure_reason = String.new('Expected the validation ').tap do |failure_reason_string|
+              failure_reason_string <<
+                if expected_scopes.empty?
+                  'not to be scoped to anything, '
+                else
+                  "to be scoped to #{inspected_expected_scopes}, "
+                end
+
+              if actual_sets_of_scopes.any?
+                failure_reason_string << 'but it was scoped to '
+                failure_reason_string << "#{inspected_actual_scopes} instead."
+              else
+                failure_reason_string << 'but it was not scoped to anything.'
+              end
+            end
 
-            @failure_reason <<
+            false
+          end
+        end
+
+        def build_failure_reason
+          String.new('Expected the validation ').tap do |failure_reason_string|
+            failure_reason_string <<
               if expected_scopes.empty?
                 'not to be scoped to anything, '
               else
@@ -421,27 +441,25 @@ module Shoulda
               end
 
             if actual_sets_of_scopes.any?
-              @failure_reason << 'but it was scoped to '
-              @failure_reason << "#{inspected_actual_scopes} instead."
+              failure_reason_string << 'but it was scoped to '
+              failure_reason_string << "#{inspected_actual_scopes} instead."
             else
-              @failure_reason << 'but it was not scoped to anything.'
+              failure_reason_string << 'but it was not scoped to anything.'
             end
-
-            false
           end
         end
 
         def does_not_match_scopes_configuration?
           if scopes_match?
-            @failure_reason = 'Expected the validation '
-
-            if expected_scopes.empty?
-              @failure_reason << 'to be scoped to nothing, '
-              @failure_reason << 'but it was scoped to '
-              @failure_reason << "#{inspected_actual_scopes} instead."
-            else
-              @failure_reason << 'not to be scoped to '
-              @failure_reason << inspected_expected_scopes
+            @failure_reason = String.new('Expected the validation ').tap do |failure_reason|
+              if expected_scopes.empty?
+                failure_reason << 'to be scoped to nothing, '
+                failure_reason << 'but it was scoped to '
+                failure_reason << "#{inspected_actual_scopes} instead."
+              else
+                failure_reason << 'not to be scoped to '
+                failure_reason << inspected_expected_scopes
+              end
             end
 
             false
@@ -618,20 +636,18 @@ module Shoulda
           else
             inspected_scopes = scopes_missing_on_model.map(&:inspect)
 
-            reason = ''
-
-            reason << inspected_scopes.to_sentence
-
-            reason <<
-              if inspected_scopes.many?
-                ' do not seem to be attributes'
-              else
-                ' does not seem to be an attribute'
-              end
+            @failure_reason = String.new.tap do |reason|
+              reason << inspected_scopes.to_sentence
 
-            reason << " on #{model.name}."
+              reason <<
+                if inspected_scopes.many?
+                  ' do not seem to be attributes'
+                else
+                  ' does not seem to be an attribute'
+                end
 
-            @failure_reason = reason
+              reason << " on #{model.name}."
+            end
 
             false
           end
@@ -643,20 +659,18 @@ module Shoulda
           else
             inspected_scopes = scopes_present_on_model.map(&:inspect)
 
-            reason = ''
-
-            reason << inspected_scopes.to_sentence
-
-            reason <<
-              if inspected_scopes.many?
-                ' seem to be attributes'
-              else
-                ' seems to be an attribute'
-              end
+            @failure_reason = String.new.tap do |reason|
+              reason << inspected_scopes.to_sentence
 
-            reason << " on #{model.name}."
+              reason <<
+                if inspected_scopes.many?
+                  ' seem to be attributes'
+                else
+                  ' seems to be an attribute'
+                end
 
-            @failure_reason = reason
+              reason << " on #{model.name}."
+            end
 
             false
           end
@@ -936,45 +950,43 @@ module Shoulda
         end
 
         def failure_message_preface # rubocop:disable Metrics/MethodLength
-          prefix = ''
-
-          if @existing_record_created
-            prefix << "After taking the given #{model.name}"
+          String.new.tap do |prefix|
+            if @existing_record_created
+              prefix << "After taking the given #{model.name}"
+
+              if attribute_setter_for_existing_record
+                prefix << ', setting '
+                prefix << description_for_attribute_setter(
+                  attribute_setter_for_existing_record,
+                )
+              else
+                prefix << ", whose :#{attribute} is "
+                prefix << "‹#{existing_value_read.inspect}›"
+              end
 
-            if attribute_setter_for_existing_record
-              prefix << ', setting '
+              prefix << ', and saving it as the existing record, then'
+            elsif attribute_setter_for_existing_record
+              prefix << "Given an existing #{model.name},"
+              prefix << ' after setting '
               prefix << description_for_attribute_setter(
                 attribute_setter_for_existing_record,
               )
+              prefix << ', then'
             else
-              prefix << ", whose :#{attribute} is "
-              prefix << "‹#{existing_value_read.inspect}›"
+              prefix << "Given an existing #{model.name} whose :#{attribute}"
+              prefix << ' is '
+              prefix << Shoulda::Matchers::Util.inspect_value(
+                existing_value_read,
+              )
+              prefix << ', after'
             end
 
-            prefix << ', and saving it as the existing record, then'
-          elsif attribute_setter_for_existing_record
-            prefix << "Given an existing #{model.name},"
-            prefix << ' after setting '
-            prefix << description_for_attribute_setter(
-              attribute_setter_for_existing_record,
-            )
-            prefix << ', then'
-          else
-            prefix << "Given an existing #{model.name} whose :#{attribute}"
-            prefix << ' is '
-            prefix << Shoulda::Matchers::Util.inspect_value(
-              existing_value_read,
-            )
-            prefix << ', after'
-          end
-
-          prefix << " making a new #{model.name} and setting "
+            prefix << " making a new #{model.name} and setting "
 
-          prefix << descriptions_for_attribute_setters_for_new_record
+            prefix << descriptions_for_attribute_setters_for_new_record
 
-          prefix << ", the matcher expected the new #{model.name} to be"
-
-          prefix
+            prefix << ", the matcher expected the new #{model.name} to be"
+          end
         end
 
         def attribute_changed_value_message

data/lib/shoulda/matchers/active_record.rb

@@ -24,6 +24,8 @@ require 'shoulda/matchers/active_record/define_enum_for_matcher'
 require 'shoulda/matchers/active_record/uniqueness'
 require 'shoulda/matchers/active_record/validate_uniqueness_of_matcher'
 require 'shoulda/matchers/active_record/have_attached_matcher'
+require 'shoulda/matchers/active_record/normalize_matcher'
+require 'shoulda/matchers/active_record/encrypt_matcher'
 
 module Shoulda
   module Matchers

data/lib/shoulda/matchers/doublespeak/double_collection.rb

@@ -18,15 +18,11 @@ module Shoulda
         end
 
         def activate
-          doubles_by_method_name.each do |_method_name, double|
-            double.activate
-          end
+          doubles_by_method_name.each_value(&:activate)
         end
 
         def deactivate
-          doubles_by_method_name.each do |_method_name, double|
-            double.deactivate
-          end
+          doubles_by_method_name.each_value(&:deactivate)
         end
 
         def calls_by_method_name

data/lib/shoulda/matchers/doublespeak/world.rb

@@ -39,15 +39,11 @@ module Shoulda
         private
 
         def activate
-          double_collections_by_class.each do |_klass, double_collection|
-            double_collection.activate
-          end
+          double_collections_by_class.each_value(&:activate)
         end
 
         def deactivate
-          double_collections_by_class.each do |_klass, double_collection|
-            double_collection.deactivate
-          end
+          double_collections_by_class.each_value(&:deactivate)
         end
 
         def double_collections_by_class

data/lib/shoulda/matchers/independent/delegate_method_matcher.rb

@@ -400,7 +400,7 @@ module Shoulda
                 false
               rescue NoMethodError => e
                 if e.message =~
-                   /undefined method `#{delegate_method}' for nil:NilClass/
+                   /undefined method `#{delegate_method}' for nil/
                   false
                 else
                   raise e
@@ -440,22 +440,20 @@ module Shoulda
         end
 
         def formatted_calls_on_delegate_object
-          string = ''
-
-          if calls_on_delegate_object.any?
-            string << "\n\n"
-            calls_on_delegate_object.each_with_index do |call, i|
-              name = call.method_name
-              args = call.args.map(&:inspect).join(', ')
-              string << "#{i + 1}) #{name}(#{args})\n"
+          String.new.tap do |string|
+            if calls_on_delegate_object.any?
+              string << "\n\n"
+              calls_on_delegate_object.each_with_index do |call, i|
+                name = call.method_name
+                args = call.args.map(&:inspect).join(', ')
+                string << "#{i + 1}) #{name}(#{args})\n"
+              end
+            else
+              string << ' (none)'
             end
-          else
-            string << ' (none)'
-          end
 
-          string.rstrip!
-
-          string
+            string.rstrip!
+          end
         end
       end
     end

data/lib/shoulda/matchers/integrations/libraries/action_controller.rb

@@ -12,15 +12,17 @@ module Shoulda
           def integrate_with(test_framework)
             test_framework.include(matchers_module, type: :controller)
 
-            include_into(::ActionController::TestCase, matchers_module) do
-              def subject # rubocop:disable Lint/NestedMethodDefinition
-                @controller
+            tap do |instance|
+              ActiveSupport.on_load(:action_controller_test_case, run_once: true) do
+                instance.include_into(::ActionController::TestCase, instance.matchers_module) do
+                  def subject # rubocop:disable Lint/NestedMethodDefinition
+                    @controller
+                  end
+                end
               end
             end
           end
 
-          private
-
           def matchers_module
             Shoulda::Matchers::ActionController
           end

data/lib/shoulda/matchers/integrations/libraries/routing.rb

@@ -12,11 +12,13 @@ module Shoulda
           def integrate_with(test_framework)
             test_framework.include(matchers_module, type: :routing)
 
-            include_into(::ActionController::TestCase, matchers_module)
+            tap do |instance|
+              ActiveSupport.on_load(:action_controller_test_case, run_once: true) do
+                instance.include_into(::ActionController::TestCase, instance.matchers_module)
+              end
+            end
           end
 
-          private
-
           def matchers_module
             Shoulda::Matchers::Routing
           end

data/lib/shoulda/matchers/rails_shim.rb

@@ -1,7 +1,7 @@
 module Shoulda
   module Matchers
     # @private
-    module RailsShim # rubocop:disable Metrics/ModuleLength
+    module RailsShim
       class << self
         def action_pack_version
           Gem::Version.new(::ActionPack::VERSION::STRING)
@@ -9,10 +9,6 @@ module Shoulda
           Gem::Version.new('0')
         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
@@ -60,9 +56,10 @@ module Shoulda
         end
 
         def serialized_attributes_for(model)
+          type_serialized_defined = Object.const_defined?('ActiveRecord::Type::Serialized')
           attribute_types_for(model).
             inject({}) do |hash, (attribute_name, attribute_type)|
-              if attribute_type.is_a?(::ActiveRecord::Type::Serialized)
+              if type_serialized_defined && attribute_type.is_a?(::ActiveRecord::Type::Serialized)
                 hash.merge(attribute_name => attribute_type.coder)
               else
                 hash
@@ -146,6 +143,10 @@ module Shoulda
             model.respond_to?(:attribute_types)
         end
 
+        def validates_column_options?
+          Gem::Requirement.new('>= 7.1.0').satisfied_by?(active_record_version)
+        end
+
         private
 
         def simply_generate_validation_message(
@@ -172,6 +173,7 @@ module Shoulda
           I18n.translate(primary_translation_key, translate_options)
         end
 
+        # @private
         class FakeAttributeType
           def initialize(model, attribute_name)
             @model = model

data/lib/shoulda/matchers/util/word_wrap.rb

@@ -41,7 +41,7 @@ module Shoulda
 
     # @private
     class Text < ::String
-      LIST_ITEM_REGEXP = /\A((?:[a-z0-9]+(?:\)|\.)|\*) )/.freeze
+      LIST_ITEM_REGEXP = /\A((?:[a-z0-9]+(?:\)|\.)|\*) )/
 
       def indented?
         self =~ /\A +/

data/lib/shoulda/matchers/util.rb

@@ -7,10 +7,9 @@ module Shoulda
       MAXIMUM_LENGTH_OF_VALUE_TO_DISPLAY = 500
 
       def self.deconstantize(path)
-        if (
-          defined?(ActiveSupport::Inflector) &&
-          ActiveSupport::Inflector.respond_to?(:deconstantize)
-        )
+        if defined?(ActiveSupport::Inflector) &&
+           ActiveSupport::Inflector.respond_to?(:deconstantize)
+
           ActiveSupport::Inflector.deconstantize(path)
         else
           path.to_s[0...(path.to_s.rindex('::') || 0)]
@@ -18,10 +17,9 @@ module Shoulda
       end
 
       def self.safe_constantize(camel_cased_word)
-        if (
-          defined?(ActiveSupport::Inflector) &&
-          ActiveSupport::Inflector.respond_to?(:safe_constantize)
-        )
+        if defined?(ActiveSupport::Inflector) &&
+           ActiveSupport::Inflector.respond_to?(:safe_constantize)
+
           ActiveSupport::Inflector.safe_constantize(camel_cased_word)
         else
           begin
@@ -68,21 +66,21 @@ module Shoulda
       end
 
       def self.inspect_range(range)
-        "#{inspect_value(range.first)} to #{inspect_value(range.last)}"
+        "#{inspect_value(range.begin)} to #{inspect_value(range.end)}"
       end
 
       def self.inspect_hash(hash)
-        output = '‹{'
-
-        output << hash.map { |key, value|
-          if key.is_a?(Symbol)
-            "#{key}: #{value.inspect}"
-          else
-            "#{key.inspect} => #{value.inspect}"
-          end
-        }.join(', ')
+        String.new('‹{').tap do |output|
+          output << hash.map { |key, value|
+            if key.is_a?(Symbol)
+              "#{key}: #{value.inspect}"
+            else
+              "#{key.inspect} => #{value.inspect}"
+            end
+          }.join(', ')
 
-        output << '}›'
+          output << '}›'
+        end
       end
 
       def self.dummy_value_for(column_type, array: false)
@@ -94,7 +92,7 @@ module Shoulda
             0
           when :date
             Date.new(2100, 1, 1)
-          when :datetime, :timestamp
+          when :datetime, :timestamp, :timestamptz
             DateTime.new(2100, 1, 1)
           when :time
             Time.new(2000, 1, 1)

data/lib/shoulda/matchers/version.rb

@@ -1,6 +1,6 @@
 module Shoulda
   module Matchers
     # @private
-    VERSION = '5.3.0'.freeze
+    VERSION = '6.2.0'.freeze
   end
 end

data/lib/shoulda/matchers.rb

@@ -14,8 +14,8 @@ require 'shoulda/matchers/active_model'
 require 'shoulda/matchers/active_record'
 require 'shoulda/matchers/routing'
 
-module Shoulda
-  module Matchers
+module Shoulda # :nodoc:
+  module Matchers # :nodoc:
     class << self
       # @private
       attr_accessor :assertion_exception_class

data/shoulda-matchers.gemspec

@@ -36,6 +36,6 @@ Gem::Specification.new do |s|
     'shoulda-matchers.gemspec']
   s.require_paths = ['lib']
 
-  s.required_ruby_version = '>= 2.6.0'
+  s.required_ruby_version = '>= 3.0.5'
   s.add_dependency('activesupport', '>= 5.2.0')
 end