mongoid 9.0.11 → 9.1.0

data/spec/mongoid/criteria/modifiable_spec.rb

@@ -1,60 +1,54 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Criteria::Modifiable do
-
-  describe "#create" do
-
+  describe '#create' do
     let(:criteria) do
-      Band.where(name: "Depeche Mode")
+      Band.where(name: 'Depeche Mode')
     end
 
-    context "when provided valid attributes" do
+    context 'when provided valid attributes' do
       let(:band) do
-        criteria.create!(genres: [ "electro" ])
+        criteria.create!(genres: [ 'electro' ])
       end
 
-      it "returns the created document" do
+      it 'returns the created document' do
         expect(band).to be_persisted
       end
 
-      it "sets the criteria attributes" do
-        expect(band.name).to eq("Depeche Mode")
+      it 'sets the criteria attributes' do
+        expect(band.name).to eq('Depeche Mode')
       end
 
-      it "sets the attributes passed to build" do
-        expect(band.genres).to eq([ "electro" ])
+      it 'sets the attributes passed to build' do
+        expect(band.genres).to eq([ 'electro' ])
       end
     end
 
-    context "when provided a block" do
-
-      context "when provided valid attributes & using block" do
-
+    context 'when provided a block' do
+      context 'when provided valid attributes & using block' do
         let(:band) do
           criteria.create! do |c|
-            c.genres = [ "electro" ]
+            c.genres = [ 'electro' ]
           end
         end
 
-        it "returns the created document" do
+        it 'returns the created document' do
           expect(band).to be_persisted
         end
 
-        it "sets the criteria attributes" do
-          expect(band.name).to eq("Depeche Mode")
+        it 'sets the criteria attributes' do
+          expect(band.name).to eq('Depeche Mode')
         end
 
-        it "sets the attributes passed to build" do
-          expect(band.genres).to eq([ "electro" ])
+        it 'sets the attributes passed to build' do
+          expect(band.genres).to eq([ 'electro' ])
         end
       end
     end
 
     context 'when the object is polymorphic' do
-
       let(:movie) do
         Movie.new
       end
@@ -77,23 +71,20 @@ describe Mongoid::Criteria::Modifiable do
     end
   end
 
-  describe "#create!" do
-
+  describe '#create!' do
     let(:criteria) do
-      Account.where(number: "11123213")
+      Account.where(number: '11123213')
     end
 
-    context "when provided invalid attributes" do
-
-      it "raises an error" do
-        expect {
+    context 'when provided invalid attributes' do
+      it 'raises an error' do
+        expect do
           criteria.create!
-        }.to raise_error(Mongoid::Errors::Validations)
+        end.to raise_error(Mongoid::Errors::Validations)
       end
     end
 
     context 'when the object is polymorphic' do
-
       let(:movie) do
         Movie.new
       end
@@ -116,81 +107,75 @@ describe Mongoid::Criteria::Modifiable do
     end
   end
 
-  [ :delete, :delete_all, :destroy, :destroy_all ].each do |method|
-
+  %i[delete delete_all destroy destroy_all].each do |method|
     describe "##{method}" do
-
       let(:name) do
-        Name.new(first_name: "Durran")
+        Name.new(first_name: 'Durran')
       end
 
       let(:address_one) do
-        Address.new(street: "Forsterstr")
+        Address.new(street: 'Forsterstr')
       end
 
       let(:address_two) do
-        Address.new(street: "Hobrechtstr")
+        Address.new(street: 'Hobrechtstr')
       end
 
       before do
-        Person.create!(title: "Madam")
-        2.times do |n|
+        Person.create!(title: 'Madam')
+        2.times do |_n|
           Person.create!(
-            title: "Sir",
+            title: 'Sir',
             name: name,
             addresses: [ address_one, address_two ]
           )
         end
       end
 
-      context "when removing root documents" do
-
+      context 'when removing root documents' do
         let(:criteria) do
-          Person.where(title: "Sir", :age.gt => 5)
+          Person.where(title: 'Sir', :age.gt => 5)
         end
 
         let!(:removed) do
           criteria.send(method)
         end
 
-        it "deletes the removes the documents from the database" do
+        it 'deletes the removes the documents from the database' do
           expect(Person.count).to eq(1)
         end
 
-        it "returns the number removed" do
+        it 'returns the number removed' do
           expect(removed).to eq(2)
         end
       end
 
-      context "when removing embedded documents" do
-
-        context "when removing a single document" do
-
+      context 'when removing embedded documents' do
+        context 'when removing a single document' do
           let(:person) do
-            Person.where(title: "Sir").first
+            Person.where(title: 'Sir').first
           end
 
           let(:criteria) do
-            person.addresses.where(street: "Forsterstr")
+            person.addresses.where(street: 'Forsterstr')
           end
 
           let!(:removed) do
             criteria.send(method)
           end
 
-          it "deletes the removes the documents from the database" do
+          it 'deletes the removes the documents from the database' do
             expect(person.addresses.count).to eq(1)
           end
 
-          it "returns the number removed" do
+          it 'returns the number removed' do
             expect(removed).to eq(1)
           end
         end
 
-        context "when removing multiple documents" do
-
+        context 'when removing multiple documents' do
           let(:person) do
-            Person.where(title: "Sir").first
+            Person.where(title: 'Sir').first
           end
 
           let(:criteria) do
@@ -201,11 +186,11 @@ describe Mongoid::Criteria::Modifiable do
             criteria.send(method)
           end
 
-          it "deletes the removes the documents from the database" do
+          it 'deletes the removes the documents from the database' do
             expect(person.addresses.count).to eq(0)
           end
 
-          it "returns the number removed" do
+          it 'returns the number removed' do
             expect(removed).to eq(2)
           end
         end
@@ -213,25 +198,20 @@ describe Mongoid::Criteria::Modifiable do
     end
   end
 
-  describe ".find_or_create_by" do
-
-    context "when the document is found" do
-
-      context "when providing an attribute" do
-
+  describe '.find_or_create_by' do
+    context 'when the document is found' do
+      context 'when providing an attribute' do
         let!(:person) do
-          Person.create!(title: "Senior")
+          Person.create!(title: 'Senior')
         end
 
-        it "returns the document" do
-          expect(Person.find_or_create_by(title: "Senior")).to eq(person)
+        it 'returns the document' do
+          expect(Person.find_or_create_by(title: 'Senior')).to eq(person)
         end
       end
 
