mongoid 8.1.5 → 9.0.0

data/spec/mongoid/association/referenced/has_many/proxy_spec.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "spec_helper"
+require 'spec_helper'
 
 module RefHasManySpec
   module OverrideInitialize
@@ -16,7 +16,7 @@ module RefHasManySpec
 
       def initialize(*args)
         super
-        self.name ||= "default"
+        self.name ||= 'default'
       end
     end
   end
@@ -35,197 +35,163 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
     Person.has_many :drugs, validate: false
   end
 
-  [ :<<, :push ].each do |method|
-
+  %i[ << push ].each do |method|
     describe "##{method}" do
+      context 'when providing the base class in child constructor' do
+        let(:person) { Person.create! }
 
-      context "when providing the base class in child constructor" do
-
-        let(:person) do
-          Person.create!
-        end
-
-        let!(:post) do
-          person.posts.send(method, Post.new(person: person))
-        end
+        before { person.posts.send(method, Post.new(person: person)) }
 
-        it "only adds the association once" do
+        it 'only adds the association once' do
           expect(person.posts.size).to eq(1)
         end
 
-        it "only persists the association once" do
+        it 'only persists the association once' do
           expect(person.reload.posts.size).to eq(1)
         end
       end
 
-      context "when the associations are not polymorphic" do
-
-        context "when the parent is a new record" do
-
-          let(:person) do
-            Person.new
-          end
-
-          context "when the child is new" do
-
-            let(:post) do
-              Post.new
-            end
+      context 'when the associations are not polymorphic' do
+        context 'when the parent is a new record' do
+          let(:person) { Person.new }
 
-            let!(:added) do
-              person.posts.send(method, post)
-            end
+          context 'when the child is new' do
+            let(:post) { Post.new }
+            let!(:added) { person.posts.send(method, post) }
 
-            it "sets the foreign key on the association" do
+            it 'sets the foreign key on the association' do
               expect(post.person_id).to eq(person.id)
             end
 
-            it "sets the base on the inverse association" do
+            it 'sets the base on the inverse association' do
               expect(post.person).to eq(person)
             end
 
-            it "sets the same instance on the inverse association" do
+            it 'sets the same instance on the inverse association' do
               expect(post.person).to eql(person)
             end
 
-            it "does not save the target" do
+            it 'does not save the target' do
               expect(post).to be_new_record
             end
 
-            it "adds the document to the target" do
+            it 'adds the document to the target' do
               expect(person.posts.size).to eq(1)
             end
 
-            it "returns the association" do
+            it 'returns the association' do
               expect(added).to eq(person.posts)
             end
           end
 
-          context "when the child is persisted" do
-
-            let(:post) do
-              Post.create!
-            end
+          context 'when the child is persisted' do
+            let(:post) { Post.create! }
 
             before do
               person.posts.send(method, post)
             end
 
-            it "sets the foreign key on the association" do
+            it 'sets the foreign key on the association' do
               expect(post.person_id).to eq(person.id)
             end
 
-            it "sets the base on the inverse association" do
+            it 'sets the base on the inverse association' do
               expect(post.person).to eq(person)
             end
 
-            it "sets the same instance on the inverse association" do
+            it 'sets the same instance on the inverse association' do
               expect(post.person).to eql(person)
             end
 
-            it "does not save the parent" do
+            it 'does not save the parent' do
               expect(person).to be_new_record
             end
 
-            it "adds the document to the target" do
+            it 'adds the document to the target' do
               expect(person.posts.size).to eq(1)
             end
 
-            context "when subsequently saving the parent" do
-
+            context 'when subsequently saving the parent' do
               before do
                 person.save!
                 post.save!
               end
 
-              it "returns the correct count of the association" do
+              it 'returns the correct count of the association' do
                 expect(person.posts.count).to eq(1)
               end
             end
           end
         end
 
-        context "when appending in a parent create block" do
-
-          let!(:post) do
-            Post.create!(title: "testing")
-          end
-
+        context 'when appending in a parent create block' do
+          let!(:post) { Post.create!(title: 'testing') }
           let!(:person) do
             Person.create! do |doc|
               doc.posts << post
             end
           end
 
-          it "adds the documents to the association" do
+          it 'adds the documents to the association' do
             expect(person.posts).to eq([ post ])
           end
 
-          it "sets the foreign key on the inverse association" do
+          it 'sets the foreign key on the inverse association' do
             expect(post.person_id).to eq(person.id)
           end
 
-          it "saves the target" do
+          it 'saves the target' do
             expect(post).to be_persisted
           end
 
-          it "adds the correct number of documents" do
+          it 'adds the correct number of documents' do
             expect(person.posts.size).to eq(1)
           end
 
-          it "persists the link" do
+          it 'persists the link' do
             expect(person.reload.posts).to eq([ post ])
           end
         end
 
-        context "when the parent is not a new record" do
-
-          let(:person) do
-            Person.create!
-          end
-
-          let(:post) do
-            Post.new
-          end
+        context 'when the parent is not a new record' do
+          let(:person) { Person.create! }
+          let(:post) { Post.new }
 
           before do
             person.posts.send(method, post)
           end
 
-          it "sets the foreign key on the association" do
+          it 'sets the foreign key on the association' do
             expect(post.person_id).to eq(person.id)
           end
 
-          it "sets the base on the inverse association" do
+          it 'sets the base on the inverse association' do
             expect(post.person).to eq(person)
           end
 
-          it "sets the same instance on the inverse association" do
+          it 'sets the same instance on the inverse association' do
             expect(post.person).to eql(person)
           end
 
-          it "saves the target" do
+          it 'saves the target' do
             expect(post).to be_persisted
           end
 
-          it "adds the document to the target" do
+          it 'adds the document to the target' do
             expect(person.posts.count).to eq(1)
           end
 
-          it "increments the counter cache" do
+          it 'increments the counter cache' do
             expect(person[:posts_count]).to eq(1)
             expect(person.posts_count).to eq(1)
           end
 
-          it "doesnt change the list of changes" do
+          it 'doesnt change the list of changes' do
             expect(person.changed).to eq([])
           end
 
-          context "when the related item has embedded associations" do
-
-            let!(:user) do
-              User.create!
-            end
+          context 'when the related item has embedded associations' do
+            let!(:user) { User.create! }
 
             before do
               p = Post.create!(roles: [ Role.create! ])
@@ -233,169 +199,137 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
               user.save!
             end
 
-            it "add the document to the target" do
+            it 'add the document to the target' do
               expect(user.posts.size).to eq(1)
               expect(user.posts.first.roles.size).to eq(1)
             end
           end
 
-          context "when saving another post" do
-
+          context 'when saving another post' do
             before do
               person.posts.send(method, Post.new)
             end
 
-            it "increments the counter cache" do
+            it 'increments the counter cache' do
               expect(person.posts_count).to eq(2)
             end
           end
 
-          context "when documents already exist on the association" do
-
-            let(:post_two) do
-              Post.new(title: "Test")
-            end
+          context 'when documents already exist on the association' do
+            let(:post_two) { Post.new(title: 'Test') }
 
             before do
               person.posts.send(method, post_two)
             end
 
-            it "sets the foreign key on the association" do
+            it 'sets the foreign key on the association' do
               expect(post_two.person_id).to eq(person.id)
             end
 
-            it "sets the base on the inverse association" do
+            it 'sets the base on the inverse association' do
               expect(post_two.person).to eq(person)
             end
 
-            it "sets the same instance on the inverse association" do
+            it 'sets the same instance on the inverse association' do
               expect(post_two.person).to eql(person)
             end
 
-            it "saves the target" do
+            it 'saves the target' do
               expect(post_two).to be_persisted
             end
 
-            it "adds the document to the target" do
+            it 'adds the document to the target' do
               expect(person.posts.count).to eq(2)
             end
 
-            it "increments the counter cache" do
+            it 'increments the counter cache' do
               expect(person.reload.posts_count).to eq(2)
             end
 
-            it "contains the initial document in the target" do
+            it 'contains the initial document in the target' do
               expect(person.posts).to include(post)
             end
 
-            it "contains the added document in the target" do
+            it 'contains the added document in the target' do
               expect(person.posts).to include(post_two)
             end
           end
         end
       end
 
-      context "when.adding to the association" do
-
-        let(:person) do
-          Person.create!
-        end
-
-        context "when the operation succeeds" do
+      context 'when.adding to the association' do
+        let(:person) { Person.create! }
 
-          let(:post) do
-            Post.new
-          end
+        context 'when the operation succeeds' do
+          let(:post) { Post.new }
 
           before do
             person.posts.send(method, post)
           end
 
-          it "adds the document to the association" do
+          it 'adds the document to the association' do
             expect(person.posts).to eq([ post ])
           end
         end
 
-        context "when the operation fails" do
-
-          let!(:existing) do
-            Post.create!
-          end
-
-          let(:post) do
-            Post.new do |doc|
-              doc._id = existing.id
-            end
-          end
+        context 'when the operation fails' do
+          let!(:existing) { Post.create! }
+          let(:post) { Post.new { |doc| doc._id = existing.id } }
 
-          it "raises an error" do
-            expect {
-              person.posts.send(method, post)
-            }.to raise_error(Mongo::Error::OperationFailure)
+          it 'raises an error' do
+            expect { person.posts.send(method, post) }
+              .to raise_error(Mongo::Error::OperationFailure)
           end
         end
       end
 
-      context "when the associations are polymorphic" do
-
-        context "when the parent is a new record" do
-
-          let(:movie) do
-            Movie.new
-          end
-
-          let(:rating) do
-            Rating.new
-          end
+      context 'when the associations are polymorphic' do
+        context 'when the parent is a new record' do
+          let(:movie) { Movie.new }
+          let(:rating) { Rating.new }
 
           before do
             movie.ratings.send(method, rating)
           end
 
-          it "sets the foreign key on the association" do
+          it 'sets the foreign key on the association' do
             expect(rating.ratable_id).to eq(movie.id)
           end
 
-          it "sets the base on the inverse association" do
+          it 'sets the base on the inverse association' do
             expect(rating.ratable).to eq(movie)
           end
 
-          it "does not save the target" do
+          it 'does not save the target' do
             expect(rating).to be_new_record
           end
 
-          it "adds the document to the target" do
+          it 'adds the document to the target' do
             expect(movie.ratings.size).to eq(1)
           end
         end
 
-        context "when the parent is not a new record" do
-
-          let(:movie) do
-            Movie.create!
-          end
-
-          let(:rating) do
-            Rating.new
-          end
+        context 'when the parent is not a new record' do
+          let(:movie) { Movie.create! }
+          let(:rating) { Rating.new }
 
           before do
             movie.ratings.send(method, rating)
           end
 
-          it "sets the foreign key on the association" do
+          it 'sets the foreign key on the association' do
             expect(rating.ratable_id).to eq(movie.id)
           end
 
-          it "sets the base on the inverse association" do
+          it 'sets the base on the inverse association' do
             expect(rating.ratable).to eq(movie)
           end
 
-          it "saves the target" do
+          it 'saves the target' do
             expect(rating).to be_persisted
           end
 
-          it "adds the document to the target" do
+          it 'adds the document to the target' do
             expect(movie.ratings.count).to eq(1)
           end
         end
@@ -403,193 +337,160 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
     end
   end
 
-  describe "#=" do
-
-    context "when the association is not polymorphic" do
-
-      context "when the parent is a new record" do
-
-        let(:person) do
-          Person.new
-        end
-
-        let(:post) do
-          Post.new
-        end
+  describe '#=' do
+    context 'when the association is not polymorphic' do
+      context 'when the parent is a new record' do
+        let(:person) { Person.new }
+        let(:post) { Post.new }
 
         before do
           person.posts = [ post ]
         end
 
-        it "sets the target of the association" do
+        it 'sets the target of the association' do
           expect(person.posts._target).to eq([ post ])
         end
 
-        it "sets the foreign key on the association" do
+        it 'sets the foreign key on the association' do
           expect(post.person_id).to eq(person.id)
         end
 
-        it "sets the base on the inverse association" do
+        it 'sets the base on the inverse association' do
           expect(post.person).to eq(person)
         end
 
-        it "does not save the target" do
-          expect(post).to_not be_persisted
+        it 'does not save the target' do
+          expect(post).not_to be_persisted
         end
       end
 
-      context "when the parent is not a new record" do
-
-        let(:person) do
-          Person.create!
-        end
-
-        let(:post) do
-          Post.new
-        end
+      context 'when the parent is not a new record' do
+        let(:person) { Person.create! }
+        let(:post) { Post.new }
 
         before do
           person.posts = [ post ]
         end
 
-        it "sets the target of the association" do
+        it 'sets the target of the association' do
           expect(person.posts._target).to eq([ post ])
         end
 
-        it "sets the foreign key of the association" do
+        it 'sets the foreign key of the association' do
           expect(post.person_id).to eq(person.id)
         end
 
-        it "sets the base on the inverse association" do
+        it 'sets the base on the inverse association' do
           expect(post.person).to eq(person)
         end
 
-        it "saves the target" do
+        it 'saves the target' do
           expect(post).to be_persisted
         end
 
-        context "when replacing the association with the same documents" do
-
-          context "when using the same in memory instance" do
-
+        context 'when replacing the association with the same documents' do
+          context 'when using the same in memory instance' do
             before do
               person.posts = [ post ]
             end
 
-            it "keeps the association intact" do
+            it 'keeps the association intact' do
               expect(person.posts).to eq([ post ])
             end
 
-            it "does not delete the association" do
+            it 'does not delete the association' do
               expect(person.reload.posts).to eq([ post ])
             end
           end
 
-          context "when using a new instance" do
-
-            let(:from_db) do
-              Person.find(person.id)
-            end
+          context 'when using a new instance' do
+            let(:from_db) { Person.find(person.id) }
 
             before do
               from_db.posts = [ post ]
             end
 
-            it "keeps the association intact" do
+            it 'keeps the association intact' do
               expect(from_db.posts).to eq([ post ])
             end
 
-            it "does not delete the association" do
+            it 'does not delete the association' do
               expect(from_db.reload.posts).to eq([ post ])
             end
           end
         end
 
-        context "when replacing the with a combination of old and new docs" do
-
-          let(:new_post) do
-            Post.create!(title: "new post")
-          end
-
-          context "when using the same in memory instance" do
+        context 'when replacing the with a combination of old and new docs' do
+          let(:new_post) { Post.create!(title: 'new post') }
 
+          context 'when using the same in memory instance' do
             before do
               person.posts = [ post, new_post ]
             end
 
-            it "keeps the association intact" do
+            it 'keeps the association intact' do
               expect(person.posts.size).to eq(2)
             end
 
-            it "keeps the first post" do
+            it 'keeps the first post' do
               expect(person.posts).to include(post)
             end
 
-            it "keeps the second post" do
+            it 'keeps the second post' do
               expect(person.posts).to include(new_post)
             end
 
-            it "does not delete the association" do
+            it 'does not delete the association' do
               expect(person.reload.posts).to eq([ post, new_post ])
             end
           end
 
-          context "when using a new instance" do
-
-            let(:from_db) do
-              Person.find(person.id)
-            end
+          context 'when using a new instance' do
+            let(:from_db) { Person.find(person.id) }
 
             before do
               from_db.posts = [ post, new_post ]
             end
 
-            it "keeps the association intact" do
+            it 'keeps the association intact' do
               expect(from_db.posts).to eq([ post, new_post ])
             end
 
-            it "does not delete the association" do
+            it 'does not delete the association' do
               expect(from_db.reload.posts).to eq([ post, new_post ])
             end
           end
         end
 
-        context "when replacing the with a combination of only new docs" do
-
-          let(:new_post) do
-            Post.create!(title: "new post")
-          end
-
-          context "when using the same in memory instance" do
+        context 'when replacing the with a combination of only new docs' do
+          let(:new_post) { Post.create!(title: 'new post') }
 
