mongoid 9.0.11 → 9.1.0

data/spec/mongoid/association/options_spec.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Association::Options do
-
   STORES_FOREIGN_KEY =
     [
       Mongoid::Association::Referenced::HasAndBelongsToMany,
@@ -20,9 +18,7 @@ describe Mongoid::Association::Options do
     Mongoid::Association::Referenced::HasOne,
     Mongoid::Association::Referenced::HasAndBelongsToMany
   ].each do |association_class|
-
     context "when the association type is #{association_class}" do
-
       let(:class_left) do
         class ClassLeft; include Mongoid::Document; end
         ClassLeft
@@ -42,14 +38,12 @@ describe Mongoid::Association::Options do
       end
 
       describe 'the :as option' do
-
-        context 'when the option is supported by the association type', if: association_class::VALID_OPTIONS.include?(:as) do
-
+        context 'when the option is supported by the association type',
+                if: association_class::VALID_OPTIONS.include?(:as) do
           context 'when :as is in the options' do
-
             let(:options) do
               {
-                  as: :nameable
+                as: :nameable
               }
             end
 
@@ -59,47 +53,42 @@ describe Mongoid::Association::Options do
           end
 
           context 'when :as is not in the options' do
-
             it 'returns nil' do
               expect(association.as).to be_nil
             end
           end
         end
 
-        context 'when the option is not supported by the association type', if: !association_class::VALID_OPTIONS.include?(:as) do
-
+        context 'when the option is not supported by the association type',
+                if: !association_class::VALID_OPTIONS.include?(:as) do
           it 'returns nil' do
             expect(association.as).to be_nil
           end
 
           context 'when the option is provided' do
-
             let(:options) do
               {
-                  as: :nameable
+                as: :nameable
               }
             end
 
             it 'raises a Mongoid::Errors::InvalidRelationOption error' do
-              expect {
+              expect do
                 association
-              }.to raise_exception(Mongoid::Errors::InvalidRelationOption)
+              end.to raise_exception(Mongoid::Errors::InvalidRelationOption)
             end
           end
         end
       end
 
       describe '#autobuilding?' do
-
-        context 'when the option is supported by the association type', if: association_class::VALID_OPTIONS.include?(:autobuild) do
-
+        context 'when the option is supported by the association type',
+                if: association_class::VALID_OPTIONS.include?(:autobuild) do
           context 'when :autobuild is in the options' do
-
             context 'when :autobuild is true' do
-
               let(:options) do
                 {
-                    autobuild: true
+                  autobuild: true
                 }
               end
 
@@ -109,10 +98,9 @@ describe Mongoid::Association::Options do
             end
 
             context 'when :autobuild is false' do
-
               let(:options) do
                 {
-                    autobuild: false
+                  autobuild: false
                 }
               end
 
@@ -122,10 +110,9 @@ describe Mongoid::Association::Options do
             end
 
             context 'when :autobuild is nil' do
-
               let(:options) do
                 {
-                    autobuild: nil
+                  autobuild: nil
                 }
               end
 
@@ -136,47 +123,42 @@ describe Mongoid::Association::Options do
           end
 
           context 'when :autobuild is not in the options' do
-
             it 'returns false' do
               expect(association.autobuilding?).to be(false)
             end
           end
         end
 
-        context 'when the option is not supported by the association type', if: !association_class::VALID_OPTIONS.include?(:autobuild) do
-
+        context 'when the option is not supported by the association type',
+                if: !association_class::VALID_OPTIONS.include?(:autobuild) do
           it 'returns false' do
             expect(association.autobuilding?).to be(false)
           end
 
           context 'when the option is provided' do
-
             let(:options) do
               {
-                  autobuild: false
+                autobuild: false
               }
             end
 
             it 'raises a Mongoid::Errors::InvalidRelationOption error' do
-              expect {
+              expect do
                 association
-              }.to raise_exception(Mongoid::Errors::InvalidRelationOption)
+              end.to raise_exception(Mongoid::Errors::InvalidRelationOption)
             end
           end
         end
       end
 
       describe '#autosave?' do
-
-        context 'when the option is supported by the association type', if: association_class::VALID_OPTIONS.include?(:autosave) do
-
+        context 'when the option is supported by the association type',
+                if: association_class::VALID_OPTIONS.include?(:autosave) do
           context 'when :autosave is in the options' do
-
             context 'when :autosave is true' do
-
               let(:options) do
                 {
-                    autosave: true
+                  autosave: true
                 }
               end
 
