mongoid 8.1.9 → 9.0.0

data/spec/mongoid/persistable/deletable_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rubocop:todo all
 
 require "spec_helper"
 
@@ -11,35 +12,15 @@ describe Mongoid::Persistable::Deletable do
     end
 
     context "when deleting a readonly document" do
-
-      context "when legacy_attributes is true" do
-        config_override :legacy_readonly, true
-
-        let(:from_db) do
-          Person.only(:_id).first
-        end
-
-        it "raises an error" do
-          expect(from_db.readonly?).to be true
-          expect {
-            from_db.delete
-          }.to raise_error(Mongoid::Errors::ReadonlyDocument)
-        end
+      let(:from_db) do
+        Person.first.tap(&:readonly!)
       end
 
-      context "when legacy_attributes is false" do
-        config_override :legacy_readonly, false
-
-        let(:from_db) do
-          Person.first.tap(&:readonly!)
-        end
-
-        it "raises an error" do
-          expect(from_db.readonly?).to be true
-          expect {
-            from_db.delete
-          }.to raise_error(Mongoid::Errors::ReadonlyDocument)
-        end
+      it "raises an error" do
+        expect(from_db.readonly?).to be true
+        expect {
+          from_db.delete
+        }.to raise_error(Mongoid::Errors::ReadonlyDocument)
       end
     end
 
@@ -57,7 +38,7 @@ describe Mongoid::Persistable::Deletable do
       end
     end
 
-    context "when removing a root document" do
+    context "when deleting a root document" do
 
       let!(:deleted) do
         person.delete
@@ -76,9 +57,28 @@ describe Mongoid::Persistable::Deletable do
       it "resets the flagged for destroy flag" do
         expect(person).to_not be_flagged_for_destroy
       end
+
+      context 'when :persist option false' do
+
+        let!(:deleted) do
+          person.delete(persist: false)
+        end
+
+        it "does not delete the document from the collection" do
+          expect(Person.find(person.id)).to eq person
+        end
+
+        it "returns true" do
+          expect(deleted).to be true
+        end
+
+        it "does not set the flagged for destroy flag" do
+          expect(person).to_not be_flagged_for_destroy
+        end
+      end
     end
 
-    context "when removing an embedded document" do
+    context "when deleting an embedded document" do
 
       let(:address) do
         person.addresses.build(street: "Bond Street")
@@ -114,13 +114,60 @@ describe Mongoid::Persistable::Deletable do
           Person.find(person.id)
         end
 
-        it "removes the object from the parent and database" do
+        it "removes the object from the parent" do
+          expect(person.addresses).to be_empty
+        end
+
+        it "removes the object from the database" do
+          expect(from_db.addresses).to be_empty
+        end
+      end
+
+      context 'when :persist option false' do
+
+        before do
+          address.save!
+          address.delete(persist: false)
+        end
+
+        let(:from_db) do
+          Person.find(person.id)
+        end
+
+        it "does not remove the object from the parent" do
+          expect(person.addresses).to eq [address]
+          expect(person.addresses.first).to_not be_flagged_for_destroy
+        end
+
+        it "does not remove the object from the database" do
+          expect(from_db.addresses).to eq [address]
+          expect(from_db.addresses.first).to_not be_flagged_for_destroy
+        end
+      end
+
+      context 'when :suppress option true' do
+
+        before do
+          address.save!
+          address.delete(suppress: true)
+        end
+
+        let(:from_db) do
+          Person.find(person.id)
+        end
+
+        it "does not remove the object from the parent" do
+          expect(person.addresses).to eq [address]
+          expect(person.addresses.first).to_not be_flagged_for_destroy
+        end
+
+        it "removes the object from the database" do
           expect(from_db.addresses).to be_empty
         end
       end
     end
 
-    context "when removing deeply embedded documents" do
+    context "when deleting deeply embedded documents" do
 
       context "when the document has been saved" do
 

data/spec/mongoid/persistable/destroyable_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rubocop:todo all
 
 require "spec_helper"
 
@@ -11,35 +12,15 @@ describe Mongoid::Persistable::Destroyable do
     end
 
     context "when destroying a readonly document" do
-
-      context "when legacy_attributes is true" do
-        config_override :legacy_readonly, true
-
-        let(:from_db) do
-          Person.only(:_id).first
-        end
-
-        it "raises an error" do
-          expect(from_db.readonly?).to be true
-          expect {
-            from_db.destroy
-          }.to raise_error(Mongoid::Errors::ReadonlyDocument)
-        end
+      let(:from_db) do
+        Person.first.tap(&:readonly!)
       end
 
