mongoid 7.3.2 → 7.4.0

data/spec/mongoid/config_spec.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# encoding: utf-8
 
 require "spec_helper"
 
@@ -219,12 +218,117 @@ describe Mongoid::Config do
         expect(Mongoid::Config.discriminator_key).to be("test")
       end
 
-      it 'is set globally' do 
+      it 'is set globally' do
         expect(Mongoid.discriminator_key).to be("test")
       end
     end
   end
 
+  shared_examples "a config option" do
+
+    before do
+      Mongoid::Config.reset
+      Mongoid.configure do |config|
+        config.load_configuration(conf)
+      end
+    end
+
+    context 'when the value is false' do
+
+      let(:conf) do
+        CONFIG.merge(options: { option => false })
+      end
+
+      it "is set to false" do
+        expect(Mongoid.send(option)).to be(false)
+      end
+    end
+
+    context 'when the value is true' do
+
+      let(:conf) do
+        CONFIG.merge(options: { option => true })
+      end
+
+      it "is set to true" do
+        expect(Mongoid.send(option)).to be(true)
+      end
+    end
+
+    context "when it is not set in the config" do
+
+      let(:conf) { CONFIG }
+
+      it "it is set to its default" do
+        expect(Mongoid.send(option)).to be(default)
+      end
+    end
+  end
+
+  context 'when setting the broken_updates option in the config' do
+    let(:option) { :broken_updates }
+    let(:default) { true }
+
+    it_behaves_like "a config option"
+  end
+
+  context 'when setting the legacy_triple_equals option in the config' do
+    let(:option) { :legacy_triple_equals }
+    let(:default) { true }
+
+    it_behaves_like "a config option"
+  end
+
+  context 'when setting the broken_scoping option in the config' do
+    let(:option) { :broken_scoping }
+    let(:default) { true }
+
+    it_behaves_like "a config option"
+  end
+
+  context 'when setting the broken_aggregables option in the config' do
+    let(:option) { :broken_aggregables }
+    let(:default) { true }
+
+    it_behaves_like "a config option"
+  end
+
+  context 'when setting the broken_alias_handling option in the config' do
+    let(:option) { :broken_alias_handling }
+    let(:default) { true }
+
+    it_behaves_like "a config option"
+  end
+
+  context 'when setting the broken_and option in the config' do
+    let(:option) { :broken_and }
+    let(:default) { true }
+
+    it_behaves_like "a config option"
+  end
+
+  context 'when setting the compare_time_by_ms option in the config' do
+    let(:option) { :compare_time_by_ms }
+    let(:default) { false }
+
+    it_behaves_like "a config option"
+  end
+
+  context 'when setting the object_id_as_json_oid option in the config' do
+    let(:option) { :object_id_as_json_oid }
+    let(:default) { true }
+
+    it_behaves_like "a config option"
+  end
+
+  context 'when setting the legacy_pluck_distinct option in the config' do
+    let(:option) { :legacy_pluck_distinct }
+    let(:default) { true }
+
+    it_behaves_like "a config option"
+  end
+
+
   describe "#load!" do
 
     before(:all) do
@@ -546,34 +650,107 @@ describe Mongoid::Config do
     end
   end
 
-  context "with an overridden database" do
-    let(:database) do
-      "test_purge_#{Time.now.to_i}"
+  describe "#purge!" do
+
+    it 'deletes models' do
+      House.create!(name: '1', model: 'Big')
+      expect(House.count).to eq(1)
+      Mongoid.purge!
+      expect(House.count).to eq(0)
     end
 