@@ -186,10 +168,9 @@ describe Mongoid::Association::Options do
             end
 
             context 'when :autosave is false' do
-
               let(:options) do
                 {
-                    autosave: false
+                  autosave: false
                 }
               end
 
@@ -199,10 +180,9 @@ describe Mongoid::Association::Options do
             end
 
             context 'when :autosave is nil' do
-
               let(:options) do
                 {
-                    autosave: nil
+                  autosave: nil
                 }
               end
 
@@ -213,45 +193,41 @@ describe Mongoid::Association::Options do
           end
 
           context 'when :autosave is not in the options' do
-
             it 'returns false' do
               expect(association.autosave?).to be(false)
             end
           end
         end
 
-        context 'when the option is not supported by the association type', if: !association_class::VALID_OPTIONS.include?(:autosave) do
-
+        context 'when the option is not supported by the association type',
+                if: !association_class::VALID_OPTIONS.include?(:autosave) do
           it 'returns false' do
             expect(association.autosave?).to be(false)
           end
 
           context 'when the option is provided' do
-
             let(:options) do
               {
-                  autosave: false
+                autosave: false
               }
             end
 
             it 'raises a Mongoid::Errors::InvalidRelationOption error' do
-              expect {
+              expect do
                 association
-              }.to raise_exception(Mongoid::Errors::InvalidRelationOption)
+              end.to raise_exception(Mongoid::Errors::InvalidRelationOption)
             end
           end
         end
       end
 
       describe 'the :dependent option' do
-
-        context 'when the option is supported by the association type', if: association_class::VALID_OPTIONS.include?(:dependent) do
-
+        context 'when the option is supported by the association type',
+                if: association_class::VALID_OPTIONS.include?(:dependent) do
           context 'when :dependent is in the options' do
-
             let(:options) do
               {
-                  dependent: :delete_all
+                dependent: :delete_all
               }
             end
 
@@ -261,45 +237,41 @@ describe Mongoid::Association::Options do
           end
 
           context 'when :dependent is not in the options' do
-
             it 'returns nil' do
               expect(association.dependent).to be_nil
             end
           end
         end
 
-        context 'when the option is not supported by the association type', if: !association_class::VALID_OPTIONS.include?(:dependent) do
-
+        context 'when the option is not supported by the association type',
+                if: !association_class::VALID_OPTIONS.include?(:dependent) do
           it 'returns nil' do
             expect(association.dependent).to be_nil
           end
 
           context 'when the option is provided' do
-
             let(:options) do
               {
-                  dependent: :delete_all
+                dependent: :delete_all
               }
             end
 
             it 'raises a Mongoid::Errors::InvalidRelationOption error' do
-              expect {
+              expect do
                 association
-              }.to raise_exception(Mongoid::Errors::InvalidRelationOption)
+              end.to raise_exception(Mongoid::Errors::InvalidRelationOption)
             end
           end
         end
       end
 
       describe 'the :foreign_key option' do
-
-        context 'when the option is supported by the association type', if: association_class::VALID_OPTIONS.include?(:foreign_key) do
-
+        context 'when the option is supported by the association type',
+                if: association_class::VALID_OPTIONS.include?(:foreign_key) do
           context 'when the :foreign_key option is specified' do
-
             let(:options) do
               {
-                  foreign_key: :some_field
+                foreign_key: :some_field
               }
             end
 
@@ -310,9 +282,7 @@ describe Mongoid::Association::Options do
 
           context 'when the association stores the foreign key', if: association_class::VALID_OPTIONS.include?(:foreign_key) &&
                                                                      STORES_FOREIGN_KEY.include?(association_class) do
-
             context 'when :foreign_key option is not specified' do
-
               it 'returns the name followed by the foreign_key_suffix' do
                 expect(association.foreign_key).to eq("name#{association.class::FOREIGN_KEY_SUFFIX}")
               end
@@ -321,9 +291,7 @@ describe Mongoid::Association::Options do
 
           context 'when the association does not store the foreign key', if: association_class::VALID_OPTIONS.include?(:foreign_key) &&
                                                                              !STORES_FOREIGN_KEY.include?(association_class) do
-
             context 'when :foreign_key option is not specified' do
-
               before do
                 allow(association).to receive(:inverse).and_return(:other)
               end
@@ -335,38 +303,35 @@ describe Mongoid::Association::Options do
           end
         end
 
-        context 'when the option is not supported by the association type', if: !association_class::VALID_OPTIONS.include?(:foreign_key) do
-
+        context 'when the option is not supported by the association type',
+                if: !association_class::VALID_OPTIONS.include?(:foreign_key) do
           it 'returns nil' do
             expect(association.dependent).to be_nil
           end
 
           context 'when the option is provided' do