-      context "when providing a document" do
-
-        context "with an owner with a BSON identity type" do
-
+      context 'when providing a document' do
+        context 'with an owner with a BSON identity type' do
           let!(:person) do
             Person.create!
           end
@@ -240,31 +220,28 @@ describe Mongoid::Criteria::Modifiable do
             Game.create!(person: person)
           end
 
-          context "when providing the object directly" do
-
+          context 'when providing the object directly' do
             let(:from_db) do
               Game.find_or_create_by(person: person)
             end
 
-            it "returns the document" do
+            it 'returns the document' do
               expect(from_db).to eq(game)
             end
           end
 
-          context "when providing the proxy relation" do
-
+          context 'when providing the proxy relation' do
             let(:from_db) do
               Game.find_or_create_by(person: game.person)
             end
 
-            it "returns the document" do
+            it 'returns the document' do
               expect(from_db).to eq(game)
             end
           end
         end
 
-        context "with an owner with an Integer identity type" do
-
+        context 'with an owner with an Integer identity type' do
           let!(:jar) do
             Jar.create!
           end
@@ -277,17 +254,15 @@ describe Mongoid::Criteria::Modifiable do
             Cookie.find_or_create_by(jar: jar)
           end
 
-          it "returns the document" do
+          it 'returns the document' do
             expect(from_db).to eq(cookie)
           end
         end
       end
     end
 
-    context "when the document is not found" do
-
-      context "when providing a document" do
-
+    context 'when the document is not found' do
+      context 'when providing a document' do
         let!(:person) do
           Person.create!
         end
@@ -300,53 +275,50 @@ describe Mongoid::Criteria::Modifiable do
           Game.find_or_create_by(person: person)
         end
 
-        it "returns the new document" do
+        it 'returns the new document' do
           expect(from_db.person).to eq(person)
         end
 
-        it "does not return an existing false document" do
-          expect(from_db).to_not eq(game)
+        it 'does not return an existing false document' do
+          expect(from_db).not_to eq(game)
         end
       end
 
-      context "when not providing a block" do
-
+      context 'when not providing a block' do
         let!(:person) do
-          Person.find_or_create_by(title: "Senorita")
+          Person.find_or_create_by(title: 'Senorita')
         end
 
-        it "creates a persisted document" do
+        it 'creates a persisted document' do
           expect(person).to be_persisted
         end
 
-        it "sets the attributes" do
-          expect(person.title).to eq("Senorita")
+        it 'sets the attributes' do
+          expect(person.title).to eq('Senorita')
         end
       end
 
-      context "when providing a block" do
-
+      context 'when providing a block' do
         let!(:person) do
-          Person.find_or_create_by(title: "Senorita") do |person|
+          Person.find_or_create_by(title: 'Senorita') do |person|
             person.pets = true
           end
         end
 
-        it "creates a persisted document" do
+        it 'creates a persisted document' do
           expect(person).to be_persisted
         end
 
-        it "sets the attributes" do
-          expect(person.title).to eq("Senorita")
+        it 'sets the attributes' do
+          expect(person.title).to eq('Senorita')
         end
 
-        it "calls the block" do
+        it 'calls the block' do
           expect(person.pets).to be true
         end
       end
 
       context 'when the object is polymorphic' do
-
         let(:movie) do
           Movie.new
         end
@@ -366,25 +338,20 @@ describe Mongoid::Criteria::Modifiable do
     end
   end
 
-  describe ".find_or_create_by!" do
-
-    context "when the document is found" do
-
-      context "when providing an attribute" do
-
+  describe '.find_or_create_by!' do
+    context 'when the document is found' do
+      context 'when providing an attribute' do
         let!(:person) do
-          Person.create!(title: "Senior")
+          Person.create!(title: 'Senior')
         end
 
-        it "returns the document" do
-          expect(Person.find_or_create_by!(title: "Senior")).to eq(person)
+        it 'returns the document' do
+          expect(Person.find_or_create_by!(title: 'Senior')).to eq(person)
         end
       end
 
-      context "when providing a document" do
-
-        context "with an owner with a BSON identity type" do
-
+      context 'when providing a document' do
+        context 'with an owner with a BSON identity type' do
           let!(:person) do
             Person.create!
           end
@@ -393,31 +360,28 @@ describe Mongoid::Criteria::Modifiable do
             Game.create!(person: person)
           end
 
-          context "when providing the object directly" do
-
+          context 'when providing the object directly' do
             let(:from_db) do
               Game.find_or_create_by!(person: person)
             end
 
-            it "returns the document" do
+            it 'returns the document' do
               expect(from_db).to eq(game)
             end
           end
 
-          context "when providing the proxy relation" do
-
+          context 'when providing the proxy relation' do
             let(:from_db) do
               Game.find_or_create_by!(person: game.person)
             end
 
-            it "returns the document" do
+            it 'returns the document' do
               expect(from_db).to eq(game)
             end
           end
         end
 
-        context "with an owner with an Integer identity type" do
-
+        context 'with an owner with an Integer identity type' do
           let!(:jar) do
             Jar.create!
           end
@@ -430,17 +394,15 @@ describe Mongoid::Criteria::Modifiable do
             Cookie.find_or_create_by!(jar: jar)
           end
 
-          it "returns the document" do
+          it 'returns the document' do
             expect(from_db).to eq(cookie)
           end
         end
       end
     end
 
-    context "when the document is not found" do
-
-      context "when providing a document" do
-
+    context 'when the document is not found' do
+      context 'when providing a document' do
         let!(:person) do
           Person.create!
         end
@@ -453,32 +415,30 @@ describe Mongoid::Criteria::Modifiable do
           Game.find_or_create_by!(person: person)
         end
 
-        it "returns the new document" do
+        it 'returns the new document' do
           expect(from_db.person).to eq(person)
         end
 
-        it "does not return an existing false document" do
-          expect(from_db).to_not eq(game)
+        it 'does not return an existing false document' do
+          expect(from_db).not_to eq(game)
         end
       end
 
-      context "when not providing a block" do
-
+      context 'when not providing a block' do
         let!(:person) do
-          Person.find_or_create_by!(title: "Senorita")
+          Person.find_or_create_by!(title: 'Senorita')
         end
 
-        it "creates a persisted document" do
+        it 'creates a persisted document' do
           expect(person).to be_persisted
         end
 
