mongoid 9.0.11 → 9.1.0

data/spec/mongoid/document_spec.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Document do
-
   let(:klass) do
     Person
   end
@@ -13,19 +11,17 @@ describe Mongoid::Document do
     Person.new
   end
 
-  it "defines a _destroy method" do
+  it 'defines a _destroy method' do
     expect(Person.new).to respond_to(:_destroy)
   end
 
-  describe "#_destroy" do
-
-    it "default to false" do
+  describe '#_destroy' do
+    it 'default to false' do
       expect(Person.new._destroy).to be false
     end
   end
 
-  describe ".included" do
-
+  describe '.included' do
     let(:models) do
       Mongoid.models
     end
@@ -37,75 +33,72 @@ describe Mongoid::Document do
     let(:new_klass) do
       Class.new do
         class << self; attr_accessor :name; end
-      end.tap{|new_klass| new_klass.name = new_klass_name}
+      end.tap { |new_klass| new_klass.name = new_klass_name }
     end
 
     let(:new_model) do
       new_klass.tap do
-        new_klass.send(:include, ::Mongoid::Document)
+        new_klass.send(:include, Mongoid::Document)
       end
     end
 
     let(:twice_a_new_model) do
       new_klass.tap do
-        2.times{ new_klass.send(:include, ::Mongoid::Document) }
+        2.times { new_klass.send(:include, Mongoid::Document) }
       end
     end
 
-    context "when Document has been included in a model" do
-      it ".models should include that model" do
+    context 'when Document has been included in a model' do
+      it '.models should include that model' do
         expect(models).to include(klass)
       end
     end
 
-    context "before Document has been included" do
-      it ".models should *not* include that model" do
-        expect(models).to_not include(new_klass)
+    context 'before Document has been included' do
+      it '.models should *not* include that model' do
+        expect(models).not_to include(new_klass)
       end
     end
 
-    context "after Document has been included" do
-      it ".models should include that model" do
+    context 'after Document has been included' do
+      it '.models should include that model' do
         expect(models).to include(new_model)
       end
     end
 
-    context "after Document has been included multiple times" do
-      it ".models should include that model just once" do
-        expect(models.count(twice_a_new_model)).to be_eql(1)
+    context 'after Document has been included multiple times' do
+      it '.models should include that model just once' do
+        expect(models.count(twice_a_new_model)).to eql(1)
       end
     end
   end
 
-  describe "._types" do
-
-    context "when the document is subclassed" do
-
+  describe '._types' do
+    context 'when the document is subclassed' do
       let(:types) do
         Person._types
       end
 
-      it "includes the root" do
-        expect(types).to include("Person")
+      it 'includes the root' do
+        expect(types).to include('Person')
       end
 
-      it "includes the subclasses" do
-        expect(types).to include("Doctor")
+      it 'includes the subclasses' do
+        expect(types).to include('Doctor')
       end
     end
 
-    context "when the document is not subclassed" do
-
+    context 'when the document is not subclassed' do
       let(:types) do
         Kangaroo._types
       end
 
-      it "returns the document" do
-        expect(types).to eq([ "Kangaroo" ])
+      it 'returns the document' do
+        expect(types).to eq([ 'Kangaroo' ])
       end
     end
 
-    context "when ._types had been called before class declaration" do
+    context 'when ._types had been called before class declaration' do
       let(:descendant) do
         Class.new(Person)
       end
@@ -115,168 +108,154 @@ describe Mongoid::Document do
         descendant
       end
 
-      it "should clear descendants' cache" do
+      it "clears descendants' cache" do
         expect(Person._types).to include(descendant.discriminator_value)
       end
     end
   end
 
-  describe "._mongoid_clear_types" do
-
-    context "when changing the discriminator_value" do
-
+  describe '._mongoid_clear_types' do
+    context 'when changing the discriminator_value' do
       before do
         Kangaroo._types
-        Kangaroo.discriminator_value = "dvalue"
+        Kangaroo.discriminator_value = 'dvalue'
       end
 
       after do
         Kangaroo.discriminator_value = nil
       end
 
-      it "has the correct _types" do
-        expect(Kangaroo._types).to eq(["dvalue"])
+      it 'has the correct _types' do
+        expect(Kangaroo._types).to eq([ 'dvalue' ])
       end
     end
 
-    context "when changing the discriminator_value in child" do
-
+    context 'when changing the discriminator_value in child' do
       before do
         Shape._types
-        Circle.discriminator_value = "dvalue"
+        Circle.discriminator_value = 'dvalue'
       end
 
       after do
         Circle.discriminator_value = nil
       end
 
-      it "has the correct _types" do
-        expect(Circle._types).to eq(["dvalue"])
+      it 'has the correct _types' do
+        expect(Circle._types).to eq([ 'dvalue' ])
       end
 
-      it "has the new Circle discriminator value" do
-        expect(Shape._types).to include("dvalue")
+      it 'has the new Circle discriminator value' do
+        expect(Shape._types).to include('dvalue')
       end
 
       it "doesn't have the old Circle discriminator value" do
