mongoid 9.0.11 → 9.1.0

data/spec/mongoid/validatable/uniqueness_spec.rb

@@ -1,16 +1,11 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Validatable::UniquenessValidator do
-
-  describe "#valid?" do
-
-    context "when the document is a root document" do
-
-      context "when setting the read preference to non-primary" do
-
+  describe '#valid?' do
+    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
@@ -19,20 +14,19 @@ describe Mongoid::Validatable::UniquenessValidator do
           Dictionary.reset_callbacks(:validate)
         end
 
-        it "reads from the primary" do
+        it 'reads from the primary' do
           expect_any_instance_of(Mongoid::Criteria).to receive(:read).once.and_wrap_original do |m, *args, **kwargs|
             crit = m.call(*args, **kwargs)
-            expect(crit.view.options["read"]).to eq({ "mode" => :primary })
+            expect(crit.view.options['read']).to eq({ 'mode' => :primary })
             crit
           end
           Dictionary.with(read: { mode: :secondary }) do |klass|
-            klass.create!(name: "Websters")
+            klass.create!(name: 'Websters')
           end
         end
       end
 
-      context "when adding custom persistence options" do
-
+      context 'when adding custom persistence options' do
         before do
           Dictionary.validates_uniqueness_of :name
         end
@@ -41,57 +35,52 @@ describe Mongoid::Validatable::UniquenessValidator do
           Dictionary.reset_callbacks(:validate)
         end
 
-        context "when persisting to another collection" do
-
+        context 'when persisting to another collection' do
           before do
-            Dictionary.with(collection: "dicts") do |klass|
-              klass.create!(name: "websters")
+            Dictionary.with(collection: 'dicts') do |klass|
+              klass.create!(name: 'websters')
             end
           end
 
-          context "when the document is not valid" do
-
+          context 'when the document is not valid' do
             let(:websters) do
               object = nil
-              valid = Dictionary.with(collection: "dicts") do |klass|
-                object = klass.new(name: "websters")
+              valid = Dictionary.with(collection: 'dicts') do |klass|
+                object = klass.new(name: 'websters')
                 object.valid?
               end
-              { :valid => valid, :object => object }
+              { valid: valid, object: object }
             end
 
-            it "performs the validation on the correct collection" do
+            it 'performs the validation on the correct collection' do
               expect(websters[:valid]).to be(false)
             end
 
-            it "adds the uniqueness error" do
-              expect(websters[:object].errors[:name]).to_not be_nil
+            it 'adds the uniqueness error' do
+              expect(websters[:object].errors[:name]).not_to be_nil
             end
 
-            it "clears the persistence options in the thread local" do
+            it 'clears the persistence options in the thread local' do
               expect(Dictionary.persistence_context).to eq(Mongoid::PersistenceContext.new(Dictionary))
             end
           end
 
-          context "when the document is valid" do
-
+          context 'when the document is valid' do
             let(:oxford) do
-              Dictionary.with(collection: "dicts") do |klass|
-                klass.new(name: "oxford")
+              Dictionary.with(collection: 'dicts') do |klass|
+                klass.new(name: 'oxford')
               end
             end
 
-            it "performs the validation on the correct collection" do
+            it 'performs the validation on the correct collection' do
               expect(oxford).to be_valid
             end
           end
         end
       end
 
-      context "when the document contains no compound key" do
-
-        context "when validating a relation" do
-
+      context 'when the document contains no compound key' do
+        context 'when validating a relation' do
           before do
             Word.validates_uniqueness_of :dictionary
           end
@@ -100,8 +89,7 @@ describe Mongoid::Validatable::UniquenessValidator do
             Word.reset_callbacks(:validate)
           end
 
-          context "when the attribute id is unique" do
-
+          context 'when the attribute id is unique' do
             let(:dictionary) do
               Dictionary.create!
             end
@@ -110,67 +98,61 @@ describe Mongoid::Validatable::UniquenessValidator do
               Word.new(dictionary: dictionary)
             end
 
-            it "returns true" do
+            it 'returns true' do
               expect(word).to be_valid
             end
           end
         end
 
-        context "when the field name is aliased" do
-
+        context 'when the field name is aliased' do
           before do
-            Dictionary.create!(language: "en")
+            Dictionary.create!(language: 'en')
           end
 
           let(:dictionary) do
-            Dictionary.new(language: "en")
+            Dictionary.new(language: 'en')
           end
 
           after do
             Dictionary.reset_callbacks(:validate)
           end
 
-          context "when the validation uses the aliased name" do
-
+          context 'when the validation uses the aliased name' do
             before do
               Dictionary.validates_uniqueness_of :language
             end
 
-            it "correctly detects a uniqueness conflict" do
-              expect(dictionary).to_not be_valid
+            it 'correctly detects a uniqueness conflict' do
+              expect(dictionary).not_to be_valid
             end
 
-            it "adds the uniqueness error to the aliased field name" do
+            it 'adds the uniqueness error to the aliased field name' do
               dictionary.valid?
               expect(dictionary.errors).to have_key(:language)
-              expect(dictionary.errors[:language]).to eq([ "has already been taken" ])
+              expect(dictionary.errors[:language]).to eq([ 'has already been taken' ])
             end
           end
 
-          context "when the validation uses the underlying field name" do
-
+          context 'when the validation uses the underlying field name' do
             before do
               Dictionary.validates_uniqueness_of :l
             end
 
-            it "correctly detects a uniqueness conflict" do
-              expect(dictionary).to_not be_valid
+            it 'correctly detects a uniqueness conflict' do
+              expect(dictionary).not_to be_valid
             end
 
-            it "adds the uniqueness error to the underlying field name" do
+            it 'adds the uniqueness error to the underlying field name' do
               dictionary.valid?
               expect(dictionary.errors).to have_key(:l)
-              expect(dictionary.errors[:l]).to eq([ "has already been taken" ])
+              expect(dictionary.errors[:l]).to eq([ 'has already been taken' ])
             end
           end
         end
 
-        context "when the field is localized" do
-
-          context "when no scope is provided" do
-
-            context "when case sensitive is true" do
-
+        context 'when the field is localized' do
+          context 'when no scope is provided' do
+            context 'when case sensitive is true' do
               before do
                 Dictionary.validates_uniqueness_of :description
               end
@@ -179,21 +161,18 @@ describe Mongoid::Validatable::UniquenessValidator do
                 Dictionary.reset_callbacks(:validate)
               end
 
-              context "when no attribute is set" do
-
-                context "when no document with no value exists in the database" do
-
+              context 'when no attribute is set' do
+                context 'when no document with no value exists in the database' do
                   let(:dictionary) do
                     Dictionary.new
                   end
 
-                  it "returns true" do
+                  it 'returns true' do
                     expect(dictionary).to be_valid
                   end
                 end
 
-                context "when a document with no value exists in the database" do
-
+                context 'when a document with no value exists in the database' do
                   before do
                     Dictionary.create!
                   end
@@ -202,96 +181,88 @@ describe Mongoid::Validatable::UniquenessValidator do
                     Dictionary.new
                   end
 
-                  it "returns false" do
-                    expect(dictionary).to_not be_valid
+                  it 'returns false' do
+                    expect(dictionary).not_to be_valid
                   end
                 end
               end
 
-              context "when the attribute is unique" do
-
-                context "when single localization" do
-
+              context 'when the attribute is unique' do
+                context 'when single localization' do
                   before do
-                    Dictionary.create!(description: "english")
+                    Dictionary.create!(description: 'english')
                   end
 
                   let(:dictionary) do
-                    Dictionary.new(description: "English")
+                    Dictionary.new(description: 'English')
                   end
 
-                  it "returns true" do
+                  it 'returns true' do
                     expect(dictionary).to be_valid
                   end
                 end
 
-                context "when multiple localizations" do
-
+                context 'when multiple localizations' do
                   before do
-                    Dictionary.
-                        create(description_translations: { "en" => "english", "de" => "german" })
+                    Dictionary
+                      .create(description_translations: { 'en' => 'english', 'de' => 'german' })
                   end
 
                   let(:dictionary) do
-                    Dictionary.new(description_translations: { "en" => "English", "de" => "German" })
+                    Dictionary.new(description_translations: { 'en' => 'English', 'de' => 'German' })
                   end
 
-                  it "returns true" do
+                  it 'returns true' do
                     expect(dictionary).to be_valid
                   end
                 end
               end
 
-              context "when the attribute is not unique" do
-
-                context "when the document is not the match" do
-
-                  context "when single localization" do
-
+              context 'when the attribute is not unique' do
+                context 'when the document is not the match' do
+                  context 'when single localization' do
                     before do
-                      Dictionary.create!(description: "english")
+                      Dictionary.create!(description: 'english')
                     end
 
                     let(:dictionary) do
-                      Dictionary.new(description: "english")
+                      Dictionary.new(description: 'english')
                     end
 
-                    it "returns false" do
-                      expect(dictionary).to_not be_valid
+                    it 'returns false' do
+                      expect(dictionary).not_to be_valid
                     end
 
-                    it "adds the uniqueness error" do
+                    it 'adds the uniqueness error' do
                       dictionary.valid?
-                      expect(dictionary.errors[:description]).to eq([ "has already been taken" ])
+                      expect(dictionary.errors[:description]).to eq([ 'has already been taken' ])
                     end
                   end
 
-                  context "when multiple localizations" do
-
+                  context 'when multiple localizations' do
                     before do
-                      Dictionary.
-                          create(description_translations: { "en" => "english", "de" => "german" })
+                      Dictionary
+                        .create(description_translations: { 'en' => 'english', 'de' => 'german' })
                     end
 
                     let(:dictionary) do
-                      Dictionary.new(description_translations: { "en" => "english", "de" => "German" })
+                      Dictionary.new(description_translations: { 'en' => 'english', 'de' => 'German' })
                     end
 
-                    it "returns false" do
-                      expect(dictionary).to_not be_valid
+                    it 'returns false' do
+                      expect(dictionary).not_to be_valid
                     end
 
-                    it "adds the uniqueness error" do
+                    it 'adds the uniqueness error' do
                       dictionary.valid?
-                      expect(dictionary.errors[:description]).to eq([ "has already been taken" ])
+                      expect(dictionary.errors[:description]).to eq([ 'has already been taken' ])
                     end
                   end
                 end
               end
             end
 
-            context "when case sensitive is false" do
-
+            context 'when case sensitive is false' do
               before do
                 Dictionary.validates_uniqueness_of :description, case_sensitive: false
               end