-    before do
-      Mongoid.override_database(database)
+    it 'drops collections' do
+      House.create!(name: '1', model: 'Big')
+      Band.create!(name: 'Fleet Foxes')
+
+      client = Mongoid.default_client
+      expect(client.collections.map(&:name).sort).to eq %w[bands houses]
+      Mongoid.purge!
+      expect(client.collections.map(&:name)).to eq []
+    end
+  end
+
+  describe "#truncate!" do
+
+    it 'deletes models' do
+      House.create!(name: '1', model: 'Big')
+      expect(House.count).to eq(1)
+      Mongoid.truncate!
+      expect(House.count).to eq(0)
+    end
+
+    it 'does not drop collections' do
+      House.create!(name: '1', model: 'Big')
+      Band.create!(name: 'Fleet Foxes')
+
+      client = Mongoid.default_client
+      expect(client.collections.map(&:name).sort).to eq %w[bands houses]
+      Mongoid.truncate!
+      expect(client.collections.map(&:name).sort).to eq %w[bands houses]
+    end
+
+    it 'does not drop indexes' do
+      User.create_indexes
+      expect(User.collection.indexes.map {|i| i['name'] }).to eq %w[_id_ name_1]
+      Mongoid.truncate!
+      expect(User.collection.indexes.map {|i| i['name'] }).to eq %w[_id_ name_1]
+    end
+  end
+
+  describe "#override_database" do
+    let(:database) do
+      "test_override_#{Time.now.to_i}"
     end
 
     after do
+      # Ensure the database override is cleared.
+      Mongoid.override_database(nil)
+    end
+
+    it 'overrides document querying and persistence' do
+      House.create!(name: '1', model: 'Big')
+      expect(House.count).to eq(1)
+
+      Mongoid.override_database(database)
+      expect(House.count).to eq(0)
+
+      expect(Band.count).to eq(0)
+      Band.create!(name: 'Wolf Alice')
+      expect(Band.count).to eq(1)
+
       Mongoid.override_database(nil)
+      expect(House.count).to eq(1)
+      expect(Band.count).to eq(0)
     end
 
-    describe "#purge!" do
-      it 'respects persistence context overrides' do
+    context '#truncate and #purge' do
+      before do
         House.create!(name: '1', model: 'Big')
         expect(House.count).to eq(1)
-        Mongoid.purge!
-        expect(House.count).to eq(0)
+        Mongoid.override_database(database)
       end
-    end
 
-    describe "#truncate!" do
-      it 'respects persistence context overrides' do
-        House.create!(name: '1', model: 'Big')
+      after do
+        Mongoid.override_database(nil)
         expect(House.count).to eq(1)
-        Mongoid.truncate!
-        expect(House.count).to eq(0)
+      end
+
+      context '#purge' do
+        it 'respects persistence context overrides' do
+          House.create!(name: '2', model: 'Tiny')
+          expect(House.count).to eq(1)
+          Mongoid.purge!
+          expect(House.count).to eq(0)
+        end
+      end
+
+      context '#truncate' do
+        it '#truncate! respects persistence context overrides' do
+          House.create!(name: '2', model: 'Tiny')
+          expect(House.count).to eq(1)
+          Mongoid.truncate!
+          expect(House.count).to eq(0)
+        end
       end
     end
   end

data/spec/mongoid/contextual/aggregable/memory_spec.rb

@@ -1,10 +1,49 @@
 # frozen_string_literal: true
-# encoding: utf-8
 
 require "spec_helper"
 
 describe Mongoid::Contextual::Aggregable::Memory do
 
+  describe "#aggregates" do
+    let(:context) do
+      Mongoid::Contextual::Memory.new(criteria)
+    end
+
+    subject { context.aggregates(:likes) }
+
+    context 'when no documents found' do
+      let(:criteria) do
+        Band.all.tap do |crit|
+          crit.documents = []
+        end
+      end
+
+      it do
+        is_expected.to eq("count" => 0, "avg" => nil, "max" => nil, "min" => nil, "sum" => 0)
+      end
+    end
+
+    context 'when documents found' do
+      let(:criteria) do
+        Band.all.tap do |crit|
+          crit.documents = [ depeche, tool ]
+        end
+      end
+
+      let!(:depeche) do
+        Band.create(name: "Depeche Mode", likes: 1000)
+      end
+
+      let!(:tool) do
+        Band.create(name: "Tool", likes: 500)
+      end
+
+      it do
+        is_expected.to eq("count" => 0, "avg" => 750.0, "max" => 1000, "min" => 500, "sum" => 1500)
+      end
+    end
+  end
+
   describe "#avg" do
 
     context "when provided a single field" do
