mongoid 9.0.11 → 9.1.0

data/spec/mongoid/association/depending_spec.rb

@@ -1,18 +1,18 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Association::Depending do
+  around do |example|
+    relations_before = Person.relations
+    example.run
+    Person.relations = relations_before
+  end
 
   describe '.included' do
-
     context 'when a destroy dependent is defined' do
-
       context 'when the model is a subclass' do
-
         context 'when transitive dependents are defined' do
-
           let(:define_classes) do
             class DependentReportCard
               include Mongoid::Document
@@ -40,7 +40,7 @@ describe Mongoid::Association::Depending do
             class DependentCollegeUser < DependentUser; end
           end
 
-          it "does not add the dependent to superclass" do
+          it 'does not add the dependent to superclass' do
             define_classes
 
             expect(DependentUser.dependents).to be_empty
@@ -74,7 +74,10 @@ describe Mongoid::Association::Depending do
             r = DependentReportCard.create!(dependent_student: s)
             s.destroy!
 
-            expect { DependentReportCard.find(r.id) }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class DependentReportCard with id\(s\)/)
+            expect do
+              DependentReportCard.find(r.id)
+            end.to raise_error(Mongoid::Errors::DocumentNotFound,
+                               /Document\(s\) not found for class DependentReportCard with id\(s\)/)
           end
 
           it 'facilitates proper transitive destroying of the object' do
@@ -85,7 +88,10 @@ describe Mongoid::Association::Depending do
             r = DependentReportCard.create!(dependent_student: s)
             s.destroy!
 
-            expect { DependentReportCard.find(r.id) }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class DependentReportCard with id\(s\)/)
+            expect do
+              DependentReportCard.find(r.id)
+            end.to raise_error(Mongoid::Errors::DocumentNotFound,
+                               /Document\(s\) not found for class DependentReportCard with id\(s\)/)
           end
 
           it 'adds the dependent to subclasses' do
@@ -106,7 +112,10 @@ describe Mongoid::Association::Depending do
             r = DependentReportCard.create!(dependent_student: s)
             s.destroy!
 
-            expect { DependentReportCard.find(r.id) }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class DependentReportCard with id\(s\)/)
+            expect do
+              DependentReportCard.find(r.id)
+            end.to raise_error(Mongoid::Errors::DocumentNotFound,
+                               /Document\(s\) not found for class DependentReportCard with id\(s\)/)
           end
 
           it "doesn't add the dependent to sibling classes" do
@@ -142,6 +151,7 @@ describe Mongoid::Association::Depending do
 
             class DependentSuperclass
               include Mongoid::Document
+
               has_one :dependent_owned_one
               has_one :dependent_owned_two
             end
@@ -176,9 +186,10 @@ describe Mongoid::Association::Depending do
             owned = DependentOwnedOne.create!(dependent_superclass: subclass)
             subclass.destroy!
 
-            expect {
+            expect do
               DependentOwnedOne.find(owned.id)
-            }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class DependentOwnedOne with id\(s\)/)
+            end.to raise_error(Mongoid::Errors::DocumentNotFound,
+                               /Document\(s\) not found for class DependentOwnedOne with id\(s\)/)
           end
         end
 
@@ -251,65 +262,56 @@ describe Mongoid::Association::Depending do
             dep = Dep.create!(double_assoc: two)
             two.destroy!
 
-            expect { Dep.find(dep.id) }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Dep with id\(s\)/)
+            expect do
+              Dep.find(dep.id)
+            end.to raise_error(Mongoid::Errors::DocumentNotFound,
+                               /Document\(s\) not found for class Dep with id\(s\)/)
           end
         end
       end
     end
   end
 
-  around(:each) do |example|
-    relations_before = Person.relations
-    example.run
-    Person.relations = relations_before
-  end
-
-  describe "#apply_destroy_dependencies!" do
-
+  describe '#apply_destroy_dependencies!' do
     let(:band) do
       Band.new
     end
 
-    context "when the association exists in the list of dependencies" do
-
-      context "when the association has no dependent strategy" do
-
+    context 'when the association exists in the list of dependencies' do
+      context 'when the association has no dependent strategy' do
         before do