-
             let(:options) do
               {
-                  foreign_key: :some_field
+                foreign_key: :some_field
               }
             end
 
             it 'raises a Mongoid::Errors::InvalidRelationOption error' do
-              expect {
+              expect do
                 association
-              }.to raise_exception(Mongoid::Errors::InvalidRelationOption)
+              end.to raise_exception(Mongoid::Errors::InvalidRelationOption)
             end
           end
         end
       end
 
       describe 'the :primary_key option' do
-
-        context 'when the option is supported by the association type', if: association_class::VALID_OPTIONS.include?(:primary_key) do
-
+        context 'when the option is supported by the association type',
+                if: association_class::VALID_OPTIONS.include?(:primary_key) do
           context 'when the option is specified' do
-
             let(:options) do
               {
-                  primary_key: :other_id
+                primary_key: :other_id
               }
             end
 
@@ -376,45 +341,41 @@ describe Mongoid::Association::Options do
           end
 
           context 'when the option is not specified' do
-
             it 'returns the default primary key' do
               expect(association.primary_key).to eq(Mongoid::Association::Relatable::PRIMARY_KEY_DEFAULT)
             end
           end
         end
 
-        context 'when the option is not supported by the association type', if: !association_class::VALID_OPTIONS.include?(:primary_key) do
-
+        context 'when the option is not supported by the association type',
+                if: !association_class::VALID_OPTIONS.include?(:primary_key) do
           it 'returns nil' do
             expect(association.primary_key).to be_nil
           end
 
           context 'when the option is provided' do
-
             let(:options) do
               {
-                  primary_key: :other_id
+                primary_key: :other_id
               }
             end
 
             it 'raises a Mongoid::Errors::InvalidRelationOption error' do
-              expect {
+              expect do
                 association
-              }.to raise_exception(Mongoid::Errors::InvalidRelationOption)
+              end.to raise_exception(Mongoid::Errors::InvalidRelationOption)
             end
           end
         end
       end
 
       describe 'the :after_add option' do
-
-        context 'when the option is supported by the association type', if: association_class::VALID_OPTIONS.include?(:after_add) do
-
+        context 'when the option is supported by the association type',
+                if: association_class::VALID_OPTIONS.include?(:after_add) do
           context 'when the :after_add option is specified' do
-
             let(:options) do
               {
-                  after_add: :method_name
+                after_add: :method_name
               }
             end
 
@@ -424,46 +385,41 @@ describe Mongoid::Association::Options do
           end
 
           context 'when the :after_add option is not specified' do
-
             it 'returns nil' do
               expect(association.get_callbacks(:after_add)).to be_empty
             end
           end
         end
 
-        context 'when the option is not supported by the association type', if: !association_class::VALID_OPTIONS.include?(:after_add) do
-
-
+        context 'when the option is not supported by the association type',
+                if: !association_class::VALID_OPTIONS.include?(:after_add) do
           it 'returns nil' do
             expect(association.get_callbacks(:after_add)).to be_empty
           end
 
           context 'when the option is provided' do
-
             let(:options) do
               {
-                  after_add: :method_name
+                after_add: :method_name
               }
             end
 
             it 'raises a Mongoid::Errors::InvalidRelationOption error' do
-              expect {
+              expect do
                 association
-              }.to raise_exception(Mongoid::Errors::InvalidRelationOption)
+              end.to raise_exception(Mongoid::Errors::InvalidRelationOption)
             end
           end
         end
       end
 
       describe 'the :after_remove option' do
-
-        context 'when the option is supported by the association type', if: association_class::VALID_OPTIONS.include?(:after_remove) do
-
+        context 'when the option is supported by the association type',
+                if: association_class::VALID_OPTIONS.include?(:after_remove) do
           context 'when the :after_remove option is specified' do
-
             let(:options) do
               {
-                  after_remove: :method_name
+                after_remove: :method_name
               }
             end
 
@@ -473,46 +429,41 @@ describe Mongoid::Association::Options do
           end
 
           context 'when the :after_remove option is not specified' do
-
             it 'returns nil' do
               expect(association.get_callbacks(:after_remove)).to be_empty
             end
           end
         end
 
-        context 'when the option is not supported by the association type', if: !association_class::VALID_OPTIONS.include?(:after_remove) do
-
-
+        context 'when the option is not supported by the association type',
+                if: !association_class::VALID_OPTIONS.include?(:after_remove) do
           it 'returns nil' do
             expect(association.get_callbacks(:after_remove)).to be_empty
           end
 
           context 'when the option is provided' do