+          context 'when using the same in memory instance' do
             before do
               person.posts = [ new_post ]
             end
 
-            it "keeps the association intact" do
+            it 'keeps the association intact' do
               expect(person.posts).to eq([ new_post ])
             end
 
-            it "does not delete the association" do
+            it 'does not delete the association' do
               expect(person.reload.posts).to eq([ new_post ])
             end
           end
 
-          context "when using a new instance" do
-
-            let(:from_db) do
-              Person.find(person.id)
-            end
+          context 'when using a new instance' do
+            let(:from_db) { Person.find(person.id) }
 
             before do
               from_db.posts = [ new_post ]
             end
 
-            it "keeps the association intact" do
+            it 'keeps the association intact' do
               expect(from_db.posts).to eq([ new_post ])
             end
 
-            it "does not delete the association" do
+            it 'does not delete the association' do
               expect(from_db.reload.posts).to eq([ new_post ])
             end
           end
@@ -597,470 +498,371 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
       end
     end
 
-    context "when the association is polymorphic" do
-
-      context "when the parent is a new record" do
-
-        let(:movie) do
-          Movie.new
-        end
-
-        let(:rating) do
-          Rating.new
-        end
+    context 'when the association is polymorphic' do
+      context 'when the parent is a new record' do
+        let(:movie) { Movie.new }
+        let(:rating) { Rating.new }
 
         before do
           movie.ratings = [ rating ]
         end
 
-        it "sets the target of the association" do
+        it 'sets the target of the association' do
           expect(movie.ratings._target).to eq([ rating ])
         end
 
-        it "sets the foreign key on the association" do
+        it 'sets the foreign key on the association' do
           expect(rating.ratable_id).to eq(movie.id)
         end
 
-        it "sets the base on the inverse association" do
+        it 'sets the base on the inverse association' do
           expect(rating.ratable).to eq(movie)
         end
 
-        it "does not save the target" do
-          expect(rating).to_not be_persisted
+        it 'does not save the target' do
+          expect(rating).not_to be_persisted
         end
       end
 
-      context "when the parent is not a new record" do
-
-        let(:movie) do
-          Movie.create!
-        end
-
-        let(:rating) do
-          Rating.new
-        end
+      context 'when the parent is not a new record' do
+        let(:movie) { Movie.create! }
+        let(:rating) { Rating.new }
 
         before do
           movie.ratings = [ rating ]
         end
 
-        it "sets the target of the association" do
+        it 'sets the target of the association' do
           expect(movie.ratings._target).to eq([ rating ])
         end
 
-        it "sets the foreign key of the association" do
+        it 'sets the foreign key of the association' do
           expect(rating.ratable_id).to eq(movie.id)
         end
 
-        it "sets the base on the inverse association" do
+        it 'sets the base on the inverse association' do
           expect(rating.ratable).to eq(movie)
         end
 
-        it "saves the target" do
+        it 'saves the target' do
           expect(rating).to be_persisted
         end
       end
     end
   end
 
-  describe "#= []" do
-
-    context "when the parent is persisted" do
-
-      let(:posts) do
-        [ Post.create!(title: "1"), Post.create!(title: "2") ]
-      end
-
-      let(:person) do
-        Person.create!(posts: posts)
-      end
-
-      context "when the parent has multiple children" do
+  describe '#= []' do
+    context 'when the parent is persisted' do
+      let(:posts) { [ Post.create!(title: '1'), Post.create!(title: '2') ] }
+      let(:person) { Person.create!(posts: posts) }
 
+      context 'when the parent has multiple children' do
         before do
           person.posts = []
         end
 
-        it "removes all the children" do
+        it 'removes all the children' do
           expect(person.posts).to be_empty
         end
 
-        it "persists the changes" do
+        it 'persists the changes' do
           expect(person.posts(true)).to be_empty
         end
       end
     end
   end
 
-  describe "#= nil" do
-
-    context "when the association is not polymorphic" do
-
-      context "when the parent is a new record" do
-
-        let(:person) do
-          Person.new
-        end
-
-        let(:post) do
-          Post.new
-        end
+  describe '#= nil' do
+    context 'when the association is not polymorphic' do
+      context 'when the parent is a new record' do
+        let(:person) { Person.new }
+        let(:post) { Post.new }
 
         before do
           person.posts = [ post ]
           person.posts = nil
         end
 
-        it "sets the association to an empty array" do
+        it 'sets the association to an empty array' do
           expect(person.posts).to be_empty
         end
 
-        it "removed the inverse association" do
+        it 'removed the inverse association' do
           expect(post.person).to be_nil
         end
 
-        it "removes the foreign key value" do
+        it 'removes the foreign key value' do
           expect(post.person_id).to be_nil
         end
       end
 
-      context "when the parent is not a new record" do
-
-        let(:person) do
-          Person.create!
-        end
-
-        context "when dependent is destructive" do
+      context 'when the parent is not a new record' do
+        let(:person) { Person.create! }
 
-          let(:post) do
-            Post.new
-          end
+        context 'when dependent is destructive' do
+          let(:post) { Post.new }
 
           before do
             person.posts = [ post ]
             person.posts = nil
           end
 
-          it "sets the association to empty" do
+          it 'sets the association to empty' do
             expect(person.posts).to be_empty
           end
 
-          it "removed the inverse association" do
+          it 'removed the inverse association' do
             expect(post.person).to be_nil
           end
 
-          it "removes the foreign key value" do
+          it 'removes the foreign key value' do
             expect(post.person_id).to be_nil
           end
 
-          it "deletes the target from the database" do
+          it 'deletes the target from the database' do
             expect(post).to be_destroyed
           end
         end
 
-        context "when dependent is not destructive" do
-
-          let(:drug) do
-            Drug.new(name: "Oxycodone")
-          end
+        context 'when dependent is not destructive' do
+          let(:drug) { Drug.new(name: 'Oxycodone') }
 
           before do
             person.drugs = [ drug ]
             person.drugs = nil
           end
 
-          it "sets the association to empty" do
+          it 'sets the association to empty' do
             expect(person.drugs).to be_empty
           end
 
-          it "removed the inverse association" do
+          it 'removed the inverse association' do
             expect(drug.person).to be_nil
           end
 
-          it "removes the foreign key value" do
+          it 'removes the foreign key value' do
             expect(drug.person_id).to be_nil
           end
 
-          it "nullifies the association" do
-            expect(drug).to_not be_destroyed
+          it 'nullifies the association' do
+            expect(drug).not_to be_destroyed
           end
         end
       end
     end
 
-    context "when the association is polymorphic" do
-
-      context "when the parent is a new record" do
-
-        let(:movie) do
-          Movie.new
-        end
-
-        let(:rating) do
-          Rating.new
-        end
+    context 'when the association is polymorphic' do
+      context 'when the parent is a new record' do
+        let(:movie) { Movie.new }
+        let(:rating) { Rating.new }
 
         before do
           movie.ratings = [ rating ]
           movie.ratings = nil
         end
 
-        it "sets the association to an empty array" do
+        it 'sets the association to an empty array' do
           expect(movie.ratings).to be_empty
         end
 
-        it "removed the inverse association" do
+        it 'removed the inverse association' do
           expect(rating.ratable).to be_nil
         end
 
-        it "removes the foreign key value" do
+        it 'removes the foreign key value' do
           expect(rating.ratable_id).to be_nil
         end
       end
 
-      context "when the parent is not a new record" do
-
-        let(:movie) do
-          Movie.create!
-        end
-
-        let(:rating) do
-          Rating.new
-        end
+      context 'when the parent is not a new record' do
+        let(:movie) { Movie.create! }
+        let(:rating) { Rating.new }
 
         before do
           movie.ratings = [ rating ]
           movie.ratings = nil
         end
 
-        it "sets the association to empty" do
+        it 'sets the association to empty' do
           expect(movie.ratings).to be_empty
         end
 
-        it "removed the inverse association" do
+        it 'removed the inverse association' do
           expect(rating.ratable).to be_nil
         end
 
-        it "removes the foreign key value" do
+        it 'removes the foreign key value' do
           expect(rating.ratable_id).to be_nil
         end
 
-        context "when dependent is nullify" do
-
-          it "does not delete the target from the database" do
-            expect(rating).to_not be_destroyed
+        context 'when dependent is nullify' do
+          it 'does not delete the target from the database' do
+            expect(rating).not_to be_destroyed
           end
         end
       end
     end
   end
 
-  describe "#\{name}_ids=" do
-
-    let(:person) do
-      Person.new
-    end
-
-    let(:post_one) do
-      Post.create!
-    end
+  describe '#\{name}_ids=' do
+    let(:person) { Person.new }
+    let(:post_one) { Post.create! }
 
-    let(:post_two) do
-      Post.create!
-    end
+    let(:post_two) { Post.create! }
 
     before do
       person.post_ids = [ post_one.id, post_two.id ]
     end
 
-    it "calls setter with documents find by given ids" do
+    it 'calls setter with documents find by given ids' do
       expect(person.posts).to eq([ post_one, post_two ])
     end
   end
 
-  describe "#\{name}_ids" do
-
-    let(:posts) do
-      [ Post.create!, Post.create! ]
-    end
-
-    let(:person) do
-      Person.create!(posts: posts)
-    end
+  describe '#\{name}_ids' do
+    let(:posts) { [ Post.create!, Post.create! ] }
+    let(:person) { Person.create!(posts: posts) }
 
-    it "returns ids of documents that are in the association" do
+    it 'returns ids of documents that are in the association' do
       expect(person.post_ids).to eq(posts.map(&:id))
     end
   end
 
-  [ :build, :new ].each do |method|
-
+  %i[ build new ].each do |method|
     describe "##{method}" do
       context 'when model has #initialize' do
         let(:parent) { RefHasManySpec::OverrideInitialize::Parent.create }
         let(:child)  { parent.children.send(method) }
 
-        it 'should call #initialize' do
-          expect(child.name).to be == "default"
+        it 'calls #initialize' do
+          expect(child.name).to be == 'default'
         end
       end
 
-      context "when the association is not polymorphic" do
-
-        context "when the parent is a new record" do
+      context 'when the association is not polymorphic' do
+        context 'when the parent is a new record' do
+          let(:person) { Person.new(title: 'sir') }
+          let!(:post) { person.posts.send(method, title: '$$$') }
 
-          let(:person) do
-            Person.new(title: "sir")
-          end
-
-          let!(:post) do
-            person.posts.send(method, title: "$$$")
-          end
-
-          it "sets the foreign key on the association" do
+          it 'sets the foreign key on the association' do
             expect(post.person_id).to eq(person.id)
           end
 
-          it "sets the base on the inverse association" do
+          it 'sets the base on the inverse association' do
             expect(post.person).to eq(person)
           end
 
-          it "sets the attributes" do
-            expect(post.title).to eq("$$$")
+          it 'sets the attributes' do
+            expect(post.title).to eq('$$$')
           end
 
-          it "sets the post processed defaults" do
+          it 'sets the post processed defaults' do
             expect(post.person_title).to eq(person.title)
           end
 
-          it "does not save the target" do
+          it 'does not save the target' do
             expect(post).to be_new_record
           end
 
-          it "adds the document to the target" do
+          it 'adds the document to the target' do
             expect(person.posts.size).to eq(1)
           end
 
-          it "does not perform validation" do
+          it 'does not perform validation' do
             expect(post.errors).to be_empty
           end
         end
 
-        context "when the parent is not a new record" do
-
-          let(:person) do
-            Person.create!
-          end
-
-          let!(:post) do
-            person.posts.send(method, text: "Testing")
-          end
+        context 'when the parent is not a new record' do
+          let(:person) { Person.create! }
+          let!(:post) { person.posts.send(method, text: 'Testing') }
 
-          it "sets the foreign key on the association" do
+          it 'sets the foreign key on the association' do
             expect(post.person_id).to eq(person.id)
           end
 
-          it "sets the base on the inverse association" do
+          it 'sets the base on the inverse association' do
             expect(post.person).to eq(person)
           end
 
-          it "sets the attributes" do
-            expect(post.text).to eq("Testing")
+          it 'sets the attributes' do
+            expect(post.text).to eq('Testing')
           end
 
-          it "does not save the target" do
+          it 'does not save the target' do
             expect(post).to be_new_record
           end
 
-          it "adds the document to the target" do
+          it 'adds the document to the target' do
             expect(person.posts.size).to eq(1)
           end
         end
       end
 
-      context "when the association is polymorphic" do
+      context 'when the association is polymorphic' do
+        context 'when the parent is a subclass' do
+          let(:video_game) { VideoGame.create! }
+          let(:rating) { video_game.ratings.build }
 
-        context "when the parent is a subclass" do
-
-          let(:video_game) do
-            VideoGame.create!
-          end
-
-          let(:rating) do
-            video_game.ratings.build
-          end
-
-          it "sets the parent on the child" do
+          it 'sets the parent on the child' do
             expect(rating.ratable).to eq(video_game)
           end
 
-          it "sets the correct polymorphic type" do
-            expect(rating.ratable_type).to eq("VideoGame")
+          it 'sets the correct polymorphic type' do
+            expect(rating.ratable_type).to eq('VideoGame')
           end
         end
 
-        context "when the parent is a new record" do
-
-          let(:movie) do
-            Movie.new
-          end
-
-          let!(:rating) do
-            movie.ratings.send(method, value: 3)
-          end
+        context 'when the parent is a new record' do
+          let(:movie) { Movie.new }
+          let!(:rating) { movie.ratings.send(method, value: 3) }
 
-          it "sets the foreign key on the association" do
+          it 'sets the foreign key on the association' do
             expect(rating.ratable_id).to eq(movie.id)
           end
 
-          it "sets the base on the inverse association" do
+          it 'sets the base on the inverse association' do
             expect(rating.ratable).to eq(movie)
           end
 
-          it "sets the attributes" do
+          it 'sets the attributes' do
             expect(rating.value).to eq(3)
           end
 
-          it "does not save the target" do
+          it 'does not save the target' do
             expect(rating).to be_new_record
           end
 
-          it "adds the document to the target" do
+          it 'adds the document to the target' do
             expect(movie.ratings.size).to eq(1)
           end
 
-          it "does not perform validation" do
+          it 'does not perform validation' do
             expect(rating.errors).to be_empty
           end
         end
 
-        context "when the parent is not a new record" do
-
-          let(:movie) do
-            Movie.create!
-          end
-
-          let!(:rating) do
-            movie.ratings.send(method, value: 4)
-          end
+        context 'when the parent is not a new record' do
+          let(:movie) { Movie.create! }
+          let!(:rating) { movie.ratings.send(method, value: 4) }
 
-          it "sets the foreign key on the association" do
+          it 'sets the foreign key on the association' do
             expect(rating.ratable_id).to eq(movie.id)
           end
 
-          it "sets the base on the inverse association" do
+          it 'sets the base on the inverse association' do
             expect(rating.ratable).to eq(movie)
           end
 
-          it "sets the attributes" do
+          it 'sets the attributes' do
             expect(rating.value).to eq(4)
           end
 
-          it "does not save the target" do
+          it 'does not save the target' do
             expect(rating).to be_new_record
           end
 
-          it "adds the document to the target" do
+          it 'adds the document to the target' do
             expect(movie.ratings.size).to eq(1)
           end
         end
@@ -1068,296 +870,232 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
     end
   end
 
-  describe "#clear" do
-
-    context "when the association is not polymorphic" do
-
-      context "when the parent has been persisted" do
-
-        let!(:person) do
-          Person.create!
-        end
-
-        context "when the children are persisted" do
-
-          let!(:post) do
-            person.posts.create!(title: "Testing")
-          end
+  describe '#clear' do
+    context 'when the association is not polymorphic' do
+      context 'when the parent has been persisted' do
+        let!(:person) { Person.create! }
 
-          let!(:association) do
-            person.posts.clear
-          end
+        context 'when the children are persisted' do
+          let!(:post) { person.posts.create!(title: 'Testing') }
+          let!(:association) { person.posts.clear }
 
