mongoid 9.0.11 → 9.1.0

data/spec/mongoid/association/accessors_spec.rb

@@ -1,179 +1,154 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Association::Accessors do
-
   describe "\#{getter}?" do
-
     let(:person) do
       Person.create!
     end
 
-    context "when the association is a has one" do
-
-      context "when the association exists" do
-
+    context 'when the association is a has one' do
+      context 'when the association exists' do
         let!(:game) do
           person.build_game
         end
 
-        it "returns true" do
+        it 'returns true' do
           expect(person).to have_game
         end
       end
 
-      context "when the association does not exist" do
-
-        context "when not autobuilding" do
-
-          it "returns false" do
-            expect(person).to_not have_game
+      context 'when the association does not exist' do
+        context 'when not autobuilding' do
+          it 'returns false' do
+            expect(person).not_to have_game
           end
         end
 
-        context "when autobuilding" do
-
-          it "returns false" do
-            expect(person).to_not have_book
+        context 'when autobuilding' do
+          it 'returns false' do
+            expect(person).not_to have_book
           end
         end
       end
     end
 
-    context "when the association is a has many" do
-
-      context "when the association has documents" do
-
+    context 'when the association is a has many' do
+      context 'when the association has documents' do
         let!(:post) do
           person.posts.build
         end
 
-        it "returns true" do
+        it 'returns true' do
           expect(person).to have_posts
         end
       end
 
-      context "when the association does not have documents" do
-
-        it "returns false" do
-          expect(person).to_not have_posts
+      context 'when the association does not have documents' do
+        it 'returns false' do
+          expect(person).not_to have_posts
         end
       end
     end
 
-    context "when the association is a has and belongs to many" do
-
-      context "when the association has documents" do
-
+    context 'when the association is a has and belongs to many' do
+      context 'when the association has documents' do
         let!(:preference) do
           person.preferences.build
         end
 
-        it "returns true" do
+        it 'returns true' do
           expect(person).to have_preferences
         end
       end
 
-      context "when the association does not have documents" do
-
-        it "returns false" do
-          expect(person).to_not have_preferences
+      context 'when the association does not have documents' do
+        it 'returns false' do
+          expect(person).not_to have_preferences
         end
       end
     end
 
-    context "when the association is a belongs to" do
-
-      context "when the association is named next" do
-
+    context 'when the association is a belongs to' do
+      context 'when the association is named next' do
         let(:user) do
           User.create!
         end
 
-        it "allows the existence check" do
-          expect(user).to_not have_next
+        it 'allows the existence check' do
+          expect(user).not_to have_next
         end
       end
 
-      context "when the association exists" do
-
+      context 'when the association exists' do
         let!(:game) do
           person.build_game
         end
 
-        it "returns true" do
+        it 'returns true' do
           expect(game).to have_person
         end
       end
 
-      context "when the association does not exist" do
-
-        context "when the association does not autobuild" do
-
+      context 'when the association does not exist' do
+        context 'when the association does not autobuild' do
           let(:game) do
             Game.new
           end
 
-          it "returns false" do
-            expect(game).to_not have_person
+          it 'returns false' do
+            expect(game).not_to have_person
           end
         end
 
-        context "when the association autobuilds" do
-
+        context 'when the association autobuilds' do
           let(:book) do
             Book.new
           end
 
-          it "returns false" do
-            expect(book).to_not have_person
+          it 'returns false' do
+            expect(book).not_to have_person
           end
         end
       end
     end
 
-    context "when the association is an embeds one" do
-
-      context "when the association exists" do
-
+    context 'when the association is an embeds one' do
+      context 'when the association exists' do
         let!(:name) do
           person.build_name
         end
 
-        it "returns true" do
+        it 'returns true' do
           expect(person).to have_name
         end
       end
 
-      context "when the association does not exist" do
-
-        context "when the association does not autobuild" do
-
-          it "returns false" do
-            expect(person).to_not have_name
+      context 'when the association does not exist' do
+        context 'when the association does not autobuild' do
+          it 'returns false' do
+            expect(person).not_to have_name
           end
         end
 
-        context "when the association autobuilds" do
-
+        context 'when the association autobuilds' do
           let(:person) do
             Person.new
           end
 
-          it "returns false" do
-            expect(person).to_not have_passport
+          it 'returns false' do
+            expect(person).not_to have_passport
           end
         end
       end
 
-      context "when the association is set to nil first" do
+      context 'when the association is set to nil first' do
         let!(:name) do
           person.build_name
         end
 
