mongoid 5.4.1 → 7.4.0

data/spec/mongoid/relations/proxy_spec.rb

@@ -1,98 +1,126 @@
-require "spec_helper"
-
-describe Mongoid::Relations::Proxy do
-
-  describe '#with', if: non_legacy_server? do
-
-    let(:circus) do
-      Circus.new
-    end
-
-    let(:animal) do
-      Animal.new
-    end
-
-    before do
-      circus.animals << animal
-      circus.save
-    end
-
-    it 'uses the new persistence options' do
-      expect {
-        animal.with(write: { w: 100 }).update_attribute(:name, 'kangaroo')
-      }.to raise_exception(Mongo::Error::OperationFailure)
-    end
-  end
-
-  describe "#find" do
-    let(:person) do
-      Person.create
-    end
-
-    let(:messages) do
-      person.messages
-    end
-
-    let(:msg1) do
-      messages.create(body: 'msg1')
-    end
-
-    it "returns nil with no arguments" do
-      expect(messages.find).to be_nil
-      expect(messages.send(:find)).to be_nil
-      expect(messages.__send__(:find)).to be_nil
-      expect(messages.public_send(:find)).to be_nil
-    end
-
-    it "returns the object corresponding to the id" do
-      expect(messages.find(msg1.id)).to eq(msg1)
-      expect(messages.send(:find, msg1.id)).to eq(msg1)
-      expect(messages.__send__(:find, msg1.id)).to eq(msg1)
-      expect(messages.public_send(:find, msg1.id)).to eq(msg1)
-    end
-  end
-
-  describe "#extend" do
-
-    before(:all) do
-      Person.reset_callbacks(:validate)
-      module Testable
-      end
-    end
-
-    after(:all) do
-      Object.send(:remove_const, :Testable)
-    end
-
-    let(:person) do
-      Person.create
-    end
-
-    let(:name) do
-      person.build_name
-    end
-
-    before do
-      name.namable.extend(Testable)
-    end
-
-    it "extends the proxied object" do
-      expect(person).to be_a(Testable)
-    end
-
-    context "when extending from the relation definition" do
-
-      let!(:address) do
-        person.addresses.create(street: "hobrecht")
-      end
-
-      let(:found) do
-        person.addresses.find_by_street("hobrecht")
-      end
-
-      it "extends the proxy" do
-        expect(found).to eq(address)
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+# require "spec_helper"
+#
+# describe Mongoid::Relations::Proxy do
+#
+#   describe '#with' do
+#
+#     let(:circus) do
+#       Circus.new
+#     end
+#
+#     let(:animal) do
+#       Animal.new
+#     end
+#
+#     before do
+#       circus.animals << animal
+#       circus.save!
+#     end
+#
+#     it 'uses the new persistence options' do
+#       expect {
+#         animal.with(write: { w: 100 }) do |an|
+#           an.update_attribute(:name, 'kangaroo')
+#         end
+#       }.to raise_exception(Mongo::Error::OperationFailure)
+#     end
+#   end
+#
+#   describe "#find" do
+#     let(:person) do
+#       Person.create!
+#     end
+#
+#     let(:messages) do
+#       person.messages
+#     end
+#
+#     let(:msg1) do
+#       messages.create!(body: 'msg1')
+#     end
+#
+#     it "returns nil with no arguments" do
+#       expect(messages.find).to be_nil
+#       expect(messages.send(:find)).to be_nil
+#       expect(messages.__send__(:find)).to be_nil
+#       expect(messages.public_send(:find)).to be_nil
+#     end
+#
+#     it "returns the object corresponding to the id" do
+#       expect(messages.find(msg1.id)).to eq(msg1)
+#       expect(messages.send(:find, msg1.id)).to eq(msg1)
+#       expect(messages.__send__(:find, msg1.id)).to eq(msg1)
+#       expect(messages.public_send(:find, msg1.id)).to eq(msg1)
+#     end
+#   end
+#
+#   describe "#extend" do
+#
+#     before(:all) do
+#       Person.reset_callbacks(:validate)
+#       module Testable
+#       end
+#     end
+#
+#     after(:all) do
+#       Object.send(:remove_const, :Testable)
+#     end
+#
+#     let(:person) do
+#       Person.create!
+#     end
+#
+#     let(:name) do
+#       person.build_name
+#     end
+#
+#     before do
+#       name.namable.extend(Testable)
+#     end
+#
+#     it "extends the proxied object" do
+#       expect(person).to be_a(Testable)
+#     end
+#
+#     context "when extending from the relation definition" do
+#
+#       let!(:address) do
+#         person.addresses.create!(street: "hobrecht")
+#       end
+#
+#       let(:found) do
+#         person.addresses.find_by_street("hobrecht")
+#       end
+#
+#       it "extends the proxy" do
+#         expect(found).to eq(address)
+#       end
+#     end
+#   end
+#
+#   describe "equality" do
+#     let(:messages) do
+#       Person.create!.messages
+#     end
+#
+#     it "is #equal? to itself" do
+#       expect(messages.equal?(messages)).to eq(true)
+#     end
+#
+#     it "is == to itself" do
+#       expect(messages == messages).to eq(true)
+#     end
+#
+#     it "is not #equal? to its target" do
+#       expect(messages.equal?(messages.target)).to eq(false)
+#       expect(messages.target.equal?(messages)).to eq(false)
+#     end
+#
+#     it "is == to its target" do
+#       expect(messages == messages.target).to eq(true)
+#       expect(messages.target == messages).to eq(true)
+#     end
+#   end
+# end

