mongoid 9.0.11 → 9.1.0

data/spec/mongoid/reloadable_spec.rb

@@ -1,14 +1,128 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Reloadable do
+  describe '#reload' do
+    context 'when called during after_save' do
+      context 'when using non-sharded documents' do
+        class NonShardedProfile
+          include Mongoid::Document
 
-  describe "#reload" do
+          attr_reader :after_save_count, :after_save_name_val
 
-    context 'when persistence options are set' do
+          field :name, type: String
+
+          after_save :on_after_save
+
+          def on_after_save
+            @after_save_count = @after_save_count ? @after_save_count + 1 : 1
+
+            reload
+
+            @after_save_name_val = name
+          end
+        end
+
+        context 'when using reload during a post-persist callback' do
+          context 'when document is not yet persisted' do
+            context 'when after_save' do
+              let(:profile) do
+                NonShardedProfile.new(name: 'Alice')
+              end
+
+              it 'reloads successfully' do
+                expect(profile.after_save_count).to be_nil
+                expect(profile.after_save_name_val).to be_nil
+                profile.name = 'Bob'
+                profile.save
+                expect(profile.after_save_count).to eq(1)
+                expect(profile.after_save_name_val).to eq('Bob')
+              end
+            end
+          end
+
+          context 'when document is already persisted' do
+            context 'when after_save' do
+              let(:profile) do
+                NonShardedProfile.create(name: 'Alice')
+              end
+
+              it 'reloads successfully' do
+                expect(profile.after_save_count).to eq(1)
+                expect(profile.after_save_name_val).to eq('Alice')
+                profile.name = 'Bob'
+                profile.save
+                expect(profile.after_save_count).to eq(2)
+                expect(profile.after_save_name_val).to eq('Bob')
+              end
+            end
+          end
+        end
+      end
+
+      context 'when using sharded documents' do
+        require_topology :sharded
+
+        class ShardedProfile
+          include Mongoid::Document
+
+          attr_reader :after_save_count, :after_save_name_val
+
+          field :name, type: String
+
+          shard_key :name
+
+          after_save :on_after_save
+
+          def on_after_save
+            @after_save_count = @after_save_count ? @after_save_count + 1 : 1
+
+            reload
 
+            @after_save_name_val = name
+          end
+        end
+
+        context 'when using reload during a post-persist callback' do
+          context 'when document is not yet persisted' do
+            context 'when after_save' do
+              let(:profile) do
+                ShardedProfile.new(name: 'Alice')
+              end
+
+              it 'reloads successfully' do
+                expect(profile.after_save_count).to be_nil
+                expect(profile.after_save_name_val).to be_nil
+                profile.name = 'Bob'
+                profile.save
+                expect(profile.after_save_count).to eq(1)
+                expect(profile.after_save_name_val).to eq('Bob')
+              end
+            end
+          end
+
+          context 'when document is already persisted' do
+            context 'when after_save' do
+              let(:profile) do
+                ShardedProfile.create(name: 'Alice')
+              end
+
+              it 'reloads successfully' do
+                expect(profile.after_save_count).to eq(1)
+                expect(profile.after_save_name_val).to eq('Alice')
+                profile.name = 'Bob'
+                profile.save
+                expect(profile.after_save_count).to eq(2)
+                expect(profile.after_save_name_val).to eq('Bob')
+              end
+            end
+          end
+        end
+      end
+    end
+
+    context 'when persistence options are set' do
       let(:person) do
         Person.with(collection: 'other') do |person_class|
           person_class.create!
@@ -26,8 +140,7 @@ describe Mongoid::Reloadable do
       end
     end
 
-    context "when using bson ids" do
-
+    context 'when using bson ids' do
       let(:person) do
         Person.create!
       end
@@ -39,43 +152,41 @@ describe Mongoid::Reloadable do
         end
       end
 
-      it "reloads the object attributes from the db" do
+      it 'reloads the object attributes from the db' do
         person.reload
         expect(person.age).to eq(35)
       end
 
-      it "reload should return self" do
+      it 'reload should return self' do
         expect(person.reload).to eq(from_db)
       end
     end
 
