shoulda-matchers 3.1.0 → 5.2.0

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

@@ -10,11 +10,11 @@ module Shoulda
       # pre-existing record (thereby failing the uniqueness check).
       #
       #     class Post < ActiveRecord::Base
-      #       validates_uniqueness_of :permalink
+      #       validates :permalink, uniqueness: true
       #     end
       #
       #     # RSpec
-      #     describe Post do
+      #     RSpec.describe Post, type: :model do
       #       it { should validate_uniqueness_of(:permalink) }
       #     end
       #
@@ -49,39 +49,50 @@ module Shoulda
       #
       # You may be tempted to test the model like this:
       #
-      #     describe Post do
+      #     RSpec.describe Post, type: :model do
       #       it { should validate_uniqueness_of(:title) }
       #     end
       #
-      # However, running this test will fail with something like:
+      # However, running this test will fail with an exception such as:
       #
-      #     Failures:
+      #     Shoulda::Matchers::ActiveRecord::ValidateUniquenessOfMatcher::ExistingRecordInvalid:
+      #       validate_uniqueness_of works by matching a new record against an
+      #       existing record. If there is no existing record, it will create one
+      #       using the record you provide.
       #
-      #       1) Post should validate :title to be case-sensitively unique
-      #          Failure/Error: it { should validate_uniqueness_of(:title) }
-      #          ActiveRecord::StatementInvalid:
-      #            SQLite3::ConstraintException: posts.content may not be NULL: INSERT INTO "posts" ("title") VALUES (?)
+      #       While doing this, the following error was raised:
+      #
+      #         PG::NotNullViolation: ERROR:  null value in column "content" violates not-null constraint
+      #         DETAIL:  Failing row contains (1, null, null).
+      #         : INSERT INTO "posts" DEFAULT VALUES RETURNING "id"
+      #
+      #       The best way to fix this is to provide the matcher with a record where
+      #       any required attributes are filled in with valid values beforehand.
+      #
+      # (The exact error message will differ depending on which database you're
+      # using, but you get the idea.)
       #
       # This happens because `validate_uniqueness_of` tries to create a new post
       # but cannot do so because of the `content` attribute: though unrelated to
-      # this test, it nevertheless needs to be filled in. The solution is to
-      # build a custom Post object ahead of time with `content` filled in:
+      # this test, it nevertheless needs to be filled in. As indicated at the
+      # end of the error message, the solution is to build a custom Post object
+      # ahead of time with `content` filled in:
       #
-      #     describe Post do
+      #     RSpec.describe Post, type: :model do
       #       describe "validations" do
-      #         subject { Post.new(content: 'Here is the content') }
+      #         subject { Post.new(content: "Here is the content") }
       #         it { should validate_uniqueness_of(:title) }
       #       end
       #     end
       #
       # Or, if you're using
-      # [FactoryGirl](http://github.com/thoughtbot/factory_girl) and you have a
+      # [FactoryBot](https://github.com/thoughtbot/factory_bot) and you have a
       # `post` factory defined which automatically fills in `content`, you can
       # say:
       #
-      #     describe Post do
+      #     RSpec.describe Post, type: :model do
       #       describe "validations" do
-      #         subject { FactoryGirl.build(:post) }
+      #         subject { FactoryBot.build(:post) }
       #         it { should validate_uniqueness_of(:title) }
       #       end
       #     end
@@ -91,11 +102,11 @@ module Shoulda
       # Use `on` if your validation applies only under a certain context.
       #
       #     class Post < ActiveRecord::Base
-      #       validates_uniqueness_of :title, on: :create
+      #       validates :title, uniqueness: true, on: :create
       #     end
       #
       #     # RSpec
-      #     describe Post do
+      #     RSpec.describe Post, type: :model do
       #       it { should validate_uniqueness_of(:title).on(:create) }
       #     end
       #
@@ -109,11 +120,11 @@ module Shoulda
       # Use `with_message` if you are using a custom validation message.
       #
       #     class Post < ActiveRecord::Base
-      #       validates_uniqueness_of :title, message: 'Please choose another title'
+      #       validates :title, uniqueness: true, message: 'Please choose another title'
       #     end
       #
       #     # RSpec
-      #     describe Post do
+      #     RSpec.describe Post, type: :model do
       #       it do
       #         should validate_uniqueness_of(:title).
       #           with_message('Please choose another title')
