mongoid 7.1.6 → 7.2.0.rc1

data/spec/mongoid/association/referenced/has_many_models.rb

@@ -6,6 +6,9 @@ class HmmCompany
 
   field :p, type: Integer
   has_many :emails, primary_key: :p, foreign_key: :f, class_name: 'HmmEmail'
+
+  # The addresses are added with different dependency mechanisms in tests:
+  #has_many :addresses, class_name: 'HmmAddress', dependent: :destroy
 end
 
 class HmmEmail
@@ -15,6 +18,12 @@ class HmmEmail
   belongs_to :company, primary_key: :p, foreign_key: :f, class_name: 'HmmCompany'
 end
 
+class HmmAddress
+  include Mongoid::Document
+
+  belongs_to :company, class_name: 'HmmCompany'
+end
+
 class HmmSchool
   include Mongoid::Document
 

data/spec/mongoid/association/referenced/has_one_models.rb

@@ -6,6 +6,9 @@ class HomCollege
 
   has_one :accreditation, class_name: 'HomAccreditation'
 
+  # The address is added with different dependency mechanisms in tests:
+  #has_one :address, class_name: 'HomAddress', dependent: :destroy
+
   field :state, type: String
 end
 
@@ -24,6 +27,12 @@ class HomAccreditation::Child
   belongs_to :hom_college
 end
 
+class HomAddress
+  include Mongoid::Document
+
+  belongs_to :college, class_name: 'HomCollege'
+end
+
 module HomNs
   class PrefixedParent
     include Mongoid::Document

data/spec/mongoid/atomic/modifiers_spec.rb

@@ -9,6 +9,26 @@ describe Mongoid::Atomic::Modifiers do
     described_class.new
   end
 
+  describe "#push_conflict?" do
+    let(:result) { modifiers.send(:push_conflict?, field) }
+
+    context 'for embeds many subdocument' do
+      context 'when another field on subdocument is being set' do
+        before do
+          modifiers.set('foo.0.a' => 1)
+        end
+
+        let(:field) { 'foo' }
+
+        it 'does not conflict' do
+          pending 'https://jira.mongodb.org/browse/MONGOID-4982'
+
+          result.should be false
+        end
+      end
+    end
+  end
+
   describe "#add_to_set" do
 
     context "when the unique adds are empty" do
@@ -344,6 +364,33 @@ describe Mongoid::Atomic::Modifiers do
         end
       end
     end
+
+    context 'when there is another operation on a sibling of a key which is nested' do
+
+      let(:first_op) do
+        { "addresses.0.name" => 'test' }
+      end
+
+      let(:push_op) do
+        { "addresses.0.locations" => { "street" => "Oxford St" } }
+      end
+
+      before do
+        modifiers.set(first_op)
+        modifiers.push(push_op)
+      end
+
+      it "does not conflict and adds push to top level" do
+        pending 'https://jira.mongodb.org/browse/MONGOID-4982'
+
+        modifiers.should == {
+          '$set' => { "addresses.0.name" => 'test' },
+          '$push' => {"addresses.0.locations" => {'$each' => [
+            { "street" => "Oxford St" },
+          ]}},
+        }
+      end
+    end
   end
 
   describe "#set" do

data/spec/mongoid/atomic_spec.rb

@@ -362,6 +362,29 @@ describe Mongoid::Atomic do
             )
           end
         end
+
+        context 'when adding nested embedded docs and updating top level embedded doc' do
+          let!(:truck) { Truck.create! }
+          let!(:crate) { truck.crates.create!(volume: 1) }
+
+          before do
+            truck.crates.first.volume = 2
+            truck.crates.first.toys.build(name: 'Bear')
+            truck.crates.build
+          end
+
+          it 'correctly distributes the operations' do
+            pending 'https://jira.mongodb.org/browse/MONGOID-4982'
+
+            truck.atomic_updates.should == {
+              '$set' => {'crates.0.volume' => 2},
+              '$push' => {'crates.0.toys' => {'$each' => [crate.toys.first.attributes]}},
+              conflicts: {
+                '$push' => {'crates' => {'$each' => [truck.crates.last.attributes]}},
+              },
+            }
+          end
+        end
       end
     end
   end