-        expect(Shape._types).to_not include("Cirlce")
+        expect(Shape._types).not_to include('Cirlce')
       end
     end
   end
 
-  describe "#attributes" do
-
+  describe '#attributes' do
     let!(:person) do
-      Person.create!(title: "Sir")
+      Person.create!(title: 'Sir')
     end
 
-    it "returns the attributes with indifferent access" do
-      expect(person[:title]).to eq("Sir")
+    it 'returns the attributes with indifferent access' do
+      expect(person[:title]).to eq('Sir')
     end
 
-    context "when instantiating a new document" do
-      it "returns a Hash" do
+    context 'when instantiating a new document' do
+      it 'returns a Hash' do
         expect(person.attributes.class).to eq(Hash)
       end
     end
 
-    context "when retrieving a document from the database" do
-
+    context 'when retrieving a document from the database' do
       let(:from_db) { Person.first }
 
-      it "returns a Hash" do
+      it 'returns a Hash' do
         expect(from_db.attributes.class).to eq(Hash)
       end
     end
   end
 
-  describe "#identity" do
-
+  describe '#identity' do
     let(:person) do
       Person.new
     end
 
-    it "returns a [doc.class, doc.id] array" do
-      expect(person.identity).to eq([person.class, person.id])
+    it 'returns a [doc.class, doc.id] array' do
+      expect(person.identity).to eq([ person.class, person.id ])
     end
   end
 
-  describe "#hash" do
-
+  describe '#hash' do
     let(:person) do
       Person.new
     end
 
-    it "returns the identity hash" do
+    it 'returns the identity hash' do
       expect(person.hash).to eq(person.identity.hash)
     end
   end
 
-  describe "#initialize" do
-
+  describe '#initialize' do
     let(:person) do
-      Person.new(title: "Sir")
+      Person.new(title: 'Sir')
     end
 
-    it "sets persisted to false" do
-      expect(person).to_not be_persisted
+    it 'sets persisted to false' do
+      expect(person).not_to be_persisted
     end
 
-    it "creates an id for the document" do
+    it 'creates an id for the document' do
       expect(person.id).to be_a(BSON::ObjectId)
     end
 
-    it "sets the attributes" do
-      expect(person.title).to eq("Sir")
+    it 'sets the attributes' do
+      expect(person.title).to eq('Sir')
     end
 
-    context "when the model has a default scope" do
-
-      context "when the default scope is settable" do
-
+    context 'when the model has a default scope' do
+      context 'when the default scope is settable' do
         let(:sound) do
           Sound.new
         end
 
-        it "sets the default scoping on the model" do
+        it 'sets the default scoping on the model' do
           expect(sound).to be_active
         end
       end
 
-      context "when the default scope is not settable" do
-
+      context 'when the default scope is not settable' do
         let(:audio) do
           Audio.new
         end
 
-        it "does not set the default scoping" do
+        it 'does not set the default scoping' do
           expect(audio.attributes.except('_id')).to be_empty
         end
       end
     end
 
-    context "when accessing a relation from an overridden setter" do
-
+    context 'when accessing a relation from an overridden setter' do
       let(:doctor) do
-        Doctor.new(specialty: "surgery")
+        Doctor.new(specialty: 'surgery')
       end
 
-      it "allows access to the relation" do
+      it 'allows access to the relation' do
         expect(doctor.users.first).to be_a(User)
       end
 
-      it "properly allows super calls" do
-        expect(doctor.specialty).to eq("surgery")
+      it 'properly allows super calls' do
+        expect(doctor.specialty).to eq('surgery')
       end
     end
 
-    context "when initialize callbacks are defined" do
-
-      context "when accessing attributes" do
-
+    context 'when initialize callbacks are defined' do
+      context 'when accessing attributes' do
         before do
           Person.set_callback :initialize, :after do |doc|
-            doc.title = "Madam"
+            doc.title = 'Madam'
           end
         end
 
@@ -284,20 +263,19 @@ describe Mongoid::Document do
           Person.reset_callbacks(:initialize)
         end
 
-        it "runs the callbacks" do
-          expect(person.title).to eq("Madam")
+        it 'runs the callbacks' do
+          expect(person.title).to eq('Madam')
         end
       end
 
-      context "when accessing relations" do
-
+      context 'when accessing relations' do
         let(:person) do
           Person.new(game: Game.new)
         end
 
         before do
           Person.after_initialize do
-            self.game.name = "Ms. Pacman"
+            game.name = 'Ms. Pacman'
           end
         end
 
@@ -305,207 +283,192 @@ describe Mongoid::Document do
           Person.reset_callbacks(:initialize)
         end
 
-        it "runs the callbacks" do
-          expect(person.game.name).to eq("Ms. Pacman")
+        it 'runs the callbacks' do
+          expect(person.game.name).to eq('Ms. Pacman')
         end
       end
     end
 
