mongoid 9.0.11 → 9.1.0

data/spec/mongoid/persistable/destroyable_spec.rb

@@ -1,26 +1,23 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Persistable::Destroyable do
-
-  describe "#destroy" do
-
+  describe '#destroy' do
     let!(:person) do
       Person.create!
     end
 
-    context "when destroying a readonly document" do
+    context 'when destroying a readonly document' do
       let(:from_db) do
         Person.first.tap(&:readonly!)
       end
 
-      it "raises an error" do
+      it 'raises an error' do
         expect(from_db.readonly?).to be true
-        expect {
+        expect do
           from_db.destroy
-        }.to raise_error(Mongoid::Errors::ReadonlyDocument)
+        end.to raise_error(Mongoid::Errors::ReadonlyDocument)
       end
     end
 
@@ -32,77 +29,75 @@ describe Mongoid::Persistable::Destroyable do
       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\)/)
+        expect do
+          person.reload
+        end.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
-
+    context 'when destroying a root document' do
       let!(:destroyed) do
         person.destroy
       end
 
-      it "destroys the document from the collection" do
-        expect {
+      it 'destroys the document from the collection' do
+        expect do
           Person.find(person.id)
-        }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Person with id\(s\)/)
+        end.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Person with id\(s\)/)
       end
 
-      it "returns true" do
+      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
+      it 'resets the flagged for destroy flag' do
+        expect(person).not_to 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
+        it 'does not destroy the document from the collection' do
           expect(Person.find(person.id)).to eq person
         end
 
-        it "returns true" do
+        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
+        it 'does not set the flagged for destroy flag' do
+          expect(person).not_to be_flagged_for_destroy
         end
       end
     end
 
-    context "when destroying an embedded document" do
-
+    context 'when destroying an embedded document' do
       let(:address) do
-        person.addresses.build(street: "Bond Street")
+        person.addresses.build(street: 'Bond Street')
       end
 
-      context "when the document is not yet saved" do
-
+      context 'when the document is not yet saved' do
         before do
           address.destroy
         end
 
-        it "removes the document from the parent" do
+        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
+        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
+        it 'resets the flagged for destroy flag' do
+          expect(address).not_to be_flagged_for_destroy
         end
       end
 
-      context "when the document has been saved" do
-
+      context 'when the document has been saved' do
         before do
           address.save!
           address.destroy
@@ -112,17 +107,16 @@ describe Mongoid::Persistable::Destroyable do
           Person.find(person.id)
         end
 
-        it "removes the object from the parent" do
+        it 'removes the object from the parent' do
           expect(person.addresses).to be_empty
         end
 
-        it "removes the object from the database" do
+        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)
@@ -132,19 +126,18 @@ describe Mongoid::Persistable::Destroyable 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
+        it 'does not remove the object from the parent' do
+          expect(person.addresses).to eq [ address ]
+          expect(person.addresses.first).not_to 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
+        it 'does not remove the object from the database' do
+          expect(from_db.addresses).to eq [ address ]
+          expect(from_db.addresses.first).not_to be_flagged_for_destroy
         end
       end
 
       context 'when :suppress option true' do
-
         before do
           address.save!
           address.destroy(suppress: true)
@@ -154,20 +147,18 @@ describe Mongoid::Persistable::Destroyable 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
+        it 'does not remove the object from the parent' do
+          expect(person.addresses).to eq [ address ]
+          expect(person.addresses.first).not_to be_flagged_for_destroy
         end
 
-        it "removes the object from the database" do
+        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
-
           let(:word) do
             Word.create!(name: 'driver')
           end
@@ -194,16 +185,14 @@ describe Mongoid::Persistable::Destroyable do
       end
     end
 
-    context "when destroying deeply embedded documents" do
-
-      context "when the document has been saved" do
-
+    context 'when destroying deeply embedded documents' do
+      context 'when the document has been saved' do
         let(:address) do
-          person.addresses.create!(street: "Bond Street")
+          person.addresses.create!(street: 'Bond Street')
         end
 
         let(:location) do
-          address.locations.create!(name: "Home")
+          address.locations.create!(name: 'Home')
         end
 
         let(:from_db) do
@@ -214,28 +203,27 @@ describe Mongoid::Persistable::Destroyable do
           location.destroy
         end
 
-        it "removes the object from the parent and database" do
+        it 'removes the object from the parent and database' do
           expect(from_db.addresses.first.locations).to be_empty
         end
 
-        it "resets the flagged for destroy flag" do
-          expect(location).to_not be_flagged_for_destroy
+        it 'resets the flagged for destroy flag' do
+          expect(location).not_to be_flagged_for_destroy
         end
       end
     end
 
     context 'when there are dependent documents' do
       context 'has_one' do
-
         context 'dependent: :destroy' do
           let!(:parent) do
             Hole.create!(bolt: Bolt.create!)
           end
 
           it 'destroys dependent documents' do
-            Bolt.count.should == 1
+            Bolt.count.should eq 1
             parent.destroy
-            Bolt.count.should == 0
+            Bolt.count.should eq 0
           end
         end
 