-    context "when using string ids" do
-
+    context 'when using string ids' do
       let(:account) do
-        Account.create!(name: "bank", number: "1000")
+        Account.create!(name: 'bank', number: '1000')
       end
 
       let!(:from_db) do
         Account.find(account.id).tap do |acc|
-          acc.number = "1001"
+          acc.number = '1001'
           acc.save!
         end
       end
 
-      it "reloads the object attributes from the db" do
+      it 'reloads the object attributes from the db' do
         account.reload
-        expect(account.number).to eq("1001")
+        expect(account.number).to eq('1001')
       end
 
-      it "reload should return self" do
+      it 'reload should return self' do
         expect(account.reload).to eq(from_db)
       end
     end
 
-    context "when an after initialize callback is defined" do
-
+    context 'when an after initialize callback is defined' do
       let!(:book) do
-        Book.create!(title: "Snow Crash")
+        Book.create!(title: 'Snow Crash')
       end
 
       before do
@@ -83,56 +194,52 @@ describe Mongoid::Reloadable do
         book.reload
       end
 
-      it "runs the callback" do
+      it 'runs the callback' do
         expect(book.chapters).to eq(5)
       end
     end
 
-    context "when the document was dirty" do
-
+    context 'when the document was dirty' do
       let(:person) do
         Person.create!
       end
 
       before do
-        person.title = "Sir"
+        person.title = 'Sir'
         person.reload
       end
 
-      it "resets the dirty modifications" do
+      it 'resets the dirty modifications' do
         expect(person.changes).to be_empty
       end
 
-      it "resets attributes_before_type_cast" do
+      it 'resets attributes_before_type_cast' do
         expect(person.attributes_before_type_cast).to eq(person.attributes)
       end
     end
 
-    context "when document not saved" do
-
-      context "when there is no document matching our id" do
-
-        it "raises an error" do
-          expect {
+    context 'when document not saved' do
+      context 'when there is no document matching our id' do
+        it 'raises an error' do
+          expect do
             Person.new.reload
-          }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Person with id\(s\)/)
+          end.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Person with id\(s\)/)
         end
       end
 
       context 'when there is a document matching our id' do
-
         let!(:previous) { Agent.create!(title: '007') }
 
         let(:agent) { Agent.new(id: previous.id) }
 
         it 'loads the existing document' do
-          agent.title.should be nil
+          agent.title.should be_nil
 
           lambda do
             agent.reload
           end.should_not raise_error
 
-          agent.title.should == '007'
+          agent.title.should eq '007'
         end
 
         it 'sets new_record to false' do
@@ -147,160 +254,168 @@ describe Mongoid::Reloadable do
       end
     end
 
-    context "when the document is embedded" do
-
+    context 'when the document is embedded' do
       let(:person) do
         Person.create!
       end
 
-      context "when embedded a single level" do
-
+      context 'when embedded a single level' do
         context 'when persistence options are set' do
-
           let(:person) do
             Person.with(collection: 'other') do |person_class|
               person_class.create!
             end
           end
 
-          let!(:address) do
+          let(:reloaded) do
+            person.with(collection: 'other') do |_person_class|
+              person.addresses.first.reload
+            end
+          end
+
+          let(:address) do
             person.with(collection: 'other') do |person_object|
-              person_object.addresses.create!(street: "Abbey Road", number: 4)
+              person_object.addresses.create!(street: 'Abbey Road', number: 4)
             end
           end
 
           before do
+            address
+
             Person.mongo_client[:other].find(
-                { "_id" => person.id }
-            ).update_one({ "$set" => { "addresses.0.number" => 3 }})
-          end
+              { '_id' => person.id }
+            ).update_one({ '$set' => { 'addresses.0.number' => 3 } })
 
-          let!(:reloaded) do
-            person.with(collection: 'other') do |person_class|
-              person.addresses.first.reload
-            end
+            reloaded
           end
 
-          it "reloads the embedded document attributes" do
+          it 'reloads the embedded document attributes' do
             expect(reloaded.number).to eq(3)
           end
-
         end
 