@@ -300,92 +271,84 @@ describe Mongoid::Validatable::UniquenessValidator do
                 Dictionary.reset_callbacks(:validate)
               end
 
-              context "when the attribute is unique" do
-
-                context "when there are no special characters" do
-
+              context 'when the attribute is unique' do
+                context 'when there are no special characters' do
                   before do
-                    Dictionary.create!(description: "english")
+                    Dictionary.create!(description: 'english')
                   end
 
                   let(:dictionary) do
-                    Dictionary.new(description: "german")
+                    Dictionary.new(description: 'german')
                   end
 
-                  it "returns true" do
+                  it 'returns true' do
                     expect(dictionary).to be_valid
                   end
                 end
 
-                context "when special characters exist" do
-
+                context 'when special characters exist' do
                   before do
-                    Dictionary.create!(description: "english")
+                    Dictionary.create!(description: 'english')
                   end
 
                   let(:dictionary) do
-                    Dictionary.new(description: "en@gl.ish")
+                    Dictionary.new(description: 'en@gl.ish')
                   end
 
-                  it "returns true" do
+                  it 'returns true' do
                     expect(dictionary).to be_valid
                   end
                 end
               end
 
-              context "when the attribute is not unique" do
-
-                context "when the document is not the match" do
-
-                  context "when signle localization" do
-
+              context 'when the attribute is not unique' do
+                context 'when the document is not the match' do
+                  context 'when single localization' do
                     before do
-                      Dictionary.create!(description: "english")
+                      Dictionary.create!(description: 'english')
                     end
 
                     let(:dictionary) do
-                      Dictionary.new(description: "English")
+                      Dictionary.new(description: 'English')
                     end
 
-                    it "returns false" do
-                      expect(dictionary).to_not be_valid
+                    it 'returns false' do
+                      expect(dictionary).not_to be_valid
                     end
 
-                    it "adds the uniqueness error" do
+                    it 'adds the uniqueness error' do
                       dictionary.valid?
-                      expect(dictionary.errors[:description]).to eq([ "has already been taken" ])
+                      expect(dictionary.errors[:description]).to eq([ 'has already been taken' ])
                     end
                   end
 
-                  context "when multiple localizations" do
-
+                  context 'when multiple localizations' do
                     before do
-                      Dictionary.
-                          create(description_translations: { "en" => "english", "de" => "german" })
+                      Dictionary
+                        .create(description_translations: { 'en' => 'english', 'de' => 'german' })
                     end
 
                     let(:dictionary) do
-                      Dictionary.new(description_translations: { "en" => "English", "de" => "German" })
+                      Dictionary.new(description_translations: { 'en' => 'English', 'de' => 'German' })
                     end
 
-                    it "returns false" do
-                      expect(dictionary).to_not be_valid
+                    it 'returns false' do
+                      expect(dictionary).not_to be_valid
                     end
 
-                    it "adds the uniqueness error" do
+                    it 'adds the uniqueness error' do
                       dictionary.valid?
-                      expect(dictionary.errors[:description]).to eq([ "has already been taken" ])
+                      expect(dictionary.errors[:description]).to eq([ 'has already been taken' ])
                     end
                   end
                 end
 
-                context "when the document is the match in the database" do
-
+                context 'when the document is the match in the database' do
                   let!(:dictionary) do
-                    Dictionary.create!(description: "english")
+                    Dictionary.create!(description: 'english')
                   end
 
-                  it "returns true" do
+                  it 'returns true' do
                     expect(dictionary).to be_valid
                   end
                 end
@@ -393,8 +356,7 @@ describe Mongoid::Validatable::UniquenessValidator do
             end
           end
 
-          context "when a scope is provided" do
-
+          context 'when a scope is provided' do
             before do
               Dictionary.validates_uniqueness_of :description, scope: :name
             end
@@ -403,34 +365,31 @@ describe Mongoid::Validatable::UniquenessValidator do
               Dictionary.reset_callbacks(:validate)
             end
 
-            context "when the attribute is not unique in the scope" do
-
-              context "when the document is not the match" do
-
+            context 'when the attribute is not unique in the scope' do
+              context 'when the document is not the match' do
                 before do
-                  Dictionary.
-                    create(description: "english", name: "test")
+                  Dictionary
+                    .create(description: 'english', name: 'test')
                 end
 
                 let(:dictionary) do
-                  Dictionary.new(description: "english", name: "test")
+                  Dictionary.new(description: 'english', name: 'test')
                 end
 
-                it "returns false" do
-                  expect(dictionary).to_not be_valid
+                it 'returns false' do
+                  expect(dictionary).not_to be_valid
                 end
 
-                it "adds the uniqueness error" do
+                it 'adds the uniqueness error' do
                   dictionary.valid?
-                  expect(dictionary.errors[:description]).to eq([ "has already been taken" ])
+                  expect(dictionary.errors[:description]).to eq([ 'has already been taken' ])
                 end
               end
             end
           end
         end
 
-        context "when no scope is provided" do
-
+        context 'when no scope is provided' do
           before do
             Dictionary.validates_uniqueness_of :name
           end
@@ -439,87 +398,80 @@ describe Mongoid::Validatable::UniquenessValidator do
             Dictionary.reset_callbacks(:validate)
           end
 
-          context "when the attribute is unique" do
-
+          context 'when the attribute is unique' do
             let!(:oxford) do
-              Dictionary.create!(name: "Oxford")
+              Dictionary.create!(name: 'Oxford')
             end
 
             let(:dictionary) do
-              Dictionary.new(name: "Webster")
+              Dictionary.new(name: 'Webster')
             end
 
-            it "returns true" do
+            it 'returns true' do
               expect(dictionary).to be_valid
             end
 
-            context "when subsequently cloning the document" do
-
+            context 'when subsequently cloning the document' do
               let(:clone) do
                 oxford.clone
               end
 
-              it "returns false for the clone" do
-                expect(clone).to_not be_valid
+              it 'returns false for the clone' do
+                expect(clone).not_to be_valid
               end
             end
           end
 
-          context "when the attribute is not unique" do
-
-            context "when the document is not the match" do
-
+          context 'when the attribute is not unique' do
+            context 'when the document is not the match' do
               before do
-                Dictionary.create!(name: "Oxford")
+                Dictionary.create!(name: 'Oxford')
               end
 
               let!(:dictionary) do
-                Dictionary.new(name: "Oxford")
+                Dictionary.new(name: 'Oxford')
               end
 
-              it "returns false" do
-                expect(dictionary).to_not be_valid
+              it 'returns false' do
+                expect(dictionary).not_to be_valid
               end
 
-              it "adds the uniqueness error" do
+              it 'adds the uniqueness error' do
                 dictionary.valid?
-                expect(dictionary.errors[:name]).to eq([ "has already been taken" ])
+                expect(dictionary.errors[:name]).to eq([ 'has already been taken' ])
               end
             end
 
-            context "when the document is the match in the database" do
-
-              context "when the field has changed" do
-
+            context 'when the document is the match in the database' do
+              context 'when the field has changed' do
                 let!(:dictionary) do
-                  Dictionary.create!(name: "Oxford")
+                  Dictionary.create!(name: 'Oxford')
                 end
 
-                it "returns true" do
+                it 'returns true' do
                   expect(dictionary).to be_valid
                 end
               end
 
-              context "when the field has not changed" do
-
+              context 'when the field has not changed' do
                 before do
                   Dictionary.default_scoping = nil
                 end
 
                 let!(:dictionary) do
-                  Dictionary.create!(name: "Oxford")
+                  Dictionary.create!(name: 'Oxford')
                 end
 
                 let!(:from_db) do
                   Dictionary.find(dictionary.id)
                 end
 
-                it "returns true" do
+                it 'returns true' do
                   expect(from_db).to be_valid
                 end
 
-                it "does not touch the database" do
-                  expect(Dictionary).to receive(:where).never
+                it 'does not touch the database' do
+                  expect(Dictionary).not_to receive(:where)
                   from_db.valid?
                 end
               end
@@ -527,11 +479,10 @@ describe Mongoid::Validatable::UniquenessValidator do
           end
         end
 
-        context "when a default scope is on the model" do
-
+        context 'when a default scope is on the model' do
           before do
             Dictionary.validates_uniqueness_of :name
-            Dictionary.default_scope(->{ Dictionary.where(year: 1990) })
+            Dictionary.default_scope(-> { Dictionary.where(year: 1990) })
           end
 
           after do
@@ -539,27 +490,24 @@ describe Mongoid::Validatable::UniquenessValidator do
             Dictionary.reset_callbacks(:validate)
           end
 
-          context "when the document with the unqiue attribute is not in default scope" do
-
-            context "when the attribute is not unique" do
-
+          context 'when the document with the unique attribute is not in default scope' do
+            context 'when the attribute is not unique' do
               before do
-                Dictionary.create!(name: "Oxford")
+                Dictionary.create!(name: 'Oxford')
               end
 
               let(:dictionary) do
-                Dictionary.new(name: "Oxford")
+                Dictionary.new(name: 'Oxford')
               end
 
-              it "returns false" do
-                expect(dictionary).to_not be_valid
+              it 'returns false' do
+                expect(dictionary).not_to be_valid
               end
             end
           end
         end
 
-        context "when an aliased scope is provided" do
-
+        context 'when an aliased scope is provided' do
           before do
             Dictionary.validates_uniqueness_of :name, scope: :language
           end
@@ -568,103 +516,95 @@ describe Mongoid::Validatable::UniquenessValidator do
             Dictionary.reset_callbacks(:validate)
           end
 
-          context "when the attribute is unique" do
-
+          context 'when the attribute is unique' do
             before do
-              Dictionary.create!(name: "Oxford", language: "English")
+              Dictionary.create!(name: 'Oxford', language: 'English')
             end
 
             let(:dictionary) do
-              Dictionary.new(name: "Webster")
+              Dictionary.new(name: 'Webster')
             end
 
-            it "returns true" do
+            it 'returns true' do
               expect(dictionary).to be_valid
             end
           end
 
-          context "when the attribute is unique in the scope" do
-
+          context 'when the attribute is unique in the scope' do
             before do
-              Dictionary.create!(name: "Oxford", language: "English")
+              Dictionary.create!(name: 'Oxford', language: 'English')
             end
 
             let(:dictionary) do
-              Dictionary.new(name: "Webster", language: "English")
+              Dictionary.new(name: 'Webster', language: 'English')
             end
 
-            it "returns true" do
+            it 'returns true' do
               expect(dictionary).to be_valid
             end
           end
 