-        it "sets the attributes" do
-          expect(person.title).to eq("Senorita")
+        it 'sets the attributes' do
+          expect(person.title).to eq('Senorita')
         end
       end
 
-      context "when validation fails" do
-
+      context 'when validation fails' do
         before do
           Person.validates_presence_of(:title)
         end
@@ -487,37 +447,35 @@ describe Mongoid::Criteria::Modifiable do
           Person.reset_callbacks(:validate)
         end
 
-        it "raises an exception" do
-          expect {
-            Person.find_or_create_by!(ssn: "test")
-          }.to raise_error(Mongoid::Errors::Validations)
+        it 'raises an exception' do
+          expect do
+            Person.find_or_create_by!(ssn: 'test')
+          end.to raise_error(Mongoid::Errors::Validations)
         end
       end
 
-      context "when providing a block" do
-
+      context 'when providing a block' do
         let!(:person) do
-          Person.find_or_create_by!(title: "Senorita") do |person|
+          Person.find_or_create_by!(title: 'Senorita') do |person|
             person.pets = true
           end
         end
 
-        it "creates a persisted document" do
+        it 'creates a persisted document' do
           expect(person).to be_persisted
         end
 
-        it "sets the attributes" do
-          expect(person.title).to eq("Senorita")
+        it 'sets the attributes' do
+          expect(person.title).to eq('Senorita')
         end
 
-        it "calls the block" do
+        it 'calls the block' do
           expect(person.pets).to be true
         end
       end
     end
 
     context 'when the object is polymorphic' do
-
       let(:movie) do
         Movie.new
       end
@@ -536,60 +494,54 @@ describe Mongoid::Criteria::Modifiable do
     end
   end
 
-  describe ".find_or_initialize_by" do
-
-    context "when the document is found" do
-
+  describe '.find_or_initialize_by' do
+    context 'when the document is found' do
       let!(:person) do
-        Person.create!(title: "Senior")
+        Person.create!(title: 'Senior')
       end
 
-      it "returns the document" do
-        expect(Person.find_or_initialize_by(title: "Senior")).to eq(person)
+      it 'returns the document' do
+        expect(Person.find_or_initialize_by(title: 'Senior')).to eq(person)
       end
     end
 
-    context "when the document is not found" do
-
-      context "when not providing a block" do
-
+    context 'when the document is not found' do
+      context 'when not providing a block' do
         let!(:person) do
-          Person.find_or_initialize_by(title: "Senorita")
+          Person.find_or_initialize_by(title: 'Senorita')
         end
 
-        it "creates a new document" do
+        it 'creates a new document' do
           expect(person).to be_new_record
         end
 
-        it "sets the attributes" do
-          expect(person.title).to eq("Senorita")
+        it 'sets the attributes' do
+          expect(person.title).to eq('Senorita')
         end
       end
 
-      context "when providing a block" do
-
+      context 'when providing a block' do
         let!(:person) do
-          Person.find_or_initialize_by(title: "Senorita") do |person|
+          Person.find_or_initialize_by(title: 'Senorita') do |person|
             person.pets = true
           end
         end
 
-        it "creates a new document" do
+        it 'creates a new document' do
           expect(person).to be_new_record
         end
 
-        it "sets the attributes" do
-          expect(person.title).to eq("Senorita")
+        it 'sets the attributes' do
+          expect(person.title).to eq('Senorita')
         end
 
-        it "calls the block" do
+        it 'calls the block' do
           expect(person.pets).to be true
         end
       end
     end
 
     context 'when the object is polymorphic' do
-
       let(:movie) do
         Movie.new
       end
@@ -608,49 +560,42 @@ describe Mongoid::Criteria::Modifiable do
     end
   end
 
-  describe "first_or_create" do
-
+  describe 'first_or_create' do
     let!(:band) do
-      Band.create!(name: "Depeche Mode")
+      Band.create!(name: 'Depeche Mode')
     end
 
-    context "when the document is found" do
-
+    context 'when the document is found' do
       let(:found) do
-        Band.where(name: "Depeche Mode").first_or_create
+        Band.where(name: 'Depeche Mode').first_or_create
       end
 
-      it "returns the document" do
+      it 'returns the document' do
         expect(found).to eq(band)
       end
     end
 
-    context "when the document is not found" do
-
-      context "when attributes are provided" do
-
+    context 'when the document is not found' do
+      context 'when attributes are provided' do
         let(:document) do
-          Band.where(name: "Tool").first_or_create(origin: "Essex")
+          Band.where(name: 'Tool').first_or_create(origin: 'Essex')
         end
 
-        it "returns a new document" do
-          expect(document.name).to eq("Tool")
+        it 'returns a new document' do
+          expect(document.name).to eq('Tool')
         end
 
-        it "returns a persisted document" do
+        it 'returns a persisted document' do
           expect(document).to be_persisted
         end
 
-        it "sets the additional attributes" do
-          expect(document.origin).to eq("Essex")
+        it 'sets the additional attributes' do
+          expect(document.origin).to eq('Essex')
         end
 
         context 'when attributes contain keys also in the criteria selector' do
-
           context 'when the selector has symbol keys' do
-
             context 'when the attributes use symbol keys' do
-
               let(:document) do
                 Band.where(name: 'Tool').first_or_create(name: 'Essex')
               end
@@ -661,7 +606,6 @@ describe Mongoid::Criteria::Modifiable do
             end
 
             context 'when the attributes use string keys' do
-
               let(:document) do
                 Band.where(name: 'Tool').first_or_create('name' => 'Essex')
               end
@@ -673,9 +617,7 @@ describe Mongoid::Criteria::Modifiable do
           end
 
           context 'when the selector has string keys' do
-
             context 'when the attributes use symbol keys' do
-
               let(:document) do
                 Band.where('name' => 'Tool').first_or_create(name: 'Essex')
               end
@@ -686,7 +628,6 @@ describe Mongoid::Criteria::Modifiable do
             end
 
             context 'when the attributes use string keys' do
-
               let(:document) do
                 Band.where('name' => 'Tool').first_or_create('name' => 'Essex')
               end
@@ -699,20 +640,18 @@ describe Mongoid::Criteria::Modifiable do
         end
 
         context 'when the query criteria is on a hash attribute' do
-
           let(:document) do
             Person.where(map: { foo: :bar }).first_or_create
           end
 
           it 'uses the values from the attributes' do