-        it "returns true" do
+        it 'returns true' do
           person.name = nil
           person.name = name
           expect(person).to have_name
@@ -181,61 +156,53 @@ describe Mongoid::Association::Accessors do
       end
     end
 
-    context "when the association is an embeds many" do
-
-      context "when the association has documents" do
-
+    context 'when the association is an embeds many' do
+      context 'when the association has documents' do
         let!(:address) do
           person.addresses.build
         end
 
-        it "returns true" do
+        it 'returns true' do
           expect(person).to have_addresses
         end
       end
 
-      context "when the association does not have documents" do
-
-        it "returns false" do
-          expect(person).to_not have_addresses
+      context 'when the association does not have documents' do
+        it 'returns false' do
+          expect(person).not_to have_addresses
         end
       end
     end
 
-    context "when the association is an embedded in" do
-
-      context "when the association exists" do
-
+    context 'when the association is an embedded in' do
+      context 'when the association exists' do
         let!(:name) do
           person.build_name
         end
 
-        it "returns true" do
+        it 'returns true' do
           expect(name).to have_namable
         end
       end
 
-      context "when the association does not exist" do
-
-        context "when the association does not autobuild" do
-
+      context 'when the association does not exist' do
+        context 'when the association does not autobuild' do
           let(:name) do
             Name.new
           end
 
-          it "returns false" do
-            expect(name).to_not have_namable
+          it 'returns false' do
+            expect(name).not_to have_namable
           end
         end
 
-        context "when the association autobuilds" do
-
+        context 'when the association autobuilds' do
           let(:passport) do
             Passport.new
           end
 
-          it "returns false" do
-            expect(passport).to_not have_person
+          it 'returns false' do
+            expect(passport).not_to have_person
           end
         end
       end
@@ -243,300 +210,270 @@ describe Mongoid::Association::Accessors do
   end
 
   describe "\#{getter}" do
-
     let(:person) do
       Person.new
     end
 
-    context "when autobuilding the association" do
-
-      context "when the association is an embeds one" do
-
-        context "when the association does not exist" do
-
+    context 'when autobuilding the association' do
+      context 'when the association is an embeds one' do
+        context 'when the association does not exist' do
           let!(:passport) do
             person.passport
           end
 
-          it "builds the new document" do
+          it 'builds the new document' do
             expect(passport).to be_a(Passport)
           end
 
-          it "stores in the altered attribute" do
-            expect(person.as_document["pass"]).to eq(passport.attributes)
+          it 'stores in the altered attribute' do
+            expect(person.as_document['pass']).to eq(passport.attributes)
           end
         end
 
-        context "when the association exists" do
-
+        context 'when the association exists' do
           let!(:passport) do
-            person.build_passport(number: "123123321")
+            person.build_passport(number: '123123321')
           end
 
-          it "does not build a new document" do
+          it 'does not build a new document' do
             expect(person.passport).to eq(passport)
           end
-
         end
       end
 
-      context "when the association is an embedded in" do
-
+      context 'when the association is an embedded in' do
         let(:passport) do
           Passport.new
         end
 
-        context "when the association does not exist" do
-
+        context 'when the association does not exist' do
           let(:person) do
             passport.person
           end
 
-          it "builds the new document" do
+          it 'builds the new document' do
             expect(person).to be_a(Person)
           end
         end
 
-        context "when the association exists" do
-
+        context 'when the association exists' do
           let!(:person) do
-            passport.build_person(title: "sir")
+            passport.build_person(title: 'sir')
           end
 
-          it "does not build a new document" do
+          it 'does not build a new document' do
             expect(passport.person).to eq(person)
           end
         end
       end
 
-      context "when the association is a has one" do
-
-        context "when the association does not exist" do
-
+      context 'when the association is a has one' do
+        context 'when the association does not exist' do
           let(:book) do
             person.book
           end
 
-          it "builds the new document" do
+          it 'builds the new document' do
             expect(book).to be_a(Book)
           end
         end
 
-        context "when the association exists" do
-
+        context 'when the association exists' do
           let!(:book) do
-            person.build_book(title: "art of war")
+            person.build_book(title: 'art of war')
           end
 
-          it "does not build a new document" do
+          it 'does not build a new document' do
             expect(person.book).to eq(book)
           end
         end
       end
 
-      context "when the association is a belongs to" do
-
+      context 'when the association is a belongs to' do
         let(:book) do
           Book.new
         end
 