-    context "when defaults are defined" do
-
-      it "sets the default values" do
+    context 'when defaults are defined' do
+      it 'sets the default values' do
         expect(person.age).to eq(100)
       end
     end
 
-    context "when a block is provided" do
-
+    context 'when a block is provided' do
       let(:person) do
         Person.new do |doc|
-          doc.title = "King"
+          doc.title = 'King'
         end
       end
 
-      it "yields to the block" do
-        expect(person.title).to eq("King")
+      it 'yields to the block' do
+        expect(person.title).to eq('King')
       end
     end
   end
 
-  describe ".instantiate" do
-
-    context "when passing a block" do
-
+  describe '.instantiate' do
+    context 'when passing a block' do
       let(:id) do
         BSON::ObjectId.new
       end
 
       let(:document) do
-        Band.instantiate("_id" => id, "name" => "Depeche Mode") do |band|
+        Band.instantiate('_id' => id, 'name' => 'Depeche Mode') do |band|
           band.likes = 1000
         end
       end
 
-      it "yields to the block" do
+      it 'yields to the block' do
         expect(document.likes).to eq(1000)
       end
     end
 
-    context "when an id exists" do
-
+    context 'when an id exists' do
       let(:id) do
         BSON::ObjectId.new
       end
 
       let!(:person) do
-        Person.instantiate("_id" => id, "title" => "Sir")
+        Person.instantiate('_id' => id, 'title' => 'Sir')
       end
 
-      it "sets the attributes" do
-        expect(person.title).to eq("Sir")
+      it 'sets the attributes' do
+        expect(person.title).to eq('Sir')
       end
 
-      it "sets persisted to true" do
+      it 'sets persisted to true' do
         expect(person).to be_persisted
       end
     end
 
-    context "when attributes are nil" do
-
+    context 'when attributes are nil' do
       let(:person) do
         Person.instantiate
       end
 
-      it "creates a new document" do
+      it 'creates a new document' do
         expect(person).to be_a(Person)
       end
     end
   end
 
-  describe "#model_name" do
-
+  describe '#model_name' do
     let(:person) do
       Person.new
     end
 
-    it "returns the class model name" do
-      expect(person.model_name).to eq("Person")
+    it 'returns the class model name' do
+      expect(person.model_name).to eq('Person')
     end
   end
 
-  describe "#raw_attributes" do
-
+  describe '#raw_attributes' do
     let(:person) do
-      Person.new(title: "Sir")
+      Person.new(title: 'Sir')
     end
 
-    it "returns the internal attributes" do
-      expect(person.raw_attributes["title"]).to eq("Sir")
+    it 'returns the internal attributes' do
+      expect(person.raw_attributes['title']).to eq('Sir')
     end
   end
 
-  describe "#as_json" do
-
+  describe '#as_json' do
     let!(:person) do
-      Person.new(title: "Sir")
+      Person.new(title: 'Sir')
     end
 
-    context "when no options are provided" do
-
-      it "does not apply any options" do
-        expect(person.as_json["title"]).to eq("Sir")
-        expect(person.as_json["age"]).to eq(100)
+    context 'when no options are provided' do
+      it 'does not apply any options' do
+        expect(person.as_json['title']).to eq('Sir')
+        expect(person.as_json['age']).to eq(100)
       end
 
-      context "when options for the super method are provided" do
-
+      context 'when options for the super method are provided' do
         let(:options) do
           { only: :title }
         end
 
-        it "passes the options through to the super method" do
-          expect(person.as_json(options)["title"]).to eq("Sir")
-          expect(person.as_json(options).keys).not_to include("age")
+        it 'passes the options through to the super method' do
+          expect(person.as_json(options)['title']).to eq('Sir')
+          expect(person.as_json(options).keys).not_to include('age')
         end
       end
     end
   end
 
-  describe "#as_document" do
-
+  describe '#as_document' do
     let!(:person) do
-      Person.new(title: "Sir")
+      Person.new(title: 'Sir')
     end
 
     let!(:address) do
-      person.addresses.build(street: "Upper")
+      person.addresses.build(street: 'Upper')
     end
 
     let!(:name) do
-      person.build_name(first_name: "James")
+      person.build_name(first_name: 'James')
     end
 
     let!(:location) do
-      address.locations.build(name: "Home")
+      address.locations.build(name: 'Home')
     end
 
-    it "includes embeds one attributes" do
-      expect(person.as_document).to have_key("name")
+    it 'includes embeds one attributes' do
+      expect(person.as_document).to have_key('name')
     end
 
-    it "includes embeds one attributes as a symbol" do
+    it 'includes embeds one attributes as a symbol' do
       expect(person.as_document).to have_key(:name)
     end
 
-    it "includes embeds many attributes" do
-      expect(person.as_document).to have_key("addresses")
+    it 'includes embeds many attributes' do
+      expect(person.as_document).to have_key('addresses')
     end
 
