mongoid 5.4.0 → 6.4.8

data/spec/mongoid/config_spec.rb

@@ -9,6 +9,12 @@ describe Mongoid::Config do
     end
   end
 
+  after do
+    Mongoid.configure do |config|
+      config.load_configuration(CONFIG)
+    end
+  end
+
   describe "#configured?" do
 
     after do
@@ -64,7 +70,7 @@ describe Mongoid::Config do
 
     before do
       if defined?(Rails)
-        RailsTemp = Rails
+        RailsTemp = Rails unless defined?(RailsTemp)
         Object.send(:remove_const, :Rails)
       end
 
@@ -82,10 +88,62 @@ describe Mongoid::Config do
     end
   end
 
+  context 'when the belongs_to_required_by_default option is not set in the config' do
+
+    before do
+      Mongoid::Config.reset
+      Mongoid.configure do |config|
+        config.load_configuration(clients: CONFIG[:clients])
+      end
+    end
+
+    it 'sets the Mongoid.belongs_to_required_by_default value to true' do
+      expect(Mongoid.belongs_to_required_by_default).to be(true)
+    end
+  end
+
+  context 'when the belongs_to_required_by_default option is set in the config' do
+
+    before do
+      Mongoid.configure do |config|
+        config.load_configuration(conf)
+      end
+    end
+
+    context 'when the value is set to true' do
+
+      let(:conf) do
+        CONFIG.merge(options: { belongs_to_required_by_default: true })
+      end
+
+      it 'sets the Mongoid.belongs_to_required_by_default value to true' do
+        expect(Mongoid.belongs_to_required_by_default).to be(true)
+      end
+    end
+
+    context 'when the value is set to false' do
+
+      let(:conf) do
+        CONFIG.merge(options: { belongs_to_required_by_default: false })
+      end
+
+      before do
+        Mongoid::Config.reset
+        Mongoid.configure do |config|
+          config.load_configuration(conf)
+        end
+      end
+
+      it 'sets the Mongoid.belongs_to_required_by_default value to false' do
+        expect(Mongoid.belongs_to_required_by_default).to be(false)
+      end
+    end
+  end
+
   context 'when the app_name is set in the config' do
 
     let(:conf) do
-      CONFIG.merge(options: {app_name: 'admin-reporting'})
+      CONFIG.merge(options: { app_name: 'admin-reporting' })
     end
 
     before do
@@ -137,6 +195,10 @@ describe Mongoid::Config do
         described_class.load!(file, :test)
       end
 
+      after do
+        client.close
+      end
+
       it "clears the previous clients" do
         expect(Mongoid::Clients.clients[:test]).to be_nil
       end
@@ -148,12 +210,6 @@ describe Mongoid::Config do
         described_class.load!(file, :test)
       end
 
-      after do
-        Mongoid.configure do |config|
-          config.load_configuration(CONFIG)
-        end
-      end
-
       it "sets the Mongoid logger level" do
         expect(Mongoid.logger.level).to eq(Logger::WARN)
       end
@@ -176,7 +232,7 @@ describe Mongoid::Config do
 
         after do
           if defined?(Rails)
-            RailsTemp = Rails
+            RailsTemp = Rails unless defined?(RailsTemp)
             Object.send(:remove_const, :Rails)
           end
         end
@@ -282,7 +338,7 @@ describe Mongoid::Config do
         context "when a default is provided" do
 
           before do
-            described_class.load!(file)
+            described_class.load!(file, :test_with_max_staleness)
           end
 
           let(:default) do
@@ -301,7 +357,7 @@ describe Mongoid::Config do
 
             it "sets the read option" do
               expect(options["read"]).to eq({ "mode" => :primary_preferred,
-                                              "tag_sets" => [{ "use" => "web" }]})
+                                              "max_staleness" => 100 })
             end
           end
         end

data/spec/mongoid/contextual/atomic_spec.rb

@@ -496,7 +496,7 @@ describe Mongoid::Contextual::Atomic do
     end
   end
 
-  describe "#push_each" do
+  describe "#push_all" do
 
     context 'when the criteria does not have a collation' do
 
@@ -517,7 +517,7 @@ describe Mongoid::Contextual::Atomic do
       end
 
       before do