-            expect(document.map).to eq('foo' => :bar )
+            expect(document.map).to eq('foo' => :bar)
           end
         end
 
         context 'when the criteria has a selector with query operators' do
-
           let(:document) do
-            Band.in(genres: ['Hiphop', 'Soul']).first_or_create(name: 'Smooth')
+            Band.in(genres: %w[Hiphop Soul]).first_or_create(name: 'Smooth')
           end
 
           it 'does not create a document with the query operators' do
@@ -721,14 +660,13 @@ describe Mongoid::Criteria::Modifiable do
         end
 
         context 'when the criteria has a nested selector with query operators' do
-
           let(:band) do
-            record = Record.new(producers: ['testing'])
-            band = Band.create!(records: [record])
+            record = Record.new(producers: [ 'testing' ])
+            Band.create!(records: [ record ])
           end
 
           let(:document) do
-            band.records.in(producers: ['nonexistent']).first_or_create(name: 'new-embedded-doc')
+            band.records.in(producers: [ 'nonexistent' ]).first_or_create(name: 'new-embedded-doc')
             band.reload
           end
 
@@ -737,7 +675,7 @@ describe Mongoid::Criteria::Modifiable do
           end
 
           it 'does not alter the existing embedded document' do
-            expect(document.records[0].producers).to eq(['testing'])
+            expect(document.records[0].producers).to eq([ 'testing' ])
           end
 
           it 'does not create a document with the query operators as attributes' do
@@ -750,14 +688,13 @@ describe Mongoid::Criteria::Modifiable do
         end
 
         context 'when the criteria has a deeply-nested selector with query operators' do
-
           let(:criteria) do
             band = Band.create!
             Mongoid::Criteria.new(Record) do |criteria|
               criteria.embedded = true
               criteria.association = Band.reflect_on_association(:records)
               criteria.parent_document = band
-              criteria.selector = { "records" => { "producers"=>{"$in"=>["nonexistent"] } } }
+              criteria.selector = { 'records' => { 'producers' => { '$in' => [ 'nonexistent' ] } } }
             end
           end
 
@@ -775,42 +712,39 @@ describe Mongoid::Criteria::Modifiable do
         end
       end
 
-      context "when attributes are not provided" do
-
+      context 'when attributes are not provided' do
         let(:document) do
-          Band.where(name: "Tool").first_or_create
+          Band.where(name: 'Tool').first_or_create
         end
 
-        it "returns a new document" do
-          expect(document.name).to eq("Tool")
+        it 'returns a new document' do
+          expect(document.name).to eq('Tool')
         end
 
-        it "returns a persisted document" do
+        it 'returns a persisted document' do
           expect(document).to be_persisted
         end
       end
 
-      context "when the criteria is on an embedded relation" do
-
+      context 'when the criteria is on an embedded relation' do
         let!(:band) do
-          Band.create!(name: "Placebo")
+          Band.create!(name: 'Placebo')
         end
 
         let(:document) do
-          band.notes.permanent.first_or_create(text: "test")
+          band.notes.permanent.first_or_create(text: 'test')
         end
 
-        it "returns a new document" do
-          expect(document.text).to eq("test")
+        it 'returns a new document' do
+          expect(document.text).to eq('test')
         end
 
-        it "returns a persisted document" do
+        it 'returns a persisted document' do
           expect(document).to be_persisted
         end
       end
 
       context 'when the object is polymorphic' do
-
         let(:movie) do
           Movie.new
         end
@@ -832,40 +766,37 @@ describe Mongoid::Criteria::Modifiable do
         end
       end
 
-      context "when a block is provided" do
-
+      context 'when a block is provided' do
         let(:document) do
-          Band.where(name: "Tool").first_or_create do |doc|
+          Band.where(name: 'Tool').first_or_create do |doc|
             doc.active = false
           end
         end
 
-        it "returns a new document" do
-          expect(document.name).to eq("Tool")
+        it 'returns a new document' do
+          expect(document.name).to eq('Tool')
         end
 
-        it "returns a persisted document" do
+        it 'returns a persisted document' do
           expect(document).to be_persisted
         end
 
-        it "yields to the block" do
+        it 'yields to the block' do
           expect(document.active).to be false
         end
       end
 
-      context "when the criteria is complex" do
-
-        context "when the document is not found" do
-
+      context 'when the criteria is complex' do
+        context 'when the document is not found' do
           let(:document) do
-            Band.in(name: [ "New Order" ]).first_or_create(active: false)
+            Band.in(name: [ 'New Order' ]).first_or_create(active: false)
           end
 
-          it "returns a new document" do
+          it 'returns a new document' do
             expect(document.active).to be false
           end
 
-          it "returns a persisted document" do
+          it 'returns a persisted document' do
             expect(document).to be_persisted
           end
         end
@@ -873,134 +804,121 @@ describe Mongoid::Criteria::Modifiable do
     end
   end
 
-  describe "first_or_create!" do
-
-    context "when validation fails on the new document" do
-
-      it "raises an error" do
-        expect {
-          Account.where(number: "12345").first_or_create!
-        }.to raise_error(Mongoid::Errors::Validations)
+  describe 'first_or_create!' do
+    context 'when validation fails on the new document' do
+      it 'raises an error' do
+        expect do
+          Account.where(number: '12345').first_or_create!
+        end.to raise_error(Mongoid::Errors::Validations)
       end
     end
 
-    context "when passing a block" do
-
+    context 'when passing a block' do
       let(:account) do
-        Account.where(number: "12345").first_or_create! do |account|
-          account.name = "testing"
+        Account.where(number: '12345').first_or_create! do |account|
+          account.name = 'testing'
         end
       end
 
-      it "passes the block to the create call" do
-        expect(account.name).to eq("testing")
+      it 'passes the block to the create call' do
+        expect(account.name).to eq('testing')
       end
 
-      it "persists the new document" do
+      it 'persists the new document' do
         expect(account).to be_persisted
       end
     end
 
-    context "when the document is found" do
-
+    context 'when the document is found' do
       let!(:band) do
-        Band.create!(name: "Depeche Mode")
+        Band.create!(name: 'Depeche Mode')
       end
 
       let(:found) do
-        Band.where(name: "Depeche Mode").first_or_create!
+        Band.where(name: 'Depeche Mode').first_or_create!
       end
 
-      it "returns the document" do
+      it 'returns the document' do
         expect(found).to eq(band)
       end
     end
 
-    context "when the document is not found" do
-
+    context 'when the document is not found' do
       let!(:band) do