-        context "when the relation is an embeds many" do
+        context 'when the relation is an embeds many' do
+          let(:address) do
+            person.addresses.create!(street: 'Abbey Road', number: 4)
+          end
 
-          let!(:address) do
-            person.addresses.create!(street: "Abbey Road", number: 4)
+          let(:reloaded) do
+            address.reload
           end
 
           before do
+            address
+
             Person.collection.find(
-              { "_id" => person.id }
-            ).update_one({ "$set" => { "addresses.0.number" => 3 }})
-          end
+              { '_id' => person.id }
+            ).update_one({ '$set' => { 'addresses.0.number' => 3 } })
 
-          let!(:reloaded) do
-            address.reload
+            reloaded
           end
 
-          it "reloads the embedded document attributes" do
+          it 'reloads the embedded document attributes' do
             expect(reloaded.number).to eq(3)
           end
 
-          it "reloads the reference on the parent" do
+          it 'reloads the reference on the parent' do
             expect(person.addresses.first).to eq(reloaded)
           end
 
-          it "retains the relation to the parent" do
+          it 'retains the relation to the parent' do
             expect(reloaded.addressable).to eq(person)
           end
         end
 
-        context "when the relation is an embeds one" do
+        context 'when the relation is an embeds one' do
+          let(:name) do
+            person.create_name(first_name: 'Syd')
+          end
 
-          let!(:name) do
-            person.create_name(first_name: "Syd")
+          let(:reloaded) do
+            name.reload
           end
 
           before do
-            Person.collection.find({ "_id" => person.id }).
-              update_one({ "$set" => { "name.last_name" => "Vicious" }})
-          end
+            name
 
-          let!(:reloaded) do
-            name.reload
+            Person.collection.find({ '_id' => person.id })
+                  .update_one({ '$set' => { 'name.last_name' => 'Vicious' } })
+
+            reloaded
           end
 
-          it "reloads the embedded document attributes" do
-            expect(reloaded.last_name).to eq("Vicious")
+          it 'reloads the embedded document attributes' do
+            expect(reloaded.last_name).to eq('Vicious')
           end
 
-          it "reloads the reference on the parent" do
+          it 'reloads the reference on the parent' do
             expect(person.name).to eq(reloaded)
           end
 
-          it "retains the relation to the parent" do
+          it 'retains the relation to the parent' do
             expect(reloaded.namable).to eq(person)
           end
         end
       end
 
-      context "when the relation is embedded multiple levels" do
+      context 'when the relation is embedded multiple levels' do
+        let(:address) do
+          person.addresses.create!(street: 'Abbey Road', number: 3)
+        end
 
-        let!(:address) do
-          person.addresses.create!(street: "Abbey Road", number: 3)
+        let(:reloaded) do
+          location.reload
         end
 
-        let!(:location) do
-          address.locations.create!(name: "home")
+        let(:location) do
+          address.locations.create!(name: 'home')
         end
 
         before do
-          Person.collection.find({ "_id" => person.id }).
-            update_one({ "$set" => { "addresses.0.locations.0.name" => "work" }})
-        end
+          address
+          location
 
-        let!(:reloaded) do
-          location.reload
+          Person.collection.find({ '_id' => person.id })
+                .update_one({ '$set' => { 'addresses.0.locations.0.name' => 'work' } })
+
+          reloaded
         end
 
-        it "reloads the embedded document attributes" do
-          expect(reloaded.name).to eq("work")
+        it 'reloads the embedded document attributes' do
+          expect(reloaded.name).to eq('work')
         end
 
-        it "reloads the reference on the parent" do
+        it 'reloads the reference on the parent' do
           expect(address.locations.first).to eq(reloaded)
         end
 
-        it "reloads the reference on the root" do
+        it 'reloads the reference on the root' do
           expect(person.addresses.first.locations.first).to eq(reloaded)
         end
       end
     end
 
-    context "when embedded documents change" do
-
+    context 'when embedded documents change' do
       let(:person) do
         Person.create!
       end
 
       let!(:address) do
-        person.addresses.create!(number: 27, street: "Maiden Lane")
+        person.addresses.create!(number: 27, street: 'Maiden Lane')
       end
 
       before do