-    it "includes embeds many attributes as a symbol" do
+    it 'includes embeds many attributes as a symbol' do
       expect(person.as_document).to have_key(:addresses)
     end
 
-    it "includes second level embeds many attributes" do
-      expect(person.as_document["addresses"].first).to have_key("locations")
+    it 'includes second level embeds many attributes' do
+      expect(person.as_document['addresses'].first).to have_key('locations')
     end
 
-    it "includes second level embeds many attributes as a symbol" do
-      expect(person.as_document["addresses"].first).to have_key(:locations)
+    it 'includes second level embeds many attributes as a symbol' do
+      expect(person.as_document['addresses'].first).to have_key(:locations)
     end
 
-    context "with relation define store_as option in embeded_many" do
-
+    context 'with relation define store_as option in embeded_many' do
       let!(:phone) do
         person.phones.build(number: '+33123456789')
       end
 
       it 'includes the store_as key association' do
-        expect(person.as_document).to have_key("mobile_phones")
+        expect(person.as_document).to have_key('mobile_phones')
       end
 
       it 'includes the store_as key association as a symbol' do
         expect(person.as_document).to have_key(:mobile_phones)
       end
 
-      it 'should not include the key of association' do
-        expect(person.as_document).to_not have_key("phones")
+      it 'does not include the key of association' do
+        expect(person.as_document).not_to have_key('phones')
       end
     end
 
-    context "when removing an embedded document" do
-
+    context 'when removing an embedded document' do
       before do
         person.save!
         person.addresses.delete(address)
       end
 
-      it "does not include the document in the hash" do
-        expect(person.as_document).to_not have_key("addresses")
+      it 'does not include the document in the hash' do
+        expect(person.as_document).not_to have_key('addresses')
       end
     end
 
-    context "when an embedded relation has been set to nil" do
-
+    context 'when an embedded relation has been set to nil' do
       before do
         # Save the doc, then set an embeds_one relation to nil
         person.save!
@@ -513,203 +476,182 @@ describe Mongoid::Document do
         person.save!
       end
 
-      it "does not include the document in the hash" do
-        expect(person.as_document).to_not have_key("name")
+      it 'does not include the document in the hash' do
+        expect(person.as_document).not_to have_key('name')
       end
     end
   end
 
-  describe "#to_key" do
-
-    context "when the document is new" do
-
+  describe '#to_key' do
+    context 'when the document is new' do
       let(:person) do
         Person.new
       end
 
-      it "returns nil" do
+      it 'returns nil' do
         expect(person.to_key).to be_nil
       end
     end
 
-    context "when the document is not new" do
-
+    context 'when the document is not new' do
       let(:person) do
         Person.create!
       end
 
-      it "returns the id in an array" do
+      it 'returns the id in an array' do
         expect(person.to_key).to eq([ person.id.to_s ])
       end
 
-      it "can query using the key" do
+      it 'can query using the key' do
         expect(person.id).to eq Person.find(person.to_key).first.id
       end
     end
 
-    context "when the document is destroyed" do
-
+    context 'when the document is destroyed' do
       let(:person) do
-        Person.instantiate("_id" => BSON::ObjectId.new).tap do |peep|
+        Person.instantiate('_id' => BSON::ObjectId.new).tap do |peep|
           peep.destroyed = true
         end
       end
 
-      it "returns the id in an array" do
+      it 'returns the id in an array' do
         expect(person.to_key).to eq([ person.id.to_s ])
       end
     end
   end
 
-  describe "#to_param" do
-
-    context "when the document is new" do
-
+  describe '#to_param' do
+    context 'when the document is new' do
       let(:person) do
         Person.new
       end
 
-      it "returns nil" do
+      it 'returns nil' do
         expect(person.to_param).to be_nil
       end
     end
 
-    context "when the document is not new" do
-
+    context 'when the document is not new' do
       let(:person) do
-        Person.instantiate("_id" => BSON::ObjectId.new)
+        Person.instantiate('_id' => BSON::ObjectId.new)
       end
 
-      it "returns the id as a string" do
+      it 'returns the id as a string' do
         expect(person.to_param).to eq(person.id.to_s)
       end
     end
   end
 
-  describe "#frozen?" do
-
+  describe '#frozen?' do
     let(:person) do
       Person.new
     end
 
-    context "when attributes are not frozen" do
-
-      it "return false" do
-        expect(person).to_not be_frozen
-        expect {
-          person.title = "something"
-        }.to_not raise_error
+    context 'when attributes are not frozen' do
+      it 'return false' do
+        expect(person).not_to be_frozen
+        expect do
+          person.title = 'something'
+        end.not_to raise_error
       end
     end
 
-    context "when attributes are frozen" do
+    context 'when attributes are frozen' do
       before do
         person.raw_attributes.freeze
       end
 
-      it "return true" do
+      it 'return true' do
         expect(person).to be_frozen
       end
     end
   end
 
-  describe "#freeze" do
-
+  describe '#freeze' do
     let(:person) do
       Person.new
     end
 