-        context.push_each(members: [ "Alan", "Fletch" ])
+        context.push_all(members: [ "Alan", "Fletch" ])
       end
 
       it "pushes the values to existing arrays" do
@@ -548,7 +548,7 @@ describe Mongoid::Contextual::Atomic do
       end
 
       before do
-        context.push_each(members: [ "Alan", "Fletch" ])
+        context.push_all(members: [ "Alan", "Fletch" ])
       end
 
       it "pushes the values to existing arrays" do

data/spec/mongoid/contextual/geo_near_spec.rb

@@ -1,6 +1,7 @@
 require "spec_helper"
 
 describe Mongoid::Contextual::GeoNear do
+  max_server_version '4.0'
 
   describe "#average_distance" do
 

data/spec/mongoid/contextual/mongo_spec.rb

@@ -228,36 +228,36 @@ describe Mongoid::Contextual::Mongo do
         it "returns the number of documents deleted" do
           expect(deleted).to eq(1)
         end
-      end
 
-      context 'when the criteria has a collation', if: collation_supported? do
+        context 'when the criteria has a collation', if: collation_supported? do
 
-        let(:criteria) do
-          Band.where(name: "DEPECHE MODE").collation(locale: 'en_US', strength: 2)
-        end
+          let(:criteria) do
+            Band.where(name: "DEPECHE MODE").collation(locale: 'en_US', strength: 2)
+          end
 
-        let(:context) do
-          described_class.new(criteria)
-        end
+          let(:context) do
+            described_class.new(criteria)
+          end
 
-        let!(:deleted) do
-          context.send(method)
-        end
+          let!(:deleted) do
+            context.send(method)
+          end
 
-        it "deletes the matching documents" do
-          expect(Band.find(new_order.id)).to eq(new_order)
-        end
+          it "deletes the matching documents" do
+            expect(Band.find(new_order.id)).to eq(new_order)
+          end
 
-        it "deletes the correct number of documents" do
-          expect(Band.count).to eq(1)
-        end
+          it "deletes the correct number of documents" do
+            expect(Band.count).to eq(1)
+          end
 
-        it "returns the number of documents deleted" do
-          expect(deleted).to eq(1)
+          it "returns the number of documents deleted" do
+            expect(deleted).to eq(1)
+          end
         end
       end
 
-      context "when the selector is not constraining" do
+      context "when the selector is not contraining" do
 
         let(:criteria) do
           Band.all
@@ -275,6 +275,23 @@ describe Mongoid::Contextual::Mongo do
           expect(Band.count).to eq(0)
         end
       end
+
+      context 'when the write concern is unacknowledged' do
+
+        let(:criteria) do
+          Band.all
+        end
+
+        let!(:deleted) do
+          criteria.with(write: { w: 0 }) do |crit|
+            crit.send(method)
+          end
+        end
+
+        it 'returns 0' do
+          expect(deleted).to eq(0)
+        end
+      end
     end
   end
 
@@ -363,6 +380,27 @@ describe Mongoid::Contextual::Mongo do
         end
       end
     end
+
+    context 'when the write concern is unacknowledged' do
+
+      before do
+        2.times { Band.create }
+      end
+
+      let(:criteria) do
+        Band.all
+      end
+
+      let!(:deleted) do
+        criteria.with(write: { w: 0 }) do |crit|
+          crit.send(method)
+        end
+      end
+
+      it 'returns 0' do
+        expect(deleted).to eq(0)
+      end
+    end
   end
 
   describe "#distinct" do
@@ -413,7 +451,7 @@ describe Mongoid::Contextual::Mongo do
       end
 
       it "returns the distinct field values" do
-        expect(context.distinct(:years)).to eq([ 30, 25 ])
+        expect(context.distinct(:years).sort).to eq([ 25, 30 ])
       end
     end
 
@@ -1124,6 +1162,92 @@ describe Mongoid::Contextual::Mongo do
         end
       end
 