-          context "when the attribute is not unique with no scope" do
-
+          context 'when the attribute is not unique with no scope' do
             before do
-              Dictionary.create!(name: "Oxford", language: "English")
+              Dictionary.create!(name: 'Oxford', language: 'English')
             end
 
             let(:dictionary) do
-              Dictionary.new(name: "Oxford")
+              Dictionary.new(name: 'Oxford')
             end
 
-            it "returns true" do
+            it 'returns true' do
               expect(dictionary).to be_valid
             end
           end
 
-          context "when the attribute is not unique in another scope" do
-
+          context 'when the attribute is not unique in another scope' do
             before do
-              Dictionary.create!(name: "Oxford", language: "English")
+              Dictionary.create!(name: 'Oxford', language: 'English')
             end
 
             let(:dictionary) do
-              Dictionary.new(name: "Oxford", language: "Deutsch")
+              Dictionary.new(name: 'Oxford', language: 'Deutsch')
             end
 
-            it "returns true" do
+            it 'returns true' do
               expect(dictionary).to be_valid
             end
           end
 
-          context "when the attribute is not unique in the same scope" do
-
-            context "when the document is not the match" do
-
+          context 'when the attribute is not unique in the same scope' do
+            context 'when the document is not the match' do
               before do
-                Dictionary.create!(name: "Oxford", language: "English")
+                Dictionary.create!(name: 'Oxford', language: 'English')
               end
 
               let(:dictionary) do
-                Dictionary.new(name: "Oxford", language: "English")
+                Dictionary.new(name: 'Oxford', language: 'English')
               end
 
-              it "returns false" do
-                expect(dictionary).to_not be_valid
+              it 'returns false' do
+                expect(dictionary).not_to be_valid
               end
 
-              it "adds the uniqueness errors" do
+              it 'adds the uniqueness errors' do
                 dictionary.valid?
-                expect(dictionary.errors[:name]).to eq([ "has already been taken" ])
+                expect(dictionary.errors[:name]).to eq([ 'has already been taken' ])
               end
             end
 
-            context "when the document is the match in the database" do
-
+            context 'when the document is the match in the database' do
               let!(:dictionary) do
-                Dictionary.create!(name: "Oxford", language: "English")
+                Dictionary.create!(name: 'Oxford', language: 'English')
               end
 
-              it "returns true" do
+              it 'returns true' do
                 expect(dictionary).to be_valid
               end
             end
           end
         end
 
-        context "when a single scope is provided" do
-
+        context 'when a single scope is provided' do
           before do
             Dictionary.validates_uniqueness_of :name, scope: :publisher
           end
@@ -673,159 +613,148 @@ describe Mongoid::Validatable::UniquenessValidator do
             Dictionary.reset_callbacks(:validate)
           end
 
-          context "when the attribute is unique" do
-
+          context 'when the attribute is unique' do
             before do
-              Dictionary.create!(name: "Oxford", publisher: "Amazon")
+              Dictionary.create!(name: 'Oxford', publisher: 'Amazon')
             end
 
             let(:dictionary) do
-              Dictionary.new(name: "Webster")
+              Dictionary.new(name: 'Webster')
             end
 
-            it "returns true" do
+            it 'returns true' do
               expect(dictionary).to be_valid
             end
           end
 
-          context "when the attribute is unique in the scope" do
-
+          context 'when the attribute is unique in the scope' do
             before do
-              Dictionary.create!(name: "Oxford", publisher: "Amazon")
+              Dictionary.create!(name: 'Oxford', publisher: 'Amazon')
             end
 
             let(:dictionary) do
-              Dictionary.new(name: "Webster", publisher: "Amazon")
+              Dictionary.new(name: 'Webster', publisher: 'Amazon')
             end
 
-            it "returns true" do
+            it 'returns true' do
               expect(dictionary).to be_valid
             end
           end
 
-          context "when uniqueness is violated due to scope change" do
-
+          context 'when uniqueness is violated due to scope change' do
             let(:personal_folder) do
-              Folder.create!(name: "Personal")
+              Folder.create!(name: 'Personal')
+            end
+            let(:item) do
+              public_folder.folder_items.last
             end
 
             let(:public_folder) do
-              Folder.create!(name: "Public")
+              Folder.create!(name: 'Public')
             end
 
             before do
-              personal_folder.folder_items << FolderItem.new(name: "non-unique")
-              public_folder.folder_items << FolderItem.new(name: "non-unique")
+              personal_folder.folder_items << FolderItem.new(name: 'non-unique')
+              public_folder.folder_items << FolderItem.new(name: 'non-unique')
             end
 
-            let(:item) do
-              public_folder.folder_items.last
-            end
-
-            it "should set an error for associated object not being unique" do
+            it 'sets an error for associated object not being unique' do
               item.update_attributes(folder_id: personal_folder.id)
-              expect(item.errors.messages[:name].first).to eq("has already been taken")
+              expect(item.errors.messages[:name].first).to eq('has already been taken')
             end
           end
 
-          context "when the attribute is not unique with no scope" do
-
+          context 'when the attribute is not unique with no scope' do
             before do
-              Dictionary.create!(name: "Oxford", publisher: "Amazon")
+              Dictionary.create!(name: 'Oxford', publisher: 'Amazon')
             end
 
             let(:dictionary) do
-              Dictionary.new(name: "Oxford")
+              Dictionary.new(name: 'Oxford')
             end
 
-            it "returns true" do
+            it 'returns true' do
               expect(dictionary).to be_valid
             end
           end
 
-          context "when the attribute is not unique in another scope" do
-
+          context 'when the attribute is not unique in another scope' do
             before do
-              Dictionary.create!(name: "Oxford", publisher: "Amazon")
+              Dictionary.create!(name: 'Oxford', publisher: 'Amazon')
             end
 
             let(:dictionary) do
-              Dictionary.new(name: "Oxford", publisher: "Addison")
+              Dictionary.new(name: 'Oxford', publisher: 'Addison')
             end
 
-            it "returns true" do
+            it 'returns true' do
               expect(dictionary).to be_valid
             end
           end
 
-          context "when the attribute is not unique in the same scope" do
-
-            context "when the document is not the match" do
-
+          context 'when the attribute is not unique in the same scope' do
+            context 'when the document is not the match' do
               before do
-                Dictionary.create!(name: "Oxford", publisher: "Amazon")
+                Dictionary.create!(name: 'Oxford', publisher: 'Amazon')
               end
 
               let(:dictionary) do
-                Dictionary.new(name: "Oxford", publisher: "Amazon")
+                Dictionary.new(name: 'Oxford', publisher: 'Amazon')
               end
 
-              it "returns false" do
-                expect(dictionary).to_not be_valid
+              it 'returns false' do
+                expect(dictionary).not_to be_valid
               end
 
-              it "adds the uniqueness errors" do
+              it 'adds the uniqueness errors' do
                 dictionary.valid?
-                expect(dictionary.errors[:name]).to eq([ "has already been taken" ])
+                expect(dictionary.errors[:name]).to eq([ 'has already been taken' ])
               end
             end
 
-            context "when the document is the match in the database" do
-
+            context 'when the document is the match in the database' do
               let!(:dictionary) do
-                Dictionary.create!(name: "Oxford", publisher: "Amazon")
+                Dictionary.create!(name: 'Oxford', publisher: 'Amazon')
               end
 
-              it "returns true" do
+              it 'returns true' do
                 expect(dictionary).to be_valid
               end
             end
 
-            context "when one of the scopes is a time" do
-
+            context 'when one of the scopes is a time' do
               before do
                 Dictionary.create!(
-                  name: "Oxford",
-                  publisher: "Amazon",
+                  name: 'Oxford',
+                  publisher: 'Amazon',
                   published: 10.days.ago.to_time
                 )
               end
 
               let(:dictionary) do
                 Dictionary.new(
-                  name: "Oxford",
-                  publisher: "Amazon",
+                  name: 'Oxford',
+                  publisher: 'Amazon',
                   published: 10.days.ago.to_time
                 )
               end
 
-              it "returns false" do
-                expect(dictionary).to_not be_valid
+              it 'returns false' do
+                expect(dictionary).not_to be_valid
               end
 
-              it "adds the uniqueness errors" do
+              it 'adds the uniqueness errors' do
                 dictionary.valid?
-                expect(dictionary.errors[:name]).to eq([ "has already been taken" ])
+                expect(dictionary.errors[:name]).to eq([ 'has already been taken' ])
               end
             end
           end
         end
 
-        context "when a range condition is provided" do
-
+        context 'when a range condition is provided' do
           before do
             Dictionary.validates_uniqueness_of(:name,
-              conditions: -> { Dictionary.where(:year.gte => 1900, :year.lt => 2000) })
+                                               conditions: -> { Dictionary.where(:year.gte => 1900, :year.lt => 2000) })
           end
 
           after do
@@ -833,11 +762,11 @@ describe Mongoid::Validatable::UniquenessValidator do
           end
 
           context 'when multiple documents would match the condition' do
-            it "prevents creation of new document" do
-              Dictionary.create!(name: "French-English", year: 1950)
+            it 'prevents creation of new document' do
+              Dictionary.create!(name: 'French-English', year: 1950)
 
               expect do
-                Dictionary.create!(name: "French-English", year: 1960)
+                Dictionary.create!(name: 'French-English', year: 1960)
               end.to raise_error(Mongoid::Errors::Validations, /Name has already been taken/)
 
               expect(Dictionary.all.size).to eq(1)
@@ -846,9 +775,9 @@ describe Mongoid::Validatable::UniquenessValidator do
 
           context 'when only new document would match the condition' do
             it 'creates the new document' do
-              Dictionary.create!(name: "French-English", year: 950)
+              Dictionary.create!(name: 'French-English', year: 950)
               expect do
-                Dictionary.create!(name: "French-English", year: 1950)
+                Dictionary.create!(name: 'French-English', year: 1950)
               end.not_to raise_error
             end
           end
@@ -857,149 +786,140 @@ describe Mongoid::Validatable::UniquenessValidator do
             it 'creates the new document' do
               pending 'https://jira.mongodb.org/browse/MONGOID-4815'
 
-              Dictionary.create!(name: "French-English", year: 1950)
+              Dictionary.create!(name: 'French-English', year: 1950)
               expect do
-                Dictionary.create!(name: "French-English", year: 950)
+                Dictionary.create!(name: 'French-English', year: 950)
               end.not_to raise_error
             end
           end
         end
 
-        context "when multiple scopes are provided" do
-
+        context 'when multiple scopes are provided' do
           before do
