mongoid 7.1.11 → 7.2.0

data/spec/mongoid/config/environment_spec.rb

@@ -5,19 +5,9 @@ require "spec_helper"
 
 describe Mongoid::Config::Environment do
 
-  around do |example|
-    if defined?(Rails)
-      SavedRails = Rails
-      example.run
-      Object.send(:remove_const, :Rails) if defined?(Rails)
-      Rails = SavedRails
-      Object.send(:remove_const, :SavedRails)
-    else
-      example.run
-      if defined?(Rails)
-        Object.send(:remove_const, :Rails)
-      end
-    end
+  after(:all) do
+    Rails = RailsTemp
+    Object.send(:remove_const, :RailsTemp)
   end
 
   describe "#env_name" do
@@ -34,6 +24,11 @@ describe Mongoid::Config::Environment do
           end
         end
 
+        after do
+          RailsTemp = Rails
+          Object.send(:remove_const, :Rails)
+        end
+
         it "returns the rails environment" do
           expect(described_class.env_name).to eq("production")
         end
@@ -91,77 +86,4 @@ describe Mongoid::Config::Environment do
       end
     end
   end
-
-  describe "#load_yaml" do
-    let(:path) { 'mongoid.yml' }
-    let(:environment) {}
-    before { allow(Rails).to receive('env').and_return('test') }
-
-    subject { described_class.load_yaml(path, environment) }
-
-    context 'when file not found' do
-      let(:path) { 'not/a/valid/path'}
-
-      it { expect { subject }.to raise_error(Errno::ENOENT) }
-    end
-
-    context 'when file found' do
-      before do
-        allow(File).to receive(:new).with('mongoid.yml').and_return(StringIO.new(file_contents))
-      end
-
-      let(:file_contents) do
-        <<~FILE
-          test:
-            clients: ['test']
-          development:
-            clients: ['dev']
-        FILE
-      end
-
-      context 'when file cannot be parsed as YAML' do
-        let(:file_contents) { "*\nbad:%123abc" }
-
-        it { expect { subject }.to raise_error(Psych::SyntaxError) }
-      end
-
-      context 'when file contains ERB errors' do
-        let(:file_contents) { '<%= foo %>' }
-
-        it { expect { subject }.to raise_error(NameError) }
-      end
-
-      context 'when file is empty' do
-        let(:file_contents) { '' }
-
-        it { expect { subject }.to raise_error(Mongoid::Errors::EmptyConfigFile) }
-      end
-
-      context 'when file does not contain a YAML Hash object' do
-        let(:file_contents) { '["this", "is", "an", "array"]' }
-
-        it { expect { subject }.to raise_error(Mongoid::Errors::InvalidConfigFile) }
-      end
-
-      context 'when environment not specified' do
-        it 'uses the rails environment' do
-          is_expected.to eq("clients"=>["test"])
-        end
-      end
-
-      context 'when environment is specified' do
-        let(:environment) { 'development' }
-
-        it 'uses the specified environment' do
-          is_expected.to eq("clients"=>["dev"])
-        end
-      end
-
-      context 'when environment is missing' do
-        let(:environment) { 'staging' }
-
-        it { is_expected.to be_nil }
-      end
-    end
-  end
 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/atomic_spec.rb

@@ -753,25 +753,12 @@ describe Mongoid::Contextual::Atomic do
       context.set(name: "Recoil")
     end
 
-    shared_examples 'writes as expected' do
-      it "sets existing fields" do
-        expect(depeche_mode.reload.name).to eq("Recoil")
-      end
-
-      it "sets non existent fields" do
-        expect(smiths.reload.name).to eq("Recoil")
-      end
+    it "sets existing fields" do
+      expect(depeche_mode.reload.name).to eq("Recoil")
     end
 
-    include_examples 'writes as expected'
-
-    context 'when fields being set have been projected out' do
-
-      let(:criteria) do
-        Band.only(:genres)
-      end
-
-      include_examples 'writes as expected'
+    it "sets non existent fields" do
+      expect(smiths.reload.name).to eq("Recoil")
     end
   end
 
@@ -801,28 +788,27 @@ describe Mongoid::Contextual::Atomic do
           context.unset(:name)
         end
 