-    context "when freezing the model" do
-
-      context "when not frozen" do
-
-        it "freezes attributes" do
+    context 'when freezing the model' do
+      context 'when not frozen' do
+        it 'freezes attributes' do
           expect(person.freeze).to eq(person)
-          expect { person.title = "something" }.to raise_error(RuntimeError)
+          expect { person.title = 'something' }.to raise_error(RuntimeError)
         end
       end
 
-      context "when frozen" do
-
+      context 'when frozen' do
         before do
           person.raw_attributes.freeze
         end
 
-        it "keeps things frozen" do
+        it 'keeps things frozen' do
           person.freeze
-          expect {
-            person.title = "something"
-          }.to raise_error(RuntimeError)
+          expect do
+            person.title = 'something'
+          end.to raise_error(RuntimeError)
         end
       end
     end
 
-    context "when freezing attributes of the model" do
-
-      context "when assigning a frozen value" do
-
-        context "when the frozen value is a hash" do
-
+    context 'when freezing attributes of the model' do
+      context 'when assigning a frozen value' do
+        context 'when the frozen value is a hash' do
           let(:hash) do
-            {"foo" => {"bar" => {"baz" => [1,2,3]}}}
+            { 'foo' => { 'bar' => { 'baz' => [ 1, 2, 3 ] } } }
           end
 
           let(:assign_hash) do
             person.map = hash.freeze
           end
 
-          it "no mutation occurs during assignment" do
-            expect{ assign_hash }.not_to raise_error
+          it 'no mutation occurs during assignment' do
+            expect { assign_hash }.not_to raise_error
           end
         end
       end
     end
   end
 
-  describe ".logger" do
-
-    it "returns the mongoid logger" do
+  describe '.logger' do
+    it 'returns the mongoid logger' do
       expect(Person.logger).to eq(Mongoid.logger)
     end
   end
 
-  describe "#logger" do
-
+  describe '#logger' do
     let(:person) do
       Person.new
     end
 
-    it "returns the mongoid logger" do
+    it 'returns the mongoid logger' do
       expect(person.send(:logger)).to eq(Mongoid.logger)
     end
   end
 
-  context "after including the document module" do
-
+  context 'after including the document module' do
     let(:movie) do
       Movie.new
     end
 
-    it "resets to the global scope" do
-      expect(movie.global_set).to be_a(::Set)
+    it 'resets to the global scope' do
+      expect(movie.global_set).to be_a(Set)
     end
   end
-  context "when a model name conflicts with a mongoid internal" do
 
+  context 'when a model name conflicts with a mongoid internal' do
     let(:scheduler) do
       Scheduler.new
     end
 
-    it "allows the model name" do
+    it 'allows the model name' do
       expect(scheduler.strategy).to be_a(Strategy)
     end
   end
 
-  describe "#initialize" do
-
-    context "when providing a block" do
-
-      it "sets the defaults before yielding" do
+  describe '#initialize' do
+    context 'when providing a block' do
+      it 'sets the defaults before yielding' do
         Person.new do |person|
           expect(person.age).to eq(100)
         end
@@ -717,8 +659,7 @@ describe Mongoid::Document do
     end
   end
 
-  context "defining a BSON::ObjectId as a field" do
-
+  context 'defining a BSON::ObjectId as a field' do
     let(:bson_id) do
       BSON::ObjectId.new
     end
@@ -731,50 +672,47 @@ describe Mongoid::Document do
       person.save!
     end
 
-    it "persists the correct type" do
+    it 'persists the correct type' do
       expect(person.reload.bson_id).to be_a(BSON::ObjectId)
     end
 
-    it "has the correct value" do
+    it 'has the correct value' do
       expect(person.bson_id).to eq(bson_id)
     end
   end
 
-  context "when setting bson id fields to empty strings" do
-
+  context 'when setting bson id fields to empty strings' do
     let(:post) do
       Post.new
     end
 
     before do
-      post.person_id = ""
+      post.person_id = ''
     end
 
-    it "converts them to nil" do
+    it 'converts them to nil' do
       expect(post.person_id).to be_nil
     end
   end
 
-  context "creating anonymous documents" do
-
-    context "when defining collection" do
-
+  context 'creating anonymous documents' do
+    context 'when defining collection' do
       let(:model) do
         Class.new do
           include Mongoid::Document
-          store_in collection: "anonymous"
+
+          store_in collection: 'anonymous'
           field :gender
         end
       end
 
-      it "allows the creation" do
-        Object.const_set "Anonymous", model
+      it 'allows the creation' do
+        Object.const_set :Anonymous, model
       end
     end
   end
 
-  describe "#becomes" do
-
+  describe '#becomes' do
     before(:all) do
       Person.validates_format_of(:ssn, without: /\$\$\$/)
 
@@ -788,55 +726,54 @@ describe Mongoid::Document do
       Object.send(:remove_const, :Manager)
     end
 