-            Dictionary.validates_uniqueness_of :name, scope: [ :publisher, :year ]
+            Dictionary.validates_uniqueness_of :name, scope: %i[publisher year]
           end
 
           after do
             Dictionary.reset_callbacks(:validate)
           end
 
-          context "when the attribute is unique" do
-
+          context 'when the attribute is unique' do
             before do
-              Dictionary.create!(name: "Oxford", publisher: "Amazon")
+              Dictionary.create!(name: 'Oxford', publisher: 'Amazon')
             end
 
             let(:dictionary) do
-              Dictionary.new(name: "Webster")
+              Dictionary.new(name: 'Webster')
             end
 
-            it "returns true" do
+            it 'returns true' do
               expect(dictionary).to be_valid
             end
           end
 
-          context "when the attribute is unique in the scope" do
-
+          context 'when the attribute is unique in the scope' do
             before do
               Dictionary.create!(
-                name: "Oxford",
-                publisher: "Amazon",
+                name: 'Oxford',
+                publisher: 'Amazon',
                 year: 2011
               )
             end
 
             let(:dictionary) do
               Dictionary.new(
-                name: "Webster",
-                publisher: "Amazon",
+                name: 'Webster',
+                publisher: 'Amazon',
                 year: 2011
               )
             end
 
-            it "returns true" do
+            it 'returns true' do
               expect(dictionary).to be_valid
             end
           end
 
-          context "when the attribute is not unique with no scope" do
-
+          context 'when the attribute is not unique with no scope' do
             before do
-              Dictionary.create!(name: "Oxford", publisher: "Amazon")
+              Dictionary.create!(name: 'Oxford', publisher: 'Amazon')
             end
 
             let(:dictionary) do
-              Dictionary.new(name: "Oxford")
+              Dictionary.new(name: 'Oxford')
             end
 
-            it "returns true" do
+            it 'returns true' do
               expect(dictionary).to be_valid
             end
           end
 
-          context "when the attribute is not unique in another scope" do
-
+          context 'when the attribute is not unique in another scope' do
             before do
               Dictionary.create!(
-                name: "Oxford",
-                publisher: "Amazon",
+                name: 'Oxford',
+                publisher: 'Amazon',
                 year: 1995
               )
             end
 
             let(:dictionary) do
               Dictionary.new(
-                name: "Oxford",
-                publisher: "Addison",
+                name: 'Oxford',
+                publisher: 'Addison',
                 year: 2011
               )
             end
 
-            it "returns true" do
+            it 'returns true' do
               expect(dictionary).to be_valid
             end
           end
 
-          context "when the attribute is not unique in the same scope" do
-
-            context "when the document is not the match" do
-
+          context 'when the attribute is not unique in the same scope' do
+            context 'when the document is not the match' do
               before do
                 Dictionary.create!(
-                  name: "Oxford",
-                  publisher: "Amazon",
+                  name: 'Oxford',
+                  publisher: 'Amazon',
                   year: 1960
                 )
               end
 
               let(:dictionary) do
                 Dictionary.new(
-                  name: "Oxford",
-                  publisher: "Amazon",
+                  name: 'Oxford',
+                  publisher: 'Amazon',
                   year: 1960
                 )
               end
 
-              it "returns false" do
-                expect(dictionary).to_not be_valid
+              it 'returns false' do
+                expect(dictionary).not_to be_valid
               end
 
-              it "adds the uniqueness errors" do
+              it 'adds the uniqueness errors' do
                 dictionary.valid?
-                expect(dictionary.errors[:name]).to eq([ "has already been taken" ])
+                expect(dictionary.errors[:name]).to eq([ 'has already been taken' ])
               end
             end
 
-            context "when the document is the match in the database" do
-
+            context 'when the document is the match in the database' do
               let!(:dictionary) do
                 Dictionary.create!(
-                  name: "Oxford",
-                  publisher: "Amazon",
+                  name: 'Oxford',
+                  publisher: 'Amazon',
                   year: 1960
                 )
               end
 
-              it "returns true" do
+              it 'returns true' do
                 expect(dictionary).to be_valid
               end
             end
           end
         end
 
-        context "when case sensitive is true" do
-
+        context 'when case sensitive is true' do
           before do
             Dictionary.validates_uniqueness_of :name
           end
@@ -1008,58 +928,53 @@ describe Mongoid::Validatable::UniquenessValidator do
             Dictionary.reset_callbacks(:validate)
           end
 
-          context "when the attribute is unique" do
-
+          context 'when the attribute is unique' do
             before do
-              Dictionary.create!(name: "Oxford")
+              Dictionary.create!(name: 'Oxford')
             end
 
             let(:dictionary) do
-              Dictionary.new(name: "Webster")
+              Dictionary.new(name: 'Webster')
             end
 
-            it "returns true" do
+            it 'returns true' do
               expect(dictionary).to be_valid
             end
           end
 
-          context "when the attribute is not unique" do
-
-            context "when the document is not the match" do
-
+          context 'when the attribute is not unique' do
+            context 'when the document is not the match' do
               before do
-                Dictionary.create!(name: "Oxford")
+                Dictionary.create!(name: 'Oxford')
               end
 
               let(:dictionary) do
-                Dictionary.new(name: "Oxford")
+                Dictionary.new(name: 'Oxford')
               end
 
-              it "returns false" do
-                expect(dictionary).to_not be_valid
+              it 'returns false' do
+                expect(dictionary).not_to be_valid
               end
 
-              it "adds the uniqueness error" do
+              it 'adds the uniqueness error' do
                 dictionary.valid?
-                expect(dictionary.errors[:name]).to eq([ "has already been taken" ])
+                expect(dictionary.errors[:name]).to eq([ 'has already been taken' ])
               end
             end
 
-            context "when the document is the match in the database" do
-
+            context 'when the document is the match in the database' do
               let!(:dictionary) do
-                Dictionary.create!(name: "Oxford")
+                Dictionary.create!(name: 'Oxford')
               end
 
-              it "returns true" do
+              it 'returns true' do
                 expect(dictionary).to be_valid
               end
             end
           end
         end
 
-        context "when case sensitive is false" do
-
+        context 'when case sensitive is false' do
           before do
             Dictionary.validates_uniqueness_of :name, case_sensitive: false
           end
@@ -1068,83 +983,75 @@ describe Mongoid::Validatable::UniquenessValidator do
             Dictionary.reset_callbacks(:validate)
           end
 
-          context "when the attribute is unique" do
-
-            context "when there are no special characters" do
-
+          context 'when the attribute is unique' do
+            context 'when there are no special characters' do
               before do
-                Dictionary.create!(name: "Oxford")
+                Dictionary.create!(name: 'Oxford')
               end
 
               let(:dictionary) do
-                Dictionary.new(name: "Webster")
+                Dictionary.new(name: 'Webster')
               end
 
-              it "returns true" do
+              it 'returns true' do
                 expect(dictionary).to be_valid
               end
             end
 
-            context "when special characters exist" do
-
+            context 'when special characters exist' do
               before do
-                Dictionary.create!(name: "Oxford")
+                Dictionary.create!(name: 'Oxford')
               end
 
               let(:dictionary) do
-                Dictionary.new(name: "Web@st.er")
+                Dictionary.new(name: 'Web@st.er')
               end
 
-              it "returns true" do
+              it 'returns true' do
                 expect(dictionary).to be_valid
               end
             end
           end
 
-          context "when the attribute is not unique" do
-
-            context "when the document is not the match" do
-
+          context 'when the attribute is not unique' do
+            context 'when the document is not the match' do
               before do
-                Dictionary.create!(name: "Oxford")
+                Dictionary.create!(name: 'Oxford')
               end
 
               let(:dictionary) do
-                Dictionary.new(name: "oxford")
+                Dictionary.new(name: 'oxford')
               end
 
-              it "returns false" do
-                expect(dictionary).to_not be_valid
+              it 'returns false' do
+                expect(dictionary).not_to be_valid
               end
 
-              it "adds the uniqueness error" do
+              it 'adds the uniqueness error' do
                 dictionary.valid?
-                expect(dictionary.errors[:name]).to eq([ "has already been taken" ])
+                expect(dictionary.errors[:name]).to eq([ 'has already been taken' ])
               end
             end
 
-            context "when the document is the match in the database" do
-
+            context 'when the document is the match in the database' do
               let!(:dictionary) do
-                Dictionary.create!(name: "Oxford")
+                Dictionary.create!(name: 'Oxford')
               end
 
-              it "returns true" do
+              it 'returns true' do
                 expect(dictionary).to be_valid
               end
             end
           end
         end
 
-        context "when not allowing nil" do
-
-          it "raises a validation error" do
+        context 'when not allowing nil' do
+          it 'raises a validation error' do
             expect { LineItem.create! }.to raise_error Mongoid::Errors::Validations
           end
         end
 
-        context "when allowing nil" do
-
+        context 'when allowing nil' do
           before do
             Dictionary.validates_uniqueness_of :name, allow_nil: true
           end
@@ -1153,8 +1060,7 @@ describe Mongoid::Validatable::UniquenessValidator do
             Dictionary.reset_callbacks(:validate)
           end
 
-          context "when the attribute is nil" do
-
+          context 'when the attribute is nil' do
             before do
               Dictionary.create!
             end
@@ -1163,14 +1069,13 @@ describe Mongoid::Validatable::UniquenessValidator do
               Dictionary.new
             end
 
-            it "returns true" do
+            it 'returns true' do
               expect(dictionary).to be_valid
             end
           end
         end
 
-        context "when allowing blank" do
-
+        context 'when allowing blank' do
           before do
             Dictionary.validates_uniqueness_of :name, allow_blank: true
           end
@@ -1179,27 +1084,24 @@ describe Mongoid::Validatable::UniquenessValidator do
             Dictionary.reset_callbacks(:validate)
           end
 
-          context "when the attribute is blank" do
-
+          context 'when the attribute is blank' do
             before do
-              Dictionary.create!(name: "")
+              Dictionary.create!(name: '')
             end
 
             let(:dictionary) do
-              Dictionary.new(name: "")
+              Dictionary.new(name: '')
             end
 
-            it "returns true" do
+            it 'returns true' do
               expect(dictionary).to be_valid
             end
           end
         end
       end
 
-      context "when the document contains a compound key" do
-
-        context "when no scope is provided" do
-
+      context 'when the document contains a compound key' do
+        context 'when no scope is provided' do
           before do
             Login.validates_uniqueness_of :username
           end
@@ -1208,58 +1110,53 @@ describe Mongoid::Validatable::UniquenessValidator do
             Login.reset_callbacks(:validate)
           end
 