-        context "when the association does not exist" do
-
+        context 'when the association does not exist' do
           let(:person) do
             book.person
           end
 
-          it "builds the new document" do
+          it 'builds the new document' do
             expect(person).to be_a(Person)
           end
         end
 
-        context "when the association exists" do
-
+        context 'when the association exists' do
           let!(:person) do
-            book.build_person(title: "sir")
+            book.build_person(title: 'sir')
           end
 
-          it "does not build a new document" do
+          it 'does not build a new document' do
             expect(book.person).to eq(person)
           end
         end
       end
     end
 
-    context "when the association is not polymorphic" do
-
+    context 'when the association is not polymorphic' do
       let(:person) do
         Person.create!
       end
 
-      context "when the association is a many to many" do
-
+      context 'when the association is a many to many' do
         let!(:preference) do
-          Preference.create!(name: "Setting")
+          Preference.create!(name: 'Setting')
         end
 
         before do
           person.preferences << Preference.last
         end
 
-        context "when reloading the association directly" do
-
+        context 'when reloading the association directly' do
           let(:preferences) do
             person.preferences(true)
           end
 
-          it "reloads the correct documents" do
+          it 'reloads the correct documents' do
             expect(preferences).to eq([ preference ])
           end
 
-          it "reloads a new instance" do
-            expect(preferences.first).to_not equal(preference)
+          it 'reloads a new instance' do
+            expect(preferences.first).not_to equal(preference)
           end
         end
 
-        context "when reloading via the base document" do
-
+        context 'when reloading via the base document' do
           let(:preferences) do
             person.reload.preferences
           end
 
-          it "reloads the correct documents" do
+          it 'reloads the correct documents' do
             expect(preferences).to eq([ preference ])
           end
 
-          it "reloads a new instance" do
-            expect(preferences.first).to_not equal(preference)
+          it 'reloads a new instance' do
+            expect(preferences.first).not_to equal(preference)
           end
         end
 
-        context "when performing a fresh find on the base" do
-
+        context 'when performing a fresh find on the base' do
           let(:preferences) do
             Person.find(person.id).preferences
           end
 
-          it "reloads the correct documents" do
+          it 'reloads the correct documents' do
             expect(preferences).to eq([ preference ])
           end
         end
       end
 
-      context "when the association is a many to one" do
-
+      context 'when the association is a many to one' do
         let!(:post) do
-          Post.create!(title: "First!")
+          Post.create!(title: 'First!')
         end
 
         before do
           person.posts << Post.last
         end
 
-        context "when reloading the association directly" do
-
+        context 'when reloading the association directly' do
           let(:posts) do
             person.posts(true)
           end
 
-          it "reloads the correct documents" do
+          it 'reloads the correct documents' do
             expect(posts).to eq([ post ])
           end
 
-          it "reloads a new instance" do
-            expect(posts.first).to_not equal(post)
+          it 'reloads a new instance' do
+            expect(posts.first).not_to equal(post)
           end
         end
 
-        context "when reloading via the base document" do
-
+        context 'when reloading via the base document' do
           let(:posts) do
             person.reload.posts
           end
 
-          it "reloads the correct documents" do
+          it 'reloads the correct documents' do
             expect(posts).to eq([ post ])
           end
 
-          it "reloads a new instance" do
-            expect(posts.first).to_not equal(post)
+          it 'reloads a new instance' do
+            expect(posts.first).not_to equal(post)
           end
         end
 
-        context "when performing a fresh find on the base" do
-
+        context 'when performing a fresh find on the base' do
           let(:posts) do
             Person.find(person.id).posts
           end
 
-          it "reloads the correct documents" do
+          it 'reloads the correct documents' do
             expect(posts).to eq([ post ])
           end
         end
       end
 
-      context "when the association is a references one" do
-
+      context 'when the association is a references one' do
         let!(:game) do
-          Game.create!(name: "Centipeded")
+          Game.create!(name: 'Centipeded')
         end
 
         before do
           person.game = Game.last
         end
 
-        context "when reloading the association directly" do
-
+        context 'when reloading the association directly' do
           let(:reloaded_game) do
             person.game(true)
           end
 
-          it "reloads the correct documents" do
+          it 'reloads the correct documents' do
             expect(reloaded_game).to eq(game)
           end
 
-          it "reloads a new instance" do
-            expect(reloaded_game).to_not equal(game)
+          it 'reloads a new instance' do
+            expect(reloaded_game).not_to equal(game)
           end
         end
 