-    context "when casting to a superclass" do
-
+    context 'when casting to a superclass' do
       let(:manager) do
-        Manager.new(title: "Sir")
+        Manager.new(title: 'Sir')
       end
 
-      context "when no embedded documents are present" do
-        context "when using the default discriminator key" do
+      context 'when no embedded documents are present' do
+        context 'when using the default discriminator key' do
           let(:person) do
             manager.becomes(Person)
           end
 
-          it "copies attributes" do
+          it 'copies attributes' do
             expect(person.title).to eq('Sir')
           end
 
-          it "keeps the same object id" do
+          it 'keeps the same object id' do
             expect(person.id).to eq(manager.id)
           end
 
-          it "sets the class type" do
-            expect(person._type).to eq("Person")
+          it 'sets the class type' do
+            expect(person._type).to eq('Person')
           end
 
-          it "raises an error when inappropriate class is provided" do
-            expect {
+          it 'raises an error when inappropriate class is provided' do
+            expect do
               manager.becomes(String)
-            }.to raise_error(ArgumentError, /A class which includes Mongoid::Document is expected/)
+            end.to raise_error(ArgumentError, /A class which includes Mongoid::Document is expected/)
           end
         end
 
-        context "when using a custom discriminator key" do
+        context 'when using a custom discriminator key' do
           before do
-            Person.discriminator_key = "dkey"
+            Person.discriminator_key = 'dkey'
           end
 
           after do
             Person.discriminator_key = nil
           end
 
-          it "sets the class type with new discriminator key" do
-            expect(person.dkey).to eq("Person")
+          it 'sets the class type with new discriminator key' do
+            expect(person.dkey).to eq('Person')
           end
         end
 
-        context "when using a custom discriminator key and discriminator value" do
+        context 'when using a custom discriminator key and discriminator value' do
           before do
-            Person.discriminator_key = "dkey"
-            Person.discriminator_value = "dvalue"
+            Person.discriminator_key = 'dkey'
+            Person.discriminator_value = 'dvalue'
           end
 
           after do
@@ -844,16 +781,14 @@ describe Mongoid::Document do
             Person.discriminator_value = nil
           end
 
-          it "sets the class type with new discriminator key" do
-            expect(person.dkey).to eq("dvalue")
+          it 'sets the class type with new discriminator key' do
+            expect(person.dkey).to eq('dvalue')
           end
         end
       end
 
-      context "when the document has embedded documents" do
-
-        context "when the attribtues are protected" do
-
+      context 'when the document has embedded documents' do
+        context 'when the attributes are protected' do
           let!(:appointment) do
             manager.appointments.build
           end
@@ -862,44 +797,41 @@ describe Mongoid::Document do
             manager.becomes(Person)
           end
 
-          it "copies the embedded documents" do
+          it 'copies the embedded documents' do
             expect(person.appointments.first).to eq(appointment)
           end
 
-          it "returns new instances" do
-            expect(person.appointments.first).to_not equal(appointment)
+          it 'returns new instances' do
+            expect(person.appointments.first).not_to equal(appointment)
           end
         end
 
-        context "when the attributes are not protected" do
-
-          context "when embedded doc is not persisted" do
-
+        context 'when the attributes are not protected' do
+          context 'when embedded doc is not persisted' do
             let!(:address) do
-              manager.addresses.build(street: "hobrecht")
+              manager.addresses.build(street: 'hobrecht')
             end
 
             let(:person) do
               manager.becomes(Person)
             end
 
-            it "copies the embedded documents" do
+            it 'copies the embedded documents' do
               expect(person.addresses.first).to eq(address)
             end
 
-            it "returns new instances" do
-              expect(person.addresses.first).to_not equal(address)
+            it 'returns new instances' do
+              expect(person.addresses.first).not_to equal(address)
             end
           end
 
-          context "when embedded doc is persisted" do
-
+          context 'when embedded doc is persisted' do
             let(:manager) do
-              Manager.create!(title: "Sir")
+              Manager.create!(title: 'Sir')
             end
 
             let!(:address) do
-              manager.addresses.create!(street: "hobrecht")
+              manager.addresses.create!(street: 'hobrecht')
             end
 
             let(:person) do
@@ -910,45 +842,42 @@ describe Mongoid::Document do
               person.save!
             end
 
-            it "copies the embedded documents" do
+            it 'copies the embedded documents' do
               expect(person.addresses.first).to eq(address)
             end
 
-            it "copies the embedded documents only once" do
+            it 'copies the embedded documents only once' do
               expect(person.reload.addresses.length).to eq(1)
             end
           end
         end
       end
 
-      context "when the document has a localize field" do
-
+      context 'when the document has a localize field' do
         let(:manager) do
-          Manager.new(title: "Sir", desc: "description")
+          Manager.new(title: 'Sir', desc: 'description')
         end
 
         let(:person) do
           manager.becomes(Person)
         end
 
-        it "copies the localize attribute" do
-          expect(person.desc).to eq("description")
+        it 'copies the localize attribute' do
+          expect(person.desc).to eq('description')
         end
       end
 
