mongoid 9.0.11 → 9.1.0

data/spec/mongoid/association/macros_spec.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Association::Macros do
-
   class TestClass
     include Mongoid::Document
   end
@@ -24,10 +22,10 @@ describe Mongoid::Association::Macros do
   end
 
   describe 'Model loading' do
-
     let(:model_associations) do
       class TestModel
         include Mongoid::Document
+
         field :associations
       end
     end
@@ -37,286 +35,267 @@ describe Mongoid::Association::Macros do
     end
 
     it 'prohibits the use of :associations as an attribute' do
-      expect {
+      expect do
         model_associations
-      }.to raise_exception(Mongoid::Errors::InvalidField)
+      end.to raise_exception(Mongoid::Errors::InvalidField)
     end
   end
 
-  describe ".embedded_in" do
-
-    it "defines the macro" do
+  describe '.embedded_in' do
+    it 'defines the macro' do
       expect(klass).to respond_to(:embedded_in)
     end
 
     context 'when the relation name is invalid' do
-
       let(:relation) do
         klass.embedded_in(:fields)
       end
 
       it 'raises an InvalidRelation exception' do
-        expect {
+        expect do
           relation
-        }.to raise_exception(Mongoid::Errors::InvalidRelation)
+        end.to raise_exception(Mongoid::Errors::InvalidRelation)
       end
     end
 
-    context "when defining the relation" do
-
+    context 'when defining the relation' do
       before do
         klass.embedded_in(:person)
       end
 
-      it "adds the association to the klass" do
-        expect(klass.relations["person"]).to_not be_nil
+      it 'adds the association to the klass' do
+        expect(klass.relations['person']).not_to be_nil
       end
 
-      it "defines the getter" do
+      it 'defines the getter' do
         expect(klass.allocate).to respond_to(:person)
       end
 
-      it "defines the setter" do
+      it 'defines the setter' do
         expect(klass.allocate).to respond_to(:person=)
       end
 
