MONGOID-5150 Test and document that read primary is used on validates_uniqueness_of (#5451)

Author: neilshweky

docs/reference/queries.txt

@@ -1487,6 +1487,15 @@ Mongoid also has some helpful methods on criteria.
           Band.all.pluck(:name, :likes)
             #=> [ ["Daft Punk", 342], ["Aphex Twin", 98], ["Ween", 227] ]
 
+   * - ``Criteria#read``
+
+       *Sets the read preference for the criteria.*
+
+     -
+        .. code-block:: ruby
+
+          Band.all.read(mode: :primary)
+
    * - ``Criteria#second``
 
        *Get the second document for the given criteria.*

docs/reference/validation.txt

@@ -16,7 +16,7 @@ validation plus an additional associated and uniqueness validator.
 See the `Active Record Validations
 <https://guides.rubyonrails.org/active_record_validations.html>`_
 Rails guide and `ActiveModel::Validations
-<https://api.rubyonrails.org/classes/ActiveModel/Validations.html>`_ 
+<https://api.rubyonrails.org/classes/ActiveModel/Validations.html>`_
 documentation for more information.
 
 Mongoid behaves slightly differently to Active Record when using ``#valid?``
@@ -38,17 +38,27 @@ value of the respective field from the model. Consider the following example:
 
   class Band
     include Mongoid::Document
-    
+
     field :name, type: String
     field :year, type: Integer
-    
+
     validates_uniqueness_of :name, conditions: -> { where(:year.gte => 2000) }
   end
-  
+
   # OK
   Band.create!(name: "Sun Project", year: 2000)
-  
+
   # Fails validation because there is a band with the "Sun Project" name
   # and year 2000 in the database, even though the model being created now
   # does not have a year.
   Band.create!(name: "Sun Project")
+
+
+Read preference with ``validates_uniqueness_of``
+================================================
+
+In order to validate the uniqueness of an attribute, Mongoid must check that
+the value for that attribute does not already exist in the database. If Mongoid
+queries a secondary member of the replica set, there is a possibility that it
+is reading stale data. Because of this, the queries used to check a
+``validates_uniqueness_of`` validation always use read preference ``primary``.

lib/mongoid/validatable/uniqueness.rb

@@ -242,7 +242,7 @@ def validate_embedded(document, attribute, value)
         relation = document._parent.send(document.association_name)
         criteria = create_criteria(relation, document, attribute, value)
         criteria = criteria.merge(options[:conditions].call) if options[:conditions]
-        criteria = criteria.limit(2)
+        criteria = criteria.read(mode: :primary).limit(2)
         add_error(document, attribute, value) if criteria.count > 1
       end
 

spec/mongoid/validatable/uniqueness_spec.rb

@@ -8,6 +8,28 @@
 
     context "when the document is a root document" do
 
+      context "when setting the read preference to non-primary" do
+
+        before do
+          Dictionary.validates_uniqueness_of :name
+        end
+
+        after do
+          Dictionary.reset_callbacks(:validate)
+        end
+
+        it "reads from the primary" do
+          expect_any_instance_of(Mongoid::Criteria).to receive(:read).once.and_wrap_original do |m, *args|
+            crit = m.call(*args)
+            expect(crit.view.options["read"]).to eq({ "mode" => :primary })
+            crit
+          end
+          Dictionary.with(read: { mode: :secondary }) do |klass|
+            klass.create!(name: "Websters")
+          end
+        end
+      end
+
       context "when adding custom persistence options" do
 
         before do
@@ -1634,6 +1656,30 @@
         word.definitions.create!(description: "2")
       end
 
+      context "when setting the read preference to non-primary" do
+
+        before do
+          Definition.validates_uniqueness_of :description
+        end
+
+        after do
+          Definition.reset_callbacks(:validate)
+        end
+
+        let(:word) { Word.create! }
+
+        it "reads from the primary" do
+          expect_any_instance_of(Mongoid::Criteria).to receive(:read).once.and_wrap_original do |m, *args|
+            crit = m.call(*args)
+            expect(crit.options[:read]).to eq({ mode: :primary })
+            crit
+          end
+          Definition.with(read: { mode: :secondary }) do |klass|
+            word.definitions.create!
+          end
+        end
+      end
+
       context "when a document is being destroyed" do
 
         before do