-      context "when the document is new" do
-
+      context 'when the document is new' do
         let(:person) do
           manager.becomes(Person)
         end
 
-        it "copies the state" do
+        it 'copies the state' do
           expect(person).to be_a_new_record
         end
       end
 
-      context "when the document is persisted" do
-
+      context 'when the document is persisted' do
         before do
           manager.save!
         end
@@ -957,13 +886,12 @@ describe Mongoid::Document do
           manager.becomes(Person)
         end
 
-        it "copies the state" do
+        it 'copies the state' do
           expect(person).to be_persisted
         end
       end
 
-      context "when the document is destroyed" do
-
+      context 'when the document is destroyed' do
         before do
           manager.destroy
         end
@@ -972,35 +900,33 @@ describe Mongoid::Document do
           manager.becomes(Person)
         end
 
-        it "copies the state" do
+        it 'copies the state' do
           expect(person).to be_destroyed
         end
       end
 
-      context "when the document is dirty" do
-
+      context 'when the document is dirty' do
         before do
           manager.save!
-          manager.ssn = "123-22-1234"
+          manager.ssn = '123-22-1234'
         end
 
         let(:person) do
           manager.becomes(Person)
         end
 
-        it "copies over the dirty changes" do
-          expect(person.changes["ssn"]).to eq([ nil, "123-22-1234" ])
+        it 'copies over the dirty changes' do
+          expect(person.changes['ssn']).to eq([ nil, '123-22-1234' ])
         end
 
-        it "adds the _type change" do
-          expect(person.changes["_type"]).to eq([ "Manager", "Person" ])
+        it 'adds the _type change' do
+          expect(person.changes['_type']).to eq(%w[Manager Person])
         end
       end
 
-      context "when the document is invalid" do
-
+      context 'when the document is invalid' do
         before do
-          manager.ssn = "$$$"
+          manager.ssn = '$$$'
           manager.valid?
         end
 
@@ -1008,75 +934,70 @@ describe Mongoid::Document do
           manager.becomes(Person)
         end
 
-        it "copies the errors" do
+        it 'copies the errors' do
           expect(person.errors).to include(:ssn)
         end
       end
     end
 
-    context "when casting to a subclass" do
-
+    context 'when casting to a subclass' do
       let(:person) do
-        Person.new(title: "Sir")
+        Person.new(title: 'Sir')
       end
 
-      context "when no embedded documents are present" do
-
+      context 'when no embedded documents are present' do
         let(:manager) do
           person.becomes(Manager)
         end
 
-        it "copies attributes" do
+        it 'copies attributes' do
           expect(manager.title).to eq('Sir')
         end
 
-        it "keeps the same object id" do
+        it 'keeps the same object id' do
           expect(manager.id).to eq(person.id)
         end
 
-        it "sets the class type" do
-          expect(manager._type).to eq("Manager")
+        it 'sets the class type' do
+          expect(manager._type).to eq('Manager')
         end
 
-        it "raises an error when inappropriate class is provided" do
-          expect {
+        it 'raises an error when inappropriate class is provided' do
+          expect do
             person.becomes(String)
-          }.to raise_error(ArgumentError)
+          end.to raise_error(ArgumentError)
         end
       end
 
-      context "when the document has embedded documents" do
-
+      context 'when the document has embedded documents' do
         let!(:address) do
-          person.addresses.build(street: "hobrecht")
+          person.addresses.build(street: 'hobrecht')
         end
 
         let(:manager) do
           person.becomes(Manager)
         end
 
-        it "copies the embedded documents" do
+        it 'copies the embedded documents' do
           expect(manager.addresses.first).to eq(address)
         end
 
-        it "returns new instances" do
-          expect(manager.addresses.first).to_not equal(address)
+        it 'returns new instances' do
+          expect(manager.addresses.first).not_to equal(address)
         end
       end
 
-      context "when the document is new" do
-
+      context 'when the document is new' do
         let(:manager) do
           person.becomes(Manager)
         end
 
-        it "copies the state" do
+        it 'copies the state' do
           expect(manager).to be_a_new_record
         end
       end
 
-      context "when the document is persisted" do
-
+      context 'when the document is persisted' do
         before do
           person.save!
         end
@@ -1085,36 +1006,34 @@ describe Mongoid::Document do
           person.becomes(Manager)
         end
 
-        it "copies the state" do
+        it 'copies the state' do
           expect(manager).to be_persisted
         end
 
-        context "when downcasted document is saved" do
-
+        context 'when downcasted document is saved' do
           before do
             manager.save!
           end
 
-          it "keeps the type" do
+          it 'keeps the type' do
             expect(manager).to be_an_instance_of(Manager)
           end
 
-          it "copies over the dirty changes" do
-            expect(manager.changes["ssn"]).to eq(person.changes["ssn"])
+          it 'copies over the dirty changes' do
+            expect(manager.changes['ssn']).to eq(person.changes['ssn'])
           end
 