data/spec/mongoid/attributes/nested_spec.rb

@@ -234,7 +234,7 @@ describe Mongoid::Attributes::Nested do
     end
   end
 
-  describe "##{name}_attributes=" do
+  describe "*_attributes=" do
 
     context "when the parent document is new" do
 

data/spec/mongoid/clients/factory_spec.rb

@@ -65,6 +65,11 @@ describe Mongoid::Clients::Factory do
             expect(client).to be_a(Mongo::Client)
           end
 
+          it 'does not produce driver warnings' do
+            Mongo::Logger.logger.should_not receive(:warn)
+            client
+          end
+
           let(:cluster_addresses) do
             cluster.addresses.map(&:to_s)
           end
@@ -74,6 +79,38 @@ describe Mongoid::Clients::Factory do
           it "sets the platform to Mongoid's platform constant" do
             expect(client.options[:platform]).to eq(Mongoid::PLATFORM_DETAILS)
           end
+
+          context 'driver 2.13+' do
+            min_driver_version '2.13'
+
+            it 'sets Mongoid as a wrapping library' do
+              client.options[:wrapping_libraries].should == [BSON::Document.new(
+                Mongoid::Clients::Factory::MONGOID_WRAPPING_LIBRARY)]
+            end
+
+            context 'when configuration specifies a wrapping library' do
+
+              let(:config) do
+                {
+                  default: { hosts: SpecConfig.instance.addresses, database: database_id },
+                  analytics: {
+                    hosts: SpecConfig.instance.addresses,
+                    database: database_id,
+                    options: {
+                      wrapping_libraries: [{name: 'Foo'}],
+                    },
+                  }
+                }
+              end
+
+              it 'adds Mongoid as another wrapping library' do
+                client.options[:wrapping_libraries].should == [
+                  BSON::Document.new(Mongoid::Clients::Factory::MONGOID_WRAPPING_LIBRARY),
+                  {'name' => 'Foo'},
+                ]
+              end
+            end
+          end
         end
 
         context "when the configuration has no ports" do

data/spec/mongoid/clients/sessions_spec.rb

@@ -20,12 +20,7 @@ describe Mongoid::Clients::Sessions do
 
   let(:subscriber) do
     client = Mongoid::Clients.with_name(:other)
-    monitoring = if client.respond_to?(:monitoring, true)
-      client.send(:monitoring)
-    else
-      # driver 2.5
-      client.instance_variable_get('@monitoring')
-    end
+    monitoring = client.send(:monitoring)
     monitoring.subscribers['Command'].find do |s|
       s.is_a?(EventSubscriber)
     end

data/spec/mongoid/config_spec.rb

@@ -197,6 +197,34 @@ describe Mongoid::Config do
     end
   end
 
+  context 'when discriminator_key override' do
+    context 'is not set in the config' do
+      it 'has the value _type by default' do
+        Mongoid::Config.reset
+        configuration = CONFIG.merge(options: {})
+
+        Mongoid.configure { |config| config.load_configuration(configuration) }
+
+        expect(Mongoid::Config.discriminator_key).to be("_type")
+      end
+    end
+
+    context 'is set in the config' do
+      it 'sets the value' do
+        Mongoid::Config.reset
+        configuration = CONFIG.merge(options: {discriminator_key: "test"})
+
+        Mongoid.configure { |config| config.load_configuration(configuration) }
+
+        expect(Mongoid::Config.discriminator_key).to be("test")
+      end
+
+      it 'is set globally' do 
+        expect(Mongoid.discriminator_key).to be("test")
+      end
+    end
+  end
+
   describe "#load!" do
 
     before(:all) do

data/spec/mongoid/contextual/mongo_spec.rb

@@ -109,11 +109,8 @@ describe Mongoid::Contextual::Mongo do
         described_class.new(criteria.cache)
       end
 