-        Person.collection.find({ "_id" => person.id }).
-          update_one({ "$set" => { "addresses" => [] }})
+        Person.collection.find({ '_id' => person.id })
+              .update_one({ '$set' => { 'addresses' => [] } })
         person.reload
       end
 
-      it "reloads the association" do
+      it 'reloads the association' do
         expect(person.addresses).to be_empty
       end
     end
 
-    context "when embedded documents are unasssigned and reassigned" do
-
+    context 'when embedded documents are unassigned and reassigned' do
       let(:palette) do
         Palette.new
       end
@@ -317,13 +432,12 @@ describe Mongoid::Reloadable do
         canvas.reload
       end
 
-      it "reloads the embedded document correctly" do
+      it 'reloads the embedded document correctly' do
         expect(canvas.palette).to eq(palette)
       end
     end
 
-    context "when embeds_many documents are cleared and reassigned" do
-
+    context 'when embeds_many documents are cleared and reassigned' do
       let(:contractor) do
         Contractor.new(name: 'contractor')
       end
@@ -332,16 +446,16 @@ describe Mongoid::Reloadable do
         Building.create!
       end
 
-      it "persists an embedded document correctly the second time" do
+      it 'persists an embedded document correctly the second time' do
         building.contractors << contractor
-        expect(building.contractors).to eq([contractor])
+        expect(building.contractors).to eq([ contractor ])
 
         building.contractors.clear
         expect(building.contractors).to eq([])
 
         building.contractors << contractor
         building.reload
-        expect(building.contractors).to eq([contractor])
+        expect(building.contractors).to eq([ contractor ])
       end
     end
 
@@ -369,11 +483,13 @@ describe Mongoid::Reloadable do
       end
     end
 
-    context "when embedded document is nil" do
-
+    context 'when embedded document is nil' do
       let(:palette) do
         Palette.new
       end
+      let(:reload) do
+        palette.reload
+      end
 
       let(:canvas) do
         Canvas.create!(palette: palette)
@@ -383,63 +499,54 @@ describe Mongoid::Reloadable do
         canvas.palette = nil
       end
 
-      let(:reload) do
-        palette.reload
-      end
-
-      it "raises a document not found error" do
+      it 'raises a document not found error' do
         expect do
           reload
         end.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Palette with id\(s\)/)
       end
     end
 
-    context "with relational associations" do
-
+    context 'with relational associations' do
       let(:person) do
         Person.create!
       end
 
-      context "for a has_one" do
-
+      context 'for a has_one' do
         let!(:game) do
           person.create_game(score: 50)
         end
 
         before do
-          Game.collection.find({ "_id" => game.id }).
-            update_one({ "$set" => { "score" => 75 }})
+          Game.collection.find({ '_id' => game.id })
+              .update_one({ '$set' => { 'score' => 75 } })
           person.reload
         end
 
-        it "reloads the association" do
+        it 'reloads the association' do
           expect(person.game.score).to eq(75)
         end
       end
 
-      context "for a belongs_to" do
-
-        context "when the relation type does not change" do
-
+      context 'for a belongs_to' do
+        context 'when the relation type does not change' do
           let!(:game) do
             person.create_game(score: 50)
           end
 
           before do
-            Person.collection.find({ "_id" => person.id }).
-              update_one({ "$set" => { "title" => "Mam" }})
+            Person.collection.find({ '_id' => person.id })
+                  .update_one({ '$set' => { 'title' => 'Mam' } })
             game.reload
           end
 
-          it "reloads the association" do
-            expect(game.person.title).to eq("Mam")
+          it 'reloads the association' do
+            expect(game.person.title).to eq('Mam')
           end
         end
       end
     end
 
-    context "when overriding #id alias" do
-
+    context 'when overriding #id alias' do
       let!(:object) do
         IdKey.create!(key: 'foo')
       end
@@ -451,23 +558,22 @@ describe Mongoid::Reloadable do
         end
       end
 
-      it "reloads the object attributes from the db" do
+      it 'reloads the object attributes from the db' do
         object.reload
         expect(object.key).to eq('bar')
       end
 