data/spec/mongoid/reloadable_spec.rb

@@ -1,19 +1,40 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Mongoid::Reloadable do
 
   describe "#reload" do
 
+    context 'when persistence options are set' do
+
+      let(:person) do
+        Person.with(collection: 'other') do |person_class|
+          person_class.create!
+        end
+      end
+
+      let(:reloaded) do
+        Person.with(collection: 'other') do |person_class|
+          person_class.first
+        end
+      end
+
+      it 'applies the persistence options' do
+        expect(person).to eq(reloaded)
+      end
+    end
+
     context "when using bson ids" do
 
       let(:person) do
-        Person.create
+        Person.create!
       end
 
       let!(:from_db) do
         Person.find(person.id).tap do |peep|
           peep.age = 35
-          peep.save
+          peep.save!
         end
       end
 
@@ -30,13 +51,13 @@ describe Mongoid::Reloadable 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.save
+          acc.save!
         end
       end
 
@@ -53,7 +74,7 @@ describe Mongoid::Reloadable 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
@@ -69,7 +90,7 @@ describe Mongoid::Reloadable do
     context "when the document was dirty" do
 
       let(:person) do
-        Person.create
+        Person.create!
       end
 
       before do
@@ -88,7 +109,7 @@ describe Mongoid::Reloadable do
 
     context "when document not saved" do
 
-      context "when raising not found error" do
+      context "when there is no document matching our id" do
 
         it "raises an error" do
           expect {
@@ -96,20 +117,69 @@ describe Mongoid::Reloadable do
           }.to raise_error(Mongoid::Errors::DocumentNotFound)
         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
+
+          lambda do
+            agent.reload
+          end.should_not raise_error
+
+          agent.title.should == '007'
+        end
+      end
     end
 
     context "when the document is embedded" do
 
       let(:person) do
-        Person.create
+        Person.create!
       end
 
       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
+            person.with(collection: 'other') do |person_object|
+              person_object.addresses.create!(street: "Abbey Road", number: 4)
+            end
+          end
+
+          before do
+            Person.mongo_client[:other].find(
+                { "_id" => person.id }
+            ).update_one({ "$set" => { "addresses.0.number" => 3 }})
+          end
+
+          let!(:reloaded) do
+            person.with(collection: 'other') do |person_class|
+              person.addresses.first.reload
+            end
+          end
+
+          it "reloads the embedded document attributes" do
+            expect(reloaded.number).to eq(3)
+          end
+
+        end
+
         context "when the relation is an embeds many" do
 
           let!(:address) do
-            person.addresses.create(street: "Abbey Road", number: 4)
+            person.addresses.create!(street: "Abbey Road", number: 4)
           end
 
           before do
@@ -167,11 +237,11 @@ describe Mongoid::Reloadable do
       context "when the relation is embedded multiple levels" do
 
         let!(:address) do
-          person.addresses.create(street: "Abbey Road", number: 3)
+          person.addresses.create!(street: "Abbey Road", number: 3)
         end
 
         let!(:location) do
-          address.locations.create(name: "home")
+          address.locations.create!(name: "home")
         end
 
         before do
@@ -200,11 +270,11 @@ describe Mongoid::Reloadable do
     context "when embedded documents change" do
 
       let(:person) do
-        Person.create
+        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
@@ -218,10 +288,137 @@ describe Mongoid::Reloadable do
       end
     end
 
