mongoid 9.0.11 → 9.1.0

data/spec/mongoid/persistable/deletable_spec.rb

@@ -1,26 +1,23 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Persistable::Deletable do
-
-  describe "#delete" do
-
+  describe '#delete' do
     let!(:person) do
       Person.create!
     end
 
-    context "when deleting a readonly document" do
+    context 'when deleting 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.delete
-        }.to raise_error(Mongoid::Errors::ReadonlyDocument)
+        end.to raise_error(Mongoid::Errors::ReadonlyDocument)
       end
     end
 
@@ -34,77 +31,73 @@ describe Mongoid::Persistable::Deletable do
       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\)/)
+        end.should raise_error(Mongoid::Errors::DocumentNotFound,
+                               /Document\(s\) not found for class Person with id\(s\)/)
       end
     end
 
-    context "when deleting a root document" do
-
+    context 'when deleting a root document' do
       let!(:deleted) do
         person.delete
       end
 
-      it "deletes the document from the collection" do
-        expect {
+      it 'deletes 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(deleted).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!(:deleted) do
           person.delete(persist: false)
         end
 
-        it "does not delete the document from the collection" do
+        it 'does not delete the document from the collection' do
           expect(Person.find(person.id)).to eq person
         end
 
-        it "returns true" do
+        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
+        it 'does not set the flagged for destroy flag' do
+          expect(person).not_to be_flagged_for_destroy
         end
       end
     end
 
-    context "when deleting an embedded document" do
-
+    context 'when deleting 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.delete
         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.delete
@@ -114,17 +107,16 @@ describe Mongoid::Persistable::Deletable 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.delete(persist: false)
@@ -134,19 +126,18 @@ describe Mongoid::Persistable::Deletable 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.delete(suppress: true)
@@ -156,27 +147,25 @@ describe Mongoid::Persistable::Deletable 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
 
-    context "when deleting deeply embedded documents" do
-
-      context "when the document has been saved" do
-
+    context 'when deleting 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
@@ -187,119 +176,115 @@ describe Mongoid::Persistable::Deletable do
           location.delete
         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 deleting subclasses" do
-
+    context 'when deleting subclasses' do
       let!(:firefox) do
-        Firefox.create!(name: "firefox")
+        Firefox.create!(name: 'firefox')
       end
 
       let!(:firefox2) do
-        Firefox.create!(name: "firefox 2")
+        Firefox.create!(name: 'firefox 2')
       end
 
       let!(:browser) do
-        Browser.create!(name: "browser")
+        Browser.create!(name: 'browser')
       end
 
       let!(:canvas) do
-        Canvas.create!(name: "canvas")
+        Canvas.create!(name: 'canvas')
       end
 
-      context "when deleting a single document" do
-
+      context 'when deleting a single document' do
         before do
           firefox.delete
         end
 
-        it "deletes from the parent class collection" do
+        it 'deletes from the parent class collection' do
           expect(Canvas.count).to eq(3)
         end
 
-        it "returns correct counts for child classes" do
+        it 'returns correct counts for child classes' do
           expect(Firefox.count).to eq(1)
         end
 
-        it "returns correct counts for root subclasses" do
+        it 'returns correct counts for root subclasses' do
           expect(Browser.count).to eq(2)
         end
       end
 
-      context "when deleting all documents" do
-
+      context 'when deleting all documents' do
         before do
           Firefox.delete_all
         end
 
-        it "deletes from the parent class collection" do
+        it 'deletes from the parent class collection' do
           expect(Canvas.count).to eq(2)
         end
 
-        it "returns correct counts for child classes" do
+        it 'returns correct counts for child classes' do
           expect(Firefox.count).to eq(0)
         end
 
-        it "returns correct counts for root subclasses" do
+        it 'returns correct counts for root subclasses' do
           expect(Browser.count).to eq(1)
         end
       end
     end
 
-    context "when deleting all documents with a custom discriminator key" do
+    context 'when deleting all documents with a custom discriminator key' do
       before do
-        Canvas.discriminator_key = "dkey"
-      end
+        Canvas.discriminator_key = 'dkey'
 
-      after do
-        Canvas.discriminator_key = nil
-      end
-
-      let!(:firefox) do
-        Firefox.create!(name: "firefox")
-      end
+        firefox
+        firefox2
+        browser
+        canvas
 
-      let!(:firefox2) do
-        Firefox.create!(name: "firefox 2")
-      end
-
-      let!(:browser) do
-        Browser.create!(name: "browser")
+        Firefox.delete_all
       end
 
-      let!(:canvas) do
-        Canvas.create!(name: "canvas")
+      after do
+        Canvas.discriminator_key = nil
       end
 
-      before do
-        Firefox.delete_all
-      end
+      let(:firefox) { Firefox.create!(name: 'firefox') }
+      let(:firefox2) { Firefox.create!(name: 'firefox 2') }
+      let(:browser) { Browser.create!(name: 'browser') }
+      let(:canvas) { Canvas.create!(name: 'canvas') }
 
-      it "deletes from the parent class collection" do
+      it 'deletes from the parent class collection' do
         expect(Canvas.count).to eq(2)
       end
 
-      it "returns correct counts for child classes" do
+      it 'returns correct counts for child classes' do
         expect(Firefox.count).to eq(0)
       end
 
-      it "returns correct counts for root subclasses" do
+      it 'returns correct counts for root subclasses' do
         expect(Browser.count).to eq(1)
       end
     end
 
-    context "when deleting all documents with a custom discriminator value" do
+    context 'when deleting all documents with a custom discriminator value' do
       before do
-        Canvas.discriminator_key = "dkey"
-        Firefox.discriminator_value = "dvalue"
+        Canvas.discriminator_key = 'dkey'
+        Firefox.discriminator_value = 'dvalue'
+
+        firefox
+        firefox2
+        browser
+        canvas
+
+        Firefox.delete_all
       end
 
       after do
@@ -307,51 +292,35 @@ describe Mongoid::Persistable::Deletable do
         Firefox.discriminator_value = nil
       end
 
-      let!(:firefox) do
-        Firefox.create!(name: "firefox")
-      end
-
-      let!(:firefox2) do
-        Firefox.create!(name: "firefox 2")
-      end
-
-      let!(:browser) do
-        Browser.create!(name: "browser")
-      end
-
-      let!(:canvas) do
-        Canvas.create!(name: "canvas")
-      end
-
-      before do
-        Firefox.delete_all
-      end
+      let(:firefox) { Firefox.create!(name: 'firefox') }
+      let(:firefox2) { Firefox.create!(name: 'firefox 2') }
+      let(:browser) { Browser.create!(name: 'browser') }
+      let(:canvas) { Canvas.create!(name: 'canvas') }
 
-      it "deletes from the parent class collection" do
+      it 'deletes from the parent class collection' do
         expect(Canvas.count).to eq(2)
       end
 
-      it "returns correct counts for child classes" do
+      it 'returns correct counts for child classes' do
         expect(Firefox.count).to eq(0)
       end
 
-      it "returns correct counts for root subclasses" do
+      it 'returns correct counts for root subclasses' do
         expect(Browser.count).to eq(1)
       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 'does not destroy dependent documents' do
-            Bolt.count.should == 1
+            Bolt.count.should eq 1
             parent.delete
-            Bolt.count.should == 1
+            Bolt.count.should eq 1
           end
         end
 
@@ -361,9 +330,9 @@ describe Mongoid::Persistable::Deletable do
           end
 
           it 'does not destroy dependent documents' do
-            Threadlocker.count.should == 1
+            Threadlocker.count.should eq 1
             parent.delete
-            Threadlocker.count.should == 1
+            Threadlocker.count.should eq 1
           end
         end
 
@@ -373,126 +342,119 @@ describe Mongoid::Persistable::Deletable do
           end
 
           it 'does not destroy dependent documents' do
-            Sealer.count.should == 1
+            Sealer.count.should eq 1
             parent.delete
-            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 'does not destroy dependent documents' do
-            Nut.count.should == 1
+            Nut.count.should eq 1
             parent.delete
-            Nut.count.should == 1
+            Nut.count.should eq 1
           end
         end
 
         context 'dependent: :delete_all' do
           let!(:parent) do
-            Hole.create!(washers: [Washer.create!])
+            Hole.create!(washers: [ Washer.create! ])
           end
 
           it 'does not destroy dependent documents' do
-            Washer.count.should == 1
+            Washer.count.should eq 1
             parent.delete
-            Washer.count.should == 1
+            Washer.count.should eq 1
           end
         end
 
         context 'dependent: :restrict_with_exception' do
           let!(:parent) do
-            Hole.create!(spacers: [Spacer.create!])
+            Hole.create!(spacers: [ Spacer.create! ])
           end
 
           it 'does not destroy dependent documents' do
-            Spacer.count.should == 1
+            Spacer.count.should eq 1
             parent.delete
-            Spacer.count.should == 1
+            Spacer.count.should eq 1
           end
         end
       end
     end
   end
 
-  describe "#delete_all" do
-
+  describe '#delete_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.delete_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.delete_all(title: "sir")
+          Person.delete_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
 
-      context "when the conditions need to be mongoized" do
-
+      context 'when the conditions need to be mongoized' do
         let!(:removed) do
           Person.delete_all(id: person.id)
         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
 
       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") }
+          Person.with(write: { w: 0 }) { |klass| klass.delete_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(deleted).to eq(0)
         end
       end
@@ -500,16 +462,15 @@ describe Mongoid::Persistable::Deletable do
 
     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 'does not destroy dependent documents' do
-            Bolt.count.should == 1
+            Bolt.count.should eq 1
             Hole.delete_all
-            Bolt.count.should == 1
+            Bolt.count.should eq 1
           end
         end
 
@@ -519,9 +480,9 @@ describe Mongoid::Persistable::Deletable do
           end
 
           it 'does not destroy dependent documents' do
-            Threadlocker.count.should == 1
+            Threadlocker.count.should eq 1
             Hole.delete_all
-            Threadlocker.count.should == 1
+            Threadlocker.count.should eq 1
           end
         end
 
@@ -531,48 +492,47 @@ describe Mongoid::Persistable::Deletable do
           end
 
           it 'does not destroy dependent documents' do
-            Sealer.count.should == 1
+            Sealer.count.should eq 1
             Hole.delete_all
-            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 'does not destroy dependent documents' do
-            Nut.count.should == 1
+            Nut.count.should eq 1
             Hole.delete_all
-            Nut.count.should == 1
+            Nut.count.should eq 1
           end
         end
 
         context 'dependent: :delete_all' do
           let!(:parent) do
-            Hole.create!(washers: [Washer.create!])
+            Hole.create!(washers: [ Washer.create! ])
           end
 
           it 'does not destroy dependent documents' do
-            Washer.count.should == 1
+            Washer.count.should eq 1
             Hole.delete_all
-            Washer.count.should == 1
+            Washer.count.should eq 1
           end
         end
 
         context 'dependent: :restrict_with_exception' do
           let!(:parent) do
-            Hole.create!(spacers: [Spacer.create!])
+            Hole.create!(spacers: [ Spacer.create! ])
           end
 
           it 'does not destroy dependent documents' do
-            Spacer.count.should == 1
+            Spacer.count.should eq 1
             Hole.delete_all
-            Spacer.count.should == 1
+            Spacer.count.should eq 1
           end
         end
       end