-          it "clears out the association" do
+          it 'clears out the association' do
             expect(person.posts).to be_empty
           end
 
-          it "marks the documents as deleted" do
+          it 'marks the documents as deleted' do
             expect(post).to be_destroyed
           end
 
-          it "deletes the documents from the db" do
+          it 'deletes the documents from the db' do
             expect(person.reload.posts).to be_empty
           end
 
-          it "returns the association" do
+          it 'returns the association' do
             expect(association).to be_empty
           end
         end
 
-        context "when the children are not persisted" do
-
-          let!(:post) do
-            person.posts.build(title: "Testing")
-          end
-
-          let!(:association) do
+        context 'when the children are not persisted' do
+          before do
+            person.posts.build(title: 'Testing')
             person.posts.clear
           end
 
-          it "clears out the association" do
+          it 'clears out the association' do
             expect(person.posts).to be_empty
           end
         end
       end
 
-      context "when the parent is not persisted" do
-
-        let(:person) do
-          Person.new
-        end
-
-        let!(:post) do
-          person.posts.build(title: "Testing")
-        end
+      context 'when the parent is not persisted' do
+        let(:person) { Person.new }
 
-        let!(:association) do
+        before do
+          person.posts.build(title: 'Testing')
           person.posts.clear
         end
 
-        it "clears out the association" do
+        it 'clears out the association' do
           expect(person.posts).to be_empty
         end
       end
     end
 
-    context "when the association is polymorphic" do
-
-      context "when the parent has been persisted" do
-
-        let!(:movie) do
-          Movie.create!
-        end
-
-        context "when the children are persisted" do
-
-          let!(:rating) do
-            movie.ratings.create!(value: 1)
-          end
+    context 'when the association is polymorphic' do
+      context 'when the parent has been persisted' do
+        let!(:movie) { Movie.create! }
 
-          let!(:association) do
-            movie.ratings.clear
-          end
+        context 'when the children are persisted' do
+          let!(:rating) { movie.ratings.create!(value: 1) }
+          let!(:association) { movie.ratings.clear }
 
-          it "clears out the association" do
+          it 'clears out the association' do
             expect(movie.ratings).to be_empty
           end
 
-          it "handles the proper dependent strategy" do
-            expect(rating).to_not be_destroyed
+          it 'handles the proper dependent strategy' do
+            expect(rating).not_to be_destroyed
           end
 
-          it "deletes the documents from the db" do
+          it 'deletes the documents from the db' do
             expect(movie.reload.ratings).to be_empty
           end
 
-          it "returns the association" do
+          it 'returns the association' do
             expect(association).to be_empty
           end
         end
 
-        context "when the children are not persisted" do
-
-          let!(:rating) do
+        context 'when the children are not persisted' do
+          before do
             movie.ratings.build(value: 3)
-          end
-
-          let!(:association) do
             movie.ratings.clear
           end
 
-          it "clears out the association" do
+          it 'clears out the association' do
             expect(movie.ratings).to be_empty
           end
         end
       end
 
-      context "when the parent is not persisted" do
-
-        let(:movie) do
-          Movie.new
-        end
+      context 'when the parent is not persisted' do
+        let(:movie) { Movie.new }
 
-        let!(:rating) do
+        before do
           movie.ratings.build(value: 2)
-        end
-
-        let!(:association) do
           movie.ratings.clear
         end
 
-        it "clears out the association" do
+        it 'clears out the association' do
           expect(movie.ratings).to be_empty
         end
       end
     end
   end
 
-  describe "#concat" do
-
-    context "when the associations are not polymorphic" do
-
-      context "when the parent is a new record" do
-
-        let(:person) do
-          Person.new
-        end
-
-        let(:post) do
-          Post.new
-        end
+  describe '#concat' do
+    context 'when the associations are not polymorphic' do
+      context 'when the parent is a new record' do
+        let(:person) { Person.new }
+        let(:post) { Post.new }
 
         before do
-          person.posts.concat([ post ])
+          person.posts.push post
         end
 
-        it "sets the foreign key on the association" do
+        it 'sets the foreign key on the association' do
           expect(post.person_id).to eq(person.id)
         end
 
-        it "sets the base on the inverse association" do
+        it 'sets the base on the inverse association' do
           expect(post.person).to eq(person)
         end
 
-        it "sets the same instance on the inverse association" do
+        it 'sets the same instance on the inverse association' do
           expect(post.person).to eql(person)
         end
 
-        it "does not save the target" do
+        it 'does not save the target' do
           expect(post).to be_new_record
         end
 
-        it "adds the document to the target" do
+        it 'adds the document to the target' do
           expect(person.posts.size).to eq(1)
         end
       end
 
-      context "when appending in a parent create block" do
-
-        let!(:post) do
-          Post.create!(title: "testing")
-        end
-
+      context 'when appending in a parent create block' do
+        let!(:post) { Post.create!(title: 'testing') }
         let!(:person) do
           Person.create! do |doc|
-            doc.posts.concat([ post ])
+            doc.posts.push post
           end
         end
 
-        it "adds the documents to the association" do
+        it 'adds the documents to the association' do
           expect(person.posts).to eq([ post ])
         end
 
-        it "sets the foreign key on the inverse association" do
+        it 'sets the foreign key on the inverse association' do
           expect(post.person_id).to eq(person.id)
         end
 
-        it "saves the target" do
+        it 'saves the target' do
           expect(post).to be_persisted
         end
 
-        it "adds the correct number of documents" do
+        it 'adds the correct number of documents' do
           expect(person.posts.size).to eq(1)
         end
 
-        it "persists the link" do
+        it 'persists the link' do
           expect(person.reload.posts).to eq([ post ])
         end
       end
 
-      context "when the parent is not a new record" do
-
-        let(:person) do
-          Person.create!
-        end
-
-        let(:post) do
-          Post.new
-        end
+      context 'when the parent is not a new record' do
+        let(:person) { Person.create! }
+        let(:post) { Post.new }
 
-        let(:post_three) do
-          Post.new
-        end
+        let(:post_three) { Post.new }
 
         before do
-          person.posts.concat([ post, post_three ])
+          person.posts.push post, post_three
         end
 
-        it "sets the foreign key on the association" do
+        it 'sets the foreign key on the association' do
           expect(post.person_id).to eq(person.id)
         end
 
-        it "sets the base on the inverse association" do
+        it 'sets the base on the inverse association' do
           expect(post.person).to eq(person)
         end
 
-        it "sets the same instance on the inverse association" do
+        it 'sets the same instance on the inverse association' do
           expect(post.person).to eql(person)
         end
 
-        it "saves the target" do
+        it 'saves the target' do
           expect(post).to be_persisted
         end
 
-        it "adds the document to the target" do
+        it 'adds the document to the target' do
           expect(person.posts.count).to eq(2)
         end
 
-        context "when documents already exist on the association" do
-
-          let(:post_two) do
-            Post.new(title: "Test")
-          end
+        context 'when documents already exist on the association' do
+          let(:post_two) { Post.new(title: 'Test') }
 
           before do
-            person.posts.concat([ post_two ])
+            person.posts.push post_two
           end
 
-          it "sets the foreign key on the association" do
+          it 'sets the foreign key on the association' do
             expect(post_two.person_id).to eq(person.id)
           end
 
-          it "sets the base on the inverse association" do
+          it 'sets the base on the inverse association' do
             expect(post_two.person).to eq(person)
           end
 
-          it "sets the same instance on the inverse association" do
+          it 'sets the same instance on the inverse association' do
             expect(post_two.person).to eql(person)
           end
 
-          it "saves the target" do
+          it 'saves the target' do
             expect(post_two).to be_persisted
           end
 
-          it "adds the document to the target" do
+          it 'adds the document to the target' do
             expect(person.posts.count).to eq(3)
           end
 
-          it "contains the initial document in the target" do
+          it 'contains the initial document in the target' do
             expect(person.posts).to include(post)
           end
 
-          it "contains the added document in the target" do
+          it 'contains the added document in the target' do
             expect(person.posts).to include(post_two)
           end
         end
@@ -1365,257 +1103,198 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
     end
   end
 
-  context "when the associations are polymorphic" do
-
-    context "when the parent is a new record" do
-
-      let(:movie) do
-        Movie.new
-      end
-
-      let(:rating) do
-        Rating.new
-      end
+  context 'when the associations are polymorphic' do
+    context 'when the parent is a new record' do
+      let(:movie) { Movie.new }
+      let(:rating) { Rating.new }
 
       before do
-        movie.ratings.concat([ rating ])
+        movie.ratings.push rating
       end
 
-      it "sets the foreign key on the association" do
+      it 'sets the foreign key on the association' do
         expect(rating.ratable_id).to eq(movie.id)
       end
 
-      it "sets the base on the inverse association" do
+      it 'sets the base on the inverse association' do
         expect(rating.ratable).to eq(movie)
       end
 
-      it "does not save the target" do
+      it 'does not save the target' do
         expect(rating).to be_new_record
       end
 
-      it "adds the document to the target" do
+      it 'adds the document to the target' do
         expect(movie.ratings.size).to eq(1)
       end
     end
 
-    context "when the parent is not a new record" do
-
-      let(:movie) do
-        Movie.create!
-      end
-
-      let(:rating) do
-        Rating.new
-      end
+    context 'when the parent is not a new record' do
+      let(:movie) { Movie.create! }
+      let(:rating) { Rating.new }
 
       before do
-        movie.ratings.concat([ rating ])
+        movie.ratings.push rating
       end
 
-      it "sets the foreign key on the association" do
+      it 'sets the foreign key on the association' do
         expect(rating.ratable_id).to eq(movie.id)
       end
 
-      it "sets the base on the inverse association" do
+      it 'sets the base on the inverse association' do
         expect(rating.ratable).to eq(movie)
       end
 
-      it "saves the target" do
+      it 'saves the target' do
         expect(rating).to be_persisted
       end
 
-      it "adds the document to the target" do
+      it 'adds the document to the target' do
         expect(movie.ratings.count).to eq(1)
       end
     end
   end
 
-  describe "#count" do
-
-    let(:movie) do
-      Movie.create!
-    end
-
-    context "when documents have been persisted" do
+  describe '#count' do
+    let(:movie) { Movie.create! }
 
-      let!(:rating) do
-        movie.ratings.create!(value: 1)
-      end
+    context 'when documents have been persisted' do
+      before { movie.ratings.create!(value: 1) }
 
-      it "returns the number of persisted documents" do
+      it 'returns the number of persisted documents' do
         expect(movie.ratings.count).to eq(1)
       end
 
-      it "block form includes persisted results" do
-        expect(movie.ratings.count {|r| r.value >= 1 }).to eq(1)
-        expect(movie.ratings.count {|r| r.value >= 2 }).to eq(0)
+      it 'block form includes persisted results' do
+        expect(movie.ratings.count { |r| r.value >= 1 }).to eq(1)
+        expect(movie.ratings.count { |r| r.value >= 2 }).to eq(0)
       end
     end
 
-    context "when documents have not been persisted" do
-
-      let!(:rating) do
-        movie.ratings.build(value: 1)
-      end
+    context 'when documents have not been persisted' do
+      before { movie.ratings.build(value: 1) }
 
-      it "returns 0" do
+      it 'returns 0' do
         expect(movie.ratings.count).to eq(0)
       end
 
-      it "block form does not include unpersisted results" do
-        expect(movie.ratings.count {|r| r.value == 1 }).to eq(0)
+      it 'block form does not include unpersisted results' do
+        expect(movie.ratings.count { |r| r.value == 1 }).to eq(0)
       end
     end
 
-    context "when mixed persisted and unpersisted documents" do
-
+    context 'when mixed persisted and unpersisted documents' do
       before do
         movie.ratings.create(value: 1)
         movie.ratings.build(value: 2)
       end
 
-      it "returns 1" do
+      it 'returns 1' do
         expect(movie.ratings.count).to eq(1)
       end
 
-      it "block form includes only persisted results" do
-        expect(movie.ratings.count {|r| r.value >= 1 }).to eq(1)
-        expect(movie.ratings.count {|r| r.value == 2 }).to eq(0)
+      it 'block form includes only persisted results' do
+        expect(movie.ratings.count { |r| r.value >= 1 }).to eq(1)
+        expect(movie.ratings.count { |r| r.value == 2 }).to eq(0)
       end
     end
 
-    context "when no document is added" do
-
-      it "returns false" do
+    context 'when no document is added' do
+      it 'returns false' do
         expect(movie.ratings.any?).to be false
       end
     end
 
-    context "when new documents exist in the database" do
-
-      context "when the documents are part of the association" do
-
+    context 'when new documents exist in the database' do
+      context 'when the documents are part of the association' do
         before do
           Rating.create!(ratable: movie)
         end
 
-        it "returns the count from the db" do
+        it 'returns the count from the db' do
           expect(movie.ratings.count).to eq(1)
         end
       end
 
-      context "when the documents are not part of the association" do
-
+      context 'when the documents are not part of the association' do
         before do
           Rating.create!
         end
 
-        it "returns the count from the db" do
+        it 'returns the count from the db' do
           expect(movie.ratings.count).to eq(0)
         end
       end
     end
   end
 
-  describe "#any?" do
-
+  describe '#any?' do
     shared_examples 'does not query database when association is loaded' do
-
-      let(:fresh_movie) { Movie.find(movie.id) }
+      let!(:fresh_movie) { Movie.find(movie.id) }
 
       context 'when association is not loaded' do
         it 'queries database on each call' do
-          fresh_movie
-
-          expect_query(1) do
-            fresh_movie.ratings.any?.should be expected_result
-          end
-
-          expect_query(1) do
-            fresh_movie.ratings.any?.should be expected_result
-          end
+          expect_query(1) { expect(fresh_movie.ratings.any?).to be expected_result }
+          expect_query(1) { expect(fresh_movie.ratings.any?).to be expected_result }
         end
 
         context 'when using a block' do
-          it 'queries database on first call only' do
-            fresh_movie
-
-            expect_query(1) do
-              fresh_movie.ratings.any? { false }.should be false
-            end
+          def fresh_movie_ratings?
+            fresh_movie.ratings.any? { false }
+          end
 
-            expect_no_queries do
-              fresh_movie.ratings.any? { false }.should be false
-            end
+          it 'queries database on first call only' do
+            expect_query(1) { expect(fresh_movie_ratings?).to be false }
+            expect_no_queries { expect(fresh_movie_ratings?).to be false }
           end
         end
       end
 
       context 'when association is loaded' do
         it 'does not query database' do
-          fresh_movie
-
-          expect_query(1) do
-            fresh_movie.ratings.any?.should be expected_result
-          end
-
+          expect_query(1) { expect(fresh_movie.ratings.any?).to be expected_result }
           fresh_movie.ratings.to_a
-
-          expect_no_queries do
-            fresh_movie.ratings.any?.should be expected_result
-          end
+          expect_no_queries { expect(fresh_movie.ratings.any?).to be expected_result }
         end
       end
     end
 
-    let(:movie) do
-      Movie.create!
-    end
-
-    context "when nothing exists on the association" do
+    let(:movie) { Movie.create! }
 
-      context "when no document is added" do
-
-        let!(:movie) do
-          Movie.create!
-        end
+    context 'when nothing exists on the association' do
+      context 'when no document is added' do
+        let!(:movie) { Movie.create! }
+        let(:expected_result) { false }
 
-        it "returns false" do
+        it 'returns false' do
           expect(movie.ratings.any?).to be false
         end
 
-        let(:expected_result) { false }
         include_examples 'does not query database when association is loaded'
       end
 
-      context "when the document is destroyed" do
-
+      context 'when the document is destroyed' do
         before do
           Rating.create!
         end
 
-        let!(:movie) do
-          Movie.create!
-        end
+        let!(:movie) { Movie.create! }
 
