mongoid 6.3.0 → 6.4.5

data/spec/mongoid/persistable/deletable_spec.rb

@@ -228,6 +228,25 @@ describe Mongoid::Persistable::Deletable do
           expect(removed).to eq(1)
         end
       end
+
+      context 'when the write concern is unacknowledged' do
+
+        before do
+          Person.create(title: 'miss')
+        end
+
+        let!(:deleted) do
+          Person.with(write: { w: 0 }) { |klass| klass.delete_all(title: "sir") }
+        end
+
+        it "removes the matching documents" do
+          expect(Person.where(title: 'miss').count).to eq(1)
+        end
+
+        it "returns 0" do
+          expect(deleted).to eq(0)
+        end
+      end
     end
   end
 end

data/spec/mongoid/persistable/destroyable_spec.rb

@@ -222,6 +222,25 @@ describe Mongoid::Persistable::Destroyable do
       end
     end
 
+    context 'when the write concern is unacknowledged' do
+
+      before do
+        Person.create(title: 'miss')
+      end
+
+      let!(:removed) do
+        Person.with(write: { w: 0 }) { |klass| klass.destroy_all(title: "sir") }
+      end
+
+      it "removes the matching documents" do
+        expect(Person.where(title: 'miss').count).to eq(1)
+      end
+
+      it "returns 0" do
+        expect(removed).to eq(0)
+      end
+    end
+
     context 'when removing a list of embedded documents' do
 
       context 'when the embedded documents list is reversed in memory' do

data/spec/mongoid/persistable/incrementable_spec.rb

@@ -66,15 +66,15 @@ describe Mongoid::Persistable::Incrementable do
       context "when providing big decimal values" do
 
         let(:five) do
-          BigDecimal.new("5.0")
+          BigDecimal("5.0")
         end
 
         let(:neg_ten) do
-          BigDecimal.new("-10.0")
+          BigDecimal("-10.0")
         end
 
         let(:thirty) do
-          BigDecimal.new("30.0")
+          BigDecimal("30.0")
         end
 
         let!(:inc) do
@@ -151,15 +151,15 @@ describe Mongoid::Persistable::Incrementable do
       context "when providing big decimal values" do
 
         let(:five) do
-          BigDecimal.new("5.0")
+          BigDecimal("5.0")
         end
 
         let(:neg_ten) do
-          BigDecimal.new("-10.0")
+          BigDecimal("-10.0")
         end
 
         let(:thirty) do
-          BigDecimal.new("30.0")
+          BigDecimal("30.0")
         end
 
         let!(:inc) do

data/spec/mongoid/persistable/settable_spec.rb

@@ -278,7 +278,22 @@ describe Mongoid::Persistable::Settable do
       end
     end
 
-    context 'when the field is a bested hash' do
+    context 'when the field is a nested hash' do
+
+      context 'when the field is reset to an empty hash' do
+
+        before do
+          church.set('location' => {})
+        end
+
+        it 'updates the field locally' do
+          expect(church.location).to eq({})
+        end
+
+        it 'updates the field in the database' do
+          expect(church.reload.location).to eq({})
+        end
+      end
 
       context 'when a leaf value in the nested hash is updated' do
 
@@ -300,6 +315,25 @@ describe Mongoid::Persistable::Settable do
         end
       end
 
+      context 'when a leaf value in the nested hash is updated to a number' do
+
+        let(:church) do
+          Church.new.tap do |a|
+            a.location = {'address' => {'city' => 'Berlin', 'street' => 'Yorckstr'}}
+            a.name = 'Church1'
+            a.save
+          end
+        end
+
+        before do
+          church.set('location.address.city' => 12345)
+        end
+
+        it 'updates the nested value to the correct value' do
+          expect(church.name).to eq('Church1')
+          expect(church.location).to eql({'address' => {'city' => 12345, 'street' => 'Yorckstr'}})
+        end
+      end
 
       context 'when the nested hash is many levels deep' do
 

data/spec/mongoid/persistable_spec.rb

@@ -52,16 +52,16 @@ describe Mongoid::Persistable do
       context "when not chaining the operations" do
 
         let(:operations) do
-          {
+          [{
             "$inc" => { "member_count" => 10 },
             "$bit" => { "likes" => { :and => 13 }},
             "$set" => { "name" => "Placebo" },
-            "$unset" => { "origin" => true }
-          }
+            "$unset" => { "origin" => true }},
+           { session: nil }]
         end
 
         before do
-          expect_any_instance_of(Mongo::Collection::View).to receive(:update_one).with(operations).and_call_original
+          expect_any_instance_of(Mongo::Collection::View).to receive(:update_one).with(*operations).and_call_original
         end
 
         let!(:update) do