@@ -245,9 +233,9 @@ describe Mongoid::Persistable::Destroyable do
           end
 
           it 'deletes dependent documents' do
-            Threadlocker.count.should == 1
+            Threadlocker.count.should eq 1
             parent.destroy
-            Threadlocker.count.should == 0
+            Threadlocker.count.should eq 0
           end
         end
 
@@ -257,69 +245,65 @@ describe Mongoid::Persistable::Destroyable do
           end
 
           it 'raises an exception' do
-            Sealer.count.should == 1
+            Sealer.count.should eq 1
             expect { parent.destroy }.to raise_error(Mongoid::Errors::DeleteRestriction)
-            Sealer.count.should == 1
+            Sealer.count.should eq 1
           end
         end
       end
 
       context 'has_many' do
-
         context 'dependent: :destroy' do
           let!(:parent) do
-            Hole.create!(nuts: [Nut.create!])
+            Hole.create!(nuts: [ Nut.create! ])
           end
 
           it 'destroys dependent documents' do
-            Nut.count.should == 1
+            Nut.count.should eq 1
             parent.destroy
-            Nut.count.should == 0
+            Nut.count.should eq 0
           end
         end
 
         context 'dependent: :destroy_all' do
           let!(:parent) do
-            Hole.create!(washers: [Washer.create!])
+            Hole.create!(washers: [ Washer.create! ])
           end
 
           it 'deletes dependent documents' do
-            Washer.count.should == 1
+            Washer.count.should eq 1
             parent.destroy
-            Washer.count.should == 0
+            Washer.count.should eq 0
           end
         end
 
         context 'dependent: :restrict_with_exception' do
           let!(:parent) do
-            Hole.create!(spacers: [Spacer.create!])
+            Hole.create!(spacers: [ Spacer.create! ])
           end
 
           it 'raises an exception' do
-            Spacer.count.should == 1
+            Spacer.count.should eq 1
             expect { parent.destroy }.to raise_error(Mongoid::Errors::DeleteRestriction)
-            Spacer.count.should == 1
+            Spacer.count.should eq 1
           end
         end
       end
     end
   end
 
-  describe "#destroy!" do
-
+  describe '#destroy!' do
     let(:person) do
       Person.create!
     end
 
-    context "when no validation callback returns false" do
-
-      it "returns true" do
+    context 'when no validation callback returns false' do
+      it 'returns true' do
         expect(person.destroy!).to eq(true)
       end
     end
 
-    context "when a validation callback returns false" do
-
+    context 'when a validation callback returns false' do
       let(:album) do
         Album.create!
       end
@@ -332,10 +316,10 @@ describe Mongoid::Persistable::Destroyable do
         Album.reset_callbacks(:destroy)
       end
 
-      it "raises an exception" do
-        expect {
+      it 'raises an exception' do
+        expect do
           album.destroy!
-        }.to raise_error(Mongoid::Errors::DocumentNotDestroyed)
+        end.to raise_error(Mongoid::Errors::DocumentNotDestroyed)
       end
     end
 
@@ -347,77 +331,75 @@ describe Mongoid::Persistable::Destroyable do
       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\)/)
+        expect do
+          person.reload
+        end.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
-
+    context 'when destroying a root document' do
       let!(:destroyed) do
         person.destroy!
       end
 
-      it "destroys the document from the collection" do
-        expect {
+      it 'destroys the document from the collection' do
+        expect do
           Person.find(person.id)
-        }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Person with id\(s\)/)
+        end.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Person with id\(s\)/)
       end
 
-      it "returns true" do
+      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
+      it 'resets the flagged for destroy flag' do
+        expect(person).not_to 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
+        it 'does not destroy the document from the collection' do
           expect(Person.find(person.id)).to eq person
         end
 
-        it "returns true" do
+        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
+        it 'does not set the flagged for destroy flag' do
+          expect(person).not_to be_flagged_for_destroy
         end
       end
     end
 
-    context "when destroying an embedded document" do
-
+    context 'when destroying an embedded document' do
       let(:address) do
-        person.addresses.build(street: "Bond Street")
+        person.addresses.build(street: 'Bond Street')
       end
 
-      context "when the document is not yet saved" do
-
+      context 'when the document is not yet saved' do
         before do
           address.destroy!
         end
 
-        it "removes the document from the parent" do
+        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
+        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
+        it 'resets the flagged for destroy flag' do
+          expect(address).not_to be_flagged_for_destroy
         end
       end
 
-      context "when the document has been saved" do
-
+      context 'when the document has been saved' do
         before do
           address.save!
           address.destroy!
@@ -427,17 +409,16 @@ describe Mongoid::Persistable::Destroyable do
           Person.find(person.id)
         end
 
-        it "removes the object from the parent" do
+        it 'removes the object from the parent' do
           expect(person.addresses).to be_empty
         end
 
-        it "removes the object from the database" do
+        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)
@@ -447,19 +428,18 @@ describe Mongoid::Persistable::Destroyable 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
+        it 'does not remove the object from the parent' do
+          expect(person.addresses).to eq [ address ]
+          expect(person.addresses.first).not_to 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
+        it 'does not remove the object from the database' do
+          expect(from_db.addresses).to eq [ address ]
+          expect(from_db.addresses.first).not_to be_flagged_for_destroy
         end
       end
 
       context 'when :suppress option true' do