-        it "returns false" do
+        it 'returns false' do
           movie.destroy
           expect(movie.ratings.any?).to be false
         end
       end
     end
 
-    context "when appending to a association and _loaded/_unloaded are empty" do
-
-      let!(:movie) do
-        Movie.create!
-      end
+    context 'when appending to a association and _loaded/_unloaded are empty' do
+      let!(:movie) { Movie.create! }
 
       before do
         movie.ratings << Rating.new
       end
 
-      it "returns true" do
+      it 'returns true' do
         expect(movie.ratings.any?).to be true
       end
 
@@ -1633,278 +1312,217 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
 
       context 'when association is loaded' do
         it 'does not query database' do
-          expect_no_queries do
-            movie.ratings.any?.should be true
-          end
-
+          expect_no_queries { expect(movie.ratings.any?).to be true }
           movie.ratings.to_a
-
-          expect_no_queries do
-            movie.ratings.any?.should be true
-          end
+          expect_no_queries { expect(movie.ratings.any?).to be true }
         end
       end
     end
 
-    context "when appending to a association in a transaction" do
+    context 'when appending to an association in a transaction' do
       require_transaction_support
 
-      let!(:movie) do
-        Movie.create!
+      let!(:movie) { Movie.create! }
+
+      def with_transaction_via(model, &block)
+        model.with_session do |session|
+          session.with_transaction(&block)
+        end
       end
 
-      it "returns true" do
-        movie.with_session do |session|
-          session.with_transaction do
-            expect{ movie.ratings << Rating.new }.to_not raise_error
-            expect(movie.ratings.any?).to be true
-          end
+      it 'returns true' do
+        with_transaction_via(movie) do
+          expect { movie.ratings << Rating.new }.not_to raise_error
+          expect(movie.ratings.any?).to be true
         end
       end
     end
 
-    context "when documents have been persisted" do
+    context 'when documents have been persisted' do
+      let(:expected_result) { true }
 
-      let!(:rating) do
+      before do
         movie.ratings.create!(value: 1)
       end
 
-      it "returns true" do
+      it 'returns true' do
         expect(movie.ratings.any?).to be true
       end
 
-      let(:expected_result) { true }
       include_examples 'does not query database when association is loaded'
     end
 
-    context "when documents have not been persisted" do
-
-      let!(:rating) do
+    context 'when documents have not been persisted' do
+      before do
         movie.ratings.build(value: 1)
       end
 
-      it "returns false" do
+      it 'returns false' do
         expect(movie.ratings.any?).to be true
       end
     end
 
-    context "when new documents exist in the database" do
+    context 'when new documents exist in the database' do
       before do
         Rating.create!(ratable: movie)
       end
 
-      it "returns true" do
+      it 'returns true' do
         expect(movie.ratings.any?).to be true
       end
     end
   end
 
-  describe "#create" do
+  describe '#create' do
+    context 'when providing multiple attributes' do
+      let(:person) { Person.create! }
+      let!(:posts) { person.posts.create!([ { text: 'Test1' }, { text: 'Test2' } ]) }
 
-    context "when providing multiple attributes" do
-
-      let(:person) do
-        Person.create!
-      end
-
-      let!(:posts) do
-        person.posts.create!([{ text: "Test1" }, { text: "Test2" }])
-      end
-
-      it "creates multiple documents" do
+      it 'creates multiple documents' do
         expect(posts.size).to eq(2)
       end
 
-      it "sets the first attributes" do
-        expect(posts.first.text).to eq("Test1")
+      it 'sets the first attributes' do
+        expect(posts.first.text).to eq('Test1')
       end
 
-      it "sets the second attributes" do
-        expect(posts.last.text).to eq("Test2")
+      it 'sets the second attributes' do
+        expect(posts.last.text).to eq('Test2')
       end
 
-      it "persists the children" do
+      it 'persists the children' do
         expect(person.posts.count).to eq(2)
       end
     end
 
-    context "when the association is not polymorphic" do
-
-      context "when the parent is a new record" do
-
-        let(:person) do
-          Person.new
-        end
+    context 'when the association is not polymorphic' do
+      context 'when the parent is a new record' do
+        let(:person) { Person.new }
+        let(:post) { person.posts.create!(text: 'Testing') }
 
-        let(:post) do
-          person.posts.create!(text: "Testing")
-        end
-
-        it "raises an unsaved document error" do
+        it 'raises an unsaved document error' do
           expect { post }.to raise_error(Mongoid::Errors::UnsavedDocument)
         end
       end
 
-      context "when.creating the document" do
-
-        context "when the operation is successful" do
-
-          let(:person) do
-            Person.create!
-          end
-
-          let!(:post) do
-            person.posts.create!(text: "Testing")
-          end
+      context 'when.creating the document' do
+        context 'when the operation is successful' do
+          let(:person) { Person.create! }
+          let!(:post) { person.posts.create!(text: 'Testing') }
 
-          it "creates the document" do
+          it 'creates the document' do
             expect(person.posts).to eq([ post ])
           end
         end
 
-        context "when the operation fails" do
+        context 'when the operation fails' do
+          let(:person) { Person.create! }
+          let!(:existing) { Post.create! }
 
-          let(:person) do
-            Person.create!
-          end
-
-          let!(:existing) do
-            Post.create!
-          end
-
-          it "raises an error" do
-            expect {
-              person.posts.create! do |doc|
-                doc._id = existing.id
-              end
-            }.to raise_error(Mongo::Error::OperationFailure)
+          it 'raises an error' do
+            expect { person.posts.create! { |doc| doc._id = existing.id } }
+              .to raise_error(Mongo::Error::OperationFailure)
           end
         end
       end
 
-      context "when the parent is not a new record" do
-
-        let(:person) do
-          Person.create!
-        end
-
+      context 'when the parent is not a new record' do
+        let(:person) { Person.create! }
         let!(:post) do
-          person.posts.create!(text: "Testing") do |post|
-            post.content = "The Content"
+          person.posts.create!(text: 'Testing') do |post|
+            post.content = 'The Content'
           end
         end
 
-        it "sets the foreign key on the association" do
+        it 'sets the foreign key on the association' do
           expect(post.person_id).to eq(person.id)
         end
 
-        it "sets the base on the inverse association" do
+        it 'sets the base on the inverse association' do
           expect(post.person).to eq(person)
         end
 
-        it "sets the attributes" do
-          expect(post.text).to eq("Testing")
+        it 'sets the attributes' do
+          expect(post.text).to eq('Testing')
         end
 
-        it "saves the target" do
-          expect(post).to_not be_a_new_record
+        it 'saves the target' do
+          expect(post).not_to be_a_new_record
         end
 
-        it "calls the passed block" do
-          expect(post.content).to eq("The Content")
+        it 'calls the passed block' do
+          expect(post.content).to eq('The Content')
         end
 
-        it "adds the document to the target" do
+        it 'adds the document to the target' do
           expect(person.posts.count).to eq(1)
         end
       end
 
-      context "when passing a new object" do
+      context 'when passing a new object' do
+        let!(:odd) { Odd.create!(name: 'one') }
 
-        let!(:odd) do
-          Odd.create!(name: 'one')
-        end
-
-        let!(:even) do
-          odd.evens.create!(name: 'two', odds: [Odd.new(name: 'three')])
+        before do
+          odd.evens.create!(name: 'two', odds: [ Odd.new(name: 'three') ])
         end
 
-        it "only push one even to the list" do
+        it 'only push one even to the list' do
           expect(odd.evens.count).to eq(1)
         end
 
-        it "saves the reference back" do
+        it 'saves the reference back' do
           expect(odd.evens.first.odds.count).to eq(1)
         end
 
-        it "only saves one even" do
+        it 'only saves one even' do
           expect(Even.count).to eq(1)
         end
 
-        it "saves the first odd and the second" do
+        it 'saves the first odd and the second' do
           expect(Odd.count).to eq(2)
         end
       end
     end
 
-    context "when the association is polymorphic" do
-
-      context "when the parent is a new record" do
+    context 'when the association is polymorphic' do
+      context 'when the parent is a new record' do
+        let(:movie) { Movie.new }
+        let(:rating) { movie.ratings.create!(value: 1) }
 
-        let(:movie) do
-          Movie.new
-        end
-
-        let(:rating) do
-          movie.ratings.create!(value: 1)
-        end
-
-        it "raises an unsaved document error" do
+        it 'raises an unsaved document error' do
           expect { rating }.to raise_error(Mongoid::Errors::UnsavedDocument)
         end
       end
 
-      context "when the parent is not a new record" do
-
-        let(:movie) do
-          Movie.create!
-        end
+      context 'when the parent is not a new record' do
+        let(:movie) { Movie.create! }
+        let!(:rating) { movie.ratings.create!(value: 3) }
 
-        let!(:rating) do
-          movie.ratings.create!(value: 3)
-        end
-
-        it "sets the foreign key on the association" do
+        it 'sets the foreign key on the association' do
           expect(rating.ratable_id).to eq(movie.id)
         end
 
-        it "sets the base on the inverse association" do
+        it 'sets the base on the inverse association' do
           expect(rating.ratable).to eq(movie)
         end
 
-        it "sets the attributes" do
+        it 'sets the attributes' do
           expect(rating.value).to eq(3)
         end
 
-        it "saves the target" do
-          expect(rating).to_not be_new_record
+        it 'saves the target' do
+          expect(rating).not_to be_new_record
         end
 
-        it "adds the document to the target" do
+        it 'adds the document to the target' do
           expect(movie.ratings.count).to eq(1)
         end
       end
     end
 
-    context "when using a different primary_key" do
-
-      let(:person) do
-        Person.create!(username: 'arthurnn')
-      end
-
-      let(:drug) do
-        person.drugs.create!
-      end
+    context 'when using a different primary_key' do
+      let(:person) { Person.create!(username: 'arthurnn') }
+      let(:drug) { person.drugs.create! }
 
       it 'saves pk value on fk field' do
         expect(drug.person_id).to eq('arthurnn')
@@ -1912,194 +1530,137 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
     end
   end
 
-  describe "#create!" do
-
-    context "when providing multiple attributes" do
-
-      let(:person) do
-        Person.create!
-      end
-
-      let!(:posts) do
-        person.posts.create!([{ text: "Test1" }, { text: "Test2" }])
-      end
+  describe '#create!' do
+    context 'when providing multiple attributes' do
+      let(:person) { Person.create! }
+      let!(:posts) { person.posts.create!([ { text: 'Test1' }, { text: 'Test2' } ]) }
 
-      it "creates multiple documents" do
+      it 'creates multiple documents' do
         expect(posts.size).to eq(2)
       end
 
-      it "sets the first attributes" do
-        expect(posts.first.text).to eq("Test1")
+      it 'sets the first attributes' do
+        expect(posts.first.text).to eq('Test1')
       end
 
-      it "sets the second attributes" do
-        expect(posts.last.text).to eq("Test2")
+      it 'sets the second attributes' do
+        expect(posts.last.text).to eq('Test2')
       end
 
-      it "persists the children" do
+      it 'persists the children' do
         expect(person.posts.count).to eq(2)
       end
     end
 
-    context "when the association is not polymorphic" do
-
-      context "when the parent is a new record" do
+    context 'when the association is not polymorphic' do
+      context 'when the parent is a new record' do
+        let(:person) { Person.new }
+        let(:post) { person.posts.create!(title: 'Testing') }
 
-        let(:person) do
-          Person.new
-        end
-
-        let(:post) do
-          person.posts.create!(title: "Testing")
-        end
-
-        it "raises an unsaved document error" do
+        it 'raises an unsaved document error' do
           expect { post }.to raise_error(Mongoid::Errors::UnsavedDocument)
         end
       end
 
-      context "when the parent is not a new record" do
-
-        let(:person) do
-          Person.create!
-        end
-
-        let!(:post) do
-          person.posts.create!(title: "Testing")
-        end
+      context 'when the parent is not a new record' do
+        let(:person) { Person.create! }
+        let!(:post) { person.posts.create!(title: 'Testing') }
 
-        it "sets the foreign key on the association" do
+        it 'sets the foreign key on the association' do
           expect(post.person_id).to eq(person.id)
         end
 
-        it "sets the base on the inverse association" do
+        it 'sets the base on the inverse association' do
           expect(post.person).to eq(person)
         end
 
-        it "sets the attributes" do
-          expect(post.title).to eq("Testing")
+        it 'sets the attributes' do
+          expect(post.title).to eq('Testing')
         end
 
-        it "saves the target" do
-          expect(post).to_not be_a_new_record
+        it 'saves the target' do
+          expect(post).not_to be_a_new_record
         end
 
-        it "adds the document to the target" do
+        it 'adds the document to the target' do
           expect(person.posts.count).to eq(1)
         end
 
-        context "when validation fails" do
-
-          it "raises an error" do
-            expect {
-              person.posts.create!(title: "$$$")
-            }.to raise_error(Mongoid::Errors::Validations)
+        context 'when validation fails' do
+          it 'raises an error' do
+            expect { person.posts.create!(title: '$$$') }
+              .to raise_error(Mongoid::Errors::Validations)
           end
         end
       end
     end
 
-    context "when the association is polymorphic" do
-
-      context "when the parent is a new record" do
-
-        let(:movie) do
-          Movie.new
-        end
-
-        let(:rating) do
-          movie.ratings.create!(value: 1)
-        end
+    context 'when the association is polymorphic' do
+      context 'when the parent is a new record' do
+        let(:movie) { Movie.new }
+        let(:rating) { movie.ratings.create!(value: 1) }
 
-        it "raises an unsaved document error" do
+        it 'raises an unsaved document error' do
           expect { rating }.to raise_error(Mongoid::Errors::UnsavedDocument)
         end
       end
 
-      context "when the parent is not a new record" do
-
-        let(:movie) do
-          Movie.create!
-        end
-
-        let!(:rating) do
-          movie.ratings.create!(value: 4)
-        end
+      context 'when the parent is not a new record' do
+        let(:movie) { Movie.create! }
+        let!(:rating) { movie.ratings.create!(value: 4) }
 
-        it "sets the foreign key on the association" do
+        it 'sets the foreign key on the association' do
           expect(rating.ratable_id).to eq(movie.id)
         end
 
-        it "sets the base on the inverse association" do
+        it 'sets the base on the inverse association' do
           expect(rating.ratable).to eq(movie)
         end
 
-        it "sets the attributes" do
+        it 'sets the attributes' do
           expect(rating.value).to eq(4)
         end
 
-        it "saves the target" do
-          expect(rating).to_not be_new_record
+        it 'saves the target' do
+          expect(rating).not_to be_new_record
         end
 
-        it "adds the document to the target" do
+        it 'adds the document to the target' do
           expect(movie.ratings.count).to eq(1)
         end
 
-        context "when validation fails" do
-
-          it "raises an error" do
-            expect {
-              movie.ratings.create!(value: 1000)
-            }.to raise_error(Mongoid::Errors::Validations)
+        context 'when validation fails' do
+          it 'raises an error' do
+            expect { movie.ratings.create!(value: 1000) }
+              .to raise_error(Mongoid::Errors::Validations)
           end
         end
       end
     end
   end
 
-  describe "#criteria" do
-
-    let(:base) do
-      Movie.new
-    end
+  describe '#criteria' do
+    let(:base) { Movie.new }
 
-    context "when the association is polymorphic" do
+    context 'when the association is polymorphic' do
+      let(:association) { Movie.relations['ratings'] }
+      let(:criteria) { association.criteria(base) }
 
-      let(:association) do
-        Movie.relations["ratings"]
-      end
-
-      let(:criteria) do
-        association.criteria(base)
-      end
-
-      it "includes the type in the criteria" do
+      it 'includes the type in the criteria' do
         expect(criteria.selector).to eq(
-                                         {
-                                             "ratable_id"    => base.id,
-                                             "ratable_type"  => "Movie"
-                                         }
-                                     )
+          { 'ratable_id' => base.id, 'ratable_type' => 'Movie' }
+        )
       end
     end
 