@@ -79,16 +79,16 @@ describe Mongoid::Persistable do
       context "when chaining the operations" do
 
         let(:operations) do
-          {
+          [{
             "$inc" => { "member_count" => 10 },
             "$bit" => { "likes" => { :and => 13 }},
             "$set" => { "name" => "Placebo" },
-            "$unset" => { "origin" => true }
-          }
+            "$unset" => { "origin" => true }},
+           { :session => nil } ]
         end
 
         before do
-          expect_any_instance_of(Mongo::Collection::View).to receive(:update_one).with(operations).and_call_original
+          expect_any_instance_of(Mongo::Collection::View).to receive(:update_one).with(*operations).and_call_original
         end
 
         let!(:update) do
@@ -107,16 +107,16 @@ describe Mongoid::Persistable do
       context "when given multiple operations of the same type" do
 
         let(:operations) do
-          {
+          [{
             "$inc" => { "member_count" => 10, "other_count" => 10 },
             "$bit" => { "likes" => { :and => 13 }},
             "$set" => { "name" => "Placebo" },
-            "$unset" => { "origin" => true }
-          }
+            "$unset" => { "origin" => true }},
+            { session: nil }]
         end
 
         before do
-          expect_any_instance_of(Mongo::Collection::View).to receive(:update_one).with(operations).and_call_original
+          expect_any_instance_of(Mongo::Collection::View).to receive(:update_one).with(*operations).and_call_original
         end
 
         let!(:update) do
@@ -144,16 +144,16 @@ describe Mongoid::Persistable do
       context "when expecting the document to be yielded" do
 
         let(:operations) do
-          {
+          [{
             "$inc" => { "member_count" => 10 },
             "$bit" => { "likes" => { :and => 13 }},
             "$set" => { "name" => "Placebo" },
-            "$unset" => { "origin" => true }
-          }
+            "$unset" => { "origin" => true }},
+            { session: nil }]
         end
 
         before do
-          expect_any_instance_of(Mongo::Collection::View).to receive(:update_one).with(operations).and_call_original
+          expect_any_instance_of(Mongo::Collection::View).to receive(:update_one).with(*operations).and_call_original
         end
 
         let!(:update) do

data/spec/mongoid/relations/embedded/many_spec.rb

@@ -2583,6 +2583,25 @@ describe Mongoid::Relations::Embedded::Many do
         person.addresses.create(street: "hermannstr")
       end
 
+      context "when the number is zero" do
+
+        let!(:popped) do
+          person.addresses.pop(0)
+        end
+
+        it "returns an empty array" do
+          expect(popped).to eq([])
+        end
+
+        it "does not remove the document from the relation" do
+          expect(person.addresses).to eq([ address_one, address_two ])
+        end
+
+        it "does not persist the pop" do
+          expect(person.reload.addresses).to eq([ address_one, address_two ])
+        end
+      end
+
       context "when the number is not larger than the relation" do
 
         let!(:popped) do
@@ -2640,6 +2659,125 @@ describe Mongoid::Relations::Embedded::Many do
     end
   end
 
+  describe "#shift" do
+
+    let(:person) do
+      Person.create
+    end
+
+    context "when no argument is provided" do
+
+      let!(:address_one) do
+        person.addresses.create(street: "sonnenallee")
+      end
+
+      let!(:address_two) do
+        person.addresses.create(street: "hermannstr")
+      end
+
+      let!(:shifted) do
+        person.addresses.shift
+      end
+
+      it "returns the shifted document" do
+        expect(shifted).to eq(address_one)
+      end
+
+      it "removes the document from the relation" do
+        expect(person.addresses).to eq([ address_two ])
+      end
+
+      it "persists the shift" do
+        expect(person.reload.addresses).to eq([ address_two ])
+      end
+    end
+
+    context "when an integer is provided" do
+
+      let!(:address_one) do
+        person.addresses.create(street: "sonnenallee")
+      end
+
+      let!(:address_two) do
+        person.addresses.create(street: "hermannstr")
+      end
+
+      context "when the number is zero" do
+
+        let!(:shifted) do
+          person.addresses.shift(0)
+        end
+
+        it "returns an empty array" do
+          expect(shifted).to eq([])
+        end
+
+        it "does not remove the document from the relation" do
+          expect(person.addresses).to eq([ address_one, address_two ])
+        end
+
+        it "does not persist the shift" do
+          expect(person.reload.addresses).to eq([ address_one, address_two ])
+        end
+      end
+
+      context "when the number is not larger than the relation" do
+
+        let!(:shifted) do
+          person.addresses.shift(2)
+        end
+
+        it "returns the shifted documents" do
+          expect(shifted).to eq([ address_one, address_two ])
+        end
+
+        it "removes the document from the relation" do
+          expect(person.addresses).to be_empty
+        end
+
+        it "persists the shift" do
+          expect(person.reload.addresses).to be_empty
+        end
+      end
+
+      context "when the number is larger than the relation" do
+
+        let!(:shifted) do
+          person.addresses.shift(4)
+        end
+
+        it "returns the shifted documents" do
+          expect(shifted).to eq([ address_one, address_two ])
+        end
+
+        it "removes the document from the relation" do
+          expect(person.addresses).to be_empty
+        end
+
+        it "persists the shift" do
+          expect(person.reload.addresses).to be_empty
+        end
+      end
+    end
+
+    context "when the relation is empty" do
+
+      context "when providing no number" do
+
+        it "returns nil" do
+          expect(person.addresses.shift).to be_nil
+        end
+      end
+
+      context "when providing a number" do
+
+        it "returns nil" do
+          expect(person.addresses.shift(2)).to be_nil
+        end
+      end
+    end
+  end
+
   describe "#scoped" do
 
     let(:person) do