-          band.dependents.push(Band.relations["records"])
+          band.dependents.push(Band.relations['records'])
         end
 
         after do
-          band.dependents.delete(Band.relations["records"])
+          band.dependents.delete(Band.relations['records'])
         end
 
-        it "ignores the dependency" do
-          expect(band.apply_destroy_dependencies!).to eq([Band.relations["records"]])
+        it 'ignores the dependency' do
+          expect(band.apply_destroy_dependencies!).to eq([ Band.relations['records'] ])
         end
       end
     end
   end
 
-  describe ".define_dependency!" do
-
+  describe '.define_dependency!' do
     let(:klass) do
       Class.new.tap { |c| c.send(:include, Mongoid::Document) }
     end
 
-    context "when the association metadata doesnt exist" do
-
+    context 'when the association metadata doesnt exist' do
       before do
-        klass.dependents.push("nothing")
+        klass.dependents.push('nothing')
       end
 
-      it "does not raise an error" do
-        expect {
+      it 'does not raise an error' do
+        expect do
           klass.new.apply_destroy_dependencies!
-        }.not_to raise_error
+        end.not_to raise_error
       end
     end
 
-    context "when a dependent option is provided" do
-
+    context 'when a dependent option is provided' do
       let!(:association) do
         klass.has_many :posts, dependent: :destroy
       end
@@ -318,13 +320,12 @@ describe Mongoid::Association::Depending do
         klass.relations.delete(association.name.to_s)
       end
 
-      it "adds the relation to the dependents" do
-        expect(klass.dependents).to include(klass.relations["posts"])
+      it 'adds the relation to the dependents' do
+        expect(klass.dependents).to include(klass.relations['posts'])
       end
     end
 
-    context "when no dependent option is provided" do
-
+    context 'when no dependent option is provided' do
       let!(:association) do
         klass.has_many :posts
       end
@@ -333,13 +334,12 @@ describe Mongoid::Association::Depending do
         klass.relations.delete(association.name.to_s)
       end
 
-      it "does not add a relation to the dependents" do
-        expect(klass.dependents).to_not include(association)
+      it 'does not add a relation to the dependents' do
+        expect(klass.dependents).not_to include(association)
       end
     end
 
     context 'when the class is defined more than once' do
-
       let!(:association) do
         klass.has_many :posts, dependent: :destroy
         klass.has_many :posts, dependent: :destroy
@@ -352,86 +352,82 @@ describe Mongoid::Association::Depending do
   end
 
   describe '#delete and #destroy' do
-    context "when cascading removals" do
-
+    context 'when cascading removals' do
       shared_examples 'destroys dependents if parent is destroyed but does not if parent is deleted' do
-        context '#destroy' do
+        describe '#destroy' do
           before do
             parent.destroy
           end
 