-    context "when the association is not polymorphic" do
+    context 'when the association is not polymorphic' do
+      let(:association) { Person.relations['posts'] }
+      let(:base) { Person.new }
 
-      let(:association) do
-        Person.relations["posts"]
-      end
-
-      let(:base) do
-        Person.new
-      end
+      let(:criteria) { association.criteria(base) }
 
-      let(:criteria) do
-        association.criteria(base)
-      end
-
-      it "does not include the type in the criteria" do
-        expect(criteria.selector).to eq({ "person_id" => base.id })
+      it 'does not include the type in the criteria' do
+        expect(criteria.selector).to eq({ 'person_id' => base.id })
       end
     end
   end
@@ -2214,131 +1775,115 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
     end
   end
 
-  [ :delete_all, :destroy_all ].each do |method|
-
+  %i[ delete_all destroy_all ].each do |method|
     describe "##{method}" do
+      context 'when the association is not polymorphic' do
+        context 'when conditions are provided' do
+          let(:person) { Person.create!(username: 'durran') }
+          let!(:post2) { person.posts.create!(title: 'Test') }
 
-      context "when the association is not polymorphic" do
+          before { person.posts.create!(title: 'Testing') }
 
-        context "when conditions are provided" do
-
-          let(:person) do
-            Person.create!(username: 'durran')
-          end
-
-          let!(:post1) { person.posts.create!(title: "Testing") }
-          let!(:post2) { person.posts.create!(title: "Test") }
-
-          it "removes the correct posts" do
-            person.posts.send(method, { title: "Testing" })
+          it 'removes the correct posts' do
+            person.posts.send(method, { title: 'Testing' })
             expect(person.posts.count).to eq(1)
             expect(person.reload.posts_count).to eq(1) if method == :destroy_all
           end
 
-          it "deletes the documents from the database" do
-            person.posts.send(method, { title: "Testing" })
-            expect(Post.where(title: "Testing").count).to eq(0)
+          it 'deletes the documents from the database' do
+            person.posts.send(method, { title: 'Testing' })
+            expect(Post.where(title: 'Testing').count).to eq(0)
           end
 
-          it "returns the number of documents deleted" do
-            expect(person.posts.send(method, { title: "Testing" })).to eq(1)
+          it 'returns the number of documents deleted' do
+            expect(person.posts.send(method, { title: 'Testing' })).to eq(1)
           end
 
-          it "sets the association locally" do
-            person.posts.send(method, { title: "Testing" })
-            expect(person.posts).to eq([post2])
+          it 'sets the association locally' do
+            person.posts.send(method, { title: 'Testing' })
+            expect(person.posts).to eq([ post2 ])
           end
         end
 
-        context "when conditions are not provided" do
-
-          let(:person) do
-            Person.create!
-          end
+        context 'when conditions are not provided' do
+          let(:person) { Person.create! }
 
           before do
-            person.posts.create!(title: "Testing")
-            person.posts.create!(title: "Test")
+            person.posts.create!(title: 'Testing')
+            person.posts.create!(title: 'Test')
           end
 
-          it "removes the correct posts" do
+          it 'removes the correct posts' do
             person.posts.send(method)
             expect(person.posts.count).to eq(0)
           end
 
-          it "deletes the documents from the database" do
+          it 'deletes the documents from the database' do
             person.posts.send(method)
-            expect(Post.where(title: "Testing").count).to eq(0)
+            expect(Post.where(title: 'Testing').count).to eq(0)
           end
 
-          it "returns the number of documents deleted" do
+          it 'returns the number of documents deleted' do
             expect(person.posts.send(method)).to eq(2)
           end
 
-          it "sets the association locally" do
+          it 'sets the association locally' do
             person.posts.send(method)
             expect(person.posts).to eq([])
           end
         end
       end
 
-      context "when the association is polymorphic" do
-
-        context "when conditions are provided" do
-
-          let(:movie) do
-            Movie.create!(title: "Bladerunner")
-          end
-
-          let!(:rating1) { movie.ratings.create!(value: 1) }
+      context 'when the association is polymorphic' do
+        context 'when conditions are provided' do
+          let(:movie) { Movie.create!(title: 'Bladerunner') }
           let!(:rating2) { movie.ratings.create!(value: 2) }
 
-          it "removes the correct ratings" do
+          before { movie.ratings.create!(value: 1) }
+
+          it 'removes the correct ratings' do
             movie.ratings.send(method, { value: 1 })
             expect(movie.ratings.count).to eq(1)
           end
 
-          it "deletes the documents from the database" do
+          it 'deletes the documents from the database' do
             movie.ratings.send(method, { value: 1 })
             expect(Rating.where(value: 1).count).to eq(0)
           end
 
-          it "returns the number of documents deleted" do
+          it 'returns the number of documents deleted' do
             expect(movie.ratings.send(method, { value: 1 })).to eq(1)
           end
 
-          it "sets the association locally" do
+          it 'sets the association locally' do
             movie.ratings.send(method, { value: 1 })
-            expect(movie.ratings).to eq([rating2])
+            expect(movie.ratings).to eq([ rating2 ])
           end
         end
 
-        context "when conditions are not provided" do
-
-          let(:movie) do
-            Movie.create!(title: "Bladerunner")
-          end
+        context 'when conditions are not provided' do
+          let(:movie) { Movie.create!(title: 'Bladerunner') }
 
           before do
             movie.ratings.create!(value: 1)
             movie.ratings.create!(value: 2)
           end
 
-          it "removes the correct ratings" do
+          it 'removes the correct ratings' do
             movie.ratings.send(method)
             expect(movie.ratings.count).to eq(0)
           end
 
-          it "deletes the documents from the database" do
+          it 'deletes the documents from the database' do
             movie.ratings.send(method)
             expect(Rating.where(value: 1).count).to eq(0)
           end
 
-          it "returns the number of documents deleted" do
+          it 'returns the number of documents deleted' do
             expect(movie.ratings.send(method)).to eq(2)
           end
 
-          it "sets the association locally" do
+          it 'sets the association locally' do
             movie.ratings.send(method)
             expect(movie.ratings).to eq([])
           end
@@ -2347,52 +1892,36 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
     end
   end
 
-  describe ".embedded?" do
-
-    it "returns false" do
-      expect(described_class).to_not be_embedded
+  describe '.embedded?' do
+    it 'returns false' do
+      expect(described_class).not_to be_embedded
     end
   end
 
-  describe "#exists?" do
-
-    let!(:person) do
-      Person.create!
-    end
-
-    context "when documents exist in the database" do
+  describe '#exists?' do
+    let!(:person) { Person.create! }
 
+    context 'when documents exist in the database' do
       before do
         person.posts.create!
       end
 
-      it "returns true" do
+      it 'returns true' do
         expect(person.posts.exists?).to be true
       end
 
       context 'when association is not loaded' do
         it 'queries database on each call' do
-          expect_query(1) do
-            person.posts.exists?.should be true
-          end
-
-          expect_query(1) do
-            person.posts.exists?.should be true
-          end
+          expect_query(1) { expect(person.posts.exists?).to be true }
+          expect_query(1) { expect(person.posts.exists?).to be true }
         end
       end
 
       context 'when association is loaded' do
         it 'queries database on each call' do
-          expect_query(1) do
-            person.posts.exists?.should be true
-          end
-
+          expect_query(1) { expect(person.posts.exists?).to be true }
           person.posts.to_a
-
-          expect_query(1) do
-            person.posts.exists?.should be true
-          end
+          expect_query(1) { expect(person.posts.exists?).to be true }
         end
       end
 
@@ -2433,72 +1962,50 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
       end
     end
 
-    context "when documents exist in application but not in database" do
-
+    context 'when documents exist in application but not in database' do
       before do
         person.posts.build
       end
 
-      it "returns false" do
+      it 'returns false' do
         expect(person.posts.exists?).to be false
       end
 
       context 'when association is not loaded' do
         it 'queries database on each call' do
-          expect_query(1) do
-            person.posts.exists?.should be false
-          end
-
-          expect_query(1) do
-            person.posts.exists?.should be false
-          end
+          expect_query(1) { expect(person.posts.exists?).to be false }
+          expect_query(1) { expect(person.posts.exists?).to be false }
         end
       end
 
       context 'when association is loaded' do
         it 'queries database on each call' do
-          expect_query(1) do
-            person.posts.exists?.should be false
-          end
-
+          expect_query(1) { expect(person.posts.exists?).to be false }
           person.posts.to_a
-
-          expect_query(1) do
-            person.posts.exists?.should be false
-          end
+          expect_query(1) { expect(person.posts.exists?).to be false }
         end
       end
     end
 
-    context "when no documents exist" do
-
-      it "returns false" do
+    context 'when no documents exist' do
+      it 'returns false' do
         expect(person.posts.exists?).to be false
       end
 
       context 'when association is not loaded' do
         it 'queries database on each call' do
-          expect_query(1) do
-            person.posts.exists?.should be false
-          end
-
-          expect_query(1) do
-            person.posts.exists?.should be false
-          end
+          expect_query(1) { expect(person.posts.exists?).to be false }
+          expect_query(1) { expect(person.posts.exists?).to be false }
         end
       end
 
       context 'when association is loaded' do
         it 'queries database on each call' do
-          expect_query(1) do
-            person.posts.exists?.should be false
-          end
+          expect_query(1) { expect(person.posts.exists?).to be false }
 
           person.posts.to_a
 
-          expect_query(1) do
-            person.posts.exists?.should be false
-          end
+          expect_query(1) { expect(person.posts.exists?).to be false }
         end
       end
 
@@ -2510,128 +2017,94 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
     end
   end
 
-  describe "#find" do
-
-    context "when iterating after the find" do
-
-      let(:person) do
-        Person.create!
-      end
-
-      let(:post_id) do
-        person.posts.first.id
-      end
+  describe '#find' do
+    context 'when iterating after the find' do
+      let(:person) { Person.create! }
+      let(:post_id) { person.posts.first.id }
 
       before do
         5.times { person.posts.create! }
       end
 
-      it "does not change the in memory size" do
-        expect {
-          person.posts.find(post_id)
-        }.not_to change { person.posts.to_a.size }
+      it 'does not change the in memory size' do
+        expect { person.posts.find(post_id) }
+          .not_to(change { person.posts.to_a.size })
       end
     end
 
-    context "when the association is not polymorphic" do
+    context 'when the association is not polymorphic' do
+      let(:person) { Person.create! }
+      let!(:post_one) { person.posts.create!(title: 'Test') }
+      let!(:post_two) { person.posts.create!(title: 'OMG I has associations') }
 
-      let(:person) do
-        Person.create!
-      end
-
-      let!(:post_one) do
-        person.posts.create!(title: "Test")
-      end
-
-      let!(:post_two) do
-        person.posts.create!(title: "OMG I has associations")
-      end
-
-      context "when providing an id" do
+      context 'when providing an id' do
+        context 'when the id matches' do
+          let(:post) { person.posts.find(post_one.id) }
 
-        context "when the id matches" do
-
-          let(:post) do
-            person.posts.find(post_one.id)
-          end
-
-          it "returns the matching document" do
+          it 'returns the matching document' do
             expect(post).to eq(post_one)
           end
         end
 
-        context "when the id matches but is not scoped to the association" do
-
-          let(:post) do
-            Post.create!(title: "Unscoped")
-          end
+        context 'when the id matches but is not scoped to the association' do
+          let(:post) { Post.create!(title: 'Unscoped') }
 
-          it "raises an error" do
-            expect {
-              person.posts.find(post.id)
-            }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Post with id\(s\)/)
+          it 'raises an error' do
+            expect { person.posts.find(post.id) }
+              .to raise_error(Mongoid::Errors::DocumentNotFound,
+                              /Document\(s\) not found for class Post with id\(s\)/)
           end
         end
 
-        context "when the id does not match" do
-
-          context "when config set to raise error" do
+        context 'when the id does not match' do
+          context 'when config set to raise error' do
             config_override :raise_not_found_error, true
 
-            it "raises an error" do
-              expect {
-                person.posts.find(BSON::ObjectId.new)
-              }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Post with id\(s\)/)
+            it 'raises an error' do
+              expect { person.posts.find(BSON::ObjectId.new) }
+                .to raise_error(Mongoid::Errors::DocumentNotFound,
+                                /Document\(s\) not found for class Post with id\(s\)/)
             end
           end
 
-          context "when config set not to raise error" do
+          context 'when config set not to raise error' do
             config_override :raise_not_found_error, false
 
-            let(:post) do
-              person.posts.find(BSON::ObjectId.new)
-            end
+            let(:post) { person.posts.find(BSON::ObjectId.new) }
 
-            it "returns nil" do
+            it 'returns nil' do
               expect(post).to be_nil
             end
           end
         end
       end
 
-      context "when providing an array of ids" do
-
-        context "when the ids match" do
-
-          let(:posts) do
-            person.posts.find([ post_one.id, post_two.id ])
-          end
+      context 'when providing an array of ids' do
+        context 'when the ids match' do
+          let(:posts) { person.posts.find([ post_one.id, post_two.id ]) }
 
-          it "returns the matching documents" do
+          it 'returns the matching documents' do
             expect(posts).to eq([ post_one, post_two ])
           end
         end
 
-        context "when the ids do not match" do
-
-          context "when config set to raise error" do
+        context 'when the ids do not match' do
+          context 'when config set to raise error' do
             config_override :raise_not_found_error, true
 
-            it "raises an error" do
-              expect {
-                person.posts.find([ BSON::ObjectId.new ])
-              }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Post with id\(s\)/)
+            it 'raises an error' do
+              expect { person.posts.find([ BSON::ObjectId.new ]) }
+                .to raise_error(Mongoid::Errors::DocumentNotFound,
+                                /Document\(s\) not found for class Post with id\(s\)/)
             end
           end
 
-          context "when config set not to raise error" do
+          context 'when config set not to raise error' do
             config_override :raise_not_found_error, false
 
-            let(:posts) do
-              person.posts.find([ BSON::ObjectId.new ])
-            end
+            let(:posts) { person.posts.find([ BSON::ObjectId.new ]) }
 
-            it "returns an empty array" do
+            it 'returns an empty array' do
               expect(posts).to be_empty
             end
           end
@@ -2639,100 +2112,85 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
       end
     end
 
-    context "when the association is polymorphic" do
+    context 'when the association is polymorphic' do
+      let(:movie) { Movie.create! }
+      let!(:rating_one) { movie.ratings.create!(value: 1) }
+      let!(:rating_two) { movie.ratings.create!(value: 5) }
 
-      let(:movie) do
-        Movie.create!
-      end
+      context 'when providing an id' do
+        context 'when the id matches' do
+          let(:rating) { movie.ratings.find(rating_one.id) }
 
-      let!(:rating_one) do
-        movie.ratings.create!(value: 1)
-      end
-
-      let!(:rating_two) do
-        movie.ratings.create!(value: 5)
-      end
-
-      context "when providing an id" do
-
-        context "when the id matches" do
-
-          let(:rating) do
-            movie.ratings.find(rating_one.id)
-          end
-
-          it "returns the matching document" do
+          it 'returns the matching document' do
             expect(rating).to eq(rating_one)
           end
         end
 
-        context "when the id does not match" do
-
-          context "when config set to raise error" do
+        context 'when the id does not match' do
+          context 'when config set to raise error' do
             config_override :raise_not_found_error, true
 
-            it "raises an error" do
-              expect {
-                movie.ratings.find(BSON::ObjectId.new)
-              }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Rating with id\(s\)/)
+            let(:expected_error) { Mongoid::Errors::DocumentNotFound }
+            let(:expected_message) do
+              /Document\(s\) not found for class Rating with id\(s\)/
+            end
+
+            it 'raises an error' do
+              expect { movie.ratings.find(BSON::ObjectId.new) }
+                .to raise_error(expected_error, expected_message)
             end
           end
 
