shoulda-matchers 6.5.0 → 8.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 28aa81eb37b239f9f7715725027b774736992c82c2f6905b0d244a35f9db080d
-  data.tar.gz: 2433121dc12d086b12c19f5313abcaf8c885cd03de594dd3bcaae0f9150c4173
+  metadata.gz: 223ff92a4826a7403e0f1016553453323108899c2d2f7029873ea9f99b68a1c0
+  data.tar.gz: 2014f3ded4620ce71736c035b8f73959a2a85c1adead8067692173fbca6907de
 SHA512:
-  metadata.gz: c3dab42effbda8285e424feab81c543bb2e84d9764b513db8007a6b6bb0a2dd923fc76db8f253013dc701588dda5ca314fa3d7e2de9e15af84a8a84f9245670b
-  data.tar.gz: 6902d75fa7b45c3adc8c97917e9fc1c610be1e99a95bb860ba5112793cdb7653189e4f303f8c879842576a679e3975a520d8ff98dc160ad2168b3fa0b105ecf5
+  metadata.gz: 3a23155ac210adef58ea71d3cead443b1277b0292972f1365c140b20c671de2f743c39516871ab0ce6ffe0e48b2298a86635533f9fb1f2838577320505b6f91f
+  data.tar.gz: 6999714a118645d1aff05c32ad2a7337111aa7c7501f42822a34ca28e31b5d7caa84d49138ecebf0c1dfad17e9f24fd25583e41b73f9e981c4b9ff1da673fd39

data/README.md

@@ -63,7 +63,7 @@ Start by including `shoulda-matchers` in your Gemfile:
 
 ```ruby
 group :test do
-  gem 'shoulda-matchers', '~> 6.0'
+  gem 'shoulda-matchers', '~> 8.0'
 end
 ```
 
@@ -125,7 +125,7 @@ Otherwise, add `shoulda-matchers` to your Gemfile:
 
 ```ruby
 group :test do
-  gem 'shoulda-matchers', '~> 6.0'
+  gem 'shoulda-matchers', '~> 8.0'
 end
 ```
 