-
         before do
           address.save!
           address.destroy!(suppress: true)
@@ -469,84 +449,77 @@ describe Mongoid::Persistable::Destroyable 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
+        it 'does not remove the object from the parent' do
+          expect(person.addresses).to eq [ address ]
+          expect(person.addresses.first).not_to be_flagged_for_destroy
         end
 
-        it "removes the object from the database" do
+        it 'removes the object from the database' do
           expect(from_db.addresses).to be_empty
         end
       end
     end
   end
 
-  describe "#destroy_all" do
-
+  describe '#destroy_all' do
     let!(:person) do
-      Person.create!(title: "sir")
+      Person.create!(title: 'sir')
     end
 
-    context "when no conditions are provided" do
-
+    context 'when no conditions are provided' do
       let!(:removed) do
         Person.destroy_all
       end
 
-      it "removes all the documents" do
+      it 'removes all the documents' do
         expect(Person.count).to eq(0)
       end
 
-      it "returns the number of documents removed" do
+      it 'returns the number of documents removed' do
         expect(removed).to eq(1)
       end
     end
 
-    context "when conditions are provided" do
-
+    context 'when conditions are provided' do
       let!(:person_two) do
         Person.create!
       end
 
-      context "when no conditions attribute provided" do
-
+      context 'when no conditions attribute provided' do
         let!(:removed) do
-          Person.destroy_all(title: "sir")
+          Person.destroy_all(title: 'sir')
         end
 
-        it "removes the matching documents" do
+        it 'removes the matching documents' do
           expect(Person.count).to eq(1)
         end
 
-        it "returns the number of documents removed" do
+        it 'returns the number of documents removed' do
           expect(removed).to eq(1)
         end
       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") }
+        Person.with(write: { w: 0 }) { |klass| klass.destroy_all(title: 'sir') }
       end
 
-      it "removes the matching documents" do
+      it 'removes the matching documents' do
         expect(Person.where(title: 'miss').count).to eq(1)
       end
 
-      it "returns 0" do
+      it 'returns 0' do
         expect(removed).to eq(0)
       end
     end
 
     context 'when destroying a list of embedded documents' do
-
       context 'when the embedded documents list is reversed in memory' do
-
         let(:word) do
           Word.create!(name: 'driver')
         end
@@ -566,7 +539,6 @@ describe Mongoid::Persistable::Destroyable do
 
     context 'when there are dependent documents' do
       context 'has_one' do
-
         context 'dependent: :destroy' do
           let!(:parent) do
             Hole.create!.tap do |hole|
@@ -575,9 +547,9 @@ describe Mongoid::Persistable::Destroyable do
           end
 
           it 'destroys dependent documents' do
-            Bolt.count.should == 1
+            Bolt.count.should eq 1
             Hole.destroy_all
-            Bolt.count.should == 0
+            Bolt.count.should eq 0
           end
         end
 
@@ -589,9 +561,9 @@ describe Mongoid::Persistable::Destroyable do
           end
 
           it 'deletes dependent documents' do
-            Threadlocker.count.should == 1
+            Threadlocker.count.should eq 1
             Hole.destroy_all
-            Threadlocker.count.should == 0
+            Threadlocker.count.should eq 0
           end
         end
 
@@ -603,48 +575,47 @@ describe Mongoid::Persistable::Destroyable do
           end
 
           it 'raises an exception' do
-            Sealer.count.should == 1
+            Sealer.count.should eq 1
             expect { Hole.destroy_all }.to raise_error(Mongoid::Errors::DeleteRestriction)
-            Sealer.count.should == 1
+            Sealer.count.should eq 1
           end
         end
       end
 
       context 'has_many' do
-
         context 'dependent: :destroy' do
           let!(:parent) do
-            Hole.create!(nuts: [Nut.create!])
+            Hole.create!(nuts: [ Nut.create! ])
           end
 
           it 'destroys dependent documents' do
-            Nut.count.should == 1
+            Nut.count.should eq 1
             Hole.destroy_all
-            Nut.count.should == 0
+            Nut.count.should eq 0
           end
         end
 
         context 'dependent: :delete_all' do
           let!(:parent) do
-            Hole.create!(washers: [Washer.create!])
+            Hole.create!(washers: [ Washer.create! ])
           end
 
           it 'deletes dependent documents' do
-            Washer.count.should == 1
+            Washer.count.should eq 1
             Hole.destroy_all
-            Washer.count.should == 0
+            Washer.count.should eq 0
           end
         end
 
         context 'dependent: :restrict_with_exception' do
           let!(:parent) do
-            Hole.create!(spacers: [Spacer.create!])
+            Hole.create!(spacers: [ Spacer.create! ])
           end
 
           it 'raises an exception' do
-            Spacer.count.should == 1
+            Spacer.count.should eq 1
             expect { Hole.destroy_all }.to raise_error(Mongoid::Errors::DeleteRestriction)
-            Spacer.count.should == 1
+            Spacer.count.should eq 1
           end
         end
       end