-          context "when config set not to raise error" do
+          context 'when config set not to raise error' do
             config_override :raise_not_found_error, false
 
-            let(:rating) do
-              movie.ratings.find(BSON::ObjectId.new)
-            end
+            let(:rating) { movie.ratings.find(BSON::ObjectId.new) }
 
-            it "returns nil" do
+            it 'returns nil' do
               expect(rating).to be_nil
             end
           end
         end
       end
 
-      context "when providing an array of ids" do
-
-        context "when the ids match" do
-
-          let(:ratings) do
-            movie.ratings.find([ rating_one.id, rating_two.id ])
-          end
+      context 'when providing an array of ids' do
+        context 'when the ids match' do
+          let(:ratings) { movie.ratings.find([ rating_one.id, rating_two.id ]) }
 
-          it "returns the first matching document" do
+          it 'returns the first matching document' do
             expect(ratings).to include(rating_one)
           end
 
-          it "returns the second matching document" do
+          it 'returns the second matching document' do
             expect(ratings).to include(rating_two)
           end
 
-          it "returns the correct number of documents" do
+          it 'returns the correct number of documents' do
             expect(ratings.size).to eq(2)
           end
         end
 
-        context "when the ids do not match" do
-
-          context "when config set to raise error" do
+        context 'when the ids do not match' do
+          context 'when config set to raise error' do
             config_override :raise_not_found_error, true
 
-            it "raises an error" do
-              expect {
-                movie.ratings.find([ BSON::ObjectId.new ])
-              }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Rating with id\(s\)/)
+            let(:expected_error) { Mongoid::Errors::DocumentNotFound }
+            let(:expected_message) do
+              /Document\(s\) not found for class Rating with id\(s\)/
+            end
+
+            it 'raises an error' do
+              expect { movie.ratings.find([ BSON::ObjectId.new ]) }
+                .to raise_error(expected_error, expected_message)
             end
           end
 
-          context "when config set not to raise error" do
+          context 'when config set not to raise error' do
             config_override :raise_not_found_error, false
 
-            let(:ratings) do
-              movie.ratings.find([ BSON::ObjectId.new ])
-            end
+            let(:ratings) { movie.ratings.find([ BSON::ObjectId.new ]) }
 
-            it "returns an empty array" do
+            it 'returns an empty array' do
               expect(ratings).to be_empty
             end
           end
@@ -2740,732 +2198,538 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
       end
     end
 
-    context "with block" do
-      let!(:author) do
-        Person.create!(title: 'Person')
-      end
-
-      let!(:post_one) do
-        author.posts.create!(title: 'post one')
-      end
+    context 'with block' do
+      let(:titles) { [ 'post one', 'post two' ] }
+      let!(:author) { Person.create!(title: 'Person') }
+      let!(:post_one) { author.posts.create!(title: titles[0]) }
 
-      let!(:post_two) do
-        author.posts.create!(title: 'post two')
-      end
+      before { author.posts.create!(title: titles[1]) }
 
-      it "finds one" do
+      it 'finds one' do
         expect(
           author.posts.find do |post|
-            post.title == 'post one'
+            post.title == titles[0]
           end
         ).to be_a(Post)
       end
 
-      it "returns first match of multiple" do
+      it 'returns first match of multiple' do
         expect(
           author.posts.find do |post|
-            ['post one', 'post two'].include?(post.title)
+            titles.include?(post.title)
           end
         ).to eq(post_one)
       end
 
-      it "returns nil when not found" do
+      it 'returns nil when not found' do
         expect(
           author.posts.find do |post|
-            post.title == 'non exiting one'
+            post.title == 'non existing one'
           end
         ).to be_nil
       end
     end
   end
 
-  describe "#find_or_create_by" do
-
-    context "when the association is not polymorphic" do
+  describe '#find_or_create_by' do
+    context 'when the association is not polymorphic' do
+      let(:person) { Person.create! }
+      let!(:post) { person.posts.create!(title: 'Testing') }
 
-      let(:person) do
-        Person.create!
-      end
+      context 'when the document exists' do
+        let(:found) { person.posts.find_or_create_by(title: 'Testing') }
 
-      let!(:post) do
-        person.posts.create!(title: "Testing")
-      end
-
-      context "when the document exists" do
-
-        let(:found) do
-          person.posts.find_or_create_by(title: "Testing")
-        end
-
-        it "returns the document" do
+        it 'returns the document' do
           expect(found).to eq(post)
         end
 
-        it "keeps the document in the association" do
+        it 'keeps the document in the association' do
           expect(found.person).to eq(person)
         end
       end
 
-      context "when the document does not exist" do
-
-        context "when there is no criteria attached" do
-
+      context 'when the document does not exist' do
+        context 'when there is no criteria attached' do
           let(:found) do
-            person.posts.find_or_create_by(title: "Test") do |post|
-              post.content = "The Content"
+            person.posts.find_or_create_by(title: 'Test') do |post|
+              post.content = 'The Content'
             end
           end
 
-          it "sets the new document attributes" do
-            expect(found.title).to eq("Test")
+          it 'sets the new document attributes' do
+            expect(found.title).to eq('Test')
           end
 
-          it "returns a newly persisted document" do
+          it 'returns a newly persisted document' do
             expect(found).to be_persisted
           end
 
-          it "calls the passed block" do
-            expect(found.content).to eq("The Content")
+          it 'calls the passed block' do
+            expect(found.content).to eq('The Content')
           end
 
-          it "keeps the document in the association" do
+          it 'keeps the document in the association' do
             expect(found.person).to eq(person)
           end
         end
 
-        context "when a criteria is attached" do
+        context 'when a criteria is attached' do
+          let(:found) { person.posts.recent.find_or_create_by(title: 'Test') }
 
-          let(:found) do
-            person.posts.recent.find_or_create_by(title: "Test")
-          end
-
-          it "sets the new document attributes" do
-            expect(found.title).to eq("Test")
+          it 'sets the new document attributes' do
+            expect(found.title).to eq('Test')
           end
 
-          it "returns a newly persisted document" do
+          it 'returns a newly persisted document' do
             expect(found).to be_persisted
           end
 
-          it "keeps the document in the association" do
+          it 'keeps the document in the association' do
             expect(found.person).to eq(person)
           end
         end
       end
     end
 
-    context "when the association is polymorphic" do
-
-      let(:movie) do
-        Movie.create!
-      end
-
-      let!(:rating) do
-        movie.ratings.create!(value: 1)
-      end
+    context 'when the association is polymorphic' do
+      let(:movie) { Movie.create! }
+      let!(:rating) { movie.ratings.create!(value: 1) }
 
-      context "when the document exists" do
+      context 'when the document exists' do
+        let(:found) { movie.ratings.find_or_create_by(value: 1) }
 
-        let(:found) do
-          movie.ratings.find_or_create_by(value: 1)
-        end
-
-        it "returns the document" do
+        it 'returns the document' do
           expect(found).to eq(rating)
         end
 
-        it "keeps the document in the association" do
+        it 'keeps the document in the association' do
           expect(found.ratable).to eq(movie)
         end
       end
 
-      context "when the document does not exist" do
+      context 'when the document does not exist' do
+        let(:found) { movie.ratings.find_or_create_by(value: 3) }
 
-        let(:found) do
-          movie.ratings.find_or_create_by(value: 3)
-        end
-
-        it "sets the new document attributes" do
+        it 'sets the new document attributes' do
           expect(found.value).to eq(3)
         end
 
-        it "returns a newly persisted document" do
+        it 'returns a newly persisted document' do
           expect(found).to be_persisted
         end
 
-        it "keeps the document in the association" do
+        it 'keeps the document in the association' do
           expect(found.ratable).to eq(movie)
         end
       end
     end
   end
 
-  describe "#find_or_create_by!" do
-
-    context "when the association is not polymorphic" do
+  describe '#find_or_create_by!' do
+    context 'when the association is not polymorphic' do
+      let(:person) { Person.create! }
+      let!(:post) { person.posts.create!(title: 'Testing') }
 
-      let(:person) do
-        Person.create!
-      end
-
-      let!(:post) do
-        person.posts.create!(title: "Testing")
-      end
-
-      context "when the document exists" do
+      context 'when the document exists' do
+        let(:found) { person.posts.find_or_create_by!(title: 'Testing') }
 
-        let(:found) do
-          person.posts.find_or_create_by!(title: "Testing")
-        end
-
-        it "returns the document" do
+        it 'returns the document' do
           expect(found).to eq(post)
         end
 
-        it "keeps the document in the association" do
+        it 'keeps the document in the association' do
           expect(found.person).to eq(person)
         end
       end
 
-      context "when the document does not exist" do
-
-        context "when there is no criteria attached" do
-
+      context 'when the document does not exist' do
+        context 'when there is no criteria attached' do
           let(:found) do
-            person.posts.find_or_create_by!(title: "Test") do |post|
-              post.content = "The Content"
+            person.posts.find_or_create_by!(title: 'Test') do |post|
+              post.content = 'The Content'
             end
           end
 
-          it "sets the new document attributes" do
-            expect(found.title).to eq("Test")
+          it 'sets the new document attributes' do
+            expect(found.title).to eq('Test')
           end
 
-          it "returns a newly persisted document" do
+          it 'returns a newly persisted document' do
             expect(found).to be_persisted
           end
 
-          it "calls the passed block" do
-            expect(found.content).to eq("The Content")
+          it 'calls the passed block' do
+            expect(found.content).to eq('The Content')
           end
 
-          it "keeps the document in the association" do
+          it 'keeps the document in the association' do
             expect(found.person).to eq(person)
           end
         end
 
-        context "when a criteria is attached" do
-
-          let(:found) do
-            person.posts.recent.find_or_create_by!(title: "Test")
-          end
+        context 'when a criteria is attached' do
+          let(:found) { person.posts.recent.find_or_create_by!(title: 'Test') }
 
-          it "sets the new document attributes" do
-            expect(found.title).to eq("Test")
+          it 'sets the new document attributes' do
+            expect(found.title).to eq('Test')
           end
 
-          it "returns a newly persisted document" do
+          it 'returns a newly persisted document' do
             expect(found).to be_persisted
           end
 
-          it "keeps the document in the association" do
+          it 'keeps the document in the association' do
             expect(found.person).to eq(person)
           end
         end
       end
     end
 
-    context "when the association is polymorphic" do
-
-      let(:movie) do
-        Movie.create!
-      end
-
-      let!(:rating) do
-        movie.ratings.create!(value: 1)
-      end
+    context 'when the association is polymorphic' do
+      let(:movie) { Movie.create! }
+      let!(:rating) { movie.ratings.create!(value: 1) }
 
-      context "when the document exists" do
-
-        let(:found) do
-          movie.ratings.find_or_create_by!(value: 1)
-        end
+      context 'when the document exists' do
+        let(:found) { movie.ratings.find_or_create_by!(value: 1) }
 
-        it "returns the document" do
+        it 'returns the document' do
           expect(found).to eq(rating)
         end
 
-        it "keeps the document in the association" do
+        it 'keeps the document in the association' do
           expect(found.ratable).to eq(movie)
         end
       end
 
-      context "when the document does not exist" do
-
-        let(:found) do
-          movie.ratings.find_or_create_by!(value: 3)
-        end
+      context 'when the document does not exist' do
+        let(:found) { movie.ratings.find_or_create_by!(value: 3) }
 
-        it "sets the new document attributes" do
+        it 'sets the new document attributes' do
           expect(found.value).to eq(3)
         end
 
-        it "returns a newly persisted document" do
+        it 'returns a newly persisted document' do
           expect(found).to be_persisted
         end
 
-        it "keeps the document in the association" do
+        it 'keeps the document in the association' do
           expect(found.ratable).to eq(movie)
         end
 
-        context "when validation fails" do
-
-          it "raises an error" do
-            expect {
-              movie.comments.find_or_create_by!(title: "")
-            }.to raise_error(Mongoid::Errors::Validations)
+        context 'when validation fails' do
+          it 'raises an error' do
+            expect { movie.comments.find_or_create_by!(title: '') }
+              .to raise_error(Mongoid::Errors::Validations)
           end
         end
       end
     end
   end
 
-  describe "#find_or_initialize_by" do
-
-    context "when the association is not polymorphic" do
-
-      let(:person) do
-        Person.create!
-      end
-
-      let!(:post) do
-        person.posts.create!(title: "Testing")
-      end
-
-      context "when the document exists" do
+  describe '#find_or_initialize_by' do
+    context 'when the association is not polymorphic' do
+      let(:person) { Person.create! }
+      let!(:post) { person.posts.create!(title: 'Testing') }
 
-        let(:found) do
-          person.posts.find_or_initialize_by(title: "Testing")
-        end
+      context 'when the document exists' do
+        let(:found) { person.posts.find_or_initialize_by(title: 'Testing') }
 
-        it "returns the document" do
+        it 'returns the document' do
           expect(found).to eq(post)
         end
       end
 
-      context "when the document does not exist" do
-
+      context 'when the document does not exist' do
         let(:found) do
-          person.posts.find_or_initialize_by(title: "Test") do |post|
-            post.content = "The Content"
+          person.posts.find_or_initialize_by(title: 'Test') do |post|
+            post.content = 'The Content'
           end
         end
 
-        it "sets the new document attributes" do
-          expect(found.title).to eq("Test")
+        it 'sets the new document attributes' do
+          expect(found.title).to eq('Test')
         end
 
-        it "returns a non persisted document" do
-          expect(found).to_not be_persisted
+        it 'returns a non persisted document' do
+          expect(found).not_to be_persisted
         end
 
-        it "calls the passed block" do
-          expect(found.content).to eq("The Content")
+        it 'calls the passed block' do
+          expect(found.content).to eq('The Content')
         end
       end
     end
 
-    context "when the association is polymorphic" do
-
-      let(:movie) do
-        Movie.create!
-      end
-
-      let!(:rating) do
-        movie.ratings.create!(value: 1)
-      end
+    context 'when the association is polymorphic' do
+      let(:movie) { Movie.create! }
+      let!(:rating) { movie.ratings.create!(value: 1) }
 
-      context "when the document exists" do
+      context 'when the document exists' do
+        let(:found) { movie.ratings.find_or_initialize_by(value: 1) }
 
-        let(:found) do
-          movie.ratings.find_or_initialize_by(value: 1)
-        end
-
-        it "returns the document" do
+        it 'returns the document' do
           expect(found).to eq(rating)
         end
       end
 
-      context "when the document does not exist" do
+      context 'when the document does not exist' do
+        let(:found) { movie.ratings.find_or_initialize_by(value: 3) }
 
-        let(:found) do
-          movie.ratings.find_or_initialize_by(value: 3)
-        end
-
-        it "sets the new document attributes" do
+        it 'sets the new document attributes' do
           expect(found.value).to eq(3)
         end
 
-        it "returns a non persisted document" do
-          expect(found).to_not be_persisted
+        it 'returns a non persisted document' do
+          expect(found).not_to be_persisted
         end
       end
     end
   end
 
-  describe "#initialize" do
-
-    context "when an illegal mixed association exists" do
+  describe '#initialize' do
+    context 'when an illegal mixed association exists' do
+      let(:post) { Post.new }
 
-      let(:post) do
-        Post.new
-      end
-
-      it "raises an error" do
-        expect {
-          post.videos
-        }.to raise_error(Mongoid::Errors::MixedRelations)
+      it 'raises an error' do
+        expect { post.videos }
+          .to raise_error(Mongoid::Errors::MixedRelations)
       end
     end
 
-    context "when a cyclic association exists" do
-
-      let(:post) do
-        Post.new
-      end
+    context 'when a cyclic association exists' do
+      let(:post) { Post.new }
 
-      it "does not raise an error" do
+      it 'does not raise an error' do
         expect(post.roles).to be_empty
       end
     end
   end
 