-
             let(:options) do
               {
-                  after_remove: :method_name
+                after_remove: :method_name
               }
             end
 
             it 'raises a Mongoid::Errors::InvalidRelationOption error' do
-              expect {
+              expect do
                 association
-              }.to raise_exception(Mongoid::Errors::InvalidRelationOption)
+              end.to raise_exception(Mongoid::Errors::InvalidRelationOption)
             end
           end
         end
       end
 
       describe 'the :before_add option' do
-
-        context 'when the option is supported by the association type', if: association_class::VALID_OPTIONS.include?(:before_add) do
-
+        context 'when the option is supported by the association type',
+                if: association_class::VALID_OPTIONS.include?(:before_add) do
           context 'when the :before_add option is specified' do
-
             let(:options) do
               {
-                  before_add: :method_name
+                before_add: :method_name
               }
             end
 
@@ -522,46 +473,41 @@ describe Mongoid::Association::Options do
           end
 
           context 'when the :before_add option is not specified' do
-
             it 'returns nil' do
               expect(association.get_callbacks(:before_add)).to be_empty
             end
           end
         end
 
-        context 'when the option is not supported by the association type', if: !association_class::VALID_OPTIONS.include?(:before_add) do
-
-
+        context 'when the option is not supported by the association type',
+                if: !association_class::VALID_OPTIONS.include?(:before_add) do
           it 'returns nil' do
             expect(association.get_callbacks(:before_add)).to be_empty
           end
 
           context 'when the option is provided' do
-
             let(:options) do
               {
-                  before_add: :method_name
+                before_add: :method_name
               }
             end
 
             it 'raises a Mongoid::Errors::InvalidRelationOption error' do
-              expect {
+              expect do
                 association
-              }.to raise_exception(Mongoid::Errors::InvalidRelationOption)
+              end.to raise_exception(Mongoid::Errors::InvalidRelationOption)
             end
           end
         end
       end
 
       describe 'the :before_remove option' do
-
-        context 'when the option is supported by the association type', if: association_class::VALID_OPTIONS.include?(:before_remove) do
-
+        context 'when the option is supported by the association type',
+                if: association_class::VALID_OPTIONS.include?(:before_remove) do
           context 'when the :before_remove option is specified' do
-
             let(:options) do
               {
-                  before_remove: :method_name
+                before_remove: :method_name
               }
             end
 
@@ -571,49 +517,42 @@ describe Mongoid::Association::Options do
           end
 
           context 'when the :before_remove option is not specified' do
-
             it 'returns nil' do
               expect(association.get_callbacks(:before_remove)).to be_empty
             end
           end
         end
 
-        context 'when the option is not supported by the association type', if: !association_class::VALID_OPTIONS.include?(:before_remove) do
-
-
+        context 'when the option is not supported by the association type',
+                if: !association_class::VALID_OPTIONS.include?(:before_remove) do
           it 'returns nil' do
             expect(association.get_callbacks(:before_remove)).to be_empty
           end
 
           context 'when the option is provided' do
-
             let(:options) do
               {
-                  before_remove: :method_name
+                before_remove: :method_name
               }
             end
 
             it 'raises a Mongoid::Errors::InvalidRelationOption error' do
-              expect {
+              expect do
                 association
-              }.to raise_exception(Mongoid::Errors::InvalidRelationOption)
+              end.to raise_exception(Mongoid::Errors::InvalidRelationOption)
             end
           end
         end
       end
 
-
       describe '#indexed?' do
-
-        context 'when the option is supported by the association type', if: association_class::VALID_OPTIONS.include?(:index) do
-
+        context 'when the option is supported by the association type',
+                if: association_class::VALID_OPTIONS.include?(:index) do
           context 'when :index is in the options' do
-
             context 'when :index is true' do
-
               let(:options) do
                 {
-                    index: true
+                  index: true
                 }
               end
 
@@ -623,10 +562,9 @@ describe Mongoid::Association::Options do
             end
 
             context 'when :index is false' do
-
               let(:options) do
                 {
-                    index: false
+                  index: false
                 }
               end
 
@@ -636,10 +574,9 @@ describe Mongoid::Association::Options do
             end
 
             context 'when :index is nil' do
-
               let(:options) do
                 {
-                    index: nil
+                  index: nil
                 }
               end
 
@@ -650,45 +587,41 @@ describe Mongoid::Association::Options do
           end
 
           context 'when :index is not in the options' do