-      before do
-        expect(context.view).to receive(:count).once.and_return(1)
-      end
-
       it "returns the count cached value after first call" do
+        expect(context.view).to receive(:count_documents).once.and_return(1)
         2.times { expect(context.count).to eq(1) }
       end
     end
@@ -195,6 +192,71 @@ describe Mongoid::Contextual::Mongo do
     end
   end
 
+  describe "#estimated_count" do
+
+    let!(:depeche) do
+      Band.create(name: "Depeche Mode")
+    end
+
+    let!(:new_order) do
+      Band.create(name: "New Order")
+    end
+
+    let(:criteria) do
+      Band.where
+    end
+
+    context "when not providing options" do
+      it 'returns the correct count' do
+        expect(criteria.estimated_count).to eq(2)
+      end
+    end
+
+    context "when providing options" do
+      it 'returns the correct count' do
+        expect(criteria.estimated_count(maxTimeMS: 1000)).to eq(2)
+      end
+    end
+
+    context "when context is cached" do
+
+      let(:context) do
+        described_class.new(criteria.cache)
+      end
+
+      it "returns the count cached value after first call" do
+        expect(context.view).to receive(:estimated_document_count).once.and_return(1)
+        2.times do
+          context.estimated_count
+        end
+      end
+    end
+
+    context "when the criteria contains a selector", :focus do
+      let(:criteria) do
+        Band.where(name: "New Order")
+      end
+
+      context "when not providing options" do
+        it 'raises an error' do
+          expect do
+            criteria.estimated_count
+          end.to raise_error(Mongoid::Errors::InvalidEstimatedCountCriteria)
+        end
+      end
+
+      context "when providing options" do
+        it 'raises an error' do
+          expect do
+            criteria.estimated_count(maxTimeMS: 1000)
+          end.to raise_error(Mongoid::Errors::InvalidEstimatedCountCriteria)
+        end
+      end
+    end
+  end
+
+
+
   [ :delete, :delete_all ].each do |method|
 
     describe "##{method}" do
@@ -1399,12 +1461,8 @@ describe Mongoid::Contextual::Mongo do
         end
 
         context "when calling more than once" do
-
-          before do
-            expect(context.view).to receive(:count).once.and_return(2)
-          end
-
           it "returns the cached value for subsequent calls" do
+            expect(context.view).to receive(:count_documents).once.and_return(2)
             2.times { expect(context.send(method)).to eq(2) }
           end
         end
@@ -1413,10 +1471,10 @@ describe Mongoid::Contextual::Mongo do
 
           before do
             context.entries
-            expect(context.view).to receive(:count).once.and_return(2)
           end
 
           it "returns the cached value for all calls" do
+            expect(context.view).to receive(:count_documents).once.and_return(2)
             expect(context.send(method)).to eq(2)
           end
 
@@ -1448,12 +1506,8 @@ describe Mongoid::Contextual::Mongo do
         end
 
         context "when calling more than once" do
-
-          before do
-            expect(context.view).to receive(:count).once.and_return(1)
-          end
-
           it "returns the cached value for subsequent calls" do
+            expect(context.view).to receive(:count_documents).once.and_return(1)
             2.times { expect(context.send(method)).to eq(1) }
           end
         end
@@ -1462,10 +1516,10 @@ describe Mongoid::Contextual::Mongo do
 
           before do
             context.entries
-            expect(context.view).to receive(:count).once.and_return(1)
           end
 
           it "returns the cached value for all calls" do
+            expect(context.view).to receive(:count_documents).once.and_return(1)
             expect(context.send(method)).to eq(1)
           end
 

data/spec/mongoid/copyable_spec.rb

@@ -195,7 +195,7 @@ describe Mongoid::Copyable do
           I18n.enforce_available_locales = false
           I18n.locale = 'pt_BR'
           person.addresses.type(ShipmentAddress).each { |address| address.shipping_name = "Título" }
-          person.save
+          person.save!
         end
 
         after do