-      context "when legacy_attributes is false" do
-        config_override :legacy_readonly, false
-
-        let(:from_db) do
-          Person.first.tap(&:readonly!)
-        end
-
-        it "raises an error" do
-          expect(from_db.readonly?).to be true
-          expect {
-            from_db.destroy
-          }.to raise_error(Mongoid::Errors::ReadonlyDocument)
-        end
+      it "raises an error" do
+        expect(from_db.readonly?).to be true
+        expect {
+          from_db.destroy
+        }.to raise_error(Mongoid::Errors::ReadonlyDocument)
       end
     end
 
@@ -51,13 +32,11 @@ describe Mongoid::Persistable::Destroyable do
       end
 
       it 'deletes the matching document from the database' do
-        lambda do
-          person.reload
-        end.should raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Person with id\(s\)/)
+        expect { person.reload }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Person with id\(s\)/)
       end
     end
 
-    context "when removing a root document" do
+    context "when destroying a root document" do
 
       let!(:destroyed) do
         person.destroy
@@ -76,9 +55,28 @@ describe Mongoid::Persistable::Destroyable do
       it "resets the flagged for destroy flag" do
         expect(person).to_not be_flagged_for_destroy
       end
+
+      context 'when :persist option false' do
+
+        let!(:destroyed) do
+          person.destroy(persist: false)
+        end
+
+        it "does not destroy the document from the collection" do
+          expect(Person.find(person.id)).to eq person
+        end
+
+        it "returns true" do
+          expect(destroyed).to be true
+        end
+
+        it "does not set the flagged for destroy flag" do
+          expect(person).to_not be_flagged_for_destroy
+        end
+      end
     end
 
-    context "when removing an embedded document" do
+    context "when destroying an embedded document" do
 
       let(:address) do
         person.addresses.build(street: "Bond Street")
@@ -114,12 +112,59 @@ describe Mongoid::Persistable::Destroyable do
           Person.find(person.id)
         end
 
-        it "removes the object from the parent and database" do
+        it "removes the object from the parent" do
+          expect(person.addresses).to be_empty
+        end
+
+        it "removes the object from the database" do
           expect(from_db.addresses).to be_empty
         end
       end
 
-      context 'when removing from a list of embedded documents' do
+      context 'when :persist option false' do
+
+        before do
+          address.save!
+          address.destroy(persist: false)
+        end
+
+        let(:from_db) do
+          Person.find(person.id)
+        end
+
+        it "does not remove the object from the parent" do
+          expect(person.addresses).to eq [address]
+          expect(person.addresses.first).to_not be_flagged_for_destroy
+        end
+
+        it "does not remove the object from the database" do
+          expect(from_db.addresses).to eq [address]
+          expect(from_db.addresses.first).to_not be_flagged_for_destroy
+        end
+      end
+
+      context 'when :suppress option true' do
+
+        before do
+          address.save!
+          address.destroy(suppress: true)
+        end
+
+        let(:from_db) do
+          Person.find(person.id)
+        end
+
+        it "does not remove the object from the parent" do
+          expect(person.addresses).to eq [address]
+          expect(person.addresses.first).to_not be_flagged_for_destroy
+        end
+
+        it "removes the object from the database" do
+          expect(from_db.addresses).to be_empty
+        end
+      end
+
+      context 'when destroying from a list of embedded documents' do
 
         context 'when the embedded documents list is reversed in memory' do
 
@@ -149,7 +194,7 @@ describe Mongoid::Persistable::Destroyable do
       end
     end
 
-    context "when removing deeply embedded documents" do
+    context "when destroying deeply embedded documents" do
 
       context "when the document has been saved" do
 
@@ -213,9 +258,7 @@ describe Mongoid::Persistable::Destroyable do
 
           it 'raises an exception' do
             Sealer.count.should == 1
-            lambda do
-              parent.destroy
-            end.should raise_error(Mongoid::Errors::DeleteRestriction)
+            expect { parent.destroy }.to raise_error(Mongoid::Errors::DeleteRestriction)
             Sealer.count.should == 1
           end
         end
@@ -254,9 +297,7 @@ describe Mongoid::Persistable::Destroyable do
 
           it 'raises an exception' do
             Spacer.count.should == 1
-            lambda do
-              parent.destroy
-            end.should raise_error(Mongoid::Errors::DeleteRestriction)
+            expect { parent.destroy }.to raise_error(Mongoid::Errors::DeleteRestriction)
             Spacer.count.should == 1
           end
         end
@@ -266,11 +307,11 @@ describe Mongoid::Persistable::Destroyable do
 
   describe "#destroy!" do
 
-    context "when no validation callback returns false" do
+    let(:person) do
+      Person.create!
+    end
 