-
             it 'returns false' do
               expect(association.indexed?).to be(false)
             end
           end
         end
 
-        context 'when the option is not supported by the association type', if: !association_class::VALID_OPTIONS.include?(:index) do
-
+        context 'when the option is not supported by the association type',
+                if: !association_class::VALID_OPTIONS.include?(:index) do
           it 'returns false' do
             expect(association.indexed?).to be(false)
           end
 
           context 'when the option is provided' do
-
             let(:options) do
               {
-                  index: true
+                index: true
               }
             end
 
             it 'raises a Mongoid::Errors::InvalidRelationOption error' do
-              expect {
+              expect do
                 association
-              }.to raise_exception(Mongoid::Errors::InvalidRelationOption)
+              end.to raise_exception(Mongoid::Errors::InvalidRelationOption)
             end
           end
         end
       end
 
       describe 'the :order option' do
-
-        context 'when the option is supported by the association type', if: association_class::VALID_OPTIONS.include?(:order) do
-
+        context 'when the option is supported by the association type',
+                if: association_class::VALID_OPTIONS.include?(:order) do
           context 'when :order is in the options' do
-
             let(:options) do
               {
-                  order: :rating.desc
+                order: :rating.desc
               }
             end
 
@@ -698,47 +631,42 @@ describe Mongoid::Association::Options do
           end
 
           context 'when :order is not in the options' do
-
             it 'returns nil' do
               expect(association.order).to be_nil
             end
           end
         end
 
-        context 'when the option is not supported by the association type', if: !association_class::VALID_OPTIONS.include?(:order) do
-
+        context 'when the option is not supported by the association type',
+                if: !association_class::VALID_OPTIONS.include?(:order) do
           it 'returns nil' do
             expect(association.order).to be_nil
           end
 
           context 'when the option is provided' do
-
             let(:options) do
               {
-                  order: :rating.desc
+                order: :rating.desc
               }
             end
 
             it 'raises a Mongoid::Errors::InvalidRelationOption error' do
-              expect {
+              expect do
                 association
-              }.to raise_exception(Mongoid::Errors::InvalidRelationOption)
+              end.to raise_exception(Mongoid::Errors::InvalidRelationOption)
             end
           end
         end
       end
 
       describe '#polymorphic' do
-
-        context 'when the option is supported by the association type', if: association_class::VALID_OPTIONS.include?(:polymorphic) do
-
+        context 'when the option is supported by the association type',
+                if: association_class::VALID_OPTIONS.include?(:polymorphic) do
           context 'when :polymorphic is in the options' do
-
             context 'when :polymorphic is true' do
-
               let(:options) do
                 {
-                    polymorphic: true
+                  polymorphic: true
                 }
               end
 
@@ -748,10 +676,9 @@ describe Mongoid::Association::Options do
             end
 
             context 'when :polymorphic is false' do
-
               let(:options) do
                 {
-                    polymorphic: false
+                  polymorphic: false
                 }
               end
 
@@ -761,10 +688,9 @@ describe Mongoid::Association::Options do
             end
 
             context 'when :polymorphic is nil' do
-
               let(:options) do
                 {
-                    polymorphic: nil
+                  polymorphic: nil
                 }
               end
 
@@ -775,47 +701,42 @@ describe Mongoid::Association::Options do
           end
 
           context 'when :polymorphic is not in the options' do
-
             it 'returns false' do
               expect(association.polymorphic?).to be(false)
             end
           end
         end
 
-        context 'when the option is not supported by the association type', if: !association_class::VALID_OPTIONS.include?(:polymorphic) do
-
+        context 'when the option is not supported by the association type',
+                if: !association_class::VALID_OPTIONS.include?(:polymorphic) do
           it 'returns false' do
             expect(association.polymorphic?).to be(false)
           end
 
           context 'when the option is provided' do
-
             let(:options) do
               {
-                  polymorphic: true
+                polymorphic: true
               }
             end
 
             it 'raises a Mongoid::Errors::InvalidRelationOption error' do
-              expect {
+              expect do
                 association
-              }.to raise_exception(Mongoid::Errors::InvalidRelationOption)
+              end.to raise_exception(Mongoid::Errors::InvalidRelationOption)
             end
           end
         end
       end
 
       describe '#cascading_callbacks?' do
-
-        context 'when the option is supported by the association type', if: association_class::VALID_OPTIONS.include?(:cascade_callbacks) do
-
+        context 'when the option is supported by the association type',
+                if: association_class::VALID_OPTIONS.include?(:cascade_callbacks) do
           context 'when :cascade_callbacks is in the options' do