-          it "deletes the associated documents" do
-            expect {
+          it 'deletes the associated documents' do
+            expect do
               child.class.find(child.id)
-            }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class #{child.class.to_s} with id\(s\)/)
+            end.to raise_error(Mongoid::Errors::DocumentNotFound,
+                               /Document\(s\) not found for class #{child.class} with id\(s\)/)
           end
         end
 
-        context '#delete' do
+        describe '#delete' do
           before do
             parent.delete
           end
 
-          it "does not delete the associated documents" do
-            child.class.find(child.id).should == child
+          it 'does not delete the associated documents' do
+            child.class.find(child.id).should eq child
           end
         end
       end
 
-      context "when strategy is delete" do
-
+      context 'when strategy is delete' do
         let(:parent) do
           Person.create!
         end
 
         let!(:child) do
-          parent.posts.create!(title: "Testing")
+          parent.posts.create!(title: 'Testing')
         end
 
         include_examples 'destroys dependents if parent is destroyed but does not if parent is deleted'
       end
 
-      context "when strategy is destroy" do
-
+      context 'when strategy is destroy' do
         let(:parent) do
           Person.create!
         end
 
         let!(:child) do
-          parent.create_game(name: "Pong")
+          parent.create_game(name: 'Pong')
         end
 
         include_examples 'destroys dependents if parent is destroyed but does not if parent is deleted'
       end
 
-      context "when strategy is nullify" do
-
+      context 'when strategy is nullify' do
         shared_examples 'removes references if parent is destroyed but does not if parent is deleted' do
-          context '#destroy' do
+          describe '#destroy' do
             before do
               parent.destroy
             end
 
-            it "removes the references to the removed document" do
+            it 'removes the references to the removed document' do
               expect(from_db.ratable_id).to be_nil
             end
           end
 
-          context '#delete' do
+          describe '#delete' do
             before do
               parent.delete
             end
 
-            it "does not remove the references to the removed document" do
-              from_db.ratable_id.should == parent.id
+            it 'does not remove the references to the removed document' do
+              from_db.ratable_id.should eq parent.id
             end
           end
         end
 
-        context "when nullifying a references many" do
-
+        context 'when nullifying a references many' do
           let(:parent) do
-            Movie.create!(title: "Bladerunner")
+            Movie.create!(title: 'Bladerunner')
           end
 
           let!(:rating) do
@@ -445,12 +441,10 @@ describe Mongoid::Association::Depending do
           include_examples 'removes references if parent is destroyed but does not if parent is deleted'
         end
 
-        context "when nullifying a references one" do
-
-          context "when the relation exists" do
-
+        context 'when nullifying a references one' do
+          context 'when the relation exists' do
             let(:parent) do
-              Book.create!(title: "Neuromancer")
+              Book.create!(title: 'Neuromancer')
             end
 
             let!(:rating) do
@@ -464,16 +458,14 @@ describe Mongoid::Association::Depending do
             include_examples 'removes references if parent is destroyed but does not if parent is deleted'
           end
 
-          context "when no association target exists" do
-
+          context 'when no association target exists' do
             let(:parent) do
-              Book.create!(title: "Neuromancer")
+              Book.create!(title: 'Neuromancer')
             end
 
-            [:delete, :destroy].each do |method|
-
+            %i[delete destroy].each do |method|
               describe "##{method}" do
-                it "succeeds" do
+                it 'succeeds' do
                   expect(parent.send(method)).to be true
                 end
               end
@@ -481,44 +473,43 @@ describe Mongoid::Association::Depending do
           end
         end
 
-        context "when nullifying a many to many" do
-
+        context 'when nullifying a many to many' do
           let(:person) do
             Person.create!
           end
 
           let!(:preference) do
-            person.preferences.create!(name: "Setting")
+            person.preferences.create!(name: 'Setting')
           end
 
           let(:from_db) do
             Preference.find(preference.id)
           end
 
-          context '#destroy' do
+          describe '#destroy' do
             before do
               person.destroy
             end
 
-            it "removes the references from the removed document" do
-              expect(person.preference_ids).to_not include(preference.id)
+            it 'removes the references from the removed document' do
+              expect(person.preference_ids).not_to include(preference.id)
             end
 
-            it "removes the references to the removed document" do
-              expect(from_db.person_ids).to_not include(person.id)
+            it 'removes the references to the removed document' do
+              expect(from_db.person_ids).not_to include(person.id)
             end
           end
 
-          context '#delete' do
+          describe '#delete' do
             before do
               person.delete
             end
 
-            it "keeps the references from the removed document" do
+            it 'keeps the references from the removed document' do
               expect(person.preference_ids).to include(preference.id)
             end
 
-            it "keeps the references to the removed document" do
+            it 'keeps the references to the removed document' do
               expect(from_db.person_ids).to include(person.id)
             end
           end
@@ -526,14 +517,13 @@ describe Mongoid::Association::Depending do
       end
 
       shared_examples 'deletes the parent with #delete and #destroy' do
-        [:delete, :destroy].each do |method|
-
+        %i[delete destroy].each do |method|
           describe "##{method}" do
-            it "raises no error" do
-              expect { person.send(method) }.to_not raise_error
+            it 'raises no error' do
+              expect { person.send(method) }.not_to raise_error
             end
 
-            it "deletes the parent" do
+            it 'deletes the parent' do
               person.send(method)
               expect(person).to be_destroyed
             end
@@ -542,24 +532,22 @@ describe Mongoid::Association::Depending do
       end
 
       shared_examples 'raises an error with #destroy and deletes the parent with #delete' do
-        context '#destroy' do
-          it "raises DeleteRestriction error" do
+        describe '#destroy' do
+          it 'raises DeleteRestriction error' do
             expect { person.destroy }.to raise_error(Mongoid::Errors::DeleteRestriction)
           end
         end
 
-        context '#delete' do
-          it "deletes the parent" do
+        describe '#delete' do
+          it 'deletes the parent' do
             person.delete
             expect(person).to be_destroyed
           end
         end
       end
 
-      context "when dependent is restrict_with_exception" do
-
-        context "when restricting a references many" do
-
+      context 'when dependent is restrict_with_exception' do
+        context 'when restricting a references many' do
           let!(:association) do
             Person.has_many :drugs, dependent: :restrict_with_exception
           end
@@ -569,8 +557,7 @@ describe Mongoid::Association::Depending do
             Person.has_many :drugs, validate: false
           end
 
-          context "when the relation is empty" do
-
+          context 'when the relation is empty' do
             let(:person) do
               Person.new drugs: []
             end
@@ -578,18 +565,16 @@ describe Mongoid::Association::Depending do
             include_examples 'deletes the parent with #delete and #destroy'
           end
 
-          context "when the relation is not empty" do
-
+          context 'when the relation is not empty' do
             let(:person) do
-              Person.new drugs: [Drug.new]
+              Person.new drugs: [ Drug.new ]
             end
 
             include_examples 'raises an error with #destroy and deletes the parent with #delete'
           end
         end
 
-        context "when restricting a references one" do
-
+        context 'when restricting a references one' do
           let!(:association) do
             Person.has_one :account, dependent: :restrict_with_exception
           end
@@ -599,8 +584,7 @@ describe Mongoid::Association::Depending do
             Person.has_one :account, validate: false
           end
 
-          context "when the relation is empty" do
-
+          context 'when the relation is empty' do
             let(:person) do
               Person.new account: nil
             end
@@ -608,8 +592,7 @@ describe Mongoid::Association::Depending do
             include_examples 'deletes the parent with #delete and #destroy'
           end
 
-          context "when the relation is not empty" do
-
+          context 'when the relation is not empty' do
             let(:person) do
               Person.new account: Account.new(name: 'test')
             end
@@ -618,8 +601,7 @@ describe Mongoid::Association::Depending do
           end
         end
 
-        context "when restricting a many to many" do
-
+        context 'when restricting a many to many' do
           let!(:association) do
             Person.has_and_belongs_to_many :houses, dependent: :restrict_with_exception
           end
@@ -629,8 +611,7 @@ describe Mongoid::Association::Depending do
             Person.has_and_belongs_to_many :houses, validate: false
           end
 
-          context "when the relation is empty" do
-
+          context 'when the relation is empty' do
             let(:person) do
               Person.new houses: []
             end
@@ -638,10 +619,9 @@ describe Mongoid::Association::Depending do
             include_examples 'deletes the parent with #delete and #destroy'
           end
 
-          context "when the relation is not empty" do
-
+          context 'when the relation is not empty' do
             let(:person) do
-              Person.new houses: [House.new]
+              Person.new houses: [ House.new ]
             end
 
             include_examples 'raises an error with #destroy and deletes the parent with #delete'
@@ -651,15 +631,12 @@ describe Mongoid::Association::Depending do
     end
 
     context 'when the strategy is :delete_all' do
-
       let(:person) do
         Person.create!
       end
 
-      context "when cascading a has one" do
-
-        context "when the relation exists" do
-
+      context 'when cascading a has one' do
+        context 'when the relation exists' do
           let!(:home) do
             person.create_home
           end
@@ -668,79 +645,77 @@ describe Mongoid::Association::Depending do
             person.destroy
           end
 
-          it "deletes the dependents" do
+          it 'deletes the dependents' do
             expect(home).to be_destroyed
           end
 
-          it "persists the deletion" do
-            expect {
+          it 'persists the deletion' do
+            expect do
               home.reload
-            }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Home with id\(s\)/)
+            end.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Home with id\(s\)/)
           end
         end
 