-      let(:person) do
-        Person.create!
-      end
+    context "when no validation callback returns false" do
 
       it "returns true" do
         expect(person.destroy!).to eq(true)
@@ -297,6 +338,147 @@ describe Mongoid::Persistable::Destroyable do
         }.to raise_error(Mongoid::Errors::DocumentNotDestroyed)
       end
     end
+
+    context 'when destroying a document that was not saved' do
+      let(:unsaved_person) { Person.new(id: person.id) }
+
+      before do
+        unsaved_person.destroy!
+      end
+
+      it 'deletes the matching document from the database' do
+        expect { person.reload }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Person with id\(s\)/)
+      end
+    end
+
+    context "when destroying a root document" do
+
+      let!(:destroyed) do
+        person.destroy!
+      end
+
+      it "destroys the document from the collection" do
+        expect {
+          Person.find(person.id)
+        }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Person with id\(s\)/)
+      end
+
+      it "returns true" do
+        expect(destroyed).to be true
+      end
+
+      it "resets the flagged for destroy flag" do
+        expect(person).to_not be_flagged_for_destroy
+      end
+
+      context 'when :persist option false' do
+
+        let!(:destroyed) do
+          person.destroy!(persist: false)
+        end
+
+        it "does not destroy the document from the collection" do
+          expect(Person.find(person.id)).to eq person
+        end
+
+        it "returns true" do
+          expect(destroyed).to be true
+        end
+
+        it "does not set the flagged for destroy flag" do
+          expect(person).to_not be_flagged_for_destroy
+        end
+      end
+    end
+
+    context "when destroying an embedded document" do
+
+      let(:address) do
+        person.addresses.build(street: "Bond Street")
+      end
+
+      context "when the document is not yet saved" do
+
+        before do
+          address.destroy!
+        end
+
+        it "removes the document from the parent" do
+          expect(person.addresses).to be_empty
+        end
+
+        it "removes the attributes from the parent" do
+          expect(person.raw_attributes["addresses"]).to be_nil
+        end
+
+        it "resets the flagged for destroy flag" do
+          expect(address).to_not be_flagged_for_destroy
+        end
+      end
+
+      context "when the document has been saved" do
+
+        before do
+          address.save!
+          address.destroy!
+        end
+
+        let(:from_db) do
+          Person.find(person.id)
+        end
+
+        it "removes the object from the parent" do
+          expect(person.addresses).to be_empty
+        end
+
+        it "removes the object from the database" do
+          expect(from_db.addresses).to be_empty
+        end
+      end
+
+      context 'when :persist option false' do
+
+        before do
+          address.save!
+          address.destroy!(persist: false)
+        end
+
+        let(:from_db) do
+          Person.find(person.id)
+        end
+
+        it "does not remove the object from the parent" do
+          expect(person.addresses).to eq [address]
+          expect(person.addresses.first).to_not be_flagged_for_destroy
+        end
+
+        it "does not remove the object from the database" do
+          expect(from_db.addresses).to eq [address]
+          expect(from_db.addresses.first).to_not be_flagged_for_destroy
+        end
+      end
+
+      context 'when :suppress option true' do
+
+        before do
+          address.save!
+          address.destroy!(suppress: true)
+        end
+
+        let(:from_db) do
+          Person.find(person.id)
+        end
+
+        it "does not remove the object from the parent" do
+          expect(person.addresses).to eq [address]
+          expect(person.addresses.first).to_not be_flagged_for_destroy
+        end
+
+        it "removes the object from the database" do
+          expect(from_db.addresses).to be_empty
+        end
+      end
+    end
   end
 
   describe "#destroy_all" do
@@ -361,7 +543,7 @@ describe Mongoid::Persistable::Destroyable do
       end
     end
 
-    context 'when removing a list of embedded documents' do
+    context 'when destroying a list of embedded documents' do
 
       context 'when the embedded documents list is reversed in memory' do
 
@@ -422,9 +604,7 @@ describe Mongoid::Persistable::Destroyable do
 
           it 'raises an exception' do
             Sealer.count.should == 1
-            lambda do
-              Hole.destroy_all
-            end.should raise_error(Mongoid::Errors::DeleteRestriction)
+            expect { Hole.destroy_all }.to raise_error(Mongoid::Errors::DeleteRestriction)
             Sealer.count.should == 1
           end
         end
@@ -463,9 +643,7 @@ describe Mongoid::Persistable::Destroyable do
 
           it 'raises an exception' do
             Spacer.count.should == 1