@@ -133,11 +144,11 @@ module Shoulda
       # unique, but the scoped attributes are not unique either.
       #
       #     class Post < ActiveRecord::Base
-      #       validates_uniqueness_of :slug, scope: :journal_id
+      #       validates :slug, uniqueness: { scope: :journal_id }
       #     end
       #
       #     # RSpec
-      #     describe Post do
+      #     RSpec.describe Post, type: :model do
       #       it { should validate_uniqueness_of(:slug).scoped_to(:journal_id) }
       #     end
       #
@@ -146,6 +157,12 @@ module Shoulda
       #       should validate_uniqueness_of(:slug).scoped_to(:journal_id)
       #     end
       #
+      # NOTE: Support for testing uniqueness validation scoped to an array of
+      # associations is not available.
+      #
+      # For more information, please refer to
+      # https://github.com/thoughtbot/shoulda-matchers/issues/814
+      #
       # ##### case_insensitive
       #
       # Use `case_insensitive` to test usage of the `:case_sensitive` option
@@ -154,11 +171,11 @@ module Shoulda
       # attributes in the pre-existing record.
       #
       #     class Post < ActiveRecord::Base
-      #       validates_uniqueness_of :key, case_sensitive: false
+      #       validates :key, uniqueness: { case_sensitive: false }
       #     end
       #
       #     # RSpec
-      #     describe Post do
+      #     RSpec.describe Post, type: :model do
       #       it { should validate_uniqueness_of(:key).case_insensitive }
       #     end
       #
@@ -182,7 +199,7 @@ module Shoulda
       # attribute.
       #
       #     class User < ActiveRecord::Base
-      #       validates_uniqueness_of :email
+      #       validates :email, uniqueness: true
       #
       #       def email=(value)
       #         super(value.downcase)
@@ -190,7 +207,7 @@ module Shoulda
       #     end
       #
       #     # RSpec
-      #     describe Post do
+      #     RSpec.describe Post, type: :model do
       #       it do
       #         should validate_uniqueness_of(:email).ignoring_case_sensitivity
       #       end
@@ -206,11 +223,11 @@ module Shoulda
       # Use `allow_nil` to assert that the attribute allows nil.
       #
       #     class Post < ActiveRecord::Base
-      #       validates_uniqueness_of :author_id, allow_nil: true
+      #       validates :author_id, uniqueness: true, allow_nil: true
       #     end
       #
       #     # RSpec
-      #     describe Post do
+      #     RSpec.describe Post, type: :model do
       #       it { should validate_uniqueness_of(:author_id).allow_nil }
       #     end
       #
@@ -226,11 +243,11 @@ module Shoulda
       # Use `allow_blank` to assert that the attribute allows a blank value.
       #
       #     class Post < ActiveRecord::Base
-      #       validates_uniqueness_of :author_id, allow_blank: true
+      #       validates :author_id, uniqueness: true, allow_blank: true
       #     end
       #
       #     # RSpec
-      #     describe Post do
+      #     RSpec.describe Post, type: :model do
       #       it { should validate_uniqueness_of(:author_id).allow_blank }
       #     end
       #
@@ -253,19 +270,19 @@ module Shoulda
           super(attribute)
           @expected_message = :taken
           @options = {
-            case_sensitivity_strategy: :sensitive
+            case_sensitivity_strategy: :sensitive,
           }
           @existing_record_created = false
           @failure_reason = nil
           @failure_reason_when_negated = nil
           @attribute_setters = {
-            existing_record: [],
-            new_record: []
+            existing_record: AttributeSetters.new,
+            new_record: AttributeSetters.new,
           }
         end
 
         def scoped_to(*scopes)
-          @options[:scopes] = [*scopes].flatten
+          @options[:scopes] = [*scopes].flatten.map(&:to_sym)
           self
         end
 
@@ -285,7 +302,7 @@ module Shoulda
         end
 
         def expects_to_allow_nil?
-          @options[:allow_nil]
+          @options[:allow_nil] == true
         end
 
         def allow_blank
@@ -294,7 +311,7 @@ module Shoulda
         end
 
         def expects_to_allow_blank?
-          @options[:allow_blank]
+          @options[:allow_blank] == true
         end
 
         def simple_description
@@ -313,15 +330,29 @@ module Shoulda
           @given_record = given_record
           @all_records = model.all
 