-  describe "#last" do
-
-    let(:person) do
-      Person.create!
-    end
-
-    let!(:persisted_post) do
-      person.posts.create!
-    end
-
-    context "when a new document is added" do
+  describe '#last' do
+    let(:person) { Person.create! }
 
-      let!(:new_post) do
-        person.posts.new
-      end
+    before { person.posts.create! }
 
-      context "when the target is subsequently loaded" do
+    context 'when a new document is added' do
+      let!(:new_post) { person.posts.new }
 
+      context 'when the target is subsequently loaded' do
         before do
           person.posts.entries
         end
 
-        it "returns the expected last document" do
+        it 'returns the expected last document' do
           expect(person.posts.last).to eq(new_post)
         end
       end
     end
   end
 
-  describe "#max" do
-
-    let(:person) do
-      Person.create!
-    end
-
-    let(:post_one) do
-      Post.create!(rating: 5)
-    end
+  describe '#max' do
+    let(:person) { Person.create! }
+    let(:post_one) { Post.create!(rating: 5) }
+    let(:post_two) { Post.create!(rating: 10) }
 
-    let(:post_two) do
-      Post.create!(rating: 10)
+    # rubocop:disable Performance/CompareWithBlock
+    let(:max) do
+      person.posts.max do |a, b|
+        a.rating <=> b.rating
+      end
     end
+    # rubocop:enable Performance/CompareWithBlock
 
     before do
       person.posts.push(post_one, post_two)
     end
 
-    let(:max) do
-      person.posts.max do |a,b|
-        a.rating <=> b.rating
-      end
-    end
-
-    it "returns the document with the max value of the supplied field" do
+    it 'returns the document with the max value of the supplied field' do
       expect(max).to eq(post_two)
     end
   end
 
-  describe "#max_by" do
-
-    let(:person) do
-      Person.create!
-    end
-
-    let(:post_one) do
-      Post.create!(rating: 5)
-    end
-
-    let(:post_two) do
-      Post.create!(rating: 10)
-    end
+  describe '#max_by' do
+    let(:person) { Person.create! }
+    let(:post_one) { Post.create!(rating: 5) }
+    let(:post_two) { Post.create!(rating: 10) }
+    let(:max) { person.posts.max_by(&:rating) }
 
     before do
       person.posts.push(post_one, post_two)
     end
 
-    let(:max) do
-      person.posts.max_by(&:rating)
-    end
-
-    it "returns the document with the max value of the supplied field" do
+    it 'returns the document with the max value of the supplied field' do
       expect(max).to eq(post_two)
     end
   end
 
-  describe "#method_missing" do
+  describe '#method_missing' do
+    let!(:person) { Person.create! }
+    let!(:post_one) { person.posts.create!(title: 'First', content: 'Posting') }
 
-    let!(:person) do
-      Person.create!
-    end
-
-    let!(:post_one) do
-      person.posts.create!(title: "First", content: "Posting")
-    end
-
-    let!(:post_two) do
-      person.posts.create!(title: "Second", content: "Testing")
+    before do
+      person.posts.create!(title: 'Second', content: 'Testing')
     end
 
-    context "when providing a single criteria" do
-
-      let(:posts) do
-        person.posts.where(title: "First")
-      end
+    context 'when providing a single criteria' do
+      let(:posts) { person.posts.where(title: 'First') }
 
-      it "applies the criteria to the documents" do
+      it 'applies the criteria to the documents' do
         expect(posts).to eq([ post_one ])
       end
 
       context 'when providing a collation' do
-        min_server_version '3.4'
+        let(:posts) { person.posts.where(title: 'FIRST').collation(locale: 'en_US', strength: 2) }
 
-        let(:posts) do
-          person.posts.where(title: "FIRST").collation(locale: 'en_US', strength: 2)
-        end
-
-        it "applies the collation option to the query" do
+        it 'applies the collation option to the query' do
           expect(posts).to eq([ post_one ])
         end
       end
     end
 
-    context "when providing a criteria class method" do
-
-      let(:posts) do
-        person.posts.posting
-      end
+    context 'when providing a criteria class method' do
+      let(:posts) { person.posts.posting }
 
-      it "applies the criteria to the documents" do
+      it 'applies the criteria to the documents' do
         expect(posts).to eq([ post_one ])
       end
     end
 
-    context "when chaining criteria" do
+    context 'when chaining criteria' do
+      let(:posts) { person.posts.posting.where(:title.in => [ 'First' ]) }
 
-      let(:posts) do
-        person.posts.posting.where(:title.in => [ "First" ])
-      end
-
-      it "applies the criteria to the documents" do
+      it 'applies the criteria to the documents' do
         expect(posts).to eq([ post_one ])
       end
     end
 
-    context "when delegating methods" do
-
-      describe "#distinct" do
-
-        let(:values) do
-          person.posts.distinct(:title)
-        end
+    context 'when delegating methods' do
+      describe '#distinct' do
+        let(:values) { person.posts.distinct(:title) }
 
-        it "returns the distinct values for the fields" do
-          expect(values).to include("First")
-          expect(values).to include("Second")
+        it 'returns the distinct values for the fields' do
+          expect(values).to include('First')
+          expect(values).to include('Second')
         end
       end
     end
   end
 
-  describe "#min" do
-
-    let(:person) do
-      Person.create!
-    end
-
-    let(:post_one) do
-      Post.create!(rating: 5)
-    end
-
-    let(:post_two) do
-      Post.create!(rating: 10)
-    end
-
-    before do
-      person.posts.push(post_one, post_two)
-    end
+  describe '#min' do
+    let(:person) { Person.create! }
+    let(:post_one) { Post.create!(rating: 5) }
+    let(:post_two) { Post.create!(rating: 10) }
 
+    # rubocop:disable Performance/CompareWithBlock
     let(:min) do
       person.posts.min do |a, b|
         a.rating <=> b.rating
       end
     end
+    # rubocop:enable Performance/CompareWithBlock
 
-    it "returns the min value of the supplied field" do
-      expect(min).to eq(post_one)
+    before do
+      person.posts.push(post_one, post_two)
     end
-  end
 
-  describe "#min_by" do
-
-    let(:person) do
-      Person.create!
+    it 'returns the min value of the supplied field' do
+      expect(min).to eq(post_one)
     end
+  end
 
-    let(:post_one) do
-      Post.create!(rating: 5)
-    end
+  describe '#min_by' do
+    let(:person) { Person.create! }
+    let(:post_one) { Post.create!(rating: 5) }
 
-    let(:post_two) do
-      Post.create!(rating: 10)
-    end
+    let(:post_two) { Post.create!(rating: 10) }
+    let(:min) { person.posts.min_by(&:rating) }
 
     before do
       person.posts.push(post_one, post_two)
     end
 
-    let(:min) do
-      person.posts.min_by(&:rating)
-    end
-
-    it "returns the min value of the supplied field" do
+    it 'returns the min value of the supplied field' do
       expect(min).to eq(post_one)
     end
   end
 
-  describe "#nullify_all" do
-
-    context "when the inverse has not been loaded" do
-
-      let(:person) do
-        Person.create!
-      end
-
-      let!(:post_one) do
-        person.posts.create!(title: "One")
-      end
-
-      let!(:post_two) do
-        person.posts.create!(title: "Two")
-      end
-
-      let(:from_db) do
-        Person.first
-      end
+  describe '#nullify_all' do
+    context 'when the inverse has not been loaded' do
+      let(:person) { Person.create! }
+      let(:from_db) { Person.first }
 
       before do
+        person.posts.create!(title: 'One')
+        person.posts.create!(title: 'Two')
         from_db.posts.nullify_all
       end
 
-      it "loads the targets before nullifying" do
+      it 'loads the targets before nullifying' do
         expect(from_db.posts).to be_empty
       end
 
-      it "persists the base nullifications" do
+      it 'persists the base nullifications' do
         expect(Person.first.posts).to be_empty
       end
 
-      it "persists the inverse nullifications" do
+      it 'persists the inverse nullifications' do
         Post.all.each do |post|
           expect(post.person).to be_nil
         end
       end
     end
 
-    context "when the association is not polymorphic" do
-
-      let(:person) do
-        Person.create!
-      end
-
-      let!(:post_one) do
-        person.posts.create!(title: "One")
-      end
-
-      let!(:post_two) do
-        person.posts.create!(title: "Two")
-      end
+    context 'when the association is not polymorphic' do
+      let(:person) { Person.create! }
+      let!(:post_one) { person.posts.create!(title: 'One') }
+      let!(:post_two) { person.posts.create!(title: 'Two') }
 
       before do
         person.posts.nullify_all
       end
 
-      it "removes all the foreign keys from the target" do
+      it 'removes all the foreign keys from the target' do
         [ post_one, post_two ].each do |post|
           expect(post.person_id).to be_nil
         end
       end
 
-      it "removes all the references from the target" do
+      it 'removes all the references from the target' do
         [ post_one, post_two ].each do |post|
           expect(post.person).to be_nil
         end
       end
 
-      it "saves the documents" do
+      it 'saves the documents' do
         expect(post_one.reload.person).to be_nil
       end
 
-      context "when adding a nullified document back to the association" do
-
+      context 'when adding a nullified document back to the association' do
         before do
           person.posts.push(post_one)
         end
 
-        it "persists the association" do
+        it 'persists the association' do
           expect(person.posts(true)).to eq([ post_one ])
         end
       end
     end
 
-    context "when the association is polymorphic" do
-
-      let(:movie) do
-        Movie.create!(title: "Oldboy")
-      end
-
-      let!(:rating_one) do
-        movie.ratings.create!(value: 10)
-      end
-
-      let!(:rating_two) do
-        movie.ratings.create!(value: 9)
-      end
+    context 'when the association is polymorphic' do
+      let(:movie) { Movie.create!(title: 'Oldboy') }
+      let!(:rating_one) { movie.ratings.create!(value: 10) }
+      let!(:rating_two) { movie.ratings.create!(value: 9) }
 
       before do
         movie.ratings.nullify_all
       end
 
-      it "removes all the foreign keys from the target" do
+      it 'removes all the foreign keys from the target' do
         [ rating_one, rating_two ].each do |rating|
           expect(rating.ratable_id).to be_nil
         end
       end
 
-      it "removes all the references from the target" do
+      it 'removes all the references from the target' do
         [ rating_one, rating_two ].each do |rating|
           expect(rating.ratable).to be_nil
         end
@@ -3473,443 +2737,323 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
     end
   end
 
-  describe "#respond_to?" do
-
-    let(:person) do
-      Person.new
-    end
-
-    let(:posts) do
-      person.posts
-    end
+  describe '#respond_to?' do
+    let(:person) { Person.new }
+    let(:posts) { person.posts }
 
     Array.public_instance_methods.each do |method|
-
       context "when checking #{method}" do
-
-        it "returns true" do
+        it 'returns true' do
           expect(posts.respond_to?(method)).to be true
         end
       end
     end
 
-    Mongoid::Association::Referenced::HasMany::Proxy.public_instance_methods.each do |method|
-
+    described_class.public_instance_methods.each do |method|
       context "when checking #{method}" do
-
-        it "returns true" do
+        it 'returns true' do
           expect(posts.respond_to?(method)).to be true
         end
       end
     end
 
-    Post.scopes.keys.each do |method|
-
+    Post.scopes.each_key do |method|
       context "when checking #{method}" do
-
-        it "returns true" do
+        it 'returns true' do
           expect(posts.respond_to?(method)).to be true
         end
       end
     end
   end
 
-  describe "#scoped" do
-
-    let(:person) do
-      Person.new
-    end
+  describe '#scoped' do
+    let(:person) { Person.new }
+    let(:scoped) { person.posts.scoped }
 
-    let(:scoped) do
-      person.posts.scoped
-    end
-
-    it "returns the association criteria" do
+    it 'returns the association criteria' do
       expect(scoped).to be_a(Mongoid::Criteria)
     end
 
-    it "returns with an empty selector" do
-      expect(scoped.selector).to eq({ "person_id" => person.id })
+    it 'returns with an empty selector' do
+      expect(scoped.selector).to eq({ 'person_id' => person.id })
     end
   end
 
-  [ :size, :length ].each do |method|
-
+  %i[ size length ].each do |method|
     describe "##{method}" do
+      let(:movie) { Movie.create! }
 
-      let(:movie) do
-        Movie.create!
-      end
-
-      context "when documents have been persisted" do
-
-        let!(:rating) do
+      context 'when documents have been persisted' do
+        before do
           movie.ratings.create!(value: 1)
         end
 
-        it "returns 1" do
+        it 'returns 1' do
           expect(movie.ratings.send(method)).to eq(1)
         end
       end
 
-      context "when documents have not been persisted" do
-
+      context 'when documents have not been persisted' do
         before do
           movie.ratings.build(value: 1)
           movie.ratings.create!(value: 2)
         end
 
-        it "returns the total number of documents" do
+        it 'returns the total number of documents' do
           expect(movie.ratings.send(method)).to eq(2)
         end
       end
     end
   end
 
-  describe "#unscoped" do
-
-    context "when the association has no default scope" do
+  describe '#unscoped' do
+    context 'when the association has no default scope' do
+      before { Post.create!(title: 'unattributed') }
 
-      let!(:person) do
-        Person.create!
-      end
+      let!(:person) { Person.create! }
+      let!(:post_one) { person.posts.create!(title: 'first') }
+      let(:unscoped) { person.posts.unscoped }
 
-      let!(:post_one) do
-        person.posts.create!(title: "first")
-      end
-
-      let!(:post_two) do
-        Post.create!(title: "second")
-      end
-
-      let(:unscoped) do
-        person.posts.unscoped
-      end
-
-      it "returns only the associated documents" do
+      it 'returns only the associated documents' do
         expect(unscoped).to eq([ post_one ])
       end
     end
 
-    context "when the association has a default scope" do
-
-      let!(:church) do
-        Church.create!
-      end
-
-      let!(:acolyte_one) do
-        church.acolytes.create!(name: "first")
-      end
-
-      let!(:acolyte_two) do
-        Acolyte.create!(name: "second")
-      end
+    context 'when the association has a default scope' do
+      before { Acolyte.create!(name: 'unaffiliated') }
 
-      let(:unscoped) do
-        church.acolytes.unscoped
-      end
+      let!(:church) { Church.create! }
+      let!(:acolyte_one) { church.acolytes.create!(name: 'first') }
+      let(:unscoped) { church.acolytes.unscoped }
 
-      it "only returns associated documents" do
+      it 'only returns associated documents' do
         expect(unscoped).to eq([ acolyte_one ])
       end
 
-      it "removes the default scoping options" do
+      it 'removes the default scoping options' do
         expect(unscoped.options).to eq({})
       end
     end
   end
 
-  context "when the association has an order defined" do
-
-    let(:person) do
-      Person.create!
-    end
-
-    let(:post_one) do
-      OrderedPost.create!(rating: 10, title: '1')
-    end
-
-    let(:post_two) do
-      OrderedPost.create!(rating: 20, title: '2')
-    end
+  context 'when the association has an order defined' do
+    let(:person) { Person.create! }
+    let(:post_one) { OrderedPost.create!(rating: 10, title: '1') }
 
-    let(:post_three) do
-      OrderedPost.create!(rating: 20, title: '3')
-    end
+    let(:post_two) { OrderedPost.create!(rating: 20, title: '2') }
+    let(:post_three) { OrderedPost.create!(rating: 20, title: '3') }
 
     before do
       person.ordered_posts.nullify_all
       person.ordered_posts.push(post_one, post_two, post_three)
     end
 
-    it "order documents" do
-      expect(person.ordered_posts(true)).to eq(
-                                                [post_two, post_three, post_one]
-                                            )
+    it 'order documents' do
+      expect(person.ordered_posts(true))
+        .to eq [ post_two, post_three, post_one ]
     end
 