-        context "when the association target does not exist" do
-
+        context 'when the association target does not exist' do
           before do
             person.destroy
           end
 
-          it "deletes the base document" do
+          it 'deletes the base document' do
             expect(person).to be_destroyed
           end
         end
       end
 
-      context "when cascading a has many" do
-
-        context "when the relation has documents" do
-
+      context 'when cascading a has many' do
+        context 'when the relation has documents' do
           let!(:post_one) do
-            person.posts.create!(title: "one")
+            person.posts.create!(title: 'one')
           end
 
           let!(:post_two) do
-            person.posts.create!(title: "two")
+            person.posts.create!(title: 'two')
           end
 
-          context "when the documents are in memory" do
-
+          context 'when the documents are in memory' do
             before do
-              expect(post_one).to receive(:delete).never
-              expect(post_two).to receive(:delete).never
+              expect(post_one).not_to receive(:delete)
+              expect(post_two).not_to receive(:delete)
               person.destroy
             end
 
-            it "deletes the first document" do
+            it 'deletes the first document' do
               expect(post_one).to be_destroyed
             end
 
-            it "deletes the second document" do
+            it 'deletes the second document' do
               expect(post_two).to be_destroyed
             end
 
-            it "unbinds the first document" do
+            it 'unbinds the first document' do
               expect(post_one.person).to be_nil
             end
 