-          existing_record_valid? &&
-            validate_attribute_present? &&
-            validate_scopes_present? &&
-            scopes_match? &&
-            validate_two_records_with_same_non_blank_value_cannot_coexist? &&
-            validate_case_sensitivity? &&
-            validate_after_scope_change? &&
-            allows_nil? &&
-            allows_blank?
+          matches_presence_of_attribute? &&
+            matches_presence_of_scopes? &&
+            matches_scopes_configuration? &&
+            matches_uniqueness_without_scopes? &&
+            matches_uniqueness_with_case_sensitivity_strategy? &&
+            matches_uniqueness_with_scopes? &&
+            matches_allow_nil? &&
+            matches_allow_blank?
+        ensure
+          Uniqueness::TestModels.remove_all
+        end
+
+        def does_not_match?(given_record)
+          @given_record = given_record
+          @all_records = model.all
+
+          does_not_match_presence_of_scopes? ||
+            does_not_match_scopes_configuration? ||
+            does_not_match_uniqueness_without_scopes? ||
+            does_not_match_uniqueness_with_case_sensitivity_strategy? ||
+            does_not_match_uniqueness_with_scopes? ||
+            does_not_match_allow_nil? ||
+            does_not_match_allow_blank?
         ensure
           Uniqueness::TestModels.remove_all
         end
@@ -370,83 +401,121 @@ module Shoulda
           end
         end
 
-        def validation
-          model._validators[@attribute].detect do |validator|
+        def validations
+          model.validators_on(@attribute).select do |validator|
             validator.is_a?(::ActiveRecord::Validations::UniquenessValidator)
           end
         end
 
-        def scopes_match?
-          if expected_scopes == actual_scopes
+        def matches_scopes_configuration?
+          if scopes_match?
             true
           else
-            @failure_reason = 'Expected the validation'
+            @failure_reason = 'Expected the validation '
 
-            if expected_scopes.empty?
-              @failure_reason << ' not to be scoped to anything'
+            @failure_reason <<
+              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 << 'but it was scoped to '
+              @failure_reason << "#{inspected_actual_scopes} instead."
             else
-              @failure_reason << " to be scoped to #{inspected_expected_scopes}"
+              @failure_reason << 'but it was not scoped to anything.'
             end
 
-            if actual_scopes.empty?
-              @failure_reason << ', but it was not scoped to anything.'
-            else
-              @failure_reason << ', but it was scoped to '
+            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
             end
 
             false
+          else
+            true
           end
         end
 
-        def expected_scopes
-          Array.wrap(@options[:scopes])
+        def scopes_match?
+          actual_sets_of_scopes.empty? && expected_scopes.empty? ||
+            actual_sets_of_scopes.any? { |scopes| scopes == expected_scopes }
         end
 
         def inspected_expected_scopes
           expected_scopes.map(&:inspect).to_sentence
         end
 
-        def actual_scopes
-          if validation
-            Array.wrap(validation.options[:scope])
+        def inspected_actual_scopes
+          inspected_actual_sets_of_scopes.to_sentence(
+            words_connector: ' and ',
+            last_word_connector: ', and',
+          )
+        end
+
+        def inspected_actual_sets_of_scopes
+          inspected_sets_of_scopes = actual_sets_of_scopes.map do |scopes|
+            scopes.map(&:inspect)
+          end
+
+          if inspected_sets_of_scopes.many?
+            inspected_sets_of_scopes.map { |x| "(#{x.to_sentence})" }
           else
-            []
+            inspected_sets_of_scopes.map(&:to_sentence)
           end
         end
 
-        def inspected_actual_scopes
-          actual_scopes.map(&:inspect).to_sentence
+        def expected_scopes
+          Array.wrap(@options[:scopes])
         end
 
-        def allows_nil?
-          if expects_to_allow_nil?
-            update_existing_record!(nil)
+        def actual_sets_of_scopes
+          validations.map do |validation|
+            Array.wrap(validation.options[:scope]).map(&:to_sym)
+          end.reject(&:empty?)
+        end
+
+        def matches_allow_nil?
+          !expects_to_allow_nil? || (
+            update_existing_record!(nil) &&
             allows_value_of(nil, @expected_message)
-          else
-            true
-          end
+          )
+        end
+
+        def does_not_match_allow_nil?
+          expects_to_allow_nil? && (
+            update_existing_record!(nil) &&
+            (@failure_reason = nil ||
+              disallows_value_of(nil, @expected_message)
+            )
+          )
         end
 