@@ -14,11 +53,11 @@ describe Mongoid::Contextual::Aggregable::Memory do
         context "when the types are integers" do
 
           let!(:depeche) do
-            Band.create(name: "Depeche Mode", likes: 1000)
+            Band.create!(name: "Depeche Mode", likes: 1000)
           end
 
           let!(:tool) do
-            Band.create(name: "Tool", likes: 500)
+            Band.create!(name: "Tool", likes: 500)
           end
 
           let(:criteria) do
@@ -43,11 +82,11 @@ describe Mongoid::Contextual::Aggregable::Memory do
         context "when the types are floats" do
 
           let!(:depeche) do
-            Band.create(name: "Depeche Mode", rating: 10)
+            Band.create!(name: "Depeche Mode", rating: 10)
           end
 
           let!(:tool) do
-            Band.create(name: "Tool", rating: 5)
+            Band.create!(name: "Tool", rating: 5)
           end
 
           let(:criteria) do
@@ -73,7 +112,7 @@ describe Mongoid::Contextual::Aggregable::Memory do
       context "when no documents match" do
 
         let!(:depeche) do
-          Band.create(name: "Depeche Mode", likes: 1000)
+          Band.create!(name: "Depeche Mode", likes: 1000)
         end
 
         let(:criteria) do
@@ -100,11 +139,11 @@ describe Mongoid::Contextual::Aggregable::Memory do
     context "when provided a single field" do
 
       let!(:depeche) do
-        Band.create(name: "Depeche Mode", likes: 1000)
+        Band.create!(name: "Depeche Mode", likes: 1000)
       end
 
       let!(:tool) do
-        Band.create(name: "Tool", likes: 500)
+        Band.create!(name: "Tool", likes: 500)
       end
 
       let(:criteria) do
@@ -167,11 +206,11 @@ describe Mongoid::Contextual::Aggregable::Memory do
     context "when provided a single field" do
 
       let!(:depeche) do
-        Band.create(name: "Depeche Mode", likes: 1000)
+        Band.create!(name: "Depeche Mode", likes: 1000)
       end
 
       let!(:tool) do
-        Band.create(name: "Tool", likes: 500)
+        Band.create!(name: "Tool", likes: 500)
       end
 
       let(:criteria) do
@@ -234,11 +273,11 @@ describe Mongoid::Contextual::Aggregable::Memory do
     context "when provided a single field" do
 
       let!(:depeche) do
-        Band.create(name: "Depeche Mode", likes: 1000)
+        Band.create!(name: "Depeche Mode", likes: 1000)
       end
 
       let!(:tool) do
-        Band.create(name: "Tool", likes: 500)
+        Band.create!(name: "Tool", likes: 500)
       end
 
       let(:criteria) do

data/spec/mongoid/contextual/aggregable/mongo_spec.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# encoding: utf-8
 
 require "spec_helper"
 
@@ -10,11 +9,11 @@ describe Mongoid::Contextual::Aggregable::Mongo do
     context "when provided a single field" do
 
       let!(:depeche) do
-        Band.create(name: "Depeche Mode", likes: 1000, years: 1000)
+        Band.create!(name: "Depeche Mode", likes: 1000, years: 1000)
       end
 
       let!(:tool) do
-        Band.create(name: "Tool", likes: 500, years: 800)
+        Band.create!(name: "Tool", likes: 500, years: 800)
       end
 
       let(:criteria) do
@@ -142,7 +141,6 @@ describe Mongoid::Contextual::Aggregable::Mongo do
             expect(aggregates["sum"]).to eq(1000)
           end
         end
-
       end
 
       context "when the field does not exist" do
@@ -167,18 +165,31 @@ describe Mongoid::Contextual::Aggregable::Mongo do
           expect(aggregates["min"]).to be_nil
         end
 
-        it "returns a sum" do
-          expect(aggregates["sum"]).to be_nil
+        context "when broken_aggregables feature flag is not set" do
+          config_override :broken_aggregables, false
+
+          it "returns a sum" do
+            expect(aggregates["sum"]).to eq 0
+          end
+        end
+
+        context "when broken_aggregables feature flag is set" do
+          config_override :broken_aggregables, true
+
+          it "returns nil" do
+            expect(aggregates["sum"]).to be_nil
+          end
         end