-            it "unbinds the second document" do
+            it 'unbinds the second document' do
               expect(post_two.person).to be_nil
             end
 
-            it "removes the documents from the relation" do
+            it 'removes the documents from the relation' do
               expect(person.posts).to be_empty
             end
 
-            it "persists the first deletion" do
-              expect {
+            it 'persists the first deletion' do
+              expect do
                 post_one.reload
-              }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Post with id\(s\)/)
+              end.to raise_error(Mongoid::Errors::DocumentNotFound,
+                                 /Document\(s\) not found for class Post with id\(s\)/)
             end
 
-            it "persists the second deletion" do
-              expect {
+            it 'persists the second deletion' do
+              expect do
                 post_two.reload
-              }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Post with id\(s\)/)
+              end.to raise_error(Mongoid::Errors::DocumentNotFound,
+                                 /Document\(s\) not found for class Post with id\(s\)/)
             end
           end
         end
@@ -748,77 +723,68 @@ describe Mongoid::Association::Depending do
     end
 
     context 'when the strategy is :destroy' do
-
       let!(:association) do
-        Person.has_many :destroyable_posts, class_name: "Post", dependent: :destroy
+        Person.has_many :destroyable_posts, class_name: 'Post', dependent: :destroy
       end
-
-      after do
-        Person.dependents.delete(association)
-      end
-
       let(:person) do
         Person.new
       end
-
       let(:post) do
         Post.new
       end
 
-      context "when the documents exist" do
+      after do
+        Person.dependents.delete(association)
+      end
 
+      context 'when the documents exist' do
         before do
           expect(post).to receive(:destroy)
           person.destroyable_posts << post
         end
 
-        it "destroys all documents in the association" do
+        it 'destroys all documents in the association' do
           person.destroy
         end
       end
 
-      context "when no documents exist" do
-
+      context 'when no documents exist' do
         before do
-          expect(post).to receive(:destroy).never
+          expect(post).not_to receive(:destroy)
         end
 
-        it "it does not destroy the association target" do
+        it 'does not destroy the association target' do
           person.destroy
         end
       end
     end
 
     context 'when the strategy is :nullify' do
-
       let!(:association) do
-        Person.has_many :nullifyable_posts, class_name: "Post", dependent: :nullify
-      end
-
-      after do
-        Person.dependents.delete(association)
+        Person.has_many :nullifyable_posts, class_name: 'Post', dependent: :nullify
       end
-
       let(:person) do
         Person.new
       end
-
       let(:posts_relation) do
         person.posts
       end
 
+      after do
+        Person.dependents.delete(association)
+      end
+
       before do
         allow(person).to receive(:nullifyable_posts).and_return(posts_relation)
         expect(posts_relation).to receive(:nullify)
       end
 