-          context "when the attribute is unique" do
-
+          context 'when the attribute is unique' do
             before do
-              Login.create!(username: "Oxford")
+              Login.create!(username: 'Oxford')
             end
 
             let(:login) do
-              Login.new(username: "Webster")
+              Login.new(username: 'Webster')
             end
 
-            it "returns true" do
+            it 'returns true' do
               expect(login).to be_valid
             end
           end
 
-          context "when the attribute is not unique" do
-
-            context "when the document is not the match" do
-
+          context 'when the attribute is not unique' do
+            context 'when the document is not the match' do
               before do
-                Login.create!(username: "Oxford")
+                Login.create!(username: 'Oxford')
               end
 
               let(:login) do
-                Login.new(username: "Oxford")
+                Login.new(username: 'Oxford')
               end
 
-              it "returns false" do
-                expect(login).to_not be_valid
+              it 'returns false' do
+                expect(login).not_to be_valid
               end
 
-              it "adds the uniqueness error" do
+              it 'adds the uniqueness error' do
                 login.valid?
-                expect(login.errors[:username]).to eq([ "has already been taken" ])
+                expect(login.errors[:username]).to eq([ 'has already been taken' ])
               end
             end
 
-            context "when the document is the match in the database" do
-
+            context 'when the document is the match in the database' do
               let!(:login) do
-                Login.create!(username: "Oxford")
+                Login.create!(username: 'Oxford')
               end
 
-              it "returns true" do
+              it 'returns true' do
                 expect(login).to be_valid
               end
             end
           end
         end
 
-        context "when a single scope is provided" do
-
+        context 'when a single scope is provided' do
           before do
             Login.validates_uniqueness_of :username, scope: :application_id
           end
@@ -1268,103 +1165,95 @@ describe Mongoid::Validatable::UniquenessValidator do
             Login.reset_callbacks(:validate)
           end
 
-          context "when the attribute is unique" do
-
+          context 'when the attribute is unique' do
             before do
-              Login.create!(username: "Oxford", application_id: 1)
+              Login.create!(username: 'Oxford', application_id: 1)
             end
 
             let(:login) do
-              Login.new(username: "Webster")
+              Login.new(username: 'Webster')
             end
 
-            it "returns true" do
+            it 'returns true' do
               expect(login).to be_valid
             end
           end
 
-          context "when the attribute is unique in the scope" do
-
+          context 'when the attribute is unique in the scope' do
             before do
-              Login.create!(username: "Oxford", application_id: 1)
+              Login.create!(username: 'Oxford', application_id: 1)
             end
 
             let(:login) do
-              Login.new(username: "Webster", application_id: 1)
+              Login.new(username: 'Webster', application_id: 1)
             end
 
-            it "returns true" do
+            it 'returns true' do
               expect(login).to be_valid
             end
           end
 
-          context "when the attribute is not unique with no scope" do
-
+          context 'when the attribute is not unique with no scope' do
             before do
-              Login.create!(username: "Oxford", application_id: 1)
+              Login.create!(username: 'Oxford', application_id: 1)
             end
 
             let(:login) do
-              Login.new(username: "Oxford")
+              Login.new(username: 'Oxford')
             end
 
-            it "returns true" do
+            it 'returns true' do
               expect(login).to be_valid
             end
           end
 
-          context "when the attribute is not unique in another scope" do
-
+          context 'when the attribute is not unique in another scope' do
             before do
-              Login.create!(username: "Oxford", application_id: 1)
+              Login.create!(username: 'Oxford', application_id: 1)
             end
 
             let(:login) do
-              Login.new(username: "Oxford", application_id: 2)
+              Login.new(username: 'Oxford', application_id: 2)
             end
 
-            it "returns true" do
+            it 'returns true' do
               expect(login).to be_valid
             end
           end
 
-          context "when the attribute is not unique in the same scope" do
-
-            context "when the document is not the match" do
-
+          context 'when the attribute is not unique in the same scope' do
+            context 'when the document is not the match' do
               before do
-                Login.create!(username: "Oxford", application_id: 1)
+                Login.create!(username: 'Oxford', application_id: 1)
               end
 
               let(:login) do
-                Login.new(username: "Oxford", application_id: 1)
+                Login.new(username: 'Oxford', application_id: 1)
               end
 
-              it "returns false" do
-                expect(login).to_not be_valid
+              it 'returns false' do
+                expect(login).not_to be_valid
               end
 
-              it "adds the uniqueness errors" do
+              it 'adds the uniqueness errors' do
                 login.valid?
-                expect(login.errors[:username]).to eq([ "has already been taken" ])
+                expect(login.errors[:username]).to eq([ 'has already been taken' ])
               end
             end
 
-            context "when the document is the match in the database" do
-
+            context 'when the document is the match in the database' do
               let!(:login) do
-                Login.create!(username: "Oxford", application_id: 1)
+                Login.create!(username: 'Oxford', application_id: 1)
               end
 
-              it "returns true" do
+              it 'returns true' do
                 expect(login).to be_valid
               end
             end
           end
         end
 
-        context "when case sensitive is true" do
-
+        context 'when case sensitive is true' do
           before do
             Login.validates_uniqueness_of :username
           end
@@ -1373,58 +1262,53 @@ describe Mongoid::Validatable::UniquenessValidator do
             Login.reset_callbacks(:validate)
           end
 
-          context "when the attribute is unique" do
-
+          context 'when the attribute is unique' do
             before do
-              Login.create!(username: "Oxford")
+              Login.create!(username: 'Oxford')
             end
 
             let(:login) do
-              Login.new(username: "Webster")
+              Login.new(username: 'Webster')
             end
 
-            it "returns true" do
+            it 'returns true' do
               expect(login).to be_valid
             end
           end
 
-          context "when the attribute is not unique" do
-
-            context "when the document is not the match" do
-
+          context 'when the attribute is not unique' do
+            context 'when the document is not the match' do
               before do
-                Login.create!(username: "Oxford")
+                Login.create!(username: 'Oxford')
               end
 
               let(:login) do
-                Login.new(username: "Oxford")
+                Login.new(username: 'Oxford')
               end
 
-              it "returns false" do
-                expect(login).to_not be_valid
+              it 'returns false' do
+                expect(login).not_to be_valid
               end
 
-              it "adds the uniqueness error" do
+              it 'adds the uniqueness error' do
                 login.valid?
-                expect(login.errors[:username]).to eq([ "has already been taken" ])
+                expect(login.errors[:username]).to eq([ 'has already been taken' ])
               end
             end
 
-            context "when the document is the match in the database" do
-
+            context 'when the document is the match in the database' do
               let!(:login) do
-                Login.create!(username: "Oxford")
+                Login.create!(username: 'Oxford')
               end
 
-              it "returns true" do
+              it 'returns true' do
                 expect(login).to be_valid
               end
             end
           end
         end
 
-        context "when case sensitive is false" do
-
+        context 'when case sensitive is false' do
           before do
             Login.validates_uniqueness_of :username, case_sensitive: false
           end
@@ -1433,76 +1317,69 @@ describe Mongoid::Validatable::UniquenessValidator do
             Login.reset_callbacks(:validate)
           end
 
-          context "when the attribute is unique" do
-
-            context "when there are no special characters" do
-
+          context 'when the attribute is unique' do
+            context 'when there are no special characters' do
               before do
-                Login.create!(username: "Oxford")
+                Login.create!(username: 'Oxford')
               end
 
               let(:login) do
-                Login.new(username: "Webster")
+                Login.new(username: 'Webster')
               end
 
-              it "returns true" do
+              it 'returns true' do
                 expect(login).to be_valid
               end
             end
 
-            context "when special characters exist" do
-
+            context 'when special characters exist' do
               before do
-                Login.create!(username: "Oxford")
+                Login.create!(username: 'Oxford')
               end
 
               let(:login) do
-                Login.new(username: "Web@st.er")
+                Login.new(username: 'Web@st.er')
               end
 
-              it "returns true" do
+              it 'returns true' do
                 expect(login).to be_valid
               end
             end
           end
 
-          context "when the attribute is not unique" do
-
-            context "when the document is not the match" do
-
+          context 'when the attribute is not unique' do
+            context 'when the document is not the match' do
               before do
-                Login.create!(username: "Oxford")
+                Login.create!(username: 'Oxford')
               end
 
               let(:login) do
-                Login.new(username: "oxford")
+                Login.new(username: 'oxford')
               end
 
-              it "returns false" do
-                expect(login).to_not be_valid
+              it 'returns false' do
+                expect(login).not_to be_valid
               end
 
-              it "adds the uniqueness error" do
+              it 'adds the uniqueness error' do
                 login.valid?
-                expect(login.errors[:username]).to eq([ "has already been taken" ])
+                expect(login.errors[:username]).to eq([ 'has already been taken' ])
               end
             end
 
-            context "when the document is the match in the database" do
-
+            context 'when the document is the match in the database' do
               let!(:login) do
-                Login.create!(username: "Oxford")
+                Login.create!(username: 'Oxford')
               end
 
-              it "returns true" do
+              it 'returns true' do
                 expect(login).to be_valid
               end
             end
           end
         end
 
-        context "when allowing nil" do
-
+        context 'when allowing nil' do
           before do
             Login.validates_uniqueness_of :username, allow_nil: true
           end
@@ -1511,8 +1388,7 @@ describe Mongoid::Validatable::UniquenessValidator do
             Login.reset_callbacks(:validate)
           end
 
-          context "when the attribute is nil" do
-
+          context 'when the attribute is nil' do
             before do
               Login.create!
             end
@@ -1521,14 +1397,13 @@ describe Mongoid::Validatable::UniquenessValidator do
               Login.new
             end
 
-            it "returns true" do
+            it 'returns true' do
               expect(login).to be_valid
             end
           end
         end
 
-        context "when allowing blank" do
-
+        context 'when allowing blank' do
           before do
             Login.validates_uniqueness_of :username, allow_blank: true
           end
@@ -1537,25 +1412,23 @@ describe Mongoid::Validatable::UniquenessValidator do
             Login.reset_callbacks(:validate)
           end
 
-          context "when the attribute is blank" do
-
+          context 'when the attribute is blank' do
             before do
-              Login.create!(username: "")
+              Login.create!(username: '')
             end
 
             let(:login) do
-              Login.new(username: "")
+              Login.new(username: '')
             end
 
-            it "returns true" do
+            it 'returns true' do
               expect(login).to be_valid
             end
           end
         end
       end
 