-        Band.create!(name: "Depeche Mode")
+        Band.create!(name: 'Depeche Mode')
       end
 
-      context "when attributes are provided" do
-
+      context 'when attributes are provided' do
         let(:document) do
-          Band.where(name: "Tool").first_or_create!(origin: "Essex")
+          Band.where(name: 'Tool').first_or_create!(origin: 'Essex')
         end
 
-        it "returns a new document" do
-          expect(document.name).to eq("Tool")
+        it 'returns a new document' do
+          expect(document.name).to eq('Tool')
         end
 
-        it "returns a persisted document" do
+        it 'returns a persisted document' do
           expect(document).to be_persisted
         end
 
-        it "sets the additional attributes" do
-          expect(document.origin).to eq("Essex")
+        it 'sets the additional attributes' do
+          expect(document.origin).to eq('Essex')
         end
       end
 
-      context "when attributes are not provided" do
-
+      context 'when attributes are not provided' do
         let(:document) do
-          Band.where(name: "Tool").first_or_create!
+          Band.where(name: 'Tool').first_or_create!
         end
 
-        it "returns a new document" do
-          expect(document.name).to eq("Tool")
+        it 'returns a new document' do
+          expect(document.name).to eq('Tool')
         end
 
-        it "returns a persisted document" do
+        it 'returns a persisted document' do
           expect(document).to be_persisted
         end
       end
 
-      context "when a block is provided" do
-
+      context 'when a block is provided' do
         let(:document) do
-          Band.where(name: "Tool").first_or_create! do |doc|
+          Band.where(name: 'Tool').first_or_create! do |doc|
             doc.active = false
           end
         end
 
-        it "returns a new document" do
-          expect(document.name).to eq("Tool")
+        it 'returns a new document' do
+          expect(document.name).to eq('Tool')
         end
 
-        it "returns a persisted document" do
+        it 'returns a persisted document' do
           expect(document).to be_persisted
         end
 
-        it "yields to the block" do
+        it 'yields to the block' do
           expect(document.active).to be false
         end
       end
 
-      context "when the criteria is complex" do
-
-        context "when the document is not found" do
-
+      context 'when the criteria is complex' do
+        context 'when the document is not found' do
           let(:document) do
-            Band.in(name: [ "New Order" ]).first_or_create!(active: false)
+            Band.in(name: [ 'New Order' ]).first_or_create!(active: false)
           end
 
-          it "returns a new document" do
+          it 'returns a new document' do
             expect(document.active).to be false
           end
 
-          it "returns a persisted document" do
+          it 'returns a persisted document' do
             expect(document).to be_persisted
           end
         end
       end
 
       context 'when attributes contain keys also in the criteria selector' do
-
         context 'when the selector has symbol keys' do
-
           context 'when the attributes use symbol keys' do
-
             let(:document) do
               Band.where(name: 'Tool').first_or_create!(name: 'Essex')
             end
@@ -1011,7 +929,6 @@ describe Mongoid::Criteria::Modifiable do
           end
 
           context 'when the attributes use string keys' do
-
             let(:document) do
               Band.where(name: 'Tool').first_or_create!('name' => 'Essex')
             end
@@ -1023,9 +940,7 @@ describe Mongoid::Criteria::Modifiable do
         end
 
         context 'when the selector has string keys' do
-
           context 'when the attributes use symbol keys' do
-
             let(:document) do
               Band.where('name' => 'Tool').first_or_create!(name: 'Essex')
             end
@@ -1036,7 +951,6 @@ describe Mongoid::Criteria::Modifiable do
           end
 
           context 'when the attributes use string keys' do
-
             let(:document) do
               Band.where('name' => 'Tool').first_or_create!('name' => 'Essex')
             end
@@ -1050,7 +964,6 @@ describe Mongoid::Criteria::Modifiable do
     end
 
     context 'when the object is polymorphic' do
-
       let(:movie) do
         Movie.new
       end
@@ -1073,25 +986,22 @@ describe Mongoid::Criteria::Modifiable do
     end
   end
 
-  describe "first_or_initialize" do
-
+  describe 'first_or_initialize' do
     let!(:band) do
-      Band.create!(name: "Depeche Mode")
+      Band.create!(name: 'Depeche Mode')
     end
 
-    context "when the document is found" do
-
+    context 'when the document is found' do
       let(:found) do
-        Band.where(name: "Depeche Mode").first_or_initialize
+        Band.where(name: 'Depeche Mode').first_or_initialize
       end
 
-      it "returns the document" do
+      it 'returns the document' do
         expect(found).to eq(band)
       end
     end
 
     context 'when the object is polymorphic' do
-
       let(:movie) do
         Movie.new
       end
@@ -1113,87 +1023,78 @@ describe Mongoid::Criteria::Modifiable do
       end
     end
 
-    context "when the document is not found" do
-
-      context "when attributes are provided" do
-
+    context 'when the document is not found' do
+      context 'when attributes are provided' do
         let(:document) do
-          Band.where(name: "Tool").first_or_initialize(origin: "Essex")
+          Band.where(name: 'Tool').first_or_initialize(origin: 'Essex')
         end
 
-        it "returns a new document" do
-          expect(document.name).to eq("Tool")
+        it 'returns a new document' do
+          expect(document.name).to eq('Tool')
         end
 
-        it "returns a non persisted document" do
-          expect(document).to_not be_persisted
+        it 'returns a non persisted document' do
+          expect(document).not_to be_persisted
         end
 
-        it "sets the additional attributes" do
-          expect(document.origin).to eq("Essex")
+        it 'sets the additional attributes' do
+          expect(document.origin).to eq('Essex')
         end
       end
 
-      context "when attributes are not provided" do
-
+      context 'when attributes are not provided' do
         let(:document) do
-          Band.where(name: "Tool").first_or_initialize
+          Band.where(name: 'Tool').first_or_initialize
         end
 
-        it "returns a new document" do
-          expect(document.name).to eq("Tool")
+        it 'returns a new document' do
+          expect(document.name).to eq('Tool')
         end
 
-        it "returns a non persisted document" do
-          expect(document).to_not be_persisted
+        it 'returns a non persisted document' do
+          expect(document).not_to be_persisted
         end
       end
 
-      context "when a block is provided" do
-
+      context 'when a block is provided' do
         let(:document) do