-        context "when reloading via the base document" do
-
+        context 'when reloading via the base document' do
           let(:reloaded_game) do
             person.reload.game
           end
 
-          it "reloads the correct documents" do
+          it 'reloads the correct documents' do
             expect(reloaded_game).to eq(game)
           end
 
-          it "reloads a new instance" do
-            expect(reloaded_game).to_not equal(game)
+          it 'reloads a new instance' do
+            expect(reloaded_game).not_to equal(game)
           end
         end
 
-        context "when performing a fresh find on the base" do
-
+        context 'when performing a fresh find on the base' do
           let(:reloaded_game) do
             Person.find(person.id).game
           end
 
-          it "reloads the correct documents" do
+          it 'reloads the correct documents' do
             expect(reloaded_game).to eq(game)
           end
         end
       end
     end
 
-    context "when the association is polymorphic" do
-
+    context 'when the association is polymorphic' do
       context "when there's a single references many/one" do
-
         let!(:movie) do
-          Movie.create!(title: "Inception")
+          Movie.create!(title: 'Inception')
         end
 
         let!(:book) do
-          Book.create!(title: "Jurassic Park")
+          Book.create!(title: 'Jurassic Park')
         end
 
         let!(:movie_rating) do
@@ -547,35 +484,32 @@ describe Mongoid::Association::Accessors do
           book.create_rating(value: 5)
         end
 
-        context "when accessing a referenced in" do
-
+        context 'when accessing a referenced in' do
           let!(:rating) do
             Rating.where(value: 10).first
           end
 
-          it "returns the correct document" do
+          it 'returns the correct document' do
             expect(rating.ratable).to eq(movie)
           end
         end
 
-        context "when accessing a references many" do
-
+        context 'when accessing a references many' do
           let(:ratings) do
             Movie.first.ratings
           end
 
-          it "returns the correct documents" do
+          it 'returns the correct documents' do
             expect(ratings).to eq([ movie_rating ])
           end
         end
 
-        context "when accessing a references one" do
-
+        context 'when accessing a references one' do
           let!(:rating) do
             Book.find(book.id).rating
           end
 
-          it "returns the correct document" do
+          it 'returns the correct document' do
             expect(rating).to eq(book_rating)
           end
         end
@@ -584,31 +518,31 @@ describe Mongoid::Association::Accessors do
 
     context 'when projecting' do
       context 'embeds_one' do
-
         let!(:person) do
-          Person.create!(passport: Passport.new(number: "123123321", country: "USA"))
+          Person.create!(passport: Passport.new(number: '123123321', country: 'USA'))
         end
 
-        context "when the record is queried with the embedded association projected" do
+        context 'when the record is queried with the embedded association projected' do
           let(:persisted_person) { Person.only(:passport).first }
 
           it 'creates an accessor for the projected embedded document' do
-            expect(persisted_person.passport.number).to eq("123123321")
-            expect(persisted_person.passport.country).to eq("USA")
+            expect(persisted_person.passport.number).to eq('123123321')
+            expect(persisted_person.passport.country).to eq('USA')
           end
         end
 
         context 'when the record is queried with a field on the embedded association projected' do
-          let(:persisted_person) { Person.only("pass.number").first }
+          let(:persisted_person) { Person.only('pass.number').first }
 
           it 'creates an accessor for the projected field on the embedded document' do
-            expect(persisted_person.passport.number).to eq("123123321")
+            expect(persisted_person.passport.number).to eq('123123321')
           end
 
           it 'does not create an accessor for another field on the embedded document' do
             expect do
               persisted_person.passport.country
-            end.to raise_error(Mongoid::Errors::AttributeNotLoaded, /Attempted to access attribute 'country' on Passport which was not loaded/)
+            end.to raise_error(Mongoid::Errors::AttributeNotLoaded,
+                               /Attempted to access attribute 'country' on Passport which was not loaded/)
           end
         end
 
@@ -626,19 +560,20 @@ describe Mongoid::Association::Accessors do
           end
 
           context 'association then field' do
-            let(:persisted_person) { Person.only(:pass, "pass.number").first }
+            let(:persisted_person) { Person.only(:pass, 'pass.number').first }
 
             context '4.2 server and lower' do
               max_server_version '4.2'
 
               it 'creates an accessor for the projected field on the embedded document' do