-        def allows_blank?
-          if expects_to_allow_blank?
-            update_existing_record!('')
+        def matches_allow_blank?
+          !expects_to_allow_blank? || (
+            update_existing_record!('') &&
             allows_value_of('', @expected_message)
-          else
-            true
-          end
+          )
         end
 
-        def existing_record_valid?
-          if existing_record.valid?
-            true
-          else
-            @failure_reason =
-              "The record you provided could not be created, " +
-              "as it failed with the following validation errors:\n\n" +
-              format_validation_errors(existing_record.errors)
-            false
-          end
+        def does_not_match_allow_blank?
+          expects_to_allow_blank? && (
+            update_existing_record!('') &&
+            (@failure_reason = nil || disallows_value_of('', @expected_message))
+          )
         end
 
         def existing_record
@@ -467,46 +536,34 @@ module Shoulda
         end
 
         def find_existing_record
-          record = model.first
-
-          if record.present?
-            record
-          else
-            nil
-          end
+          model.first.presence
         end
 
         def create_existing_record
           @given_record.tap do |existing_record|
-            ensure_secure_password_set(existing_record)
-            existing_record.save
+            existing_record.save(validate: false)
           end
+        rescue ::ActiveRecord::StatementInvalid => e
+          raise ExistingRecordInvalid.create(underlying_exception: e)
         end
 
         def update_existing_record!(value)
           if existing_value_read != value
-            set_attribute_on!(
-              :existing_record,
-              existing_record,
-              @attribute,
-              value
-            )
-            existing_record.save!
+            set_attribute_on_existing_record!(@attribute, value)
+            # It would be nice if we could ensure that the record was valid,
+            # but that would break users' existing tests
+            existing_record.save(validate: false)
           end
-        end
 
-        def ensure_secure_password_set(instance)
-          if has_secure_password?
-            instance.password = "password"
-            instance.password_confirmation = "password"
-          end
+          true
         end
 
         def arbitrary_non_blank_value
+          non_blank_value = dummy_value_for(@attribute)
           limit = column_limit_for(@attribute)
-          non_blank_value = 'an arbitrary value'
 
-          if limit && limit < non_blank_value.length
+          is_string_value = non_blank_value.is_a?(String)
+          if is_string_value && limit && limit < non_blank_value.length
             'x' * limit
           else
             non_blank_value
@@ -514,9 +571,7 @@ module Shoulda
         end
 
         def has_secure_password?
-          model.ancestors.map(&:to_s).include?(
-            'ActiveModel::SecurePassword::InstanceMethodsOnActivation'
-          )
+          Shoulda::Matchers::RailsShim.has_secure_password?(subject, @attribute)
         end
 
         def build_new_record
@@ -525,15 +580,15 @@ module Shoulda
           attribute_names_under_test.each do |attribute_name|
             set_attribute_on_new_record!(
               attribute_name,
-              existing_record.public_send(attribute_name)
+              existing_record.public_send(attribute_name),
             )
           end
 
           @new_record
         end
 
-        def validate_attribute_present?
-          if model.method_defined?("#{attribute}=")
+        def matches_presence_of_attribute?
+          if attribute_present_on_model?
             true
           else
             @failure_reason =
@@ -542,19 +597,37 @@ module Shoulda
           end
         end
 
-        def validate_scopes_present?
-          if all_scopes_present_on_model?
+        def does_not_match_presence_of_attribute?
+          if attribute_present_on_model?
+            @failure_reason =
+              ":#{attribute} seems to be an attribute on #{model.name}."
+            false
+          else
+            true
+          end
+        end
+
+        def attribute_present_on_model?
+          model.method_defined?("#{attribute}=") ||
+            model.columns_hash.key?(attribute.to_s)
+        end
+
+        def matches_presence_of_scopes?
+          if scopes_missing_on_model.none?
             true
           else
+            inspected_scopes = scopes_missing_on_model.map(&:inspect)
+
             reason = ''
 
-            reason << inspected_scopes_missing_on_model.to_sentence
+            reason << inspected_scopes.to_sentence
 