-      it "reload should return self" do
+      it 'reload should return self' do
         expect(object.reload).to eq(from_db)
       end
     end
 
     context 'when the document is readonly' do
-
       before do
         Person.create!
       end
 
-      context "when legacy_readonly is on" do
+      context 'when legacy_readonly is on' do
         config_override :legacy_readonly, true
 
         let(:reloaded) do
@@ -479,7 +585,7 @@ describe Mongoid::Reloadable do
         end
       end
 
-      context "when legacy_readonly is off" do
+      context 'when legacy_readonly is off' do
         config_override :legacy_readonly, false
 
         let(:reloaded) do
@@ -510,13 +616,13 @@ describe Mongoid::Reloadable do
       let(:subscriber) do
         client = Mongoid::Clients.with_name(:other)
         monitoring = client.send(:monitoring)
-        subscriber = monitoring.subscribers['Command'].find do |s|
+        monitoring.subscribers['Command'].find do |s|
           s.is_a?(EventSubscriber)
         end
       end
 
       let(:find_events) do
-        find_events = subscriber.started_events.select { |event| event.command_name.to_s == 'find' }
+        subscriber.started_events.select { |event| event.command_name.to_s == 'find' }
       end
 
       before do
@@ -537,14 +643,13 @@ describe Mongoid::Reloadable do
         end
 
         it 'uses the shard key to reload the document' do
-          expect(find_events.length). to eq(1)
+          expect(find_events.length).to eq(1)
 
           event = find_events.first
           expect(event.command['filter'].keys).to include('name')
         end
       end
 
-
       context 'with embedded document' do
         let(:profile_image) do
           Profile.with(client: :other) do |klass|
@@ -560,7 +665,7 @@ describe Mongoid::Reloadable do
         end
 
         it 'uses the shard key to reload the embedded document' do
-          expect(find_events.length). to eq(1)
+          expect(find_events.length).to eq(1)
 
           event = find_events.first
           expect(event.command['filter'].keys).to include('name')
@@ -579,11 +684,11 @@ describe Mongoid::Reloadable do
         end
 
         it 'reloads the document' do
-          band.name.should == 'test'
+          band.name.should eq 'test'
 
           band.reload
 
-          band.name.should == 'Sun Project'
+          band.name.should eq 'Sun Project'
         end
       end
 
@@ -596,12 +701,12 @@ describe Mongoid::Reloadable do
 
         it 'creates a new document with default values' do
           original_id = band.id
-          band.name.should == 'test'
+          band.name.should eq 'test'
 
           band.reload
 
-          band.name.should be nil
-          band.id.should_not be nil
+          band.name.should be_nil
+          band.id.should_not be_nil
           # _id changes
           band.id.should_not == original_id
         end
@@ -624,7 +729,7 @@ describe Mongoid::Reloadable do
 
     context 'when document has referenced associations' do
       let!(:church) do
-        Church.create!(name: 'Test', acolytes: [Acolyte.new(name: 'Borg')])
+        Church.create!(name: 'Test', acolytes: [ Acolyte.new(name: 'Borg') ])
       end
 
       before do
@@ -632,13 +737,13 @@ describe Mongoid::Reloadable do
       end
 
       it 'resets the associations' do
-        church.acolytes.first.name.should == 'test'
+        church.acolytes.first.name.should eq 'test'
 
         church.reload
 
         church.acolytes._loaded?.should be false
 
-        church.acolytes.first.name.should == 'Borg'
+        church.acolytes.first.name.should eq 'Borg'
       end
     end
 
@@ -654,7 +759,7 @@ describe Mongoid::Reloadable do
           person.reload
         end
 
-        it "resets previous changes" do
+        it 'resets previous changes' do
           expect(person.title_previously_was).to be_nil
           expect(person).not_to be_previously_persisted
         end
@@ -669,7 +774,7 @@ describe Mongoid::Reloadable do
           person.reload
         end
 
-        it "resets previous changes" do
+        it 'resets previous changes' do
           expect(person).not_to be_previously_new_record
         end
       end