-    it "chaining order criteria" do
-      expect(person.ordered_posts.order_by(:title.desc).to_a).to eq(
-                                                                     [post_three, post_two, post_one]
-                                                                 )
+    it 'chaining order criteria' do
+      expect(person.ordered_posts.order_by(:title.desc).to_a)
+        .to eq [ post_three, post_two, post_one ]
     end
   end
 
-  context "when reloading the association" do
+  context 'when reloading the association' do
+    let!(:person) { Person.create! }
+    let!(:post_one) { Post.create!(title: 'one') }
 
-    let!(:person) do
-      Person.create!
-    end
-
-    let!(:post_one) do
-      Post.create!(title: "one")
-    end
-
-    let!(:post_two) do
-      Post.create!(title: "two")
-    end
+    let!(:post_two) { Post.create!(title: 'two') }
 
     before do
       person.posts << post_one
     end
 
-    context "when the association references the same documents" do
-
+    context 'when the association references the same documents' do
       before do
-        Post.collection.find({ _id: post_one.id }).
-            update_one({ "$set" => { title: "reloaded" }})
+        Post.collection.find({ _id: post_one.id })
+            .update_one({ '$set' => { title: 'reloaded' } })
       end
 
-      let(:reloaded) do
-        person.posts(true)
-      end
+      let(:reloaded) { person.posts(true) }
 
-      it "reloads the document from the database" do
-        expect(reloaded.first.title).to eq("reloaded")
+      it 'reloads the document from the database' do
+        expect(reloaded.first.title).to eq('reloaded')
       end
     end
 
-    context "when the association references different documents" do
-
+    context 'when the association references different documents' do
       before do
         person.posts << post_two
       end
 
-      let(:reloaded) do
-        person.posts(true)
-      end
+      let(:reloaded) { person.posts(true) }
 
-      it "reloads the first document from the database" do
+      it 'reloads the first document from the database' do
         expect(reloaded).to include(post_one)
       end
 
-      it "reloads the new document from the database" do
+      it 'reloads the new document from the database' do
         expect(reloaded).to include(post_two)
       end
     end
   end
 
-  context "when the parent is using integer ids" do
-
+  context 'when the parent is using integer ids' do
     let(:jar) do
       Jar.create! do |doc|
         doc._id = 1
       end
     end
 
-    it "allows creation of the document" do
+    it 'allows creation of the document' do
       expect(jar.id).to eq(1)
     end
   end
 
-  context "when adding a document" do
+  context 'when adding a document' do
+    let(:person) { Person.new }
+    let(:post_one) { Post.new }
+    let(:first_add) { person.posts.push(post_one) }
 
-    let(:person) do
-      Person.new
-    end
+    context 'when chaining a second add' do
+      let(:post_two) { Post.new }
+      let(:result) { first_add.push(post_two) }
 
-    let(:post_one) do
-      Post.new
-    end
-
-    let(:first_add) do
-      person.posts.push(post_one)
-    end
-
-    context "when chaining a second add" do
-
-      let(:post_two) do
-        Post.new
-      end
-
-      let(:result) do
-        first_add.push(post_two)
-      end
-
-      it "adds both documents" do
+      it 'adds both documents' do
         expect(result).to eq([ post_one, post_two ])
       end
     end
   end
 
-  context "when pushing with a before_add callback" do
-
-    let(:artist) do
-      Artist.new
-    end
-
-    let(:album) do
-      Album.new
-    end
-
-    context "when execution raises no errors" do
+  context 'when pushing with a before_add callback' do
+    let(:artist) { Artist.new }
+    let(:album) { Album.new }
 
+    context 'when execution raises no errors' do
       before do
         artist.albums << album
       end
 
-      it "it executes method callbacks" do
+      it 'executes method callbacks' do
         expect(artist.before_add_referenced_called).to be true
       end
 
-      it "it executes proc callbacks" do
+      it 'executes proc callbacks' do
         expect(album.before_add_called).to be true
       end
 
-      it "adds the document to the association" do
+      it 'adds the document to the association' do
         expect(artist.albums).to eq([ album ])
       end
     end
 
-    context "when execution raises errors" do
-
+    context 'when execution raises errors' do
       before do
-        expect(artist).to receive(:before_add_album).and_raise
-        begin; artist.albums << album; rescue; end
+        allow(artist).to receive(:before_add_album).and_raise
       end
 
-      it "does not add the document to the association" do
+      it 'does not add the document to the association' do
+        expect { artist.albums << album }.to raise_error(StandardError)
         expect(artist.albums).to be_empty
       end
     end
   end
 
-  context "when pushing with an after_add callback" do
+  context 'when pushing with an after_add callback' do
+    let(:artist) { Artist.new }
+    let(:album) { Album.new }
 
-    let(:artist) do
-      Artist.new
-    end
-
-    let(:album) do
-      Album.new
-    end
-
-    it "executes the callback" do
+    it 'executes the callback' do
       artist.albums << album
       expect(artist.after_add_referenced_called).to be true
     end
 
-    context "when execution raises errors" do
-
+    context 'when execution raises errors' do
       before do
-        expect(artist).to receive(:after_add_album).and_raise
-        begin; artist.albums << album; rescue; end
+        allow(artist).to receive(:after_add_album).and_raise
       end
 
-      it "adds the document to the association" do
+      it 'adds the document to the association' do
+        expect { artist.albums << album }.to raise_error(StandardError)
         expect(artist.albums).to eq([ album ])
       end
     end
 
     context 'when the association already exists' do
-
       before do
         artist.albums << album
         album.save!
         artist.save!
-        expect(artist).not_to receive(:after_add_album)
       end
 
       let(:reloaded_album) do
-        Album.where(artist_id: artist.id).first
+        Album.where(artist_id: artist.id).first.tap do |a|
+          allow(a.artist).to receive(:after_add_album)
+        end
       end
 
+      let(:reloaded_album_artist) { reloaded_album.artist }
+
       it 'does not execute the callback when the association is accessed' do
-        expect(reloaded_album.artist.after_add_referenced_called).to be(nil)
+        expect(reloaded_album_artist.after_add_referenced_called).to be_nil
+        expect(reloaded_album_artist).not_to have_received(:after_add_album)
       end
     end
   end
 
-  context "when #delete or #clear with before_remove callback" do
-
-    let(:artist) do
-      Artist.new
-    end
-
-    let(:album) do
-      Album.new
-    end
+  context 'when #delete or #clear with before_remove callback' do
+    let(:artist) { Artist.new }
+    let(:album) { Album.new }
 
     before do
       artist.albums << album
     end
 
-    context "when executing raises no errors" do
-
-      describe "#delete" do
-
+    context 'when executing raises no errors' do
+      describe '#delete' do
         before do
           artist.albums.delete album
         end
 
-        it "executes the callback" do
+        it 'executes the callback' do
           expect(artist.before_remove_referenced_called).to be true
         end
 
-        it "removes the document from the association" do
+        it 'removes the document from the association' do
           expect(artist.albums).to be_empty
         end
       end
 
-      describe "#clear" do
-
+      describe '#clear' do
         before do
           artist.albums.clear
         end
 
-        it "executes the callback" do
+        it 'executes the callback' do
           expect(artist.before_remove_referenced_called).to be true
         end
 
-        it "clears the association" do
+        it 'clears the association' do
           expect(artist.albums).to be_empty
         end
       end
 
-      context "when execution raises errors" do
-
+      context 'when execution raises errors' do
         before do
-          expect(artist).to receive(:before_remove_album).and_raise
+          allow(artist).to receive(:before_remove_album).and_raise
         end
 
-        describe "#delete" do
-
-          before do
-            begin; artist.albums.delete(album); rescue; end
-          end
-
-          it "does not remove the document from the association" do
+        describe '#delete' do
+          it 'does not remove the document from the association' do
+            expect { artist.albums.delete(album) }.to raise_error(StandardError)
             expect(artist.albums).to eq([ album ])
           end
         end
 
-        describe "#clear" do
-
-          before do
-            begin; artist.albums.clear; rescue; end
-          end
-
-          it "does not clear the association" do
+        describe '#clear' do
+          it 'does not clear the association' do
+            expect { artist.albums.clear }.to raise_error(StandardError)
             expect(artist.albums).to eq([ album ])
           end
         end
@@ -3917,130 +3061,83 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
     end
   end
 
-  context "when #delete or #clear with after_remove callback" do
-
-    let(:artist) do
-      Artist.new
-    end
-
-    let(:album) do
-      Album.new
-    end
+  context 'when #delete or #clear with after_remove callback' do
+    let(:artist) { Artist.new }
+    let(:album) { Album.new }
 
     before do
       artist.albums << album
     end
 
-    context "without errors" do
-
-      describe "#delete" do
-
-        before do
-          artist.albums.delete album
-        end
-
-        it "executes the callback" do
+    context 'without errors' do
+      describe '#delete' do
+        it 'executes the callback' do
+          expect { artist.albums.delete album }.not_to raise_error
           expect(artist.after_remove_referenced_called).to be true
         end
       end
 
-      describe "#clear" do
-
-        before do
-          artist.albums.clear
-        end
-
-        it "executes the callback" do
-          artist.albums.clear
+      describe '#clear' do
+        it 'executes the callback' do
+          expect { artist.albums.clear }.not_to raise_error
           expect(artist.after_remove_referenced_called).to be true
         end
       end
     end
 
-    context "when errors are raised" do
-
+    context 'when errors are raised' do
       before do
-        expect(artist).to receive(:after_remove_album).and_raise
+        allow(artist).to receive(:after_remove_album).and_raise
       end
 
-      describe "#delete" do
-
-        before do
-          begin; artist.albums.delete(album); rescue; end
-        end
-
-        it "removes the documents from the association" do
+      describe '#delete' do
+        it 'removes the documents from the association' do
+          expect { artist.albums.delete(album) }.to raise_error(StandardError)
           expect(artist.albums).to be_empty
         end
       end
 
-      describe "#clear" do
-
-        before do
-          begin; artist.albums.clear; rescue; end
-        end
-
-        it "removes the documents from the association" do
+      describe '#clear' do
+        it 'removes the documents from the association' do
+          expect { artist.albums.clear }.to raise_error(StandardError)
           expect(artist.albums).to be_empty
         end
       end
     end
   end
 
-  context "when executing a criteria call on an ordered association" do
-
-    let(:person) do
-      Person.create!
-    end
-
-    let!(:post_one) do
-      person.ordered_posts.create!(rating: 1)
-    end
-
-    let!(:post_two) do
-      person.ordered_posts.create!(rating: 5)
-    end
+  context 'when executing a criteria call on an ordered association' do
+    let(:person) { Person.create! }
+    let!(:post_one) { person.ordered_posts.create!(rating: 1) }
 
-    let(:criteria) do
-      person.ordered_posts.only(:_id, :rating)
-    end
+    let!(:post_two) { person.ordered_posts.create!(rating: 5) }
+    let(:criteria) { person.ordered_posts.only(:_id, :rating) }
 
-    it "does not drop the ordering" do
+    it 'does not drop the ordering' do
       expect(criteria).to eq([ post_two, post_one ])
     end
   end
 
-  context "when accessing a scope named open" do
-
-    let(:person) do
-      Person.create!
-    end
-
-    let!(:post) do
-      person.posts.create!(title: "open")
-    end
+  context 'when accessing a scope named open' do
+    let(:person) { Person.create! }
+    let!(:post) { person.posts.create!(title: 'open') }
 
-    it "returns the appropriate documents" do
+    it 'returns the appropriate documents' do
       expect(person.posts.open).to eq([ post ])
     end
   end
 
-  context "when accessing a association named parent" do
-
-    let!(:parent) do
-      Odd.create!(name: "odd parent")
-    end
-
+  context 'when accessing a association named parent' do
+    let!(:parent) { Odd.create!(name: 'odd parent') }
     let(:child) do
-      Even.create!(parent_id: parent.id, name: "original even child")
+      Even
+        .create!(parent_id: parent.id, name: 'original even child')
+        .tap(&:parent) # preload the parent association
     end
 
-    it "updates the child after accessing the parent" do
-      # Access parent association on the child to make sure it is loaded
-      child.parent
-
-      new_child_name = "updated even child"
+    let(:new_child_name) { 'updated even child' }
 
+    it 'updates the child after accessing the parent' do
       child.name = new_child_name
       child.save!
 
@@ -4050,18 +3147,10 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
   end
 
   context 'when a document has referenced and embedded associations' do
+    let(:agent) { Agent.new }
+    let(:basic) { Basic.new }
 
-    let(:agent) do
-      Agent.new
-    end
-
-    let(:basic) do
-      Basic.new
-    end
-
-    let(:address) do
-      Address.new
-    end
+    let(:address) { Address.new }
 
     before do
       agent.basics << basic
@@ -4074,14 +3163,8 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
   end
 
   context 'when the two models use the same name to refer to the association' do
-
-    let(:agent) do
-      Agent.new
-    end
-
-    let(:band) do
-      Band.new
-    end
+    let(:agent) { Agent.new }
+    let(:band) { Band.new }
 
     before do
       agent.same_name = band
@@ -4091,60 +3174,60 @@ describe Mongoid::Association::Referenced::HasMany::Proxy do
     end
 
     it 'constructs the correct criteria' do
-      expect(band.same_name).to eq([agent])
+      expect(band.same_name).to eq [ agent ]
     end
   end
 
-  context "when removing a document with counter_cache on" do
+  context 'when updating a document with counter_cache on' do
     let(:post) { Post.create! }
-    let(:person1) { Person.create! }
-    let(:person2) { Person.create! }
+    let(:arthur) { Person.create! }
+    let(:betty) { Person.create! }
 
-    before do
-      post.update_attribute(:person, person1)
-      expect(person1.posts_count).to eq 1
-
-      person2
-      post.update_attribute(:person, person2)
-      person1.reload
-      expect(person1.posts_count).to eq 0
-      expect(person2.posts_count).to eq 1
-
-      post.update_attribute(:person, nil)
-      person1.reload
-      person2.reload
+    context 'when setting an attribution' do
+      it 'sets the counter correctly' do
+        post.update_attribute(:person, arthur)
+        expect(arthur.reload.posts_count).to eq 1
+      end
     end
 
-    it "the count field is updated" do
-      expect(person2.posts_count).to eq 0
+    context 'when changing an attribution' do
+      it 'sets the counter correctly' do
+        post.update_attribute(:person, arthur)
+        post.update_attribute(:person, betty)
+        expect(arthur.reload.posts_count).to eq 0
+        expect(betty.reload.posts_count).to eq 1
+      end
     end
-  end
 
-  context "when there is a foreign key in the aliased associations" do
-    it "has the correct aliases" do
-      expect(Band.aliased_associations["artist_ids"]).to eq("artists")
-      expect(Artist.aliased_associations.key?("band_id")).to be false
-      expect(Artist.aliased_fields["band"]).to eq("band_id")
+    context 'when removing an attribution' do
+      it 'sets the counter correctly' do
+        post.update_attribute(:person, arthur)
+        post.update_attribute(:person, nil)
+        expect(arthur.reload.posts_count).to eq 0
+      end
     end
   end
 
-  context "when executing concat on foreign key array from the db" do
-    config_override :legacy_attributes, false
+  context 'when there is a foreign key in the aliased associations' do
+    it 'has the correct aliases' do
+      expect(Band.aliased_associations['artist_ids']).to eq('artists')
+      expect(Artist.aliased_associations.key?('band_id')).to be false
+      expect(Artist.aliased_fields['band']).to eq('band_id')
+    end
+  end
 
+  context 'when executing concat on foreign key array from the db' do
     before do
       Agent.create!
       Basic.create!
+      agent.basic_ids.push basic.id
     end
 
     let!(:agent) { Agent.first }
     let!(:basic) { Basic.first }
 
-    before do
-      agent.basic_ids.concat([basic.id])
-    end
-
-    it "works on the first attempt" do
-      expect(agent.basic_ids).to eq([basic.id])
+    it 'works on the first attempt' do
+      expect(agent.basic_ids).to eq [ basic.id ]
     end
   end
 end