+    context "when embedded documents are unasssigned and reassigned" do
+
+      context "when broken_updates feature flag is not set" do
+        config_override :broken_updates, false
+
+        let(:palette) do
+          Palette.new
+        end
+
+        let(:canvas) do
+          Canvas.create!
+        end
+
+        before do
+          canvas.palette = palette
+          canvas.palette = nil
+          canvas.palette = palette
+          canvas.save!
+          canvas.reload
+        end
+
+        it "reloads the embedded document correctly" do
+          expect(canvas.palette).to eq(palette)
+        end
+      end
+
+      context "when broken_updates feature flag is set" do
+        config_override :broken_updates, true
+
+        let(:palette) do
+          Palette.new
+        end
+
+        let(:canvas) do
+          Canvas.create!
+        end
+
+        before do
+          canvas.palette = palette
+          canvas.palette = nil
+          canvas.palette = palette
+          canvas.save!
+          canvas.reload
+        end
+
+        it "does not reload the embedded document correctly" do
+          expect(canvas.palette).to be_nil
+        end
+      end
+    end
+
+    context "when embeds_many documents are cleared and reassigned" do
+
+      context "when broken_updates feature flag is not set" do
+        config_override :broken_updates, false
+
+        let(:contractor) do
+          Contractor.new(name: 'contractor')
+        end
+
+        let(:building) do
+          Building.create!
+        end
+
+        it "persists an embedded document correctly the second time" do
+          building.contractors << 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])
+        end
+      end
+
+      context "when broken_updates feature flag is set" do
+        config_override :broken_updates, true
+
+        let(:contractor) do
+          Contractor.new(name: 'contractor')
+        end
+
+        let(:building) do
+          Building.create!
+        end
+
+        it "doesn't persist the embedded document correctly the second time" do
+          building.contractors << 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([])
+        end
+      end
+    end
+
+    context "when embedded document is nil" do
+
+      let(:palette) do
+        Palette.new
+      end
+
+      let(:canvas) do
+        Canvas.create!(palette: palette)
+      end
+
+      before do
+        canvas.palette = nil
+      end
+
+      let(:reload) do
+        palette.reload
+      end
+
+      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
 
       let(:person) do
-        Person.create
+        Person.create!
       end
 
       context "for a has_one" do
@@ -265,13 +462,13 @@ describe Mongoid::Reloadable do
     context "when overriding #id alias" do
 
       let!(:object) do
-        IdKey.create(key: 'foo')
+        IdKey.create!(key: 'foo')
       end
 
       let!(:from_db) do
         IdKey.find(object._id).tap do |object|
           object.key = 'bar'
-          object.save
+          object.save!
         end
       end
 
@@ -288,7 +485,7 @@ describe Mongoid::Reloadable do
     context 'when the document is readonly' do
 
       before do
-        Person.create
+        Person.create!
       end
 
       let(:reloaded) do
@@ -299,5 +496,137 @@ describe Mongoid::Reloadable do
         expect(reloaded.readonly?).to be(false)
       end
     end
+
+    context 'on sharded cluster' do
+      require_topology :sharded
+
+      before(:all) do
+        CONFIG[:clients][:other] = CONFIG[:clients][:default].dup
+        CONFIG[:clients][:other][:database] = 'other'
+        Mongoid::Clients.clients.values.each(&:close)
+        Mongoid::Config.send(:clients=, CONFIG[:clients])
+        Mongoid::Clients.with_name(:other).subscribe(Mongo::Monitoring::COMMAND, EventSubscriber.new)
+      end
+
+      let(:subscriber) do
+        client = Mongoid::Clients.with_name(:other)
+        monitoring = client.send(:monitoring)
+        subscriber = 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' }
+      end
+
+      before do
+        subscriber.clear_events!
+      end
+
+      context 'without embedded document' do
+        let(:profile) do
+          Profile.with(client: :other) do |klass|
+            klass.create!
+          end
+        end
+
+        before do
+          Profile.with(client: :other) do
+            profile.reload
+          end
+        end
+
+        it 'uses the shard key to reload the document' do
+          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|
+            profile = klass.create!
+            ProfileImage.create!(profile: profile)
+          end
+        end
+
+        before do
+          Profile.with(client: :other) do
+            profile_image.reload
+          end
+        end
+
+        it 'uses the shard key to reload the embedded document' do
+          expect(find_events.length). to eq(1)
+
+          event = find_events.first
+          expect(event.command['filter'].keys).to include('name')
+        end
+      end
+    end
+
+    context 'when raise_not_found_error is false' do
+      config_override :raise_not_found_error, false
+
+      let!(:band) { Band.create!(name: 'Sun Project') }
+
+      context 'when document exists in the database' do
+        before do
+          band.name = 'test'
+        end
+
+        it 'reloads the document' do
+          band.name.should == 'test'
+
+          band.reload
+
+          band.name.should == 'Sun Project'
+        end
+      end
+
+      context 'when document does not exist in the database' do
+        before do
+          band.name = 'test'
+
+          band.destroy
+        end
+
+        it 'creates a new document with default values' do
+          original_id = band.id
+          band.name.should == 'test'
+
+          band.reload
+
+          band.name.should be nil
+          band.id.should_not be nil
+          # _id changes
+          band.id.should_not == original_id
+        end
+      end
+    end
+
+    context 'when document has referenced associations' do
+      let!(:church) do
+        Church.create!(name: 'Test', acolytes: [Acolyte.new(name: 'Borg')])
+      end
+
+      before do
+        church.acolytes.first.name = 'test'
+      end
+
+      it 'resets the associations' do
+        church.acolytes.first.name.should == 'test'
+
+        church.reload
+
+        church.acolytes._loaded?.should be false
+
+        church.acolytes.first.name.should == 'Borg'
+      end
+    end
   end
 end