-            lambda do
-              Hole.destroy_all
-            end.should raise_error(Mongoid::Errors::DeleteRestriction)
+            expect { Hole.destroy_all }.to raise_error(Mongoid::Errors::DeleteRestriction)
             Spacer.count.should == 1
           end
         end

data/spec/mongoid/persistable/incrementable_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rubocop:todo all
 
 require "spec_helper"
 

data/spec/mongoid/persistable/logical_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rubocop:todo all
 
 require "spec_helper"
 

data/spec/mongoid/persistable/maxable_spec.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+# rubocop:todo all
+
+require "spec_helper"
+
+describe Mongoid::Persistable::Maxable do
+
+  describe "#set_max" do
+
+    shared_examples_for 'a max-able interface' do
+      context "when the document is a root document" do
+        let(:initial_name) { "Manhattan Transfer" }
+        let(:initial_members) { 4 }
+        let(:initial_founded) { Date.new(1972, 10, 1) }
+
+        let(:band) do
+          Band.create!(
+            name: initial_name,
+            member_count: initial_members,
+            founded: initial_founded)
+        end
+
+        shared_examples_for "a max-able root document" do
+          before do
+            band.send(max_method,
+              name: given_name,
+              member_count: given_members,
+              founded: given_founded)
+          end
+
+          it 'sets the fields to larger of current vs. given' do
+            expect(band.reload.name).to be == [ initial_name, given_name ].max
+            expect(band.member_count).to be == [ initial_members, given_members ].max
+            expect(band.founded).to be == [ initial_founded, given_founded ].max
+          end
+
+          it "resets dirty changes" do
+            expect(band).to_not be_changed
+          end
+        end
+
+        context 'when given < initial' do
+          let(:given_name) { "A" }
+          let(:given_members) { 3 }
+          let(:given_founded) { Date.new(1970, 1, 1) }
+
+          it_behaves_like "a max-able root document"
+        end
+
+        context 'when given == initial' do
+          let(:given_name) { initial_name }
+          let(:given_members) { initial_members }
+          let(:given_founded) { initial_founded }
+
+          it_behaves_like "a max-able root document"
+        end
+
+        context 'when given > initial' do
+          let(:given_name) { "Z" }
+          let(:given_members) { 10 }
+          let(:given_founded) { Date.today }
+
+          it_behaves_like "a max-able root document"
+        end
+      end
+
+      context "when the document is an embedded document" do
+        let(:initial_city) { "Manhattan" }
+        let(:initial_number) { 100 }
+        let(:initial_end_date) { Date.today }
+
+        let(:person) { Person.create! }
+        let(:address) do
+          person.addresses.create!(
+            city: initial_city,
+            number: initial_number,
+            end_date: initial_end_date)
+        end
+
+        shared_examples_for "a max-able embedded document" do
+          before do
+            address.send(max_method,
+              city: given_city,
+              number: given_number,
+              end_date: given_end_date)
+          end
+
+          it 'sets the fields to smaller of current vs. given' do
+            expect(address.reload.city).to be == [ initial_city, given_city ].max
+            expect(address.number).to be == [ initial_number, given_number ].max
+            expect(address.end_date).to be == [ initial_end_date, given_end_date ].max
+          end
+
+          it "resets dirty changes" do
+            expect(address).to_not be_changed
+          end
+        end
+
+        context 'when given < initial' do
+          let(:given_city) { "A" }
+          let(:given_number) { 10 }
+          let(:given_end_date) { 5.days.ago.to_date }
+
+          it_behaves_like "a max-able embedded document"
+        end
+
+        context 'when given == initial' do
+          let(:given_city) { initial_city }
+          let(:given_number) { initial_number }
+          let(:given_end_date) { initial_end_date }
+
+          it_behaves_like "a max-able embedded document"
+        end
+
+        context 'when given > initial' do
+          let(:given_city) { "Z" }
+          let(:given_number) { 1000 }
+          let(:given_end_date) { 5.days.from_now.to_date }
+
+          it_behaves_like "a max-able embedded document"
+        end
+      end
+
+      context "when executing atomically" do
+        let(:band) { Band.create!(member_count: 10, name: "Manhattan Transfer") }
+
+        it "marks a dirty change for the modified fields" do
+          band.atomically do
+            band.send(max_method, member_count: 15, name: "Manhattan Transfer")
+            expect(band.changes)
+              .to be == { "member_count" => [10, 15] }
+          end
+        end
+      end
+    end
+
+    context 'as itself' do
+      let(:max_method) { :set_max }
+      it_behaves_like 'a max-able interface'
+    end
+
+    context 'as #clamp_lower_bound' do
+      let(:max_method) { :clamp_lower_bound }
+      it_behaves_like 'a max-able interface'
+    end
+  end
+end