-            if inspected_scopes_missing_on_model.many?
-              reason << " do not seem to be attributes"
-            else
-              reason << " does not seem to be an attribute"
-            end
+            reason <<
+              if inspected_scopes.many?
+                ' do not seem to be attributes'
+              else
+                ' does not seem to be an attribute'
+              end
 
             reason << " on #{model.name}."
 
@@ -564,21 +637,44 @@ module Shoulda
           end
         end
 
-        def all_scopes_present_on_model?
-          scopes_missing_on_model.none?
+        def does_not_match_presence_of_scopes?
+          if scopes_missing_on_model.any?
+            true
+          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
+
+            reason << " on #{model.name}."
+
+            @failure_reason = reason
+
+            false
+          end
         end
 
-        def scopes_missing_on_model
-          @_missing_scopes ||= expected_scopes.select do |scope|
-            !model.method_defined?("#{scope}=")
+        def scopes_present_on_model
+          @_scopes_present_on_model ||= expected_scopes.select do |scope|
+            model.method_defined?("#{scope}=")
           end
         end
 
-        def inspected_scopes_missing_on_model
-          scopes_missing_on_model.map(&:inspect)
+        def scopes_missing_on_model
+          @_scopes_missing_on_model ||= expected_scopes.reject do |scope|
+            model.method_defined?("#{scope}=")
+          end
         end
 
-        def validate_two_records_with_same_non_blank_value_cannot_coexist?
+        def matches_uniqueness_without_scopes?
           if existing_value_read.blank?
             update_existing_record!(arbitrary_non_blank_value)
           end
@@ -586,8 +682,18 @@ module Shoulda
           disallows_value_of(existing_value_read, @expected_message)
         end
 
-        def validate_case_sensitivity?
-          if should_validate_case_sensitivity?
+        def does_not_match_uniqueness_without_scopes?
+          @failure_reason = nil
+
+          if existing_value_read.blank?
+            update_existing_record!(arbitrary_non_blank_value)
+          end
+
+          allows_value_of(existing_value_read, @expected_message)
+        end
+
+        def matches_uniqueness_with_case_sensitivity_strategy?
+          if should_test_case_sensitivity?
             value = existing_value_read
             swapcased_value = value.swapcase
 
@@ -596,7 +702,7 @@ module Shoulda
                 raise NonCaseSwappableValueError.create(
                   model: model,
                   attribute: @attribute,
-                  value: value
+                  value: value,
                 )
               end
 
@@ -609,7 +715,32 @@ module Shoulda
           end
         end
 
-        def should_validate_case_sensitivity?
+        def does_not_match_uniqueness_with_case_sensitivity_strategy?
+          if should_test_case_sensitivity?
+            @failure_reason = nil
+
+            value = existing_value_read
+            swapcased_value = value.swapcase
+
+            if case_sensitivity_strategy == :sensitive
+              disallows_value_of(swapcased_value, @expected_message)
+            else
+              if value == swapcased_value
+                raise NonCaseSwappableValueError.create(
+                  model: model,
+                  attribute: @attribute,
+                  value: value,
+                )
+              end
+
+              allows_value_of(swapcased_value, @expected_message)
+            end
+          else
+            true
+          end
+        end
+
+        def should_test_case_sensitivity?
           case_sensitivity_strategy != :ignore &&
             existing_value_read.respond_to?(:swapcase) &&
             !existing_value_read.empty?
@@ -621,37 +752,49 @@ module Shoulda
           false
         end
 
-        def validate_after_scope_change?
-          if expected_scopes.empty? || all_scopes_are_booleans?
-            true
-          else
+        def matches_uniqueness_with_scopes?
+          expected_scopes.none? ||
+            all_scopes_are_booleans? ||
             expected_scopes.all? do |scope|
-              previous_value = @all_records.map(&scope).compact.max
+              setting_next_value_for(scope) do
+                allows_value_of(existing_value_read, @expected_message)
+              end
+            end
+        end
 
-              next_value =
-                if previous_value.blank?
-                  dummy_value_for(scope)
-                else
-                  next_value_for(scope, previous_value)
-                end
+        def does_not_match_uniqueness_with_scopes?
+          expected_scopes.any? &&
+            !all_scopes_are_booleans? &&
+            expected_scopes.any? do |scope|
+              setting_next_value_for(scope) do
+                @failure_reason = nil
+                disallows_value_of(existing_value_read, @expected_message)
+              end
+            end
+        end
 