-
             context 'when :cascade_callbacks is true' do
-
               let(:options) do
                 {
-                    cascade_callbacks: true
+                  cascade_callbacks: true
                 }
               end
 
@@ -825,10 +746,9 @@ describe Mongoid::Association::Options do
             end
 
             context 'when :cascade_callbacks is false' do
-
               let(:options) do
                 {
-                    cascade_callbacks: false
+                  cascade_callbacks: false
                 }
               end
 
@@ -838,10 +758,9 @@ describe Mongoid::Association::Options do
             end
 
             context 'when :cascade_callbacks is nil' do
-
               let(:options) do
                 {
-                    cascade_callbacks: nil
+                  cascade_callbacks: nil
                 }
               end
 
@@ -852,47 +771,42 @@ describe Mongoid::Association::Options do
           end
 
           context 'when :cascade_callbacks is not in the options' do
-
             it 'returns false' do
               expect(association.cascading_callbacks?).to be(false)
             end
           end
         end
 
-        context 'when the option is not supported by the association type', if: !association_class::VALID_OPTIONS.include?(:cascade_callbacks) do
-
+        context 'when the option is not supported by the association type',
+                if: !association_class::VALID_OPTIONS.include?(:cascade_callbacks) do
           it 'returns false' do
             expect(association.cascading_callbacks?).to be(false)
           end
 
           context 'when the option is provided' do
-
             let(:options) do
               {
-                  cascade_callbacks: true
+                cascade_callbacks: true
               }
             end
 
             it 'raises a Mongoid::Errors::InvalidRelationOption error' do
-              expect {
+              expect do
                 association
-              }.to raise_exception(Mongoid::Errors::InvalidRelationOption)
+              end.to raise_exception(Mongoid::Errors::InvalidRelationOption)
             end
           end
         end
       end
 
       describe '#cyclic?' do
-
-        context 'when the option is supported by the association type', if: association_class::VALID_OPTIONS.include?(:cyclic) do
-
+        context 'when the option is supported by the association type',
+                if: association_class::VALID_OPTIONS.include?(:cyclic) do
           context 'when :cyclic is in the options' do
-
             context 'when :cyclic is true' do
-
               let(:options) do
                 {
-                    cyclic: true
+                  cyclic: true
                 }
               end
 
@@ -902,10 +816,9 @@ describe Mongoid::Association::Options do
             end
 
             context 'when :cyclic is false' do
-
               let(:options) do
                 {
-                    cyclic: false
+                  cyclic: false
                 }
               end
 
@@ -915,10 +828,9 @@ describe Mongoid::Association::Options do
             end
 
             context 'when :cyclic is nil' do
-
               let(:options) do
                 {
-                    cyclic: nil
+                  cyclic: nil
                 }
               end
 
@@ -929,45 +841,41 @@ describe Mongoid::Association::Options do
           end
 
           context 'when :cyclic is not in the options' do
-
             it 'returns false' do
               expect(association.cyclic?).to be(false)
             end
           end
         end
 
-        context 'when the option is not supported by the association type', if: !association_class::VALID_OPTIONS.include?(:cyclic) do
-
+        context 'when the option is not supported by the association type',
+                if: !association_class::VALID_OPTIONS.include?(:cyclic) do
           it 'returns false' do
             expect(association.cyclic?).to be(false)
           end
 
           context 'when the option is provided' do
-
             let(:options) do
               {
-                  cyclic: true
+                cyclic: true
               }
             end
 
             it 'raises a Mongoid::Errors::InvalidRelationOption error' do
-              expect {
+              expect do
                 association
-              }.to raise_exception(Mongoid::Errors::InvalidRelationOption)
+              end.to raise_exception(Mongoid::Errors::InvalidRelationOption)
             end
           end
         end
       end
 
       describe 'the :store_as option' do
-
-        context 'when the option is supported by the association type', if: association_class::VALID_OPTIONS.include?(:store_as) do
-
+        context 'when the option is supported by the association type',
+                if: association_class::VALID_OPTIONS.include?(:store_as) do
           context 'when :store_as is in the options' do
-
             let(:options) do
               {
-                  store_as: :another_name
+                store_as: :another_name
               }
             end
 
@@ -977,45 +885,41 @@ describe Mongoid::Association::Options do
           end
 
           context 'when :store_as is not in the options' do
-
             it 'returns the name as a string' do
-              expect(association.store_as).to eq("name")
+              expect(association.store_as).to eq('name')
             end
           end
         end
 