-      context "when the attribute is a custom type" do
-
+      context 'when the attribute is a custom type' do
         before do
           Bar.validates_uniqueness_of :lat_lng
         end
@@ -1564,8 +1437,7 @@ describe Mongoid::Validatable::UniquenessValidator do
           Bar.reset_callbacks(:validate)
         end
 
-        context "when the attribute is unique" do
-
+        context 'when the attribute is unique' do
           before do
             Bar.create!(lat_lng: LatLng.new(52.30, 13.25))
           end
@@ -1574,14 +1446,12 @@ describe Mongoid::Validatable::UniquenessValidator do
             Bar.new(lat_lng: LatLng.new(54.30, 14.25))
           end
 
-          it "returns true" do
+          it 'returns true' do
             expect(unique_bar).to be_valid
           end
-
         end
 
-        context "when the attribute is not unique" do
-
+        context 'when the attribute is not unique' do
           before do
             Bar.create!(lat_lng: LatLng.new(52.30, 13.25))
           end
@@ -1590,25 +1460,22 @@ describe Mongoid::Validatable::UniquenessValidator do
             Bar.new(lat_lng: LatLng.new(52.30, 13.25))
           end
 
-          it "returns false" do
-            expect(non_unique_bar).to_not be_valid
+          it 'returns false' do
+            expect(non_unique_bar).not_to be_valid
           end
-
         end
       end
 
-      context "when conditions is set" do
-
+      context 'when conditions is set' do
         before do
-          Band.validates_uniqueness_of :name, conditions: ->{ Band.where(active: true) }
+          Band.validates_uniqueness_of :name, conditions: -> { Band.where(active: true) }
         end
 
         after do
           Band.reset_callbacks(:validate)
         end
 
-        context "when the attribute is unique" do
-
+        context 'when the attribute is unique' do
           before do
             Band.create!(name: 'Foo', active: false)
           end
@@ -1617,14 +1484,12 @@ describe Mongoid::Validatable::UniquenessValidator do
             Band.new(name: 'Foo')
           end
 
-          it "returns true" do
+          it 'returns true' do
             expect(unique_band).to be_valid
           end
-
         end
 
-        context "when the attribute is not unique" do
-
+        context 'when the attribute is not unique' do
           before do
             Band.create!(name: 'Foo')
           end
@@ -1633,32 +1498,29 @@ describe Mongoid::Validatable::UniquenessValidator do
             Band.new(name: 'Foo')
           end
 
-          it "returns false" do
-            expect(non_unique_band).to_not be_valid
+          it 'returns false' do
+            expect(non_unique_band).not_to be_valid
           end
         end
       end
     end
   end
 
-  context "when the document is embedded" do
-
+  context 'when the document is embedded' do
     let(:word) do
-      Word.create!(name: "Schadenfreude")
+      Word.create!(name: 'Schadenfreude')
     end
 
-    context "when in an embeds_many" do
-
+    context 'when in an embeds_many' do
       let!(:def_one) do
-        word.definitions.create!(description: "1")
+        word.definitions.create!(description: '1')
       end
 
       let!(:def_two) do
-        word.definitions.create!(description: "2")
+        word.definitions.create!(description: '2')
       end
 
-      context "when setting the read preference to non-primary" do
-
+      context 'when setting the read preference to non-primary' do
         before do
           Definition.validates_uniqueness_of :description
         end
@@ -1669,20 +1531,19 @@ describe Mongoid::Validatable::UniquenessValidator do
 
         let(:word) { Word.create! }
 
-        it "reads from the primary" do
+        it 'reads from the primary' do
           expect_any_instance_of(Mongoid::Criteria).to receive(:read).once.and_wrap_original do |m, *args, **kwargs|
             crit = m.call(*args, **kwargs)
             expect(crit.options[:read]).to eq({ mode: :primary })
             crit
           end
-          Definition.with(read: { mode: :secondary }) do |klass|
+          Definition.with(read: { mode: :secondary }) do |_klass|
             word.definitions.create!
           end
         end
       end
 
-      context "when a document is being destroyed" do
-
+      context 'when a document is being destroyed' do
         before do
           Definition.validates_uniqueness_of :description
         end
@@ -1691,13 +1552,12 @@ describe Mongoid::Validatable::UniquenessValidator do
           Definition.reset_callbacks(:validate)
         end
 
-        context "when changing a document to the destroyed property" do
-
+        context 'when changing a document to the destroyed property' do
           let(:attributes) do
             {
               definitions_attributes: {
-                "0" => { id: def_one.id, description: "0", "_destroy" => 1 },
-                "1" => { id: def_two.id, description: "1" }
+                '0' => { id: def_one.id, description: '0', '_destroy' => 1 },
+                '1' => { id: def_two.id, description: '1' }
               }
             }
           end
@@ -1706,16 +1566,14 @@ describe Mongoid::Validatable::UniquenessValidator do
             word.attributes = attributes
           end
 
-          it "returns true" do
+          it 'returns true' do
             expect(def_two).to be_valid
           end
         end
       end
 
-      context "when the document does not use composite keys" do
-
-        context "when no scope is provided" do
-
+      context 'when the document does not use composite keys' do
+        context 'when no scope is provided' do
           before do
             Definition.validates_uniqueness_of :description
           end
@@ -1724,58 +1582,53 @@ describe Mongoid::Validatable::UniquenessValidator do
             Definition.reset_callbacks(:validate)
           end
 
-          context "when the attribute is unique" do
-
+          context 'when the attribute is unique' do
             before do
-              word.definitions.build(description: "Malicious joy")
+              word.definitions.build(description: 'Malicious joy')
             end
 
             let(:definition) do
-              word.definitions.build(description: "Gloating")
+              word.definitions.build(description: 'Gloating')
             end
 
-            it "returns true" do
+            it 'returns true' do
               expect(definition).to be_valid
             end
           end
 
-          context "when the attribute is not unique" do
-
-            context "when the document is not the match" do
-
+          context 'when the attribute is not unique' do
+            context 'when the document is not the match' do
               before do
-                word.definitions.build(description: "Malicious joy")
+                word.definitions.build(description: 'Malicious joy')
               end
 
               let(:definition) do
-                word.definitions.build(description: "Malicious joy")
+                word.definitions.build(description: 'Malicious joy')
               end
 
-              it "returns false" do
-                expect(definition).to_not be_valid
+              it 'returns false' do
+                expect(definition).not_to be_valid
               end
 
-              it "adds the uniqueness error" do
+              it 'adds the uniqueness error' do
                 definition.valid?
-                expect(definition.errors[:description]).to eq([ "has already been taken" ])
+                expect(definition.errors[:description]).to eq([ 'has already been taken' ])
               end
             end
 
-            context "when the document is the match in the database" do
-
+            context 'when the document is the match in the database' do
               let!(:definition) do
-                word.definitions.build(description: "Malicious joy")
+                word.definitions.build(description: 'Malicious joy')
               end
 
-              it "returns true" do
+              it 'returns true' do
                 expect(definition).to be_valid
               end
             end
           end
         end
 
-        context "when a single scope is provided" do
-
+        context 'when a single scope is provided' do
           before do
             Definition.validates_uniqueness_of :description, scope: :part
           end
@@ -1784,268 +1637,252 @@ describe Mongoid::Validatable::UniquenessValidator do
             Definition.reset_callbacks(:validate)
           end
 
-          context "when the attribute is unique" do
-
+          context 'when the attribute is unique' do
             before do
               word.definitions.build(
-                description: "Malicious joy", part: "Noun"
+                description: 'Malicious joy', part: 'Noun'
               )
             end
 
             let(:definition) do
-              word.definitions.build(description: "Gloating")
+              word.definitions.build(description: 'Gloating')
             end
 
-            it "returns true" do
+            it 'returns true' do
               expect(definition).to be_valid
             end
           end
 
-          context "when the attribute is unique in the scope" do
-
+          context 'when the attribute is unique in the scope' do
             before do
               word.definitions.build(
-                description: "Malicious joy",
-                part: "Noun"
+                description: 'Malicious joy',
+                part: 'Noun'
               )
             end
 
             let(:definition) do
               word.definitions.build(
-                description: "Gloating",
-                part: "Noun"
+                description: 'Gloating',
+                part: 'Noun'
               )
             end
 
-            it "returns true" do
+            it 'returns true' do
               expect(definition).to be_valid
             end
           end
 
-          context "when the attribute is not unique with no scope" do
-
+          context 'when the attribute is not unique with no scope' do
             before do
               word.definitions.build(
-                description: "Malicious joy",
-                part: "Noun"
+                description: 'Malicious joy',
+                part: 'Noun'
               )
             end
 
             let(:definition) do
-              word.definitions.build(description: "Malicious joy")
+              word.definitions.build(description: 'Malicious joy')
             end
 
-            it "returns true" do
+            it 'returns true' do
               expect(definition).to be_valid
             end
           end
 
-          context "when the attribute is not unique in another scope" do
-
+          context 'when the attribute is not unique in another scope' do
             before do
               word.definitions.build(
-                description: "Malicious joy",
-                part: "Noun"
+                description: 'Malicious joy',
+                part: 'Noun'
               )
             end
 
             let(:definition) do
               word.definitions.build(
-                description: "Malicious joy",
-                part: "Adj"
+                description: 'Malicious joy',
+                part: 'Adj'
               )
             end
 
-            it "returns true" do
+            it 'returns true' do
               expect(definition).to be_valid
             end
           end
 
-          context "when the attribute is not unique in the same scope" do
-
-            context "when the document is not the match" do
-
+          context 'when the attribute is not unique in the same scope' do
+            context 'when the document is not the match' do
               before do
                 word.definitions.build(
-                  description: "Malicious joy",
-                  part: "Noun"
+                  description: 'Malicious joy',
+                  part: 'Noun'
                 )
               end
 
               let(:definition) do
                 word.definitions.build(
-                  description: "Malicious joy",
-                  part: "Noun"
+                  description: 'Malicious joy',
+                  part: 'Noun'
                 )
               end
 
-              it "returns false" do
-                expect(definition).to_not be_valid
+              it 'returns false' do
+                expect(definition).not_to be_valid
               end
 
-              it "adds the uniqueness errors" do
+              it 'adds the uniqueness errors' do
                 definition.valid?
-                expect(definition.errors[:description]).to eq([ "has already been taken" ])
+                expect(definition.errors[:description]).to eq([ 'has already been taken' ])
               end
             end
 