@@ -341,6 +341,7 @@ RSpec.describe MySpecialModel, type: :model do
 end
 ```
 
+<a name="should-vs-is_expectedto"></a>
 ### `should` vs `is_expected.to`
 
 In this README and throughout the documentation, you'll notice that we use the
@@ -503,14 +504,18 @@ machine, understanding the codebase, and creating a good pull request.
 
 ## Compatibility
 
-Shoulda Matchers is tested and supported against Ruby 3.0+, Rails
-6.1+, RSpec 3.x, and Minitest 5.x.
+Shoulda Matchers is tested and supported against Ruby 3.3+, Rails
+7.2+, RSpec 3.x, and Minitest 5.x.
 
 - For Ruby < 2.4 and Rails < 4.1 compatibility, please use [v3.1.3][v3.1.3].
 - For Ruby < 3.0 and Rails < 6.1 compatibility, please use [v4.5.1][v4.5.1].
+- For Rails < 7.1 compatibility, please use [v6.5.0][v6.5.0].
+- For Ruby < 3.3 and Rails < 7.2 compatibility, please use [v7.0.1][v7.0.1].
 
 [v3.1.3]: https://github.com/thoughtbot/shoulda-matchers/tree/v3.1.3
 [v4.5.1]: https://github.com/thoughtbot/shoulda-matchers/tree/v4.5.1
+[v6.5.0]: https://github.com/thoughtbot/shoulda-matchers/tree/v6.5.0
+[v7.0.1]: https://github.com/thoughtbot/shoulda-matchers/tree/v7.0.1
 
 ## Versioning
 
@@ -559,5 +564,4 @@ We are [available for hire][hire].
 [community]: https://thoughtbot.com/community?utm_source=github
 [hire]: https://thoughtbot.com/hire-us?utm_source=github
 
-
 <!-- END /templates/footer.md -->

data/lib/shoulda/matchers/action_controller/render_with_layout_matcher.rb

@@ -111,11 +111,7 @@ module Shoulda
         end
 
         def rendered_with_expected_layout?
-          if @expected_layout.nil?
-            true
-          else
-            rendered_layouts.include?(@expected_layout)
-          end
+          @expected_layout.nil? || rendered_layouts.include?(@expected_layout)
         end
 
         def rendered_layouts

data/lib/shoulda/matchers/action_controller/route_matcher.rb

@@ -125,7 +125,7 @@ module Shoulda
       # @return [RouteMatcher]
       #
       def route(method, path, port: nil)
-        RouteMatcher.new(self, method, path, port: port)
+        RouteMatcher.new(self, method, path, port:)
       end
 
       # @private
@@ -190,7 +190,7 @@ module Shoulda
         def route_recognized?
           context.send(
             :assert_routing,
-            { method: method, path: path },
+            { method:, path: },
             params,
           )
           true

data/lib/shoulda/matchers/action_controller/route_params.rb

@@ -27,7 +27,7 @@ module Shoulda
 
         def extract_params_from_string
           controller, action = args[0].split('#')
-          params = (args[1] || {}).merge!(controller: controller, action: action)
+          params = (args[1] || {}).merge!(controller:, action:)
           normalize_values(params)
         end
 

data/lib/shoulda/matchers/active_model/allow_value_matcher/attribute_setter.rb

@@ -204,9 +204,9 @@ module Shoulda
           def attribute_changed_value_error
             AttributeChangedValueError.create(
               model: object.class,
-              attribute_name: attribute_name,
-              value_written: value_written,
-              value_read: value_read,
+              attribute_name:,
+              value_written:,
+              value_read:,
             )
           end
 
@@ -217,7 +217,7 @@ module Shoulda
           def attribute_does_not_exist_error
             AttributeDoesNotExistError.create(
               model: object.class,
-              attribute_name: attribute_name,
+              attribute_name:,
               value: value_written,
             )
           end

data/lib/shoulda/matchers/active_model/allow_value_matcher/attribute_setter_and_validator.rb

@@ -31,9 +31,9 @@ module Shoulda
             @_attribute_setter ||= AttributeSetter.new(
               matcher_name: :allow_value,
               object: instance,
-              attribute_name: attribute_name,
-              value: value,
-              ignore_interference_by_writer: ignore_interference_by_writer,
+              attribute_name:,
+              value:,
+              ignore_interference_by_writer:,
               after_set_callback: after_setting_value_callback,
             )
           end
@@ -46,9 +46,9 @@ module Shoulda
             @_validator ||= Validator.new(
               instance,
               attribute_to_check_message_against,
-              context: context,
+              context:,
               expects_strict: expects_strict?,
-              expected_message: expected_message,
+              expected_message:,
             )
           end
 

data/lib/shoulda/matchers/active_model/allow_value_matcher.rb

@@ -458,7 +458,7 @@ module Shoulda
               message << '.'
             else
               message << " producing these validation errors:\n\n"
-              message << validator.all_formatted_validation_error_messages
+              message << validator.formatted_validation_error_messages
             end
           end
 
@@ -672,8 +672,8 @@ pass, or do something else entirely.
 
         def default_attribute_message_values
           defaults = {
-            model_name: model_name,
-            instance: instance,
+            model_name:,
+            instance:,
             attribute: attribute_to_check_message_against,
           }
 

data/lib/shoulda/matchers/active_model/errors.rb

@@ -7,7 +7,7 @@ module Shoulda
       # @private
       class NonNullableBooleanError < Shoulda::Matchers::Error
         def self.create(attribute)
-          super(attribute: attribute)
+          super(attribute:)
         end
 
         attr_accessor :attribute
@@ -24,7 +24,7 @@ Hence, this test will fail and there is no way to make it pass.
       # @private
       class CouldNotSetPasswordError < Shoulda::Matchers::Error
         def self.create(model)
-          super(model: model)
+          super(model:)
         end
 
         attr_accessor :model

data/lib/shoulda/matchers/active_model/have_secure_password_matcher.rb

@@ -73,7 +73,7 @@ module Shoulda
 
         def failure_message_when_negated
           MESSAGES[:should_not_have_secure_password] %
-            { subject: @subject.class, description: description }
+            { subject: @subject.class, description: }
         end
 
         protected

data/lib/shoulda/matchers/active_model/helpers.rb

@@ -7,8 +7,10 @@ module Shoulda
           format_validation_errors(object.errors)
         end
 
-        def format_validation_errors(errors)
+        def format_validation_errors(errors, attr = nil)
           list_items = errors.to_hash.keys.map do |attribute|
+            next if attr && attr.to_sym != attribute.to_sym
+
             messages = errors[attribute]
             "* #{attribute}: #{messages}"
           end

data/lib/shoulda/matchers/active_model/validate_absence_of_matcher.rb

@@ -70,10 +70,33 @@ module Shoulda
       #         with_message("there shall be peace on Earth")
       #     end
       #
+      # #### Multiple attributes
+      #
+      # You can pass multiple attributes to assert that each one has the
+      # validation. Any qualifier chained on the matcher is applied to
+      # every attribute uniformly.
+      #
+      #     class Robot
+      #       include ActiveModel::Model
+      #       attr_accessor :arms, :legs
+      #
+      #       validates_absence_of :arms, :legs
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Robot, type: :model do
+      #       it { should validate_absence_of(:arms, :legs) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class RobotTest < ActiveSupport::TestCase
+      #       should validate_absence_of(:arms, :legs)
+      #     end
+      #
       # @return [ValidateAbsenceOfMatcher}
       #
-      def validate_absence_of(attr)
-        ValidateAbsenceOfMatcher.new(attr)
+      def validate_absence_of(*attrs)
+        MatcherCollection.build(attrs) { |attr| ValidateAbsenceOfMatcher.new(attr) }
       end
 
       # @private

data/lib/shoulda/matchers/active_model/validate_acceptance_of_matcher.rb

@@ -73,10 +73,33 @@ module Shoulda
       #         with_message('You must accept the terms of service')
       #     end
       #
+      # #### Multiple attributes
+      #
+      # You can pass multiple attributes to assert that each one has the
+      # validation. Any qualifier chained on the matcher is applied to
+      # every attribute uniformly.
+      #
+      #     class User
+      #       include ActiveModel::Model
+      #       attr_accessor :terms, :privacy_policy
+      #
+      #       validates_acceptance_of :terms, :privacy_policy
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe User, type: :model do
+      #       it { should validate_acceptance_of(:terms, :privacy_policy) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class UserTest < ActiveSupport::TestCase
+      #       should validate_acceptance_of(:terms, :privacy_policy)
+      #     end
+      #
       # @return [ValidateAcceptanceOfMatcher]
       #
-      def validate_acceptance_of(attr)
-        ValidateAcceptanceOfMatcher.new(attr)
+      def validate_acceptance_of(*attrs)
+        MatcherCollection.build(attrs) { |attr| ValidateAcceptanceOfMatcher.new(attr) }
       end
 
       # @private

data/lib/shoulda/matchers/active_model/validate_comparison_of_matcher.rb

@@ -272,10 +272,33 @@ module Shoulda
       #       should validate_comparison_of(:age).is_greater_than(0).allow_nil
       #     end
       #
+      # #### Multiple attributes
+      #
+      # You can pass multiple attributes to assert that each one has the
+      # validation. Any qualifier chained on the matcher is applied to
+      # every attribute uniformly.
+      #
+      #     class Item
+      #       include ActiveModel::Model
+      #       attr_accessor :width, :height
+      #
+      #       validates_comparison_of :width, :height, greater_than: 0
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Item, type: :model do
+      #       it { should validate_comparison_of(:width, :height).is_greater_than(0) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class ItemTest < ActiveSupport::TestCase
+      #       should validate_comparison_of(:width, :height).is_greater_than(0)
+      #     end
+      #
       # @return [ValidateComparisonOfMatcher]
       #
-      def validate_comparison_of(attr)
-        ValidateComparisonOfMatcher.new(attr)
+      def validate_comparison_of(*attrs)
+        MatcherCollection.build(attrs) { |attr| ValidateComparisonOfMatcher.new(attr) }
       end
 
       # @private
@@ -378,6 +401,13 @@ module Shoulda
           end
         end
 
+        def failure_reason
+          raw_submatcher_failure_reason_for(
+            first_submatcher_that_fails_to_match,
+            :failure_message,
+          )
+        end
+
         def given_numeric_column?
           attribute_is_active_record_column? &&
             [:integer, :float, :decimal].include?(column_type)
@@ -485,21 +515,26 @@ module Shoulda
           submatcher,
           failure_message_method
         )
+          Shoulda::Matchers.word_wrap(
+            raw_submatcher_failure_reason_for(submatcher, failure_message_method),
+            indent: 2,
+          )
+        end
+
+        def raw_submatcher_failure_reason_for(submatcher, failure_message_method)
           failure_message = submatcher.public_send(failure_message_method)
           submatcher_description = submatcher.simple_description.
             sub(/\bvalidate that\b/, 'validates').
             sub(/\bdisallow\b/, 'disallows').
             sub(/\ballow\b/, 'allows')
-          submatcher_message =
-            if number_of_submatchers_for_failure_message > 1
-              "In checking that #{model.name} #{submatcher_description}, " +
-                failure_message[0].downcase +
-                failure_message[1..]
-            else
-              failure_message
-            end
 
-          Shoulda::Matchers.word_wrap(submatcher_message, indent: 2)
+          if number_of_submatchers_for_failure_message > 1
+            "In checking that #{model.name} #{submatcher_description}, " +
+              failure_message[0].downcase +
+              failure_message[1..]
+          else
+            failure_message
+          end
         end
 
         def comparison_descriptions

data/lib/shoulda/matchers/active_model/validate_confirmation_of_matcher.rb

@@ -70,10 +70,33 @@ module Shoulda
       #         with_message('Please re-enter your password')
       #     end
       #
+      # #### Multiple attributes
+      #
+      # You can pass multiple attributes to assert that each one has the
+      # validation. Any qualifier chained on the matcher is applied to
+      # every attribute uniformly.
+      #
+      #     class User
+      #       include ActiveModel::Model
+      #       attr_accessor :password, :password_confirmation, :email, :email_confirmation
+      #
+      #       validates_confirmation_of :password, :email
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe User, type: :model do
+      #       it { should validate_confirmation_of(:password, :email) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class UserTest < ActiveSupport::TestCase
+      #       should validate_confirmation_of(:password, :email)
+      #     end
+      #
       # @return [ValidateConfirmationOfMatcher]
       #
-      def validate_confirmation_of(attr)
-        ValidateConfirmationOfMatcher.new(attr)
+      def validate_confirmation_of(*attrs)
+        MatcherCollection.build(attrs) { |attr| ValidateConfirmationOfMatcher.new(attr) }
       end
 
       # @private
@@ -153,7 +176,7 @@ module Shoulda
           matcher.with_message(
             @expected_message,
             against: confirmation_attribute,
-            values: { attribute: attribute },
+            values: { attribute: },
           )
         end
       end

data/lib/shoulda/matchers/active_model/validate_exclusion_of_matcher.rb

@@ -112,10 +112,33 @@ module Shoulda
       #         with_message('You chose a puny weapon')
       #     end
       #
+      # #### Multiple attributes
+      #
+      # You can pass multiple attributes to assert that each one has the
+      # validation. Any qualifier chained on the matcher is applied to
+      # every attribute uniformly.
+      #
+      #     class Article
+      #       include ActiveModel::Model
+      #       attr_accessor :slug, :handle
+      #
+      #       validates_exclusion_of :slug, :handle, in: %w[admin root]
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Article, type: :model do
+      #       it { should validate_exclusion_of(:slug, :handle).in_array(%w[admin root]) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class ArticleTest < ActiveSupport::TestCase
+      #       should validate_exclusion_of(:slug, :handle).in_array(%w[admin root])
+      #     end
+      #
       # @return [ValidateExclusionOfMatcher]
       #
-      def validate_exclusion_of(attr)
-        ValidateExclusionOfMatcher.new(attr)
+      def validate_exclusion_of(*attrs)
+        MatcherCollection.build(attrs) { |attr| ValidateExclusionOfMatcher.new(attr) }
       end
 
       # @private

data/lib/shoulda/matchers/active_model/validate_inclusion_of_matcher.rb

@@ -263,10 +263,33 @@ module Shoulda
       #         allow_blank
       #     end
       #
+      # #### Multiple attributes
+      #
+      # You can pass multiple attributes to assert that each one has the
+      # validation. Any qualifier chained on the matcher is applied to
+      # every attribute uniformly.
+      #
+      #     class Article
+      #       include ActiveModel::Model
+      #       attr_accessor :status, :category
+      #
+      #       validates_inclusion_of :status, :category, in: %w[draft published]
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Article, type: :model do
+      #       it { should validate_inclusion_of(:status, :category).in_array(%w[draft published]) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class ArticleTest < ActiveSupport::TestCase
+      #       should validate_inclusion_of(:status, :category).in_array(%w[draft published])
+      #     end
+      #
       # @return [ValidateInclusionOfMatcher]
       #
-      def validate_inclusion_of(attr)
-        ValidateInclusionOfMatcher.new(attr)
+      def validate_inclusion_of(*attrs)
+        MatcherCollection.build(attrs) { |attr| ValidateInclusionOfMatcher.new(attr) }
       end
 
       # @private
@@ -278,18 +301,6 @@ module Shoulda
         ARBITRARY_OUTSIDE_DATE = Date.jd(9999999)
         ARBITRARY_OUTSIDE_DATETIME = DateTime.jd(9999999)
         ARBITRARY_OUTSIDE_TIME = Time.at(9999999999)
-        BOOLEAN_ALLOWS_BOOLEAN_MESSAGE = <<EOT.freeze
-You are using `validate_inclusion_of` to assert that a boolean column allows
-boolean values and disallows non-boolean ones. Be aware that it is not possible
-to fully test this, as boolean columns will automatically convert non-boolean
-values to boolean ones. Hence, you should consider removing this test.
-EOT
-        BOOLEAN_ALLOWS_NIL_MESSAGE = <<EOT.freeze
-You are using `validate_inclusion_of` to assert that a boolean column allows nil.
-Be aware that it is not possible to fully test this, as anything other than
-true, false or nil will be converted to false. Hence, you should consider
-removing this test.
-EOT
 
         def initialize(attribute)
           super(attribute)
@@ -400,6 +411,24 @@ EOT
 
         private
 
+        def boolean_allows_boolean_message
+          <<-EOT.strip
+            You are using `validate_inclusion_of` to assert that the column '#{@subject.class.name}##{attribute}'
+            allows boolean values and disallows non-boolean ones. Be aware that it
+            is not possible to fully test this, as boolean columns will automatically
+            convert non-boolean values to boolean ones. Hence, you should consider
+            removing this test.
+          EOT
+        end
+
+        def boolean_allows_nil_message
+          <<-EOT.strip
+            You are using `validate_inclusion_of` to assert that the column '#{@subject.class.name}##{attribute}'
+            allows nil. Be aware that it is not possible to fully test this, as anything other than
+            true, false or nil will be converted to false. Hence, you should consider removing this test.
+          EOT
+        end
+
         def minimum_range_value
           @range.begin
         end
@@ -492,11 +521,11 @@ EOT
           if attribute_type == :boolean
             case @array
             when [false, true], [true, false]
-              Shoulda::Matchers.warn BOOLEAN_ALLOWS_BOOLEAN_MESSAGE
+              Shoulda::Matchers.warn boolean_allows_boolean_message
               return true
             when [nil]
               if attribute_column.null
-                Shoulda::Matchers.warn BOOLEAN_ALLOWS_NIL_MESSAGE
+                Shoulda::Matchers.warn boolean_allows_nil_message
                 return true
               else
                 raise NonNullableBooleanError.create(@attribute)
@@ -513,11 +542,11 @@ EOT
           if attribute_type == :boolean
             case @array
             when [false, true], [true, false]
-              Shoulda::Matchers.warn BOOLEAN_ALLOWS_BOOLEAN_MESSAGE
+              Shoulda::Matchers.warn boolean_allows_boolean_message
               return true
             when [nil]
               if attribute_column.null
-                Shoulda::Matchers.warn BOOLEAN_ALLOWS_NIL_MESSAGE
+                Shoulda::Matchers.warn boolean_allows_nil_message
                 return true
               else
                 raise NonNullableBooleanError.create(@attribute)

data/lib/shoulda/matchers/active_model/validate_length_of_matcher.rb

@@ -240,7 +240,6 @@ module Shoulda
       #       should validate_length_of(:bio).is_at_least(15).allow_nil
       #     end
       #
-      # @return [ValidateLengthOfMatcher]
       #
       # ##### allow_blank
       #
@@ -286,8 +285,32 @@ module Shoulda
       #       should validate_length_of(:arr).as_array.is_at_least(15)
       #     end
       #
-      def validate_length_of(attr)
-        ValidateLengthOfMatcher.new(attr)
+      # #### Multiple attributes
+      #
+      # You can pass multiple attributes to assert that each one has the
+      # validation. Any qualifier chained on the matcher is applied to
+      # every attribute uniformly.
+      #
+      #     class User
+      #       include ActiveModel::Model
+      #       attr_accessor :first_name, :last_name
+      #
+      #       validates_length_of :first_name, :last_name, minimum: 2
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe User, type: :model do
+      #       it { should validate_length_of(:first_name, :last_name).is_at_least(2) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class UserTest < ActiveSupport::TestCase
+      #       should validate_length_of(:first_name, :last_name).is_at_least(2)
+      #     end
+      #
+      # @return [ValidateLengthOfMatcher]
+      def validate_length_of(*attrs)
+        MatcherCollection.build(attrs) { |attr| ValidateLengthOfMatcher.new(attr) }
       end
 
       # @private