@@ -3846,7 +3984,7 @@ describe Mongoid::Relations::Embedded::Many do
     end
   end
 
-  context "#delete or #clear with before_remove callback" do
+  context "#delete, or #clear, or #pop, or #shift with before_remove callback" do
 
     let(:artist) do
       Artist.new
@@ -3892,35 +4030,81 @@ describe Mongoid::Relations::Embedded::Many do
         end
       end
 
-      context "when errors are raised" do
+      describe "#pop" do
 
         before do
-          expect(artist).to receive(:before_remove_song).and_raise
+          artist.songs.pop
         end
 
-        describe "#delete" do
+        it "executes the callback" do
+          artist.songs.pop
+          expect(artist.before_remove_embedded_called).to be true
+        end
+      end
 
-          it "does not remove the document from the relation" do
-            begin; artist.songs.delete(song); rescue; end
-            expect(artist.songs).to eq([ song ])
-          end
+      describe "#shift" do
+
+        before do
+          artist.songs.shift
         end
 
-        describe "#clear" do
+        it "executes the callback" do
+          artist.songs.shift
+          expect(artist.before_remove_embedded_called).to be true
+        end
+      end
+    end
 
-          before do
-            begin; artist.songs.clear; rescue; end
-          end
+    context "when errors are raised" do
 
-          it "removes the documents from the relation" do
-            expect(artist.songs).to eq([ song ])
-          end
+      before do
+        expect(artist).to receive(:before_remove_song).and_raise
+      end
+
+      describe "#delete" do
+
+        it "does not remove the document from the relation" do
+          begin; artist.songs.delete(song); rescue; end
+          expect(artist.songs).to eq([ song ])
+        end
+      end
+
+      describe "#clear" do
+
+        before do
+          begin; artist.songs.clear; rescue; end
+        end
+
+        it "removes the documents from the relation" do
+          expect(artist.songs).to eq([ song ])
+        end
+      end
+
+      describe "#pop" do
+
+        before do
+          begin; artist.songs.pop; rescue; end
+        end
+
+        it "should remove from collection" do
+          expect(artist.songs).to eq([ song ])
+        end
+      end
+
+      describe "#shift" do
+
+        before do
+          begin; artist.songs.shift; rescue; end
+        end
+
+        it "should remove from collection" do
+          expect(artist.songs).to eq([ song ])
         end
       end
     end
   end
 
-  context "#delete or #clear with after_remove callback" do
+  context "#delete, or #clear, or #pop, or #shift with after_remove callback" do
 
     let(:artist) do
       Artist.new
@@ -3957,6 +4141,30 @@ describe Mongoid::Relations::Embedded::Many do
           expect(artist.after_remove_embedded_called).to be true
         end
       end
+
+      describe "#pop" do
+
+        before do
+          artist.labels.pop
+        end
+
+        it "executes the callback" do
+          artist.labels.pop
+          expect(artist.after_remove_embedded_called).to be true
+        end
+      end
+
+      describe "#shift" do
+
+        before do
+          artist.labels.shift
+        end
+
+        it "executes the callback" do
+          artist.labels.shift
+          expect(artist.after_remove_embedded_called).to be true
+        end
+      end
     end
 
     context "when errors are raised" do
@@ -3986,6 +4194,28 @@ describe Mongoid::Relations::Embedded::Many do
           expect(artist.labels).to be_empty
         end
       end
+
+      describe "#pop" do
+
+        before do
+          begin; artist.labels.pop; rescue; end
+        end
+
+        it "should remove from collection" do
+          expect(artist.labels).to be_empty
+        end
+      end
+
+      describe "#shift" do
+
+        before do
+          begin; artist.labels.shift; rescue; end
+        end
+
+        it "should remove from collection" do
+          expect(artist.labels).to be_empty
+        end
+      end
     end
   end