-                expect(persisted_person.passport.number).to eq("123123321")
+                expect(persisted_person.passport.number).to eq('123123321')
               end
 
               it 'does not create an accessor for another field on the embedded document' do
                 expect do
                   persisted_person.passport.country
-                end.to raise_error(Mongoid::Errors::AttributeNotLoaded, /Attempted to access attribute 'country' on Passport which was not loaded/)
+                end.to raise_error(Mongoid::Errors::AttributeNotLoaded,
+                                   /Attempted to access attribute 'country' on Passport which was not loaded/)
               end
             end
 
@@ -652,11 +587,11 @@ describe Mongoid::Association::Accessors do
               max_server_version '4.2'
 
               it 'creates an accessor for the projected field on the embedded document' do
-                expect(persisted_person.passport.number).to eq("123123321")
+                expect(persisted_person.passport.number).to eq('123123321')
               end
 
               it 'retrieves other fields' do
-                persisted_person.passport.country.should == 'USA'
+                persisted_person.passport.country.should eq 'USA'
               end
             end
 
@@ -666,11 +601,10 @@ describe Mongoid::Association::Accessors do
       end
 
       context 'embeds_many' do
-
         let!(:person) do
           Person.create!(phone_numbers: [
-            Phone.new(number: '111-111-1111', landline: true),
-          ])
+                           Phone.new(number: '111-111-1111', landline: true)
+                         ])
         end
 
         context 'when the record is queried with the embedded association projected' do
@@ -684,7 +618,7 @@ describe Mongoid::Association::Accessors do
 
         shared_examples 'allows access to field of projected association' do
           it 'creates an accessor for the embedded document' do
-            expect(persisted_person.phone_numbers.first).to be_a_kind_of(Phone)
+            expect(persisted_person.phone_numbers.first).to be_a(Phone)
           end
 
           it 'creates an accessor for the projected field on the embedded document' do
@@ -693,19 +627,19 @@ describe Mongoid::Association::Accessors do
         end
 
         context 'when the record is queried with a field on the embedded association projected' do
-          let(:persisted_person) { Person.only("phone_numbers.number").first }
+          let(:persisted_person) { Person.only('phone_numbers.number').first }
 
           include_examples 'allows access to field of projected association'
 
           it 'does not create an accessor for another field on the embedded document' do
             expect do
               persisted_person.phone_numbers.first.landline
-            end.to raise_error(Mongoid::Errors::AttributeNotLoaded, /Attempted to access attribute 'landline' on Phone which was not loaded/)
+            end.to raise_error(Mongoid::Errors::AttributeNotLoaded,
+                               /Attempted to access attribute 'landline' on Phone which was not loaded/)
           end
         end
 
         context 'when projecting association and a field in association' do
-
           shared_examples 'is prohibited on 4.4+ server' do
             context '4.4 server and higher' do
               min_server_version '4.4'
@@ -729,9 +663,9 @@ describe Mongoid::Association::Accessors do
               it 'does not create an accessor for another field on the embedded document' do
                 expect do
                   persisted_person.phone_numbers.first.landline
-                end.to raise_error(Mongoid::Errors::AttributeNotLoaded, /Attempted to access attribute 'landline' on Phone which was not loaded/)
+                end.to raise_error(Mongoid::Errors::AttributeNotLoaded,
+                                   /Attempted to access attribute 'landline' on Phone which was not loaded/)
               end
-
             end
 
             include_examples 'is prohibited on 4.4+ server'
@@ -757,120 +691,108 @@ describe Mongoid::Association::Accessors do
     end
   end
 
-  context "when setting associations to empty values" do
-
-    context "when the document is a referenced in" do
-
+  context 'when setting associations to empty values' do
+    context 'when the document is a referenced in' do
       let(:post) do
         Post.new
       end
 
-      context "when setting the association directly" do
-
+      context 'when setting the association directly' do
         before do
-          post.person = ""
+          post.person = ''
         end
 
-        it "converts them to nil" do
+        it 'converts them to nil' do
           expect(post.person).to be_nil
         end
       end
 
-      context "when setting the foreign key" do
-
+      context 'when setting the foreign key' do
         before do
-          post.person_id = ""
+          post.person_id = ''
         end
 
-        it "converts it to nil" do
+        it 'converts it to nil' do
           expect(post.person_id).to be_nil
         end
       end
     end
 
-    context "when the document is a references one" do
-
+    context 'when the document is a references one' do
       let(:person) do
         Person.new
       end
 
-      context "when setting the association directly" do
-
+      context 'when setting the association directly' do
         before do