+      context 'when the criteria has no sort' do
+
+        let(:criteria) do
+          Band.all
+        end
+
+        let(:context) do
+          described_class.new(criteria)
+        end
+
+
+        it 'applies a sort on _id' do
+          expect(context.send(method)).to eq(depeche_mode)
+        end
+
+        context 'when calling #last' do
+
+          it 'returns the last document, sorted by _id' do
+            expect(context.send(method)).to eq(depeche_mode)
+            expect(context.last).to eq(new_order)
+          end
+        end
+
+        context 'with option { sort: :none }' do
+
+          let(:opts) do
+            { id_sort: :none }
+          end
+
+          it 'does not apply the sort on _id' do
+            expect(context.send(method, opts)).to eq(depeche_mode)
+          end
+
+          context 'when calling #last' do
+
+            it 'does not apply a sort on _id' do
+              expect(context.send(method, opts)).to eq(depeche_mode)
+              expect(context.last(opts)).to eq(depeche_mode)
+            end
+          end
+        end
+      end
+
+      context 'when the criteria has a sort' do
+
+        let(:criteria) do
+          Band.desc(:name)
+        end
+
+        let(:context) do
+          described_class.new(criteria)
+        end
+
+
+        it 'applies the criteria sort' do
+          expect(context.send(method)).to eq(new_order)
+        end
+
+        context 'when calling #last' do
+
+          it 'applies the criteria sort' do
+            expect(context.send(method)).to eq(new_order)
+            expect(context.last).to eq(depeche_mode)
+          end
+        end
+
+        context 'with option { sort: :none }' do
+
+          let(:opts) do
+            { id_sort: :none }
+          end
+
+          it 'applies the criteria sort' do
+            expect(context.send(method, opts)).to eq(new_order)
+          end
+
+          context 'when calling #last' do
+
+            it 'applies the criteria sort' do
+              expect(context.send(method, opts)).to eq(new_order)
+              expect(context.last(opts)).to eq(depeche_mode)
+            end
+          end
+        end
+      end
+
       context "when using .sort" do
 
         let(:criteria) do
@@ -1674,6 +1798,65 @@ describe Mongoid::Contextual::Mongo do
       end
     end
 
+    context "when the output specifies a different db" do
+
+      let(:criteria) do
+        Band.limit(1)
+      end
+
+      let(:context) do
+        described_class.new(criteria)
+      end
+
+      after do
+        Band.with(database: 'another-db') do |b|
+          b.all.delete
+        end
+      end
+
+      context 'when db is a string' do
+
+        let(:results) do
+          context.map_reduce(map, reduce).out(merge: :mr_output, db: 'another-db')
+        end
+
+        it "returns the correct number of documents" do
+          expect(results.count).to eq(1)
+        end
+
+        it "contains the entire results" do
+          expect(results).to eq([
+                                    { "_id" => "Depeche Mode", "value" => { "likes" => 200 }}
+                                ])
+        end
+
+        it 'writes to the specified db' do
+          expect(Band.mongo_client.with(database: 'another-db')[:mr_output].find.count).to eq(1)
+        end
+      end
+
+      context 'when db is a symbol' do
+
+        let(:results) do
+          context.map_reduce(map, reduce).out(merge: :mr_output, 'db' => 'another-db')
+        end
+
+        it "returns the correct number of documents" do
+          expect(results.count).to eq(1)
+        end
+
+        it "contains the entire results" do
+          expect(results).to eq([
+                                    { "_id" => "Depeche Mode", "value" => { "likes" => 200 }}
+                                ])
+        end
+
+        it 'writes to the specified db' do
+          expect(Band.mongo_client.with(database: 'another-db')[:mr_output].find.count).to eq(1)
+        end
+      end
+    end
+
     context "when providing no output" do
 
       let(:criteria) do
@@ -1949,6 +2132,41 @@ describe Mongoid::Contextual::Mongo do
         expect(context.update).to be false
       end
     end