-        context 'when the option is not supported by the association type', if: !association_class::VALID_OPTIONS.include?(:store_as) do
-
+        context 'when the option is not supported by the association type',
+                if: !association_class::VALID_OPTIONS.include?(:store_as) do
           it 'returns nil' do
             expect(association.store_as).to be_nil
           end
 
           context 'when the option is provided' do
-
             let(:options) do
               {
-                  store_as: :another_name
+                store_as: :another_name
               }
             end
 
             it 'raises a Mongoid::Errors::InvalidRelationOption error' do
-              expect {
+              expect do
                 association
-              }.to raise_exception(Mongoid::Errors::InvalidRelationOption)
+              end.to raise_exception(Mongoid::Errors::InvalidRelationOption)
             end
           end
         end
       end
 
       describe 'the :class_name option' do
-
-        context 'when the option is supported by the association type', if: association_class::VALID_OPTIONS.include?(:class_name) do
-
+        context 'when the option is supported by the association type',
+                if: association_class::VALID_OPTIONS.include?(:class_name) do
           context 'when :class_name is in the options' do
-
             let(:options) do
               {
-                  class_name: :a_class
+                class_name: :a_class
               }
             end
 
@@ -1025,45 +929,40 @@ describe Mongoid::Association::Options do
           end
 
           context 'when :class_name is not in the options' do
-
             it 'returns the name deduced from the association name' do
               expect(association.class_name).to eq(ActiveSupport::Inflector.classify(:name))
             end
           end
         end
 
-        context 'when the option is not supported by the association type', if: !association_class::VALID_OPTIONS.include?(:class_name) do
-
+        context 'when the option is not supported by the association type',
+                if: !association_class::VALID_OPTIONS.include?(:class_name) do
           it 'returns the name deduced from the association name' do
             expect(association.class_name).to eq(ActiveSupport::Inflector.classify(:name))
           end
 
           context 'when the option is provided' do
-
             let(:options) do
               {
-                  class_name: :a_class
+                class_name: :a_class
               }
             end
 
-            it 'should support the option' do
-              fail('All association types should support this option')
+            it 'supports the option' do
+              raise('All association types should support this option')
             end
           end
         end
       end
 
       describe '#counter_cached?' do
-
-        context 'when the option is supported by the association type', if: association_class::VALID_OPTIONS.include?(:counter_cache) do
-
+        context 'when the option is supported by the association type',
+                if: association_class::VALID_OPTIONS.include?(:counter_cache) do
           context 'when :counter_cache is in the options' do
-
             context 'when :counter_cache is true' do
-
               let(:options) do
                 {
-                    counter_cache: true
+                  counter_cache: true
                 }
               end
 
@@ -1073,10 +972,9 @@ describe Mongoid::Association::Options do
             end
 
             context 'when :counter_cache is false' do
-
               let(:options) do
                 {
-                    counter_cache: false
+                  counter_cache: false
                 }
               end
 
@@ -1086,10 +984,9 @@ describe Mongoid::Association::Options do
             end
 
             context 'when :counter_cache is nil' do
-
               let(:options) do
                 {
-                    counter_cache: nil
+                  counter_cache: nil
                 }
               end
 
@@ -1100,44 +997,41 @@ describe Mongoid::Association::Options do
           end
 
           context 'when :counter_cache is not in the options' do
-
             it 'returns false' do
               expect(association.counter_cached?).to be(false)
             end
           end
         end
 
-        context 'when the option is not supported by the association type', if: !association_class::VALID_OPTIONS.include?(:counter_cache) do
-
+        context 'when the option is not supported by the association type',
+                if: !association_class::VALID_OPTIONS.include?(:counter_cache) do
           it 'returns false' do
             expect(association.counter_cached?).to be(false)
           end
 
           context 'when the option is provided' do
-
             let(:options) do
               {
-                  counter_cache: :column_name
+                counter_cache: :column_name
               }
             end
 
             it 'raises a Mongoid::Errors::InvalidRelationOption error' do
-              expect {
+              expect do
                 association
-              }.to raise_exception(Mongoid::Errors::InvalidRelationOption)
+              end.to raise_exception(Mongoid::Errors::InvalidRelationOption)
             end
           end
         end
       end
 
       describe '#extension' do
-
-        context 'when the option is supported by the association type', if: association_class::VALID_OPTIONS.include?(:extend) do
-
+        context 'when the option is supported by the association type',
+                if: association_class::VALID_OPTIONS.include?(:extend) do
           context 'when a block is passed' do
-
             let!(:association) do