-          person.game = ""
+          person.game = ''
         end
 
-        it "converts them to nil" do
+        it 'converts them to nil' do
           expect(person.game).to be_nil
         end
       end
 
-      context "when setting the foreign key" do
-
+      context 'when setting the foreign key' do
         let(:game) do
           Game.new
         end
 
         before do
-          game.person_id = ""
+          game.person_id = ''
         end
 
-        it "converts it to nil" do
+        it 'converts it to nil' do
           expect(game.person_id).to be_nil
         end
       end
     end
 
-    context "when the document is a references many" do
-
+    context 'when the document is a references many' do
       let(:person) do
         Person.new
       end
 
-      context "when setting the foreign key" do
-
+      context 'when setting the foreign key' do
         let(:post) do
           Post.new
         end
 
         before do
-          post.person_id = ""
+          post.person_id = ''
         end
 
-        it "converts it to nil" do
+        it 'converts it to nil' do
           expect(post.person).to be_nil
         end
       end
 
-      context "when setting the _ids accessor" do
-
+      context 'when setting the _ids accessor' do
         let(:post) do
           Post.create!
         end
 
         before do
-          person.post_ids = [ "" ]
+          person.post_ids = [ '' ]
         end
 
-        it "ignore blank values" do
+        it 'ignore blank values' do
           expect(person.post_ids).to be_empty
         end
       end
     end
 
-    context "when the document is a references many to many" do
-
+    context 'when the document is a references many to many' do
       let(:person) do
         Person.new
       end
 
-      context "when setting the foreign key" do
-
+      context 'when setting the foreign key' do
         before do
-          person.preference_ids = [ "", "" ]
+          person.preference_ids = [ '', '' ]
         end
 
-        it "does not add them" do
+        it 'does not add them' do
           expect(person.preference_ids).to be_empty
         end
       end
@@ -916,8 +838,7 @@ describe Mongoid::Association::Accessors do
     end
   end
 
-  context "when setting association foreign keys" do
-
+  context 'when setting association foreign keys' do
     let(:game) do
       Game.new
     end
@@ -926,67 +847,61 @@ describe Mongoid::Association::Accessors do
       Person.create!
     end
 
-    context "when value is an empty string" do
-
+    context 'when value is an empty string' do
       before do
-        game.person_id = ""
+        game.person_id = ''
         game.save!
       end
 
-      it "sets the foreign key to empty" do
+      it 'sets the foreign key to empty' do
         expect(game.reload.person_id).to be_blank
       end
     end
 
-    context "when value is a populated string" do
-
+    context 'when value is a populated string' do
       before do
         game.person_id = person.id.to_s
         game.save!
       end
 
-      it "sets the foreign key as ObjectID" do
+      it 'sets the foreign key as ObjectID' do
         expect(game.reload.person_id).to eq(person.id)
       end
     end
 
-    context "when value is a ObjectID" do
-
+    context 'when value is a ObjectID' do
       before do
         game.person_id = person.id
         game.save!
       end
 
-      it "keeps the foreign key as ObjectID" do
+      it 'keeps the foreign key as ObjectID' do
         expect(game.reload.person_id).to eq(person.id)
       end
     end
 
-    context "when setting ids multiple times on the association itself" do
-
+    context 'when setting ids multiple times on the association itself' do
       before do
         game.person = person.id
         game.person = person.id
       end
 
-      it "sets the association foreign key" do
+      it 'sets the association foreign key' do
         expect(game.person_id).to eq(person.id)
       end
 
-      it "sets the appropriate association" do
+      it 'sets the appropriate association' do
         expect(game.person).to eq(person)
       end
     end
   end
 
   context 'when setting the association more than once' do
-
     let(:person) do
       Person.create!
     end
 
     context 'when the association is a references one' do
-
       let(:game) do
         Game.create!
       end
@@ -1002,9 +917,8 @@ describe Mongoid::Association::Accessors do
     end
 
     context 'when the association is a references many' do
-
       let!(:preference) do
-        Preference.create!(name: "Setting")
+        Preference.create!(name: 'Setting')
       end
 
       before do
@@ -1017,7 +931,6 @@ describe Mongoid::Association::Accessors do
     end
 
     context 'when the association is an embeds one' do
-
       let!(:name) do
         Name.new
       end
@@ -1033,7 +946,6 @@ describe Mongoid::Association::Accessors do
     end
 
     context 'when the association is an embeds many' do
-
       let!(:address) do
         Address.new
       end