-        it "unsets the fields from all documents" do
-          depeche_mode.reload
-          new_order.reload
-          expect(depeche_mode.name).to be_nil
-          expect(depeche_mode.years).to_not be_nil
-          expect(new_order.name).to be_nil
-          expect(new_order.years).to_not be_nil
+        it "unsets the first existing field" do
+          expect(depeche_mode.reload.name).to be_nil
+        end
+
+        it "unsets the last existing field" do
+          expect(new_order.reload.name).to be_nil
         end
       end
 
       context "when the field is aliased" do
+
         before do
           context.unset(:years)
         end
 
-        it "unsets the fields from all documents" do
-          depeche_mode.reload
-          new_order.reload
-          expect(depeche_mode.name).to_not be_nil
-          expect(depeche_mode.years).to be_nil
-          expect(new_order.name).to_not be_nil
-          expect(new_order.years).to be_nil
+        it "unsets the first existing field" do
+          expect(depeche_mode.reload.years).to be_nil
+        end
+
+        it "unsets the last existing field" do
+          expect(new_order.reload.years).to be_nil
         end
       end
     end
@@ -830,8 +816,7 @@ describe Mongoid::Contextual::Atomic do
     context "when unsetting multiple fields" do
 
       let!(:new_order) do
-        Band.create(name: "New Order", genres: %w[electro dub], years: 10,
-          likes: 200, rating: 4.3, origin: 'Space')
+        Band.create(name: "New Order", genres: [ "electro", "dub" ], years: 10)
       end
 
       let(:criteria) do
@@ -848,62 +833,27 @@ describe Mongoid::Contextual::Atomic do
           context.unset(:name, :genres)
         end
 
-        it "unsets the specified fields" do
-          new_order.reload
-          expect(new_order.name).to be_nil
-          expect(new_order.genres).to be_nil
-          expect(new_order.years).to_not be_nil
-          expect(new_order.likes).to_not be_nil
-          expect(new_order.rating).to_not be_nil
+        it "unsets name field" do
+          expect(new_order.reload.name).to be_nil
         end
-      end
 
-      context "when the field is aliased" do
-
-        before do
-          context.unset(:name, :years)
-        end
-
-        it "unsets the specified fields" do
-          new_order.reload
-          expect(new_order.name).to be_nil
-          expect(new_order.genres).to_not be_nil
-          expect(new_order.years).to be_nil
-          expect(new_order.likes).to_not be_nil
-          expect(new_order.rating).to_not be_nil
+        it "unsets genres field" do
+          expect(new_order.reload.genres).to be_nil
         end
       end
 
-      context "when using Hash arguments" do
+      context "when the field is aliased" do
 
         before do
-          context.unset({ years: true, likes: "" }, { rating: false, origin: nil })
-        end
-
-        it "unsets the specified fields" do
-          new_order.reload
-          expect(new_order.name).to_not be_nil
-          expect(new_order.genres).to_not be_nil
-          expect(new_order.years).to be_nil
-          expect(new_order.likes).to be_nil
-          expect(new_order.rating).to be_nil
-          expect(new_order.origin).to be_nil
+          context.unset(:name, :years)
         end
-      end
-
-      context "when mixing argument types" do
 
-        before do
-          context.unset(:name, [:years], { likes: "" }, { rating: false })
+        it "unsets the unaliased field" do
+          expect(new_order.reload.name).to be_nil
         end
 
-        it "unsets the specified fields" do
-          new_order.reload
-          expect(new_order.name).to be_nil
-          expect(new_order.genres).to_not be_nil
-          expect(new_order.years).to be_nil
-          expect(new_order.likes).to be_nil
-          expect(new_order.rating).to be_nil
+        it "unsets the aliased field" do
+          expect(new_order.reload.years).to be_nil
         end
       end
     end
@@ -932,9 +882,7 @@ describe Mongoid::Contextual::Atomic do
       end
 
       it "unsets the unaliased field" do
-        depeche_mode.reload
-        expect(depeche_mode.name).to be_nil
-        expect(depeche_mode.years).to_not be_nil
+        expect(depeche_mode.reload.name).to be_nil
       end
     end
   end

data/spec/mongoid/contextual/geo_near_spec.rb

@@ -59,7 +59,7 @@ describe Mongoid::Contextual::GeoNear do
       end
 
       it "is nil except for 4.0 sharded when it is 0" do
-        expect(geo_near.average_distance).to eq expected_value
+        expect(geo_near.average_distance).to be expected_value
       end
     end
   end

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