+
       end
 
       context "when the field sometimes exists" do
         let!(:oasis) do
-          Band.create(name: "Oasis", likes: 50)
+          Band.create!(name: "Oasis", likes: 50)
         end
 
         let!(:radiohead) do
-          Band.create(name: "Radiohead")
+          Band.create!(name: "Radiohead")
         end
 
         context "and the field doesn't exist on the last document" do
@@ -205,7 +216,7 @@ describe Mongoid::Contextual::Aggregable::Mongo do
 
         context "and the field doesn't exist on the before-last document" do
           let!(:u2) do
-            Band.create(name: "U2", likes: 100)
+            Band.create!(name: "U2", likes: 100)
           end
 
           let(:criteria) do
@@ -240,8 +251,20 @@ describe Mongoid::Contextual::Aggregable::Mongo do
           context.aggregates(:non_existent)
         end
 
-        it "returns nil" do
-          expect(aggregates).to eq({ "count" => 0, "sum" => nil, "avg" => nil, "min" => nil, "max" => nil })
+        context "when broken_aggregables feature flag is not set" do
+          config_override :broken_aggregables, false
+
+          it "returns empty result" do
+            expect(aggregates).to eq({ "count" => 0, "sum" => 0, "avg" => nil, "min" => nil, "max" => nil })
+          end
+        end
+
+        context "when broken_aggregables feature flag is set" do
+          config_override :broken_aggregables, true
+
+          it "returns empty result" do
+            expect(aggregates).to eq({ "count" => 0, "sum" => nil, "avg" => nil, "min" => nil, "max" => nil })
+          end
         end
       end
     end
@@ -254,11 +277,11 @@ describe Mongoid::Contextual::Aggregable::Mongo do
       context "when there are matching documents" do
 
         let!(:depeche) do
-          Band.create(name: "Depeche Mode", likes: 1000)
+          Band.create!(name: "Depeche Mode", likes: 1000)
         end
 
         let!(:tool) do
-          Band.create(name: "Tool", likes: 500)
+          Band.create!(name: "Tool", likes: 500)
         end
 
         let(:criteria) do
@@ -281,7 +304,7 @@ describe Mongoid::Contextual::Aggregable::Mongo do
       context "when no documents match" do
 
         let!(:depeche) do
-          Band.create(name: "Depeche Mode", likes: 1000)
+          Band.create!(name: "Depeche Mode", likes: 1000)
         end
 
         let(:criteria) do
@@ -308,7 +331,7 @@ describe Mongoid::Contextual::Aggregable::Mongo do
     context 'when the field does not exist in any document' do
 
       let!(:depeche) do
-        Band.create(name: "Depeche Mode", likes: 1000)
+        Band.create!(name: "Depeche Mode", likes: 1000)
       end
 
       let(:criteria) do
@@ -331,11 +354,11 @@ describe Mongoid::Contextual::Aggregable::Mongo do
     context "when provided a single field" do
 
       let!(:depeche) do
-        Band.create(name: "Depeche Mode", likes: 1000)
+        Band.create!(name: "Depeche Mode", likes: 1000)
       end
 
       let!(:tool) do
-        Band.create(name: "Tool", likes: 500)
+        Band.create!(name: "Tool", likes: 500)
       end
 
       let(:criteria) do
@@ -396,11 +419,11 @@ describe Mongoid::Contextual::Aggregable::Mongo do
     context "when provided a single field" do
 
       let!(:depeche) do
-        Band.create(name: "Depeche Mode", likes: 1000)
+        Band.create!(name: "Depeche Mode", likes: 1000)
       end
 
       let!(:tool) do
-        Band.create(name: "Tool", likes: 500)
+        Band.create!(name: "Tool", likes: 500)
       end
 
       let(:criteria) do
@@ -461,11 +484,11 @@ describe Mongoid::Contextual::Aggregable::Mongo do
     context "when provided a single field" do
 
       let!(:depeche) do