-              set_attribute_on_new_record!(scope, next_value)
+        def setting_next_value_for(scope)
+          previous_value = @all_records.map(&scope).compact.max
 
-              if allows_value_of(existing_value_read, @expected_message)
-                set_attribute_on_new_record!(scope, previous_value)
-                true
-              else
-                false
-              end
+          next_value =
+            if previous_value.blank?
+              dummy_value_for(scope)
+            else
+              next_value_for(scope, previous_value)
             end
-          end
+
+          set_attribute_on_new_record!(scope, next_value)
+
+          yield
+        ensure
+          set_attribute_on_new_record!(scope, previous_value)
         end
 
         def dummy_value_for(scope)
           column = column_for(scope)
 
           if column.respond_to?(:array) && column.array
-            [ dummy_scalar_value_for(column) ]
+            [dummy_scalar_value_for(column)]
           else
             dummy_scalar_value_for(column)
           end
@@ -663,7 +806,7 @@ module Shoulda
 
         def next_value_for(scope, previous_value)
           if previous_value.is_a?(Array)
-            [ next_scalar_value_for(scope, previous_value[0]) ]
+            [next_scalar_value_for(scope, previous_value[0])]
           else
             next_scalar_value_for(scope, previous_value)
           end
@@ -682,7 +825,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
@@ -697,7 +840,7 @@ module Shoulda
         end
 
         def boolean_value?(value)
-          value.in?([true, false])
+          [true, false].include?(value)
         end
 
         def defined_as_enum?(scope)
@@ -719,7 +862,7 @@ module Shoulda
           attribute_setter = build_attribute_setter(
             record,
             attribute_name,
-            value
+            value,
           )
           attribute_setter.set!
 
@@ -731,7 +874,7 @@ module Shoulda
             :existing_record,
             existing_record,
             attribute_name,
-            value
+            value,
           )
         end
 
@@ -740,7 +883,7 @@ module Shoulda
             :new_record,
             new_record,
             attribute_name,
-            value
+            value,
           )
         end
 
@@ -748,18 +891,24 @@ module Shoulda
           @attribute_setters[:existing_record].last
         end
 
+        def attribute_setters_for_new_record
+          @attribute_setters[:new_record] +
+            [last_attribute_setter_used_on_new_record]
+        end
+
         def attribute_names_under_test
           [@attribute] + expected_scopes
         end
 
         def build_attribute_setter(record, attribute_name, value)
-          Shoulda::Matchers::ActiveModel::AllowValueMatcher::AttributeSetter.new(
-            matcher_name: :validate_uniqueness_of,
-            object: record,
-            attribute_name: attribute_name,
-            value: value,
-            ignore_interference_by_writer: ignore_interference_by_writer
-          )
+          Shoulda::Matchers::ActiveModel::AllowValueMatcher::AttributeSetter.
+            new(
+              matcher_name: :validate_uniqueness_of,
+              object: record,
+              attribute_name: attribute_name,
+              value: value,
+              ignore_interference_by_writer: ignore_interference_by_writer,
+            )
         end
 
         def existing_value_read
@@ -786,47 +935,42 @@ module Shoulda
           @given_record.class
         end
 
-        def failure_message_preface
+        def failure_message_preface # rubocop:disable Metrics/MethodLength
           prefix = ''
 
           if @existing_record_created
             prefix << "After taking the given #{model.name}"
 
             if attribute_setter_for_existing_record
-              prefix << ', setting its '
+              prefix << ', setting '
               prefix << description_for_attribute_setter(
-                attribute_setter_for_existing_record
+                attribute_setter_for_existing_record,
               )
             else
               prefix << ", whose :#{attribute} is "
               prefix << "‹#{existing_value_read.inspect}›"
             end
 
-            prefix << ", and saving it as the existing record, then"
+            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
-            if attribute_setter_for_existing_record
-              prefix << "Given an existing #{model.name},"
-              prefix << ' after setting its '
-              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 << "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 its "
+          prefix << " making a new #{model.name} and setting "
 
-          prefix << description_for_attribute_setter(
-            last_attribute_setter_used_on_new_record,
-            same_as_existing: existing_and_new_values_are_same?
-          )
+          prefix << descriptions_for_attribute_setters_for_new_record
 
           prefix << ", the matcher expected the new #{model.name} to be"
 