-      it "creates the correct relation" do
-        expect(klass.relations["person"]).to be_a(
+      it 'creates the correct relation' do
+        expect(klass.relations['person']).to be_a(
           Mongoid::Association::Embedded::EmbeddedIn
         )
       end
 
-      it "does not add associated validations" do
+      it 'does not add associated validations' do
         expect(klass._validators).to be_empty
       end
 
       context 'when an invalid option is provided' do
-
         it 'raises an InvalidRelationOption exception' do
-          expect {
+          expect do
             klass.embedded_in(:person, sandwich: true)
-          }.to raise_exception(Mongoid::Errors::InvalidRelationOption)
+          end.to raise_exception(Mongoid::Errors::InvalidRelationOption)
         end
       end
 
-      context "association properties" do
-
+      context 'association properties' do
         let(:association) do
-          klass.relations["person"]
+          klass.relations['person']
         end
 
-        it "automatically adds the name" do
+        it 'automatically adds the name' do
           expect(association.name).to eq(:person)
         end
 
-        it "automatically adds the inverse class name" do
-          expect(association.inverse_class_name).to eq("TestClass")
+        it 'automatically adds the inverse class name' do
+          expect(association.inverse_class_name).to eq('TestClass')
         end
       end
     end
   end
 
-  describe ".embeds_many" do
-
-    it "defines the macro" do
+  describe '.embeds_many' do
+    it 'defines the macro' do
       expect(klass).to respond_to(:embeds_many)
     end
 
-    context "when defining the relation" do
+    context 'when defining the relation' do
+      before do
+        klass.embeds_many(:addresses)
+      end
 
       context 'when the relation name is invalid' do
-
         let(:relation) do
           klass.embeds_many(:fields)
         end
 
         it 'raises an InvalidRelation exception' do
-          expect {
+          expect do
             relation
-          }.to raise_exception(Mongoid::Errors::InvalidRelation)
+          end.to raise_exception(Mongoid::Errors::InvalidRelation)
         end
       end
 
-      before do
-        klass.embeds_many(:addresses)
-      end
-
-      it "adds the association to the klass" do
-        expect(klass.relations["addresses"]).to_not be_nil
+      it 'adds the association to the klass' do
+        expect(klass.relations['addresses']).not_to be_nil
       end
 
-      it "defines the getter" do
+      it 'defines the getter' do
         expect(klass.allocate).to respond_to(:addresses)
       end
 
-      it "defines the setter" do
+      it 'defines the setter' do
         expect(klass.allocate).to respond_to(:addresses=)
       end
 
-      it "creates the correct relation" do
-        expect(klass.relations["addresses"]).to be_a(
+      it 'creates the correct relation' do
+        expect(klass.relations['addresses']).to be_a(
           Mongoid::Association::Embedded::EmbedsMany
         )
       end
 
-      it "adds an associated validation" do
+      it 'adds an associated validation' do
         expect(klass._validators[:addresses].first).to be_a(
           Mongoid::Validatable::AssociatedValidator
         )
       end
 
       context 'when an invalid option is provided' do
-
         it 'raises an InvalidRelationOption exception' do
-          expect {
+          expect do
             klass.embeds_many(:addresses, sandwich: true)
-          }.to raise_exception(Mongoid::Errors::InvalidRelationOption)
+          end.to raise_exception(Mongoid::Errors::InvalidRelationOption)
         end
       end
 
-      context "association properties" do
-
+      context 'association properties' do
         let(:association) do
-          klass.relations["addresses"]
+          klass.relations['addresses']
         end
 
-        it "automatically adds the name" do
+        it 'automatically adds the name' do
           expect(association.name).to eq(:addresses)
         end
 
-        it "automatically adds the inverse class name" do
-          expect(association.inverse_class_name).to eq("TestClass")
+        it 'automatically adds the inverse class name' do
+          expect(association.inverse_class_name).to eq('TestClass')
         end
       end
     end
 
     context 'when defining order on relation' do
-
       before do
         klass.embeds_many(:addresses, order: :number.asc)
       end
 
       let(:association) do
-        klass.relations["addresses"]
+        klass.relations['addresses']
       end
 
-      it "adds association to klass" do
-        expect(association.order).to_not be_nil
+      it 'adds association to klass' do
+        expect(association.order).not_to be_nil
       end
 
-      it "returns Mongoid::Criteria::Queryable::Key" do
-        expect(association.order).to be_kind_of(Mongoid::Criteria::Queryable::Key)
+      it 'returns Mongoid::Criteria::Queryable::Key' do
+        expect(association.order).to be_a(Mongoid::Criteria::Queryable::Key)
       end
     end
 
-    context "when setting validate to false" do
-
+    context 'when setting validate to false' do
       before do
         klass.embeds_many(:addresses, validate: false)
       end
 
-      it "does not add associated validations" do
+      it 'does not add associated validations' do
         expect(klass._validators).to be_empty
       end
     end
   end
 
-  describe ".embeds_one" do
-
-    it "defines the macro" do
+  describe '.embeds_one' do
+    it 'defines the macro' do
       expect(klass).to respond_to(:embeds_one)
     end
 
-    context "when defining the relation" do
+    context 'when defining the relation' do
+      before do
+        klass.embeds_one(:name)
+      end
 
       context 'when the relation name is invalid' do
-
         let(:relation) do
           klass.embeds_one(:fields)
         end
 
         it 'raises an InvalidRelation exception' do
-          expect {
+          expect do
             relation
-          }.to raise_exception(Mongoid::Errors::InvalidRelation)
+          end.to raise_exception(Mongoid::Errors::InvalidRelation)
         end
       end
 
-      before do
-        klass.embeds_one(:name)
-      end
-
-      it "adds the association to the klass" do
-        expect(klass.relations["name"]).to_not be_nil
+      it 'adds the association to the klass' do
+        expect(klass.relations['name']).not_to be_nil
       end
 
-      it "defines the getter" do
+      it 'defines the getter' do
         expect(klass.allocate).to respond_to(:name)
       end
 
-      it "defines the setter" do
+      it 'defines the setter' do
         expect(klass.allocate).to respond_to(:name=)
       end
 
-      it "defines the builder" do
+      it 'defines the builder' do
         expect(klass.allocate).to respond_to(:build_name)
       end
 
-      it "defines the creator" do
+      it 'defines the creator' do
         expect(klass.allocate).to respond_to(:create_name)
       end
 
-      it "creates the correct relation" do
-        expect(klass.relations["name"]).to be_a(
+      it 'creates the correct relation' do
+        expect(klass.relations['name']).to be_a(
           Mongoid::Association::Embedded::EmbedsOne
         )
       end
 
-      it "adds an associated validation" do
+      it 'adds an associated validation' do
         expect(klass._validators[:name].first).to be_a(
           Mongoid::Validatable::AssociatedValidator
         )
       end
 
       context 'when an invalid option is provided' do
-
         it 'raises an InvalidRelationOption exception' do
-          expect {
+          expect do
             klass.embeds_one(:name, sandwich: true)
-          }.to raise_exception(Mongoid::Errors::InvalidRelationOption)
+          end.to raise_exception(Mongoid::Errors::InvalidRelationOption)
         end
       end
 
-      context "association properties" do
-
+      context 'association properties' do
         let(:association) do
-          klass.relations["name"]
+          klass.relations['name']
         end
 
-        it "automatically adds the name" do
+        it 'automatically adds the name' do
           expect(association.name).to eq(:name)
         end
 
-        it "automatically adds the inverse class name" do
-          expect(association.inverse_class_name).to eq("TestClass")
+        it 'automatically adds the inverse class name' do
+          expect(association.inverse_class_name).to eq('TestClass')
         end
       end
     end
 
-    context "when setting validate to false" do
-
+    context 'when setting validate to false' do
       before do
         klass.embeds_one(:name, validate: false)
       end
 
-      it "does not add associated validations" do
+      it 'does not add associated validations' do
         expect(klass._validators).to be_empty
       end
     end
   end
 
-  describe ".belongs_to" do
-
+  describe '.belongs_to' do
     let(:_class) do
       class RelationsTestClass
         include Mongoid::Document
@@ -352,33 +331,27 @@ describe Mongoid::Association::Macros do
       end
     end
 
-    it "defines the macro" do
+    it 'defines the macro' do
       expect(_class).to respond_to(:belongs_to)
     end
 
     context 'when the relation has options' do
-
       context 'when an invalid option is provided' do
-
         it 'raises an InvalidRelationOption exception' do
-          expect {
+          expect do
             klass.belongs_to(:person, sandwich: true)
-          }.to raise_exception(Mongoid::Errors::InvalidRelationOption)
+          end.to raise_exception(Mongoid::Errors::InvalidRelationOption)
         end
       end
 
       context 'when the relation has the option :required' do
-
         context 'when the relation does not have the :optional option' do
-
           context 'when :required is true' do
-
             let(:relation_options) do
               { required: true }
             end
 
             context 'when the default config is to require the association' do
-
               let(:default_require) { true }
 
               it 'requires the association' do
@@ -387,7 +360,6 @@ describe Mongoid::Association::Macros do
             end
 
             context 'when the default config is to not require the association' do
-
               let(:default_require) { false }
 
               it 'requires the association' do
@@ -397,13 +369,11 @@ describe Mongoid::Association::Macros do
           end
 
           context 'when :required is false' do
-
             let(:relation_options) do
               { required: false }
             end
 
             context 'when the default config is to require the association' do
-
               let(:default_require) { true }
 
               it 'does not require the association' do
@@ -412,7 +382,6 @@ describe Mongoid::Association::Macros do
             end
 
             context 'when the default config is to not require the association' do
-
               let(:default_require) { false }
 
               it 'does not require the association' do
@@ -423,11 +392,8 @@ describe Mongoid::Association::Macros do
         end
 
         context 'when the relation has the option :optional' do
-
           context 'when :required is true' do
-
             context 'when :optional is true' do
-
               let(:relation_options) do
                 {
                   required: true,
@@ -436,7 +402,6 @@ describe Mongoid::Association::Macros do
               end
 
               context 'when the default config is to require the association' do
-
                 let(:default_require) { true }
 
                 it 'requires the association' do
@@ -445,7 +410,6 @@ describe Mongoid::Association::Macros do
               end
 
               context 'when the default config is to not require the association' do
-
                 let(:default_require) { false }
 
                 it 'requires the association' do
@@ -455,7 +419,6 @@ describe Mongoid::Association::Macros do
             end
 
             context 'when :optional is false' do
-
               let(:relation_options) do
                 {
                   required: true,
@@ -464,7 +427,6 @@ describe Mongoid::Association::Macros do
               end
 
               context 'when the default config is to require the association' do
-
                 let(:default_require) { true }
 
                 it 'requires the association' do
@@ -473,7 +435,6 @@ describe Mongoid::Association::Macros do
               end
 
               context 'when the default config is to not require the association' do
-
                 let(:default_require) { false }
 
                 it 'requires the association' do
@@ -484,9 +445,7 @@ describe Mongoid::Association::Macros do
           end
 
           context 'when :required is false' do
-
             context 'when :optional is true' do
-
               let(:relation_options) do
                 {
                   required: false,
@@ -495,7 +454,6 @@ describe Mongoid::Association::Macros do
               end
 
               context 'when the default config is to require the association' do
-
                 let(:default_require) { true }
 
                 it 'does not require the association' do
@@ -504,7 +462,6 @@ describe Mongoid::Association::Macros do
               end
 
               context 'when the default config is to not require the association' do
-
                 let(:default_require) { true }
 
                 it 'does not require the association' do
@@ -514,7 +471,6 @@ describe Mongoid::Association::Macros do
             end
 
             context 'when :optional is false' do
-
               let(:relation_options) do
                 {
                   required: false,
@@ -523,7 +479,6 @@ describe Mongoid::Association::Macros do
               end
 
               context 'when the default config is to require the association' do
-
                 let(:default_require) { true }
 
                 it 'does not require the association' do
@@ -532,7 +487,6 @@ describe Mongoid::Association::Macros do
               end
 
               context 'when the default config is to not require the association' do
-
                 let(:default_require) { false }
 
                 it 'does not require the association' do
@@ -545,17 +499,13 @@ describe Mongoid::Association::Macros do
       end
 
       context 'when the relation does not have the option :required' do
-
         context 'when the relation has the option :optional' do
-
           context 'when :optional is true' do
-
             let(:relation_options) do
               { optional: true }
             end
 
             context 'when the default config is to require the association' do
-
               let(:default_require) { true }
 
               it 'does not require the association' do
@@ -564,7 +514,6 @@ describe Mongoid::Association::Macros do
             end
 
             context 'when the default config is to not require the association' do
-
               let(:default_require) { false }
 
               it 'does not require the association' do
@@ -574,13 +523,11 @@ describe Mongoid::Association::Macros do
           end
 
           context 'when :optional is false' do
-
             let(:relation_options) do
               { optional: false }
             end
 
             context 'when the default config is to require the association' do
-
               let(:default_require) { true }
 
               it 'requires the association' do
@@ -589,7 +536,6 @@ describe Mongoid::Association::Macros do
             end
 
             context 'when the default config is to not require the association' do
-
               let(:default_require) { false }
 
               it 'requires the association' do
@@ -602,9 +548,7 @@ describe Mongoid::Association::Macros do
     end
 
     context 'when the relation does not have options' do
-
       context 'when the default config is to require the association' do
-
         let(:default_require) { true }
 
         it 'requires the association' do
@@ -613,7 +557,6 @@ describe Mongoid::Association::Macros do
       end
 
       context 'when the default config is to not require the association' do
-
         let(:default_require) { false }
 
         it 'does not require the association' do
@@ -622,10 +565,8 @@ describe Mongoid::Association::Macros do
       end
     end
 
-    context "when the relation is polymorphic" do
-
-      context "when indexed is true" do
-
+    context 'when the relation is polymorphic' do
+      context 'when indexed is true' do
         before do
           klass.belongs_to(:relatable, polymorphic: true, index: true)
         end
@@ -634,425 +575,400 @@ describe Mongoid::Association::Macros do
           klass.index_specifications.first
         end
 
-        it "adds the background index to the definitions" do
+        it 'adds the background index to the definitions' do
           expect(index.key).to eq(relatable_id: 1, relatable_type: 1)
         end
       end
     end
 
-    context "when defining the relation" do
+    context 'when defining the relation' do
+      before do
+        klass.belongs_to(:person)
+      end
 
       context 'when the relation name is invalid' do
-
         let(:relation) do
           klass.belongs_to(:fields)
         end
 
         it 'raises an InvalidRelation exception' do
-          expect {
+          expect do
             relation
-          }.to raise_exception(Mongoid::Errors::InvalidRelation)
+          end.to raise_exception(Mongoid::Errors::InvalidRelation)
         end
       end
 
-      before do
-        klass.belongs_to(:person)
+      it 'adds the association to the klass' do
+        expect(klass.relations['person']).not_to be_nil
       end
 
-      it "adds the association to the klass" do
-        expect(klass.relations["person"]).to_not be_nil
-      end
-
-      it "defines the getter" do
+      it 'defines the getter' do
         expect(klass.allocate).to respond_to(:person)
       end
 
-      it "defines the setter" do
+      it 'defines the setter' do
         expect(klass.allocate).to respond_to(:person=)
       end
 
-      it "defines the builder" do
+      it 'defines the builder' do
         expect(klass.allocate).to respond_to(:build_person)
       end
 
-      it "defines the creator" do
+      it 'defines the creator' do
         expect(klass.allocate).to respond_to(:create_person)
       end
 
-      it "creates the correct relation" do
-        expect(klass.relations["person"]).to be_a(
+      it 'creates the correct relation' do
+        expect(klass.relations['person']).to be_a(
           Mongoid::Association::Referenced::BelongsTo
         )
       end
 
-      it "creates the field for the foreign key" do
+      it 'creates the field for the foreign key' do
         expect(klass.allocate).to respond_to(:person_id)
       end
 
-      context "association properties" do
-
+      context 'association properties' do
         let(:association) do
-          klass.relations["person"]
+          klass.relations['person']
         end
 
-        it "automatically adds the name" do
+        it 'automatically adds the name' do
           expect(association.name).to eq(:person)
         end
 
-        it "automatically adds the inverse class name" do
-          expect(association.inverse_class_name).to eq("TestClass")
+        it 'automatically adds the inverse class name' do
+          expect(association.inverse_class_name).to eq('TestClass')
         end
       end
     end
   end
 
-  describe ".has_many" do
-
-    it "defines the macro" do
+  describe '.has_many' do
+    it 'defines the macro' do
       expect(klass).to respond_to(:has_many)
     end
 
-    context "when defining the relation" do
+    context 'when defining the relation' do
+      before do
+        klass.has_many(:posts)
+      end
 
       context 'when the relation name is invalid' do
-
         let(:relation) do
           klass.has_many(:fields)
         end
 
         it 'raises an InvalidRelation exception' do
-          expect {
+          expect do
             relation
-          }.to raise_exception(Mongoid::Errors::InvalidRelation)
+          end.to raise_exception(Mongoid::Errors::InvalidRelation)
         end
       end
 
-      before do
-        klass.has_many(:posts)
-      end
-
-      it "adds the association to the klass" do
-        expect(klass.relations["posts"]).to_not be_nil
+      it 'adds the association to the klass' do
+        expect(klass.relations['posts']).not_to be_nil
       end
 
-      it "defines the getter" do
+      it 'defines the getter' do
         expect(klass.allocate).to respond_to(:posts)
       end
 
-      it "defines the setter" do
+      it 'defines the setter' do
         expect(klass.allocate).to respond_to(:posts=)
       end
 
-      it "creates the correct relation" do
-        expect(klass.relations["posts"]).to be_a(
+      it 'creates the correct relation' do
+        expect(klass.relations['posts']).to be_a(
           Mongoid::Association::Referenced::HasMany
         )
       end
 
-      it "adds an associated validation" do
+      it 'adds an associated validation' do
         expect(klass._validators[:posts].first).to be_a(
           Mongoid::Validatable::AssociatedValidator
         )
       end
 
-      context "association properties" do
-
+      context 'association properties' do
         let(:association) do
-          klass.relations["posts"]
+          klass.relations['posts']
         end
 
-        it "automatically adds the name" do
+        it 'automatically adds the name' do
           expect(association.name).to eq(:posts)
         end
 
-        it "automatically adds the inverse class name" do
-          expect(association.inverse_class_name).to eq("TestClass")
+        it 'automatically adds the inverse class name' do
+          expect(association.inverse_class_name).to eq('TestClass')
         end
       end
 
       context 'when an invalid option is provided' do
-
         it 'raises an InvalidRelationOption exception' do
-          expect {
+          expect do
             klass.has_many(:names, sandwich: true)
-          }.to raise_exception(Mongoid::Errors::InvalidRelationOption)
+          end.to raise_exception(Mongoid::Errors::InvalidRelationOption)
         end
       end
     end
 
     context 'when defining order on relation' do
-
       before do
         klass.has_many(:posts, order: :rating.asc)
       end
 
       let(:association) do
-        klass.relations["posts"]
+        klass.relations['posts']
       end
 
-      it "adds association to klass" do
-        expect(association.order).to_not be_nil
+      it 'adds association to klass' do
+        expect(association.order).not_to be_nil
       end
 
-      it "returns Mongoid::Criteria::Queryable::Key" do
-        expect(association.order).to be_kind_of(Mongoid::Criteria::Queryable::Key)
+      it 'returns Mongoid::Criteria::Queryable::Key' do
+        expect(association.order).to be_a(Mongoid::Criteria::Queryable::Key)
       end
     end
 
-    context "when setting validate to false" do
-
+    context 'when setting validate to false' do
       before do
         klass.has_many(:posts, validate: false)
       end
 
-      it "does not add associated validations" do
+      it 'does not add associated validations' do
         expect(klass._validators).to be_empty
       end
     end
   end
 
-  describe ".has_and_belongs_to_many" do
-
-    it "defines the macro" do
+  describe '.has_and_belongs_to_many' do
+    it 'defines the macro' do
       expect(klass).to respond_to(:has_and_belongs_to_many)
     end
 
-    context "when defining the relation" do
+    context 'when defining the relation' do
+      before do
+        klass.has_and_belongs_to_many(:preferences)
+      end
 
       context 'when the relation name is invalid' do
-
         let(:relation) do
           klass.has_and_belongs_to_many(:fields)
         end
 
         it 'raises an InvalidRelation exception' do
-          expect {
+          expect do
             relation
-          }.to raise_exception(Mongoid::Errors::InvalidRelation)
+          end.to raise_exception(Mongoid::Errors::InvalidRelation)
         end
       end
 
       context 'when an invalid option is provided' do
-
         it 'raises an InvalidRelationOption exception' do
-          expect {
+          expect do
             klass.has_and_belongs_to_many(:fields, sandwich: true)
-          }.to raise_exception(Mongoid::Errors::InvalidRelationOption)
+          end.to raise_exception(Mongoid::Errors::InvalidRelationOption)
         end
       end
 
-      before do
-        klass.has_and_belongs_to_many(:preferences)
-      end
-
-      it "adds the association to the klass" do
-        expect(klass.relations["preferences"]).to_not be_nil
+      it 'adds the association to the klass' do
+        expect(klass.relations['preferences']).not_to be_nil
       end
 
-      it "defines the getter" do
+      it 'defines the getter' do
         expect(klass.allocate).to respond_to(:preferences)
       end
 
-      it "defines the setter" do
+      it 'defines the setter' do
         expect(klass.allocate).to respond_to(:preferences=)
       end
 
-      it "creates the correct relation" do
-        expect(klass.relations["preferences"]).to be_a(
+      it 'creates the correct relation' do
+        expect(klass.relations['preferences']).to be_a(
           Mongoid::Association::Referenced::HasAndBelongsToMany
         )
       end
 
-      it "creates the field for the foreign key" do
+      it 'creates the field for the foreign key' do
         expect(klass.allocate).to respond_to(:preference_ids)
       end
 
       context 'when defining order on relation' do
-
         before do
           klass.has_and_belongs_to_many(:preferences, order: :ranking.asc)
         end
 
         let(:association) do
-          klass.relations["preferences"]
+          klass.relations['preferences']
         end
 
-        it "adds association to klass" do
-          expect(association.order).to_not be_nil
+        it 'adds association to klass' do
+          expect(association.order).not_to be_nil
         end
 
-        it "returns Mongoid::Criteria::Queryable::Key" do
-          expect(association.order).to be_kind_of(Mongoid::Criteria::Queryable::Key)
+        it 'returns Mongoid::Criteria::Queryable::Key' do
+          expect(association.order).to be_a(Mongoid::Criteria::Queryable::Key)
         end
       end
 
-      context "association properties" do
-
+      context 'association properties' do
         let(:association) do
-          klass.relations["preferences"]
+          klass.relations['preferences']
         end
 
-        it "automatically adds the name" do
+        it 'automatically adds the name' do
           expect(association.name).to eq(:preferences)
         end
 
-        it "automatically adds the inverse class name" do
-          expect(association.inverse_class_name).to eq("TestClass")
+        it 'automatically adds the inverse class name' do
+          expect(association.inverse_class_name).to eq('TestClass')
         end
       end
     end
   end
 
-  describe ".has_one" do
-
-    it "defines the macro" do
+  describe '.has_one' do
+    it 'defines the macro' do
       expect(klass).to respond_to(:has_one)
     end
 
-    context "when defining the relation" do
+    context 'when defining the relation' do
+      before do
+        klass.has_one(:game)
+      end
 
       context 'when the relation name is invalid' do
-
         let(:relation) do
           klass.has_one(:fields)
         end
 
         it 'raises an InvalidRelation exception' do
-          expect {
+          expect do
             relation
-          }.to raise_exception(Mongoid::Errors::InvalidRelation)
+          end.to raise_exception(Mongoid::Errors::InvalidRelation)
         end
       end
 
       context 'when an invalid option is provided' do
-
         it 'raises an InvalidRelationOption exception' do
-          expect {
+          expect do
             klass.has_one(:game, sandwich: true)
-          }.to raise_exception(Mongoid::Errors::InvalidRelationOption)
+          end.to raise_exception(Mongoid::Errors::InvalidRelationOption)
         end
       end
 
-      before do
-        klass.has_one(:game)
-      end
-
-      it "adds the association to the klass" do
-        expect(klass.relations["game"]).to_not be_nil
+      it 'adds the association to the klass' do
+        expect(klass.relations['game']).not_to be_nil
       end
 
-      it "defines the getter" do
+      it 'defines the getter' do
         expect(klass.allocate).to respond_to(:game)
       end
 
-      it "defines the setter" do
+      it 'defines the setter' do
         expect(klass.allocate).to respond_to(:game=)
       end
 
-      it "defines the builder" do
+      it 'defines the builder' do
         expect(klass.allocate).to respond_to(:build_game)
       end
 
-      it "defines the creator" do
+      it 'defines the creator' do
         expect(klass.allocate).to respond_to(:create_game)
       end
 
-      it "creates the correct relation" do
-        expect(klass.relations["game"]).to be_a(
+      it 'creates the correct relation' do
+        expect(klass.relations['game']).to be_a(
           Mongoid::Association::Referenced::HasOne
         )
       end
 
-      it "adds an associated validation" do
+      it 'adds an associated validation' do
         expect(klass._validators[:game].first).to be_a(
           Mongoid::Validatable::AssociatedValidator
         )
       end
 
-      context "association properties" do
-
+      context 'association properties' do
         let(:association) do
-          klass.relations["game"]
+          klass.relations['game']
         end
 
-        it "automatically adds the name" do
+        it 'automatically adds the name' do
           expect(association.name).to eq(:game)
         end
 
-        it "automatically adds the inverse class name" do
-          expect(association.inverse_class_name).to eq("TestClass")
+        it 'automatically adds the inverse class name' do
+          expect(association.inverse_class_name).to eq('TestClass')
         end
       end
     end
 
-    context "when setting validate to false" do
-
+    context 'when setting validate to false' do
       before do
         klass.has_one(:game, validate: false)
       end
 
-      it "does not add associated validations" do
+      it 'does not add associated validations' do
         expect(klass._validators).to be_empty
       end
     end
   end
 
-  describe "#relations" do
-
+  describe '#relations' do
     before do
       klass.embeds_one(:name)
     end
 
-    it "returns a bson document of relations" do
-      expect(klass.allocate.relations).to be_a_kind_of(BSON::Document)
+    it 'returns a bson document of relations' do
+      expect(klass.allocate.relations).to be_a(BSON::Document)
     end
 
-    it "has keys that are the relation name" do
+    it 'has keys that are the relation name' do
       expect(klass.allocate.relations['name']).to be_a(Mongoid::Association::Embedded::EmbedsOne)
     end
 
-    it "has keys that can be accessed by a String" do
+    it 'has keys that can be accessed by a String' do
       expect(klass.allocate.relations['name']).to be_a(Mongoid::Association::Embedded::EmbedsOne)
     end
 
-    it "has keys that can be accessed by a Symbol" do
+    it 'has keys that can be accessed by a Symbol' do
       expect(klass.allocate.relations[:name]).to be_a(Mongoid::Association::Embedded::EmbedsOne)
     end
 
-    it "has values that are association" do
+    it 'has values that are association' do
       expect(
         klass.allocate.relations.values.first
-      ).to be_a_kind_of(Mongoid::Association::Embedded::EmbedsOne)
+      ).to be_a(Mongoid::Association::Embedded::EmbedsOne)
     end
   end
 
-  describe ".relations" do
-
+  describe '.relations' do
     before do
       klass.embeds_one(:name)
     end
 
-    it "has keys that are the relation name" do
+    it 'has keys that are the relation name' do
       expect(klass.allocate.relations['name']).to be_a(Mongoid::Association::Embedded::EmbedsOne)
     end
 
-    it "has keys that can be accessed by a String" do
+    it 'has keys that can be accessed by a String' do
       expect(klass.allocate.relations['name']).to be_a(Mongoid::Association::Embedded::EmbedsOne)
     end
 
-    it "has keys that can be accessed by a Symbol" do
+    it 'has keys that can be accessed by a Symbol' do
       expect(klass.allocate.relations[:name]).to be_a(Mongoid::Association::Embedded::EmbedsOne)
     end
 
-    it "has values that are association" do
+    it 'has values that are association' do
       expect(
         klass.relations.values.first
       ).to be_a(Mongoid::Association::Embedded::EmbedsOne)
     end
   end
 
-  context "when creating an association with an extension" do
-
+  context 'when creating an association with an extension' do
     class Peep
       include Mongoid::Document
     end
@@ -1062,13 +978,13 @@ describe Mongoid::Association::Macros do
 
       module Extension
         def short_name
-          "spec"
+          'spec'
         end
       end
 
       module AnotherExtension
         def very_short_name
-          "spec"
+          'spec'
         end
       end
     end
@@ -1077,40 +993,37 @@ describe Mongoid::Association::Macros do
       Peep.new(handle: Handle.new)
     end
 
-    context "when the extension is a block" do
-
+    context 'when the extension is a block' do
       before do
         Peep.embeds_one(:handle) do
           def full_name
-            "spec"
+            'spec'
           end
         end
       end
 
-      it "extends the relation" do
-        expect(peep.handle.full_name).to eq("spec")
+      it 'extends the relation' do
+        expect(peep.handle.full_name).to eq('spec')
       end
     end
 
-    context "when the extension is a module" do
-
+    context 'when the extension is a module' do
       before do
         Peep.embeds_one(:handle, extend: Handle::Extension)
       end
 
-      it "extends the relation" do
-        expect(peep.handle.short_name).to eq("spec")
+      it 'extends the relation' do
+        expect(peep.handle.short_name).to eq('spec')
       end
     end
 
-    context "when the extension is two modules" do
-
+    context 'when the extension is two modules' do
       before do
         Peep.embeds_one(:handle, extend: [ Handle::Extension, Handle::AnotherExtension ])
       end
 
-      it "extends the relation" do
-        expect(peep.handle.very_short_name).to eq("spec")
+      it 'extends the relation' do
+        expect(peep.handle.very_short_name).to eq('spec')
       end
     end
   end