-            context "when the document is the match in the database" do
-
+            context 'when the document is the match in the database' do
               let!(:definition) do
                 word.definitions.build(
-                  description: "Malicious joy",
-                  part: "Noun"
+                  description: 'Malicious joy',
+                  part: 'Noun'
                 )
               end
 
-              it "returns true" do
+              it 'returns true' do
                 expect(definition).to be_valid
               end
             end
           end
         end
 
-        context "when multiple scopes are provided" do
-
+        context 'when multiple scopes are provided' do
           before do
-            Definition.validates_uniqueness_of :description, scope: [ :part, :regular ]
+            Definition.validates_uniqueness_of :description, scope: %i[part regular]
           end
 
           after do
             Definition.reset_callbacks(:validate)
           end
 
-          context "when the attribute is unique" do
-
+          context 'when the attribute is unique' do
             before do
               word.definitions.build(
-                description: "Malicious joy",
-                part: "Noun"
+                description: 'Malicious joy',
+                part: 'Noun'
               )
             end
 
             let(:definition) do
-              word.definitions.build(description: "Gloating")
+              word.definitions.build(description: 'Gloating')
             end
 
-            it "returns true" do
+            it 'returns true' do
               expect(definition).to be_valid
             end
           end
 
-          context "when the attribute is unique in the scope" do
-
+          context 'when the attribute is unique in the scope' do
             before do
               word.definitions.build(
-                description: "Malicious joy",
-                part: "Noun",
+                description: 'Malicious joy',
+                part: 'Noun',
                 regular: true
               )
             end
 
             let(:definition) do
               word.definitions.build(
-                description: "Gloating",
-                part: "Noun",
+                description: 'Gloating',
+                part: 'Noun',
                 regular: true
               )
             end
 
-            it "returns true" do
+            it 'returns true' do
               expect(definition).to be_valid
             end
           end
 
-          context "when the attribute is not unique with no scope" do
-
+          context 'when the attribute is not unique with no scope' do
             before do
               word.definitions.build(
-                description: "Malicious joy",
-                part: "Noun"
+                description: 'Malicious joy',
+                part: 'Noun'
               )
             end
 
             let(:definition) do
-              word.definitions.build(description: "Malicious scope")
+              word.definitions.build(description: 'Malicious scope')
             end
 
-            it "returns true" do
+            it 'returns true' do
               expect(definition).to be_valid
             end
           end
 
-          context "when the attribute is not unique in another scope" do
-
+          context 'when the attribute is not unique in another scope' do
             before do
               word.definitions.build(
-                description: "Malicious joy",
-                part: "Noun",
+                description: 'Malicious joy',
+                part: 'Noun',
                 regular: true
               )
             end
 
             let(:definition) do
               word.definitions.build(
-                description: "Malicious joy",
-                part: "Adj",
+                description: 'Malicious joy',
+                part: 'Adj',
                 regular: true
               )
             end
 
-            it "returns true" do
+            it 'returns true' do
               expect(definition).to be_valid
             end
           end
 
-          context "when the attribute is not unique in the same scope" do
-
-            context "when the document is not the match" do
-
+          context 'when the attribute is not unique in the same scope' do
+            context 'when the document is not the match' do
               before do
                 word.definitions.build(
-                  description: "Malicious joy",
-                  part: "Noun",
+                  description: 'Malicious joy',
+                  part: 'Noun',
                   regular: true
                 )
               end
 
               let(:definition) do
                 word.definitions.build(
-                  description: "Malicious joy",
-                  part: "Noun",
+                  description: 'Malicious joy',
+                  part: 'Noun',
                   regular: true
                 )
               end
 
-              it "returns false" do
-                expect(definition).to_not be_valid
+              it 'returns false' do
+                expect(definition).not_to be_valid
               end
 
-              it "adds the uniqueness errors" do
+              it 'adds the uniqueness errors' do
                 definition.valid?
-                expect(definition.errors[:description]).to eq([ "has already been taken" ])
+                expect(definition.errors[:description]).to eq([ 'has already been taken' ])
               end
             end
 
-            context "when the document is the match in the database" do
-
+            context 'when the document is the match in the database' do
               let!(:definition) do
                 word.definitions.build(
-                  description: "Malicious joy",
-                  part: "Noun",
+                  description: 'Malicious joy',
+                  part: 'Noun',
                   regular: false
                 )
               end
 
-              it "returns true" do
+              it 'returns true' do
                 expect(definition).to be_valid
               end
             end
           end
         end
 
-        context "when case sensitive is true" do
-
+        context 'when case sensitive is true' do
           before do
             Definition.validates_uniqueness_of :description
           end
@@ -2054,58 +1891,53 @@ describe Mongoid::Validatable::UniquenessValidator do
             Definition.reset_callbacks(:validate)
           end
 
-          context "when the attribute is unique" do
-
+          context 'when the attribute is unique' do
             before do
-              word.definitions.build(description: "Malicious jo")
+              word.definitions.build(description: 'Malicious jo')
             end
 
             let(:definition) do
-              word.definitions.build(description: "Gloating")
+              word.definitions.build(description: 'Gloating')
             end
 
-            it "returns true" do
+            it 'returns true' do
               expect(definition).to be_valid
             end
           end
 
-          context "when the attribute is not unique" do
-
-            context "when the document is not the match" do
-
+          context 'when the attribute is not unique' do
+            context 'when the document is not the match' do
               before do
-                word.definitions.build(description: "Malicious joy")
+                word.definitions.build(description: 'Malicious joy')
               end
 
               let(:definition) do
-                word.definitions.build(description: "Malicious joy")
+                word.definitions.build(description: 'Malicious joy')
               end
 
-              it "returns false" do
-                expect(definition).to_not be_valid
+              it 'returns false' do
+                expect(definition).not_to be_valid
               end
 
-              it "adds the uniqueness error" do
+              it 'adds the uniqueness error' do
                 definition.valid?
-                expect(definition.errors[:description]).to eq([ "has already been taken" ])
+                expect(definition.errors[:description]).to eq([ 'has already been taken' ])
               end
             end
 
-            context "when the document is the match in the database" do
-
+            context 'when the document is the match in the database' do
               let!(:definition) do
-                word.definitions.build(description: "Malicious joy")
+                word.definitions.build(description: 'Malicious joy')
               end
 
-              it "returns true" do
+              it 'returns true' do
                 expect(definition).to be_valid
               end
             end
           end
         end
 
-        context "when case sensitive is false" do
-
+        context 'when case sensitive is false' do
           before do
             Definition.validates_uniqueness_of :description, case_sensitive: false
           end
@@ -2114,76 +1946,69 @@ describe Mongoid::Validatable::UniquenessValidator do
             Definition.reset_callbacks(:validate)
           end
 
-          context "when the attribute is unique" do
-
-            context "when there are no special characters" do
-
+          context 'when the attribute is unique' do
+            context 'when there are no special characters' do
               before do
-                word.definitions.build(description: "Malicious joy")
+                word.definitions.build(description: 'Malicious joy')
               end
 
               let(:definition) do
-                word.definitions.build(description: "Gloating")
+                word.definitions.build(description: 'Gloating')
               end
 
-              it "returns true" do
+              it 'returns true' do
                 expect(definition).to be_valid
               end
             end
 
-            context "when special characters exist" do
-
+            context 'when special characters exist' do
               before do
-                word.definitions.build(description: "Malicious joy")
+                word.definitions.build(description: 'Malicious joy')
               end
 
               let(:definition) do
-                word.definitions.build(description: "M@licious.joy")
+                word.definitions.build(description: 'M@licious.joy')
               end
 
-              it "returns true" do
+              it 'returns true' do
                 expect(definition).to be_valid
               end
             end
           end
 
-          context "when the attribute is not unique" do
-
-            context "when the document is not the match" do
-
+          context 'when the attribute is not unique' do
+            context 'when the document is not the match' do
               before do
-                word.definitions.build(description: "Malicious joy")
+                word.definitions.build(description: 'Malicious joy')
               end
 
               let(:definition) do
-                word.definitions.build(description: "Malicious JOY")
+                word.definitions.build(description: 'Malicious JOY')
               end
 
-              it "returns false" do
-                expect(definition).to_not be_valid
+              it 'returns false' do
+                expect(definition).not_to be_valid
               end
 
-              it "adds the uniqueness error" do
+              it 'adds the uniqueness error' do
                 definition.valid?
-                expect(definition.errors[:description]).to eq([ "has already been taken" ])
+                expect(definition.errors[:description]).to eq([ 'has already been taken' ])
               end
             end
 
-            context "when the document is the match in the database" do
-
+            context 'when the document is the match in the database' do
               let!(:definition) do
-                word.definitions.build(description: "Malicious joy")
+                word.definitions.build(description: 'Malicious joy')
               end
 
-              it "returns true" do
+              it 'returns true' do
                 expect(definition).to be_valid
               end
             end
           end
         end
 
-        context "when allowing nil" do
-
+        context 'when allowing nil' do
           before do
             Definition.validates_uniqueness_of :description, allow_nil: true
           end
@@ -2192,8 +2017,7 @@ describe Mongoid::Validatable::UniquenessValidator do
             Definition.reset_callbacks(:validate)
           end
 
-          context "when the attribute is nil" do
-
+          context 'when the attribute is nil' do
             before do
               word.definitions.build
             end
@@ -2202,14 +2026,13 @@ describe Mongoid::Validatable::UniquenessValidator do
               word.definitions.build
             end
 
-            it "returns true" do
+            it 'returns true' do
               expect(definition).to be_valid
             end
           end
         end
 
-        context "when allowing blank" do
-
+        context 'when allowing blank' do
           before do
             Definition.validates_uniqueness_of :description, allow_blank: true
           end
@@ -2218,113 +2041,104 @@ describe Mongoid::Validatable::UniquenessValidator do
             Definition.reset_callbacks(:validate)
           end
 
-          context "when the attribute is blank" do
-
+          context 'when the attribute is blank' do
             before do
-              word.definitions.build(description: "")
+              word.definitions.build(description: '')
             end
 
             let(:definition) do
-              word.definitions.build(description: "")
+              word.definitions.build(description: '')
             end
 
-            it "returns true" do
+            it 'returns true' do
               expect(definition).to be_valid
             end
           end
         end
 
-        context "when the field name is aliased" do
-
+        context 'when the field name is aliased' do
           before do
-            word.definitions.build(part: "noun", synonyms: "foo")
+            word.definitions.build(part: 'noun', synonyms: 'foo')
           end
 
           let(:definition) do
-            word.definitions.build(part: "noun", synonyms: "foo")
+            word.definitions.build(part: 'noun', synonyms: 'foo')
           end
 
           after do
             Definition.reset_callbacks(:validate)
           end
 