@@ -848,21 +992,24 @@ different altogether.
           MESSAGE
         end
 
-        def description_for_attribute_setter(attribute_setter, same_as_existing: nil)
-          description = ":#{attribute_setter.attribute_name} to "
+        def description_for_attribute_setter(
+          attribute_setter,
+          same_as_existing: nil
+        )
+          description = "its :#{attribute_setter.attribute_name} to "
 
           if same_as_existing == false
             description << 'a different value, '
           end
 
           description << Shoulda::Matchers::Util.inspect_value(
-            attribute_setter.value_written
+            attribute_setter.value_written,
           )
 
           if attribute_setter.attribute_changed_value?
             description << ' (read back as '
             description << Shoulda::Matchers::Util.inspect_value(
-              attribute_setter.value_read
+              attribute_setter.value_read,
             )
             description << ')'
           end
@@ -874,6 +1021,23 @@ different altogether.
           description
         end
 
+        def descriptions_for_attribute_setters_for_new_record
+          attribute_setter_descriptions_for_new_record.to_sentence
+        end
+
+        def attribute_setter_descriptions_for_new_record
+          attribute_setters_for_new_record.map do |attribute_setter|
+            same_as_existing = (
+              attribute_setter.value_written ==
+              existing_value_written
+            )
+            description_for_attribute_setter(
+              attribute_setter,
+              same_as_existing: same_as_existing,
+            )
+          end
+        end
+
         def existing_and_new_values_are_same?
           last_value_set_on_new_record == existing_value_written
         end
@@ -886,6 +1050,50 @@ different altogether.
           last_submatcher_run.last_value_set
         end
 
+        # @private
+        class AttributeSetters
+          include Enumerable
+
+          def initialize
+            @attribute_setters = []
+          end
+
+          def <<(given_attribute_setter)
+            index = find_index_of(given_attribute_setter)
+
+            if index
+              @attribute_setters[index] = given_attribute_setter
+            else
+              @attribute_setters << given_attribute_setter
+            end
+          end
+
+          def +(other_attribute_setters)
+            dup.tap do |attribute_setters|
+              other_attribute_setters.each do |attribute_setter|
+                attribute_setters << attribute_setter
+              end
+            end
+          end
+
+          def each(&block)
+            @attribute_setters.each(&block)
+          end
+
+          def last
+            @attribute_setters.last
+          end
+
+          private
+
+          def find_index_of(given_attribute_setter)
+            @attribute_setters.find_index do |attribute_setter|
+              attribute_setter.attribute_name ==
+                given_attribute_setter.attribute_name
+            end
+          end
+        end
+
         # @private
         class NonCaseSwappableValueError < Shoulda::Matchers::Error
           attr_accessor :model, :attribute, :value
@@ -895,7 +1103,7 @@ different altogether.
 Your #{model.name} model has a uniqueness validation on :#{attribute} which is
 declared to be case-sensitive, but the value the uniqueness matcher used,
 #{value.inspect}, doesn't contain any alpha characters, so using it to
-to test the case-sensitivity part of the validation is ineffective. There are
+test the case-sensitivity part of the validation is ineffective. There are
 two possible solutions for this depending on what you're trying to do here:
 
 a) If you meant for the validation to be case-sensitive, then you need to give
@@ -908,7 +1116,29 @@ b) If you meant for the validation to be case-insensitive, then you need to
 
 For more information, please see:
 
-http://matchers.shoulda.io/docs/v#{Shoulda::Matchers::VERSION}/file.NonCaseSwappableValueError.html
+https://matchers.shoulda.io/docs/v#{Shoulda::Matchers::VERSION}/file.NonCaseSwappableValueError.html
+            MESSAGE
+          end
+        end
+
+        # @private
+        class ExistingRecordInvalid < Shoulda::Matchers::Error
+          include Shoulda::Matchers::ActiveModel::Helpers
+
+          attr_accessor :underlying_exception
+
+          def message
+            <<-MESSAGE.strip
+validate_uniqueness_of works by matching a new record against an
+existing record. If there is no existing record, it will create one
+using the record you provide.
+
+While doing this, the following error was raised:
+
+#{Shoulda::Matchers::Util.indent(underlying_exception.message, 2)}
+
+The best way to fix this is to provide the matcher with a record where
+any required attributes are filled in with valid values beforehand.
             MESSAGE
           end
         end