-          Band.where(name: "Tool").first_or_initialize do |doc|
+          Band.where(name: 'Tool').first_or_initialize do |doc|
             doc.active = false
           end
         end
 
-        it "returns a new document" do
-          expect(document.name).to eq("Tool")
+        it 'returns a new document' do
+          expect(document.name).to eq('Tool')
         end
 
-        it "returns a non persisted document" do
-          expect(document).to_not be_persisted
+        it 'returns a non persisted document' do
+          expect(document).not_to be_persisted
         end
 
-        it "yields to the block" do
+        it 'yields to the block' do
           expect(document.active).to be false
         end
       end
 
-      context "when the criteria is complex" do
-
-        context "when the document is not found" do
-
+      context 'when the criteria is complex' do
+        context 'when the document is not found' do
           let(:document) do
-            Band.in(name: [ "New Order" ]).first_or_initialize(active: false)
+            Band.in(name: [ 'New Order' ]).first_or_initialize(active: false)
           end
 
-          it "returns a new document" do
+          it 'returns a new document' do
             expect(document.active).to be false
           end
 
-          it "returns a non persisted document" do
-            expect(document).to_not be_persisted
+          it 'returns a non persisted document' do
+            expect(document).not_to be_persisted
           end
         end
       end
 
       context 'when attributes contain keys also in the criteria selector' do
-
         context 'when the selector has symbol keys' do
-
           context 'when the attributes use symbol keys' do
-
             let(:document) do
               Band.where(name: 'Tool').first_or_initialize(name: 'Essex')
             end
@@ -1204,7 +1105,6 @@ describe Mongoid::Criteria::Modifiable do
           end
 
           context 'when the attributes use string keys' do
-
             let(:document) do
               Band.where(name: 'Tool').first_or_initialize('name' => 'Essex')
             end
@@ -1216,9 +1116,7 @@ describe Mongoid::Criteria::Modifiable do
         end
 
         context 'when the selector has string keys' do
-
           context 'when the attributes use symbol keys' do
-
             let(:document) do
               Band.where('name' => 'Tool').first_or_initialize(name: 'Essex')
             end
@@ -1229,7 +1127,6 @@ describe Mongoid::Criteria::Modifiable do
           end
 
           context 'when the attributes use string keys' do
-
             let(:document) do
               Band.where('name' => 'Tool').first_or_initialize('name' => 'Essex')
             end
@@ -1243,50 +1140,45 @@ describe Mongoid::Criteria::Modifiable do
     end
   end
 
-  describe "#update" do
-
+  describe '#update' do
     let!(:person) do
-      Person.create!(title: "Sir")
+      Person.create!(title: 'Sir')
     end
 
     let!(:address_one) do
-      person.addresses.create!(street: "Oranienstr")
+      person.addresses.create!(street: 'Oranienstr')
     end
 
     let!(:address_two) do
-      person.addresses.create!(street: "Wienerstr")
+      person.addresses.create!(street: 'Wienerstr')
     end
 
-    context "when updating the root document" do
-
-      context "when updating with a criteria" do
-
+    context 'when updating the root document' do
+      context 'when updating with a criteria' do
         before do
-          Person.where(title: "Sir").update(title: "Madam")
+          Person.where(title: 'Sir').update(title: 'Madam')
         end
 
-        it "updates all the matching documents" do
-          expect(person.reload.title).to eq("Madam")
+        it 'updates all the matching documents' do
+          expect(person.reload.title).to eq('Madam')
         end
       end
 
-      context "when updating all directly" do
-
+      context 'when updating all directly' do
         before do
-          Person.update(title: "Madam")
+          Person.update(title: 'Madam')
         end
 
-        it "updates all the matching documents" do
-          expect(person.reload.title).to eq("Madam")
+        it 'updates all the matching documents' do
+          expect(person.reload.title).to eq('Madam')
         end
       end
     end
 
-    context "when updating an embedded document" do
-
+    context 'when updating an embedded document' do
       before do