-        Band.create(name: "Depeche Mode", likes: 1000)
+        Band.create!(name: "Depeche Mode", likes: 1000)
       end
 
       let!(:tool) do
-        Band.create(name: "Tool", likes: 500)
+        Band.create!(name: "Tool", likes: 500)
       end
 
       let(:criteria) do
@@ -518,4 +541,80 @@ describe Mongoid::Contextual::Aggregable::Mongo do
       end
     end
   end
+
+  describe '#pipeline' do
+    let(:context) { Mongoid::Contextual::Mongo.new(criteria) }
+    let(:pipeline) { context.send(:pipeline, :likes) }
+    subject(:stages) { pipeline.map {|s| s.keys.first } }
+
+    context "with sort" do
+
+      context "without limit or skip" do
+        let(:criteria) { Band.desc(:name) }
+
+        it 'should omit the $sort stage' do
+          expect(stages).to eq %w[$match $group]
+        end
+      end
+
+      context "with limit" do
+        let(:criteria) { Band.desc(:name).limit(1) }
+
+        it 'should include the $sort stage' do
+          expect(stages).to eq %w[$match $sort $limit $group]
+        end
+      end
+
+      context "with skip" do
+        let(:criteria) { Band.desc(:name).skip(1) }
+
+        it 'should include the $sort stage' do
+          expect(stages).to eq %w[$match $sort $skip $group]
+        end
+      end
+
+      context "with skip and skip" do
+        let(:criteria) { Band.desc(:name).limit(1).skip(1) }
+
+        it 'should include the $sort stage' do
+          expect(stages).to eq %w[$match $sort $skip $limit $group]
+        end
+      end
+    end
+
+    context "without sort" do
+
+      context "without limit or skip" do
+        let(:criteria) { Band.all }
+
+        it 'should omit the $sort stage' do
+          expect(stages).to eq %w[$match $group]
+        end
+      end
+
+      context "with limit" do
+        let(:criteria) { Band.limit(1) }
+
+        it 'should include the $sort stage' do
+          expect(stages).to eq %w[$match $limit $group]
+        end
+      end
+
+      context "with skip" do
+        let(:criteria) { Band.skip(1) }
+
+        it 'should include the $sort stage' do
+          expect(stages).to eq %w[$match $skip $group]
+        end
+      end
+
+      context "with skip and skip" do
+        let(:criteria) { Band.limit(1).skip(1) }
+
+        it 'should include the $sort stage' do
+          expect(stages).to eq %w[$match $skip $limit $group]
+        end
+      end
+    end
+  end
 end

data/spec/mongoid/contextual/aggregable/none_spec.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Mongoid::Contextual::Aggregable::None do
+
+  before do
+    Band.create!(name: "Depeche Mode")
+  end
+
+  let(:context) do
+    Mongoid::Contextual::None.new(Band.where(name: "Depeche Mode"))
+  end
+
+  describe "#aggregates" do
+    it "returns fixed values" do
+      expect(context.aggregates(:likes)).to eq("count" => 0, "avg" => nil, "max" => nil, "min" => nil, "sum" => 0)
+    end
+  end
+
+  describe "#sum" do
+    it "returns zero" do
+      expect(context.sum).to eq(0)
+    end
+
+    context "when broken_aggregables feature flag is not set" do
+      config_override :broken_aggregables, false
+
+      it "returns zero when arg given" do
+        expect(context.sum(:likes)).to eq(0)
+      end
+    end
+
+    context "when broken_aggregables feature flag is set" do
+      config_override :broken_aggregables, true
+
+      it "returns the input when arg given" do
+        expect(context.sum(:likes)).to eq(:likes)
+      end
+    end
+  end
+
+  describe "#avg" do
+    it "returns nil" do
+      expect(context.avg(:likes)).to eq(nil)
+    end
+  end
+
+  describe "#min and #max" do
+    it "returns nil" do
+      expect(context.min).to eq(nil)
+      expect(context.max).to eq(nil)
+    end
+
+    it "returns nil when arg given" do
+      expect(context.min(:likes)).to eq(nil)
+      expect(context.max(:likes)).to eq(nil)
+    end
+  end
+end