-      it "nullifies the association target" do
+      it 'nullifies the association target' do
         person.destroy
       end
     end
 
     context 'when the strategy is :restrict_with_exception' do
-
       let(:person) do
         Person.new
       end
@@ -828,7 +794,7 @@ describe Mongoid::Association::Depending do
       end
 
       let!(:association) do
-        Person.has_many :restrictable_posts, class_name: "Post", dependent: :restrict_with_exception
+        Person.has_many :restrictable_posts, class_name: 'Post', dependent: :restrict_with_exception
       end
 
       after do
@@ -836,11 +802,10 @@ describe Mongoid::Association::Depending do
       end
 
       context 'when there are related objects' do
-
         before do
           person.restrictable_posts << post
-          expect(post).to receive(:delete).never
-          expect(post).to receive(:destroy).never
+          expect(post).not_to receive(:delete)
+          expect(post).not_to receive(:destroy)
         end
 
         it 'raises an exception and leaves the related one intact' do
@@ -849,10 +814,9 @@ describe Mongoid::Association::Depending do
       end
 
       context 'when there are no related objects' do
-
         before do
-          expect(post).to receive(:delete).never
-          expect(post).to receive(:destroy).never
+          expect(post).not_to receive(:delete)
+          expect(post).not_to receive(:destroy)
         end
 
         it 'deletes the object and leaves the other one intact' do
@@ -862,9 +826,7 @@ describe Mongoid::Association::Depending do
     end
 
     context 'when the strategy is :restrict_with_error' do
-
-      context "when restricting a one-to-many" do
-
+      context 'when restricting a one-to-many' do
         let(:person) do
           Person.new
         end
@@ -874,7 +836,7 @@ describe Mongoid::Association::Depending do
         end
 
         let!(:association) do
-          Person.has_many :restrictable_posts, class_name: "Post", dependent: :restrict_with_error
+          Person.has_many :restrictable_posts, class_name: 'Post', dependent: :restrict_with_error
         end
 
         after do
@@ -882,7 +844,6 @@ describe Mongoid::Association::Depending do
         end
 
         context 'when there are related objects' do
-
           before do
             person.restrictable_posts << post
           end
@@ -890,16 +851,15 @@ describe Mongoid::Association::Depending do
           it 'adds an error to the parent object' do
             expect(person.destroy).to be(false)
 
-            person.errors[:restrictable_posts].first.should ==
-              "is not empty and prevents the document from being destroyed"
+            person.errors[:restrictable_posts].first.should eq \
+              'is not empty and prevents the document from being destroyed'
           end
         end
 
         context 'when there are no related objects' do
-
           before do
-            expect(post).to receive(:delete).never
-            expect(post).to receive(:destroy).never
+            expect(post).not_to receive(:delete)
+            expect(post).not_to receive(:destroy)
           end
 
           it 'deletes the object and leaves the other one intact' do
@@ -917,39 +877,37 @@ describe Mongoid::Association::Depending do
           it 'doesn\'t raise an exception' do
             person.with_session do |session|
               session.with_transaction do
-                expect { person.destroy }.to_not raise_error
+                expect { person.destroy }.not_to raise_error
               end
             end
           end
         end
       end
 
-      context "when restricting a many to many" do
-
+      context 'when restricting a many to many' do
         let!(:association) do
           Person.has_and_belongs_to_many :houses, dependent: :restrict_with_error
         end
+        let(:person) do
+          Person.new houses: [ House.new ]
+        end
 
         after do
           Person.dependents.delete(association)
           Person.has_and_belongs_to_many :houses, validate: false
         end
 
-        let(:person) do
-          Person.new houses: [House.new]
-        end
-
-        it "returns false" do
+        it 'returns false' do
           expect(person.destroy).to be false
         end
 
-        context "when inside a transaction" do
+        context 'when inside a transaction' do
           require_transaction_support
 
           it 'doesn\'t raise an exception inside a transaction' do
             person.with_session do |session|
               session.with_transaction do
-                expect { person.destroy }.to_not raise_error
+                expect { person.destroy }.not_to raise_error
               end
             end
           end