-          it "can by queried by the parent class" do
+          it 'can by queried by the parent class' do
             expect(Person.find(manager.id)).to be_an_instance_of(Manager)
           end
 
-          it "can by queried by the main class" do
+          it 'can by queried by the main class' do
             expect(Manager.find(manager.id)).to be_an_instance_of(Manager)
           end
         end
       end
 
-      context "when the document is destroyed" do
-
+      context 'when the document is destroyed' do
         before do
           person.destroy
         end
@@ -1123,35 +1042,33 @@ describe Mongoid::Document do
           person.becomes(Manager)
         end
 
-        it "copies the state" do
+        it 'copies the state' do
           expect(manager).to be_destroyed
         end
       end
 
-      context "when the document is dirty" do
-
+      context 'when the document is dirty' do
         before do
           person.save!
-          person.ssn = "123-22-1234"
+          person.ssn = '123-22-1234'
         end
 
         let(:manager) do
           person.becomes(Manager)
         end
 
-        it "copies over the dirty changes" do
-          expect(manager.changes["ssn"]).to eq([ nil, "123-22-1234" ])
+        it 'copies over the dirty changes' do
+          expect(manager.changes['ssn']).to eq([ nil, '123-22-1234' ])
         end
 
-        it "adds the _type change" do
-          expect(manager.changes["_type"]).to eq([ "Person", "Manager" ])
+        it 'adds the _type change' do
+          expect(manager.changes['_type']).to eq(%w[Person Manager])
         end
       end
 
-      context "when the document is invalid" do
-
+      context 'when the document is invalid' do
         before do
-          person.ssn = "$$$"
+          person.ssn = '$$$'
           person.valid?
         end
 
@@ -1159,99 +1076,90 @@ describe Mongoid::Document do
           person.becomes(Manager)
         end
 
-        it "copies the errors" do
+        it 'copies the errors' do
           expect(manager.errors).to include(:ssn)
         end
-
       end
 
-      context "when the subclass validates attributes not present on the parent class" do
-
+      context 'when the subclass validates attributes not present on the parent class' do
         before do
-          Manager.validates_inclusion_of(:level, in: [1, 2])
+          Manager.validates_inclusion_of(:level, in: [ 1, 2 ])
         end
 
         let(:manager) do
           person.becomes(Manager)
         end
 
-        it "validates the instance of the subclass" do
+        it 'validates the instance of the subclass' do
           manager.level = 3
           expect(manager.valid?).to be false
         end
       end
 
-      context "when the subclass has defaults" do
-
+      context 'when the subclass has defaults' do
         let(:manager) do
           Person.new(title: 'Sir').becomes(Manager)
         end
 
-        it "applies default attributes" do
+        it 'applies default attributes' do
           expect(manager.level).to eq(1)
         end
       end
     end
   end
 
-  context "when marshalling the document" do
-
+  context 'when marshalling the document' do
     let(:agency) do
       Agency.new
     end
 
     let!(:agent) do
-      agency.agents.build(title: "VIP")
+      agency.agents.build(title: 'VIP')
     end
 
-    describe Marshal, ".dump" do
-
-      it "successfully dumps the document" do
-        expect {
+    describe Marshal, '.dump' do
+      it 'successfully dumps the document' do
+        expect do
           Marshal.dump(agency)
           Marshal.dump(agent)
-        }.not_to raise_error
+        end.not_to raise_error
       end
     end
 
-    describe Marshal, ".load" do
-
-      it "successfully loads the document" do
+    describe Marshal, '.load' do
+      it 'successfully loads the document' do
         expect(Marshal.load(Marshal.dump(agency))).to eq(agency)
       end
     end
   end
 
-  context "when putting a document in the cache" do
-
+  context 'when putting a document in the cache' do
     describe ActiveSupport::Cache do
-
       let(:cache) do
         ActiveSupport::Cache::MemoryStore.new
       end
 
-      describe "#fetch" do
-
+      describe '#fetch' do
         let(:agency) do
           Agency.new
         end
 
         let(:agent) do
-          agency.agents.build(title: "VIP", address: address)
+          agency.agents.build(title: 'VIP', address: address)
         end
 
         let(:address) do
           Address.new(city: 'Berlin')
         end
 
-        it "stores the parent object" do
-          expect(cache.fetch("key") { agency }).to eq(agency)
-          expect(cache.fetch("key")).to eq(agency)
+        it 'stores the parent object' do
+          expect(cache.fetch('key') { agency }).to eq(agency)
+          expect(cache.fetch('key')).to eq(agency)
         end
 
-        it "stores the embedded object" do
-          expect(cache.fetch("key") { agent }).to eq(agent)
-          expect(cache.fetch("key").address).to eq(agent.address)
+        it 'stores the embedded object' do
+          expect(cache.fetch('key') { agent }).to eq(agent)
+          expect(cache.fetch('key').address).to eq(agent.address)
         end
       end
     end