-              association_class.new(class_left, :name, options) do; end
+              association_class.new(class_left, :name, options) do
+              end
             end
 
             after do
@@ -1154,7 +1048,6 @@ describe Mongoid::Association::Options do
           end
 
           context 'when a module name is passed' do
-
             before do
               class ClassLeft; end
               module ClassLeft::Handle; end
@@ -1162,7 +1055,7 @@ describe Mongoid::Association::Options do
 
             let(:options) do
               {
-                  extend: ClassLeft::Handle
+                extend: ClassLeft::Handle
               }
             end
 
@@ -1176,7 +1069,6 @@ describe Mongoid::Association::Options do
           end
 
           context 'when a block is not passed' do
-
             it 'does not define an extension module' do
               expect(defined?(ClassLeft::ClassLeftNameRelationExtension)).to be_nil
             end
@@ -1185,27 +1077,23 @@ describe Mongoid::Association::Options do
               expect(association.extension).to be_nil
             end
           end
-
-
         end
 
-        context 'when the option is not supported by the association type', if: !association_class::VALID_OPTIONS.include?(:extend) do
-
-          it 'should support the option' do
-            fail('All association types should support this option')
+        context 'when the option is not supported by the association type',
+                if: !association_class::VALID_OPTIONS.include?(:extend) do
+          it 'supports the option' do
+            raise('All association types should support this option')
           end
         end
       end
 
       describe 'the :inverse_of option' do
-
-        context 'when the option is supported by the association type', if: association_class::VALID_OPTIONS.include?(:inverse_of) do
-
+        context 'when the option is supported by the association type',
+                if: association_class::VALID_OPTIONS.include?(:inverse_of) do
           context 'when :inverse_of is in the options' do
-
             let(:options) do
               {
-                  inverse_of: :inverse_name
+                inverse_of: :inverse_name
               }
             end
 
@@ -1215,46 +1103,40 @@ describe Mongoid::Association::Options do
           end
 
           context 'when :inverse_of is not in the options' do
-
             it 'returns nil' do
               expect(association.inverse_of).to be_nil
             end
           end
         end
 
-        context 'when the option is not supported by the association type', if: !association_class::VALID_OPTIONS.include?(:inverse_of) do
-
+        context 'when the option is not supported by the association type',
+                if: !association_class::VALID_OPTIONS.include?(:inverse_of) do
           it 'returns nil' do
             expect(association.inverse_of).to be_nil
           end
 
-
           context 'when the option is provided' do
-
             let(:options) do
               {
-                  inverse_of: :inverse_name
+                inverse_of: :inverse_name
               }
             end
 
-            it 'should support the option' do
-              fail('All association types should support this option')
+            it 'supports the option' do
+              raise('All association types should support this option')
             end
           end
         end
       end
 
       describe '#validate?' do
-
-        context 'when the option is supported by the association type', if: association_class::VALID_OPTIONS.include?(:validate) do
-
+        context 'when the option is supported by the association type',
+                if: association_class::VALID_OPTIONS.include?(:validate) do
           context 'when :validate is in the options' do
-
             context 'when :validate is true' do
-
               let(:options) do
                 {
-                    validate: true
+                  validate: true
                 }
               end
 
@@ -1264,10 +1146,9 @@ describe Mongoid::Association::Options do
             end
 
             context 'when :validate is false' do
-
               let(:options) do
                 {
-                    validate: false
+                  validate: false
                 }
               end
 
@@ -1277,10 +1158,9 @@ describe Mongoid::Association::Options do
             end
 
             context 'when :validate is nil' do
-
               let(:options) do
                 {
-                    validate: nil
+                  validate: nil
                 }
               end
 
@@ -1291,30 +1171,27 @@ describe Mongoid::Association::Options do
           end
 
           context 'when :validate is not in the options' do
-
             it 'returns the validation default' do
               expect(association.send(:validate?)).to be(association.validation_default)
             end
           end
         end
 
-        context 'when the option is not supported by the association type', if: !association_class::VALID_OPTIONS.include?(:validate) do
-
+        context 'when the option is not supported by the association type',
+                if: !association_class::VALID_OPTIONS.include?(:validate) do
           it 'returns false' do
             expect(association.send(:validate?)).to be(false)
           end
 
-
           context 'when the option is provided' do
-
             let(:options) do
               {
-                  validate: true
+                validate: true
               }
             end
 
-            it 'should support the option' do
-              fail('All association types should support this option')
+            it 'supports the option' do
+              raise('All association types should support this option')
             end
           end
         end