-          context "when the validation uses the aliased name" do
-
+          context 'when the validation uses the aliased name' do
             before do
               Definition.validates_uniqueness_of :part, case_sensitive: false
             end
 
-            it "correctly detects a uniqueness conflict" do
-              expect(definition).to_not be_valid
+            it 'correctly detects a uniqueness conflict' do
+              expect(definition).not_to be_valid
             end
 
-            it "adds the uniqueness error to the aliased field name" do
+            it 'adds the uniqueness error to the aliased field name' do
               definition.valid?
               expect(definition.errors).to have_key(:part)
-              expect(definition.errors[:part]).to eq([ "has already been taken" ])
+              expect(definition.errors[:part]).to eq([ 'has already been taken' ])
             end
           end
 
-          context "when the validation uses the underlying field name" do
-
+          context 'when the validation uses the underlying field name' do
             before do
               Definition.validates_uniqueness_of :p, case_sensitive: false
             end
 
-            it "correctly detects a uniqueness conflict" do
-              expect(definition).to_not be_valid
+            it 'correctly detects a uniqueness conflict' do
+              expect(definition).not_to be_valid
             end
 
-            it "adds the uniqueness error to the underlying field name" do
+            it 'adds the uniqueness error to the underlying field name' do
               definition.valid?
               expect(definition.errors).to have_key(:p)
-              expect(definition.errors[:p]).to eq([ "has already been taken" ])
+              expect(definition.errors[:p]).to eq([ 'has already been taken' ])
             end
           end
 
-          context "when the field is localized" do
-
-            context "when the validation uses the aliased name" do
-
+          context 'when the field is localized' do
+            context 'when the validation uses the aliased name' do
               before do
                 Definition.validates_uniqueness_of :synonyms, case_sensitive: false
               end
 
-              it "correctly detects a uniqueness conflict" do
-                expect(definition).to_not be_valid
+              it 'correctly detects a uniqueness conflict' do
+                expect(definition).not_to be_valid
               end
 
-              it "adds the uniqueness error to the aliased field name" do
+              it 'adds the uniqueness error to the aliased field name' do
                 definition.valid?
                 expect(definition.errors).to have_key(:synonyms)
-                expect(definition.errors[:synonyms]).to eq([ "has already been taken" ])
+                expect(definition.errors[:synonyms]).to eq([ 'has already been taken' ])
               end
             end
 
-            context "when the validation uses the underlying field name" do
-
+            context 'when the validation uses the underlying field name' do
               before do
                 Definition.validates_uniqueness_of :syn, case_sensitive: false
               end
 
-              it "correctly detects a uniqueness conflict" do
-                expect(definition).to_not be_valid
+              it 'correctly detects a uniqueness conflict' do
+                expect(definition).not_to be_valid
               end
 
-              it "adds the uniqueness error to the aliased field name" do
+              it 'adds the uniqueness error to the aliased field name' do
                 definition.valid?
                 expect(definition.errors).to have_key(:syn)
-                expect(definition.errors[:syn]).to eq([ "has already been taken" ])
+                expect(definition.errors[:syn]).to eq([ 'has already been taken' ])
               end
             end
           end
         end
       end
 
-      context "when the document uses composite keys" do
-
-        context "when no scope is provided" do
-
+      context 'when the document uses composite keys' do
+        context 'when no scope is provided' do
           before do
             WordOrigin.validates_uniqueness_of :origin_id
           end
@@ -2333,8 +2147,7 @@ describe Mongoid::Validatable::UniquenessValidator do
             WordOrigin.reset_callbacks(:validate)
           end
 
-          context "when the attribute is unique" do
-
+          context 'when the attribute is unique' do
             before do
               word.word_origins.build(origin_id: 1)
             end
@@ -2343,15 +2156,13 @@ describe Mongoid::Validatable::UniquenessValidator do
               word.word_origins.build(origin_id: 2)
             end
 
-            it "returns true" do
+            it 'returns true' do
               expect(word_origin).to be_valid
             end
           end
 
-          context "when the attribute is not unique" do
-
-            context "when the document is not the match" do
-
+          context 'when the attribute is not unique' do
+            context 'when the document is not the match' do
               before do
                 word.word_origins.build(origin_id: 1)
               end
@@ -2360,31 +2171,29 @@ describe Mongoid::Validatable::UniquenessValidator do
                 word.word_origins.build(origin_id: 1)
               end
 
-              it "returns false" do
-                expect(word_origin).to_not be_valid
+              it 'returns false' do
+                expect(word_origin).not_to be_valid
               end
 
-              it "adds the uniqueness error" do
+              it 'adds the uniqueness error' do
                 word_origin.valid?
-                expect(word_origin.errors[:origin_id]).to eq([ "has already been taken" ])
+                expect(word_origin.errors[:origin_id]).to eq([ 'has already been taken' ])
               end
             end
 
-            context "when the document is the match in the database" do
-
+            context 'when the document is the match in the database' do
               let!(:word_origin) do
                 word.word_origins.build(origin_id: 1)
               end
 
-              it "returns true" do
+              it 'returns true' do
                 expect(word_origin).to be_valid
               end
             end
           end
         end
 
-        context "when allowing nil" do
-
+        context 'when allowing nil' do
           before do
             WordOrigin.validates_uniqueness_of :origin_id, allow_nil: true
           end
@@ -2393,8 +2202,7 @@ describe Mongoid::Validatable::UniquenessValidator do
             WordOrigin.reset_callbacks(:validate)
           end
 
-          context "when the attribute is nil" do
-
+          context 'when the attribute is nil' do
             before do
               word.word_origins.build
             end
@@ -2403,14 +2211,13 @@ describe Mongoid::Validatable::UniquenessValidator do
               word.word_origins.build
             end
 
-            it "returns true" do
+            it 'returns true' do
               expect(word_origin).to be_valid
             end
           end
         end
 
-        context "when allowing blank" do
-
+        context 'when allowing blank' do
           before do
             WordOrigin.validates_uniqueness_of :origin_id, allow_blank: true
           end
@@ -2419,17 +2226,16 @@ describe Mongoid::Validatable::UniquenessValidator do
             WordOrigin.reset_callbacks(:validate)
           end
 
-          context "when the attribute is blank" do
-
+          context 'when the attribute is blank' do
             before do
-              word.word_origins.build(origin_id: "")
+              word.word_origins.build(origin_id: '')
             end
 
             let(:word_origin) do
-              word.word_origins.build(origin_id: "")
+              word.word_origins.build(origin_id: '')
             end
 
-            it "returns true" do
+            it 'returns true' do
               expect(word_origin).to be_valid
             end
           end
@@ -2437,8 +2243,7 @@ describe Mongoid::Validatable::UniquenessValidator do
       end
     end
 
-    context "when in an embeds_one" do
-
+    context 'when in an embeds_one' do
       before do
         Pronunciation.validates_uniqueness_of :sound
       end
@@ -2448,31 +2253,30 @@ describe Mongoid::Validatable::UniquenessValidator do
       end
 
       let(:pronunciation) do
-        word.build_pronunciation(sound: "Schwa")
+        word.build_pronunciation(sound: 'Schwa')
       end
 
-      it "always returns true" do
+      it 'always returns true' do
         expect(pronunciation).to be_valid
       end
     end
   end
 
-  context "when describing validation on the instance level" do
-
+  context 'when describing validation on the instance level' do
     let!(:dictionary) do
-      Dictionary.create!(name: "en")
+      Dictionary.create!(name: 'en')
     end
 
     let(:validators) do
       dictionary.validates_uniqueness_of :name
     end
 
-    it "adds the validation only to the instance" do
+    it 'adds the validation only to the instance' do
       expect(validators).to eq([ described_class ])
     end
   end
 
-  context "when validation works with inheritance" do
+  context 'when validation works with inheritance' do
     class EuropeanActor < Actor
       validates_uniqueness_of :name
     end
@@ -2481,23 +2285,22 @@ describe Mongoid::Validatable::UniquenessValidator do
     end
 
     before do
-      EuropeanActor.create!(name: "Antonio Banderas")
+      EuropeanActor.create!(name: 'Antonio Banderas')
     end
 
     let!(:subclass_document_with_duplicated_name) do
-      SpanishActor.new(name: "Antonio Banderas")
+      SpanishActor.new(name: 'Antonio Banderas')
     end
 
-    it "should be invalid" do
+    it 'is invalid' do
       subclass_document_with_duplicated_name.tap do |d|
         expect(d).to be_invalid
-        expect(d.errors[:name]).to eq([ "has already been taken" ])
+        expect(d.errors[:name]).to eq([ 'has already been taken' ])
       end
     end
   end
 
-  context "when persisting with safe options" do
-
+  context 'when persisting with safe options' do
     before do
       Person.validates_uniqueness_of(:username)
       Person.index({ ssn: 1 }, { unique: true })
@@ -2505,7 +2308,7 @@ describe Mongoid::Validatable::UniquenessValidator do
     end
 
     let!(:person) do
-      Person.create!(ssn: "132-11-1111", username: "aaasdaffff")
+      Person.create!(ssn: '132-11-1111', username: 'aaasdaffff')
     end
 
     after do
@@ -2513,15 +2316,14 @@ describe Mongoid::Validatable::UniquenessValidator do
       Person.collection.drop
     end
 
-    it "transfers the options to the cloned client" do
-      expect {
-        Person.create!(ssn: "132-11-1111", username: "asdfsdfA")
-      }.to raise_error(Mongo::Error::OperationFailure)
+    it 'transfers the options to the cloned client' do
+      expect do
+        Person.create!(ssn: '132-11-1111', username: 'asdfsdfA')
+      end.to raise_error(Mongo::Error::OperationFailure)
     end
   end
 
-  describe "i18n" do
-
+  describe 'i18n' do
     context 'when using a different locale' do
       with_default_i18n_configs
 
@@ -2536,11 +2338,11 @@ describe Mongoid::Validatable::UniquenessValidator do
         I18n.backend.translations.delete(:fr)
       end
 
-      it "correctly translates the error message" do
+      it 'correctly translates the error message' do
         Circus.create!(slogan: 'The Greatest Show on Mars')
         dict = Circus.new(slogan: 'The Greatest Show on Mars')
         dict.valid?
-        expect(dict.errors.messages[:slogan]).to eq(["est déjà utilisé(e)"])
+        expect(dict.errors.messages[:slogan]).to eq([ 'est déjà utilisé(e)' ])
       end
     end
   end