+
+    context 'when provided array filters', if: array_filters_supported? do
+
+      before do
+        Band.delete_all
+        b = Band.new(name: 'Depeche Mode')
+        b.labels << Label.new(name: 'Warner')
+        b.labels << Label.new(name: 'Sony')
+        b.labels << Label.new(name: 'Cbs')
+        b.save
+
+        b = Band.new(name: 'FKA Twigs')
+        b.labels << Label.new(name: 'Warner')
+        b.labels << Label.new(name: 'Cbs')
+        b.save
+      end
+
+
+      let(:criteria) do
+        Band.where(name: 'Depeche Mode')
+      end
+
+      let!(:update) do
+        context.update({ '$set' => { 'labels.$[i].name' => 'Sony' } },
+                       array_filters: [{ 'i.name' => 'Cbs' }])
+      end
+
+      it 'applies the array filters' do
+        expect(Band.where(name: 'Depeche Mode').first.labels.collect(&:name)).to match_array(['Warner', 'Sony', 'Sony'])
+      end
+
+      it 'does not affect other documents' do
+        expect(Band.where(name: 'FKA Twigs').first.labels.collect(&:name)).to match_array(['Warner', 'Cbs'])
+      end
+    end
   end
 
   describe "#update_all" do
@@ -2086,6 +2304,41 @@ describe Mongoid::Contextual::Mongo do
         expect(context.update_all).to be false
       end
     end
+
+    context 'when provided array filters', if: array_filters_supported? do
+
+      before do
+        Band.delete_all
+        b = Band.new(name: 'Depeche Mode')
+        b.labels << Label.new(name: 'Warner')
+        b.labels << Label.new(name: 'Sony')
+        b.labels << Label.new(name: 'Cbs')
+        b.save
+
+        b = Band.new(name: 'FKA Twigs')
+        b.labels << Label.new(name: 'Warner')
+        b.labels << Label.new(name: 'Cbs')
+        b.save
+      end
+
+
+      let(:criteria) do
+        Band.all
+      end
+
+      let!(:update) do
+        context.update_all({ '$set' => { 'labels.$[i].name' => 'Sony' } },
+                           array_filters: [{ 'i.name' => 'Cbs' }])
+      end
+
+      it 'applies the array filters' do
+        expect(Band.where(name: 'Depeche Mode').first.labels.collect(&:name)).to match_array(['Warner', 'Sony', 'Sony'])
+      end
+
+      it 'updates all documents' do
+        expect(Band.where(name: 'FKA Twigs').first.labels.collect(&:name)).to match_array(['Warner', 'Sony'])
+      end
+    end
   end
 
   describe '#pipeline' do
@@ -2110,7 +2363,7 @@ describe Mongoid::Contextual::Mongo do
       end
 
       it 'creates a pipeline with the selector as one of the $match criteria' do
-        expect(pipeline_match).to include({ :'$text' => { :'$search' => "New Order" } })
+        expect(pipeline_match).to include({ '$text' => { '$search' => "New Order" } })
       end
 
       it 'creates a pipeline with the $exists operator as one of the $match criteria' do

data/spec/mongoid/contextual/none_spec.rb

@@ -65,6 +65,21 @@ describe Mongoid::Contextual::None do
     end
   end
 
+  describe "#distinct" do
+
+    let!(:band) do
+      Band.create(name: "Depeche Mode")
+    end
+
+    let(:context) do
+      described_class.new(Band.where(name: "Depeche Mode"))
+    end
+
+    it "returns an empty array" do
+      expect(context.distinct(:id)).to eq([])
+    end
+  end
+
   describe "#pluck" do
 
     let!(:band) do

data/spec/mongoid/copyable_spec.rb

@@ -54,22 +54,31 @@ describe Mongoid::Copyable do
         end
       end
 
-      context "when a document has old renamed fields" do
+      context "when a document has fields from a legacy schema" do
 
         let!(:actor) do
           Actor.create(name: "test")
         end
 
         before do
-          Actor.collection.find(_id: actor.id).update_one("$set" => { "this_is_not_a_field" => 1 })
+          legacy_fields = { "this_is_not_a_field" => 1, "this_legacy_field_is_nil" => nil }
+          Actor.collection.find(_id: actor.id).update_one("$set" => legacy_fields)
         end
 
         let(:cloned) do
           actor.reload.send(method)
         end
 
-        it "copies the document without error" do
-          expect(cloned.this_is_not_a_field).to eq(1)
+        it "sets the legacy attribute" do
+          expect(cloned.attributes['this_is_not_a_field']).to eq(1)
+        end
+
+        it "contains legacy attributes that are nil" do
+          expect(cloned.attributes.key?('this_legacy_field_is_nil')).to eq(true)
+        end
+
+        it "copies the known attributes" do
+          expect(cloned.name).to eq('test')
         end
       end