-        Person.where(title: "Sir").update(
-          "addresses.0.city" => "Berlin"
+        Person.where(title: 'Sir').update(
+          'addresses.0.city' => 'Berlin'
         )
       end
 
@@ -1294,199 +1186,184 @@ describe Mongoid::Criteria::Modifiable do
         Person.first
       end
 
-      it "updates all the matching documents" do
-        expect(from_db.addresses.first.city).to eq("Berlin")
+      it 'updates all the matching documents' do
+        expect(from_db.addresses.first.city).to eq('Berlin')
       end
 
-      it "does not update non matching documents" do
+      it 'does not update non matching documents' do
         expect(from_db.addresses.last.city).to be_nil
       end
     end
 
-    context "when updating a relation" do
-
-      context "when the relation is an embeds many" do
-
+    context 'when updating a relation' do
+      context 'when the relation is an embeds many' do
         let(:from_db) do
           Person.first
         end
 
-        context "when updating the relation directly" do
-
+        context 'when updating the relation directly' do
           before do
-            person.addresses.update(city: "London")
+            person.addresses.update(city: 'London')
           end
 
-          it "updates the first document" do
-            expect(from_db.addresses.first.city).to eq("London")
+          it 'updates the first document' do
+            expect(from_db.addresses.first.city).to eq('London')
           end
 
-          it "does not update the last document" do
+          it 'does not update the last document' do
             expect(from_db.addresses.last.city).to be_nil
           end
         end
 
-        context "when updating the relation through a criteria" do
-
+        context 'when updating the relation through a criteria' do
           before do
-            person.addresses.where(street: "Oranienstr").update(city: "Berlin")
+            person.addresses.where(street: 'Oranienstr').update(city: 'Berlin')
           end
 
-          it "updates the matching documents" do
-            expect(from_db.addresses.first.city).to eq("Berlin")
+          it 'updates the matching documents' do
+            expect(from_db.addresses.first.city).to eq('Berlin')
           end
 
-          it "does not update non matching documents" do
+          it 'does not update non matching documents' do
             expect(from_db.addresses.last.city).to be_nil
           end
         end
       end
 
-      context "when the relation is a references many" do
-
+      context 'when the relation is a references many' do
         before do
-          person.posts.create!(title: "First")
-          person.posts.create!(title: "Second")
+          person.posts.create!(title: 'First')
+          person.posts.create!(title: 'Second')
         end
 
-        context "when updating the relation directly" do
-
+        context 'when updating the relation directly' do
           before do
-            person.posts.update(title: "London")
+            person.posts.update(title: 'London')
           end
 
           let(:from_db) do
             Person.first
           end
 
-          it "updates the first document" do
-            expect(from_db.posts.map(&:title)).to eq(["London", "Second"])
+          it 'updates the first document' do
+            expect(from_db.posts.map(&:title)).to eq(%w[London Second])
           end
 
-          it "does not update the last document" do
-            expect(from_db.posts[1].title).to eq("Second")
+          it 'does not update the last document' do
+            expect(from_db.posts[1].title).to eq('Second')
           end
         end
 
-        context "when updating the relation through a criteria" do
-
+        context 'when updating the relation through a criteria' do
           before do
-            person.posts.where(title: "First").update(title: "Berlin")
+            person.posts.where(title: 'First').update(title: 'Berlin')
           end
 
           let!(:from_db) do
             Person.first
           end
 
-          it "updates the matching documents" do
-            expect(from_db.posts.where(title: "Berlin").count).to eq(1)
+          it 'updates the matching documents' do
+            expect(from_db.posts.where(title: 'Berlin').count).to eq(1)
           end
 
-          it "does not update non matching documents" do
-            expect(from_db.posts.where(title: "Second").count).to eq(1)
+          it 'does not update non matching documents' do
+            expect(from_db.posts.where(title: 'Second').count).to eq(1)
           end
         end
       end
 
-      context "when the relation is a references many to many" do
-
+      context 'when the relation is a references many to many' do
         let(:from_db) do
           Person.first
         end
 
         let!(:preference_one) do
-          person.preferences.create!(name: "First")
+          person.preferences.create!(name: 'First')
         end
 
         let!(:preference_two) do
-          person.preferences.create!(name: "Second")
+          person.preferences.create!(name: 'Second')
         end
 
-        context "when updating the relation directly" do
-
+        context 'when updating the relation directly' do
           before do
-            person.preferences.update(name: "London")
+            person.preferences.update(name: 'London')
           end
 
-          it "updates the first document" do
-            expect(from_db.preferences[0].name).to eq("London")
+          it 'updates the first document' do
+            expect(from_db.preferences[0].name).to eq('London')
           end
 
-          it "does not update the last document" do
-            expect(from_db.preferences[1].name).to eq("Second")
+          it 'does not update the last document' do
+            expect(from_db.preferences[1].name).to eq('Second')
           end
         end
 
-        context "when updating the relation through a criteria" do
-
+        context 'when updating the relation through a criteria' do
           before do
-            person.preferences.where(name: "First").update(name: "Berlin")
+            person.preferences.where(name: 'First').update(name: 'Berlin')
           end
 
-          it "updates the matching documents" do
-            expect(from_db.preferences[0].name).to eq("Berlin")
+          it 'updates the matching documents' do
+            expect(from_db.preferences[0].name).to eq('Berlin')
           end
 
-          it "does not update non matching documents" do
-            expect(from_db.preferences[1].name).to eq("Second")
+          it 'does not update non matching documents' do
+            expect(from_db.preferences[1].name).to eq('Second')
           end
         end
       end
     end
   end
 
-  describe "#update_all" do
-
+  describe '#update_all' do
     let!(:person) do
-      Person.create!(title: "Sir")
+      Person.create!(title: 'Sir')
     end
 
     let!(:address_one) do
-      person.addresses.create!(street: "Oranienstr")
+      person.addresses.create!(street: 'Oranienstr')
     end
 
     let!(:address_two) do
-      person.addresses.create!(street: "Wienerstr")
+      person.addresses.create!(street: 'Wienerstr')
     end
 
-    context "when updating the root document" do
-
-      context "when updating with a criteria" do
-
+    context 'when updating the root document' do
+      context 'when updating with a criteria' do
         let(:from_db) do
           Person.first
         end
 
         before do
-          Person.where(title: "Sir").update_all(title: "Madam")
+          Person.where(title: 'Sir').update_all(title: 'Madam')
         end
 
-        it "updates all the matching documents" do
-          expect(from_db.title).to eq("Madam")
+        it 'updates all the matching documents' do
+          expect(from_db.title).to eq('Madam')
         end
       end
 
-      context "when updating all directly" do
-
+      context 'when updating all directly' do
         let(:from_db) do
           Person.first
         end
 
         before do
-          Person.update_all(title: "Madam")
+          Person.update_all(title: 'Madam')
         end
 
-        it "updates all the matching documents" do
-          expect(from_db.title).to eq("Madam")
+        it 'updates all the matching documents' do
+          expect(from_db.title).to eq('Madam')
         end
       end
     end
 
-    context "when updating an embedded document" do
-
+    context 'when updating an embedded document' do
       before do
-        Person.where(title: "Sir").update_all(
-          "addresses.0.city" => "Berlin"
+        Person.where(title: 'Sir').update_all(
+          'addresses.0.city' => 'Berlin'
         )
       end
 
@@ -1494,144 +1371,134 @@ describe Mongoid::Criteria::Modifiable do
         Person.first
       end
 
-      it "updates all the matching documents" do
-        expect(from_db.addresses.first.city).to eq("Berlin")
+      it 'updates all the matching documents' do
+        expect(from_db.addresses.first.city).to eq('Berlin')
       end
 
-      it "does not update non matching documents" do
+      it 'does not update non matching documents' do
         expect(from_db.addresses.last.city).to be_nil
       end
     end
 
-    context "when updating a relation" do
-
-      context "when the relation is an embeds many" do
-
+    context 'when updating a relation' do
+      context 'when the relation is an embeds many' do
         let(:from_db) do
           Person.first
         end
 
-        context "when updating the relation directly" do
-
+        context 'when updating the relation directly' do
           before do
-            person.addresses.update_all(city: "London")
+            person.addresses.update_all(city: 'London')
           end
 
-          it "updates the first document" do
-            expect(from_db.addresses.first.city).to eq("London")
+          it 'updates the first document' do
+            expect(from_db.addresses.first.city).to eq('London')
           end
 
-          it "updates the last document" do
-            expect(from_db.addresses.last.city).to eq("London")
+          it 'updates the last document' do
+            expect(from_db.addresses.last.city).to eq('London')
           end
         end
 
-        context "when updating the relation through a criteria" do
-
+        context 'when updating the relation through a criteria' do
           before do
-            person.addresses.where(street: "Oranienstr").update_all(city: "Berlin")
+            person.addresses.where(street: 'Oranienstr').update_all(city: 'Berlin')
           end
 
-          it "updates the matching documents" do
-            expect(from_db.addresses.first.city).to eq("Berlin")
+          it 'updates the matching documents' do
+            expect(from_db.addresses.first.city).to eq('Berlin')
           end
 
-          it "does not update non matching documents" do
+          it 'does not update non matching documents' do
             expect(from_db.addresses.last.city).to be_nil
           end
         end
       end
 
-      context "when the relation is a references many" do
-
+      context 'when the relation is a references many' do
         let!(:post_one) do
-          person.posts.create!(title: "First")
+          person.posts.create!(title: 'First')
         end
 
         let!(:post_two) do
-          person.posts.create!(title: "Second")
+          person.posts.create!(title: 'Second')
         end
 
-        context "when updating the relation directly" do
-
+        context 'when updating the relation directly' do
           before do
-            person.posts.update_all(title: "London")
+            person.posts.update_all(title: 'London')
           end
 
           let!(:from_db) do
             Person.first
           end
 
-          it "updates the first document" do
-            expect(from_db.posts.first.title).to eq("London")
+          it 'updates the first document' do
+            expect(from_db.posts.first.title).to eq('London')
           end
 
-          it "updates the last document" do
-            expect(from_db.posts.last.title).to eq("London")
+          it 'updates the last document' do
+            expect(from_db.posts.last.title).to eq('London')
           end
         end
 
-        context "when updating the relation through a criteria" do
-
+        context 'when updating the relation through a criteria' do
           before do
-            person.posts.where(title: "First").update_all(title: "Berlin")
+            person.posts.where(title: 'First').update_all(title: 'Berlin')
           end
 
           let!(:from_db) do
             Person.first
           end
 
-          it "updates the matching documents" do
-            expect(from_db.posts.where(title: "Berlin").count).to eq(1)
+          it 'updates the matching documents' do
+            expect(from_db.posts.where(title: 'Berlin').count).to eq(1)
           end
 
-          it "does not update non matching documents" do
-            expect(from_db.posts.where(title: "Second").count).to eq(1)
+          it 'does not update non matching documents' do
+            expect(from_db.posts.where(title: 'Second').count).to eq(1)
           end
         end
       end
 
-      context "when the relation is a references many to many" do
-
+      context 'when the relation is a references many to many' do
         let(:from_db) do
           Person.first
         end
 
         let!(:preference_one) do
-          person.preferences.create!(name: "First")
+          person.preferences.create!(name: 'First')
         end
 
         let!(:preference_two) do
-          person.preferences.create!(name: "Second")
+          person.preferences.create!(name: 'Second')
         end
 
-        context "when updating the relation directly" do
-
+        context 'when updating the relation directly' do
           before do
-            person.preferences.update_all(name: "London")
+            person.preferences.update_all(name: 'London')
           end
 
-          it "updates the first document" do
-            expect(from_db.preferences.first.name).to eq("London")
+          it 'updates the first document' do
+            expect(from_db.preferences.first.name).to eq('London')
           end
 
-          it "updates the last document" do
-            expect(from_db.preferences.last.name).to eq("London")
+          it 'updates the last document' do
+            expect(from_db.preferences.last.name).to eq('London')
           end
         end
 
-        context "when updating the relation through a criteria" do
-
+        context 'when updating the relation through a criteria' do
           before do
-            person.preferences.where(name: "First").update_all(name: "Berlin")
+            person.preferences.where(name: 'First').update_all(name: 'Berlin')
           end
 
-          it "updates the matching documents" do
-            expect(from_db.preferences[0].name).to eq("Berlin")
+          it 'updates the matching documents' do
+            expect(from_db.preferences[0].name).to eq('Berlin')
           end
 
-          it "does not update non matching documents" do
-            expect(from_db.preferences[1].name).to eq("Second")
+          it 'does not update non matching documents' do
+            expect(from_db.preferences[1].name).to eq('Second')
           end
         end
       end
@@ -1639,9 +1506,7 @@ describe Mongoid::Criteria::Modifiable do
   end
 
   describe '#create_with' do
-
     context 'when called on the class' do
-
       let(:attrs) do
         { 'username' => 'Turnip' }
       end
@@ -1655,16 +1520,13 @@ describe Mongoid::Criteria::Modifiable do
       end
 
       context 'when a create is chained' do
-
         context 'when a write method is chained' do
-
           it 'executes the method' do
             expect(Person.create_with(attrs).new.username).to eq('Turnip')
           end
         end
 
         context 'when a write method is chained' do
-
           let(:query) do
             { 'age' => 50 }
           end
@@ -1698,7 +1560,6 @@ describe Mongoid::Criteria::Modifiable do
           end
 
           context 'when the attributes are shared with the write method args' do
-
             let(:query) do
               { 'username' => 'Beet', 'age' => 50 }
             end
@@ -1717,7 +1578,6 @@ describe Mongoid::Criteria::Modifiable do
     end
 
     context 'when called on a criteria' do
-
       let(:criteria_selector) do
         { 'username' => 'Artichoke', 'age' => 25 }
       end
@@ -1727,9 +1587,7 @@ describe Mongoid::Criteria::Modifiable do
       end
 
       context 'when the original criteria shares attributes with the attribute args' do
-
         context 'when all the original attributes are shared with the new attributes' do
-
           let(:attrs) do
             { 'username' => 'Beet', 'age' => 50 }
           end
@@ -1745,7 +1603,6 @@ describe Mongoid::Criteria::Modifiable do
       end
 
       context 'when only some of the original attributes are shared with the attribute args' do
-
         let(:attrs) do
           { 'username' => 'Beet' }
         end
@@ -1760,7 +1617,6 @@ describe Mongoid::Criteria::Modifiable do
       end
 
       context 'when a method is chained' do
-
         let(:attrs) do
           { 'username' => 'Turnip' }
         end
@@ -1769,7 +1625,6 @@ describe Mongoid::Criteria::Modifiable do
         end
 
         context 'when a create method is chained' do
-
           it 'executes the method' do
             expect(criteria.create_with(attrs).new.username).to eq('Turnip')
             expect(criteria.create_with(attrs).new.age).to eq(25)
@@ -1777,7 +1632,6 @@ describe Mongoid::Criteria::Modifiable do
         end
 
         context 'when a write method is chained producing conflicting criteria' do
-
           let(:new_person) do
             criteria.create_with(attrs).find_or_create_by(query)
           end