@@ -353,6 +353,83 @@ describe Mongoid::Copyable do
             end
           end
         end
+
+        context "when using a custom discriminator_key" do
+          before do
+            Person.discriminator_key = "dkey"
+          end
+
+          after do
+            Person.discriminator_key = nil
+          end
+
+          let(:copy) do
+            person.send(method)
+          end
+
+          before do
+            person[:versions] = [ { number: 1 } ]
+          end
+
+          it "copys embeds many documents" do
+            expect(copy.addresses).to eq(person.addresses)
+          end
+
+          it "copys deep embeds many documents" do
+            expect(copy.name.translations).to eq(person.name.translations)
+          end
+
+          it "sets the embedded many documents as new" do
+            expect(copy.addresses.first).to be_new_record
+          end
+
+          it "sets the deep embedded many documents as new" do
+            expect(copy.name.translations.first).to be_new_record
+          end
+
+          it "creates new embeds many instances" do
+            expect(copy.addresses).to_not equal(person.addresses)
+          end
+
+          it "creates new deep embeds many instances" do
+            expect(copy.name.translations).to_not equal(person.name.translations)
+          end
+
+          it "copys embeds one documents" do
+            expect(copy.name).to eq(person.name)
+          end
+
+          it "flags the embeds one documents as new" do
+            expect(copy.name).to be_new_record
+          end
+
+          it "creates a new embeds one instance" do
+            expect(copy.name).to_not equal(person.name)
+          end
+
+          context "when saving the copy" do
+
+            let(:reloaded) do
+              copy.reload
+            end
+
+            before do
+              copy.save(validate: false)
+            end
+
+            it "persists the attributes" do
+              expect(reloaded.title).to eq("Sir")
+            end
+
+            it "persists the embeds many relation" do
+              expect(reloaded.addresses).to eq(person.addresses)
+            end
+
+            it "persists the embeds one relation" do
+              expect(reloaded.name).to eq(person.name)
+            end
+          end
+        end
       end
 
       context "when the document is not new" do
@@ -517,6 +594,81 @@ describe Mongoid::Copyable do
           end
         end
       end
+
+      context "when cloning a document with an embedded child class and a custom discriminator value" do
+
+        before do
+          ShipmentAddress.discriminator_value = "dvalue"
+        end
+
+        after do
+          ShipmentAddress.discriminator_value = nil
+        end
+
+        let!(:shipment_address) do
+          person.addresses.build({}, ShipmentAddress)
+        end
+
+        before do
+          person.save
+        end
+
+        let!(:from_db) do
+          Person.find(person.id)
+        end
+
+        let(:copy) do
+          from_db.send(method)
+        end
+
+        it "copys embeds many documents" do
+          expect(copy.addresses).to eq(person.addresses)
+        end
+      end
+
+      context 'when cloning a document with embedded child that uses inheritance' do
+        let(:original) do
+          CopyableSpec::A.new(influencers: [child_cls.new])
+        end
+
+        let(:copy) do
+          original.send(method)
+        end
+
+        context 'embedded child is root of hierarchy' do
+          let(:child_cls) do
+            CopyableSpec::Influencer
+          end
+
+          before do
+            # When embedded class is the root in hierarchy, their
+            # discriminator value is not explicitly stored.
+            child_cls.discriminator_mapping[child_cls.name].should be nil
+          end
+
+          it 'works' do
+            copy.class.should be original.class
+            copy.object_id.should_not == original.object_id
+          end
+        end
+
+        context 'embedded child is leaf of hierarchy' do
+          let(:child_cls) do
+            CopyableSpec::Youtuber
+          end
+
+          before do
+            # When embedded class is a leaf in hierarchy, their
+            # discriminator value is explicitly stored.
+            child_cls.discriminator_mapping[child_cls.name].should_not be nil
+          end
+
+          it 'works' do
+            copy.class.should be original.class
+            copy.object_id.should_not == original.object_id
+          end
+        end
+      end
     end
   end
 end