mongoid 9.0.11 → 9.1.0

data/spec/mongoid/persistable/creatable_spec.rb

@@ -1,151 +1,140 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Persistable::Creatable do
-
-  describe ".create" do
-
-    context "when provided an array of attributes" do
-
-      context "when no block is passed" do
-
+  describe '.create' do
+    context 'when provided an array of attributes' do
+      context 'when no block is passed' do
         let(:people) do
-          Person.create([{ title: "sir" }, { title: "madam" }])
+          Person.create([ { title: 'sir' }, { title: 'madam' } ])
         end
 
-        it "creates the first document" do
-          expect(people.first.title).to eq("sir")
+        it 'creates the first document' do
+          expect(people.first.title).to eq('sir')
         end
 
-        it "persists the first document" do
+        it 'persists the first document' do
           expect(people.first).to be_persisted
         end
 
-        it "creates the second document" do
-          expect(people.last.title).to eq("madam")
+        it 'creates the second document' do
+          expect(people.last.title).to eq('madam')
         end
 
-        it "persists the second document" do
+        it 'persists the second document' do
           expect(people.last).to be_persisted
         end
       end
 
-      context "when no block is passed" do
-
+      context 'when no block is passed' do
         let(:people) do
-          Person.create([{ title: "sir" }, { title: "madam" }]) do |person|
+          Person.create([ { title: 'sir' }, { title: 'madam' } ]) do |person|
             person.age = 36
           end
         end
 
-        it "creates the first document" do
-          expect(people.first.title).to eq("sir")
+        it 'creates the first document' do
+          expect(people.first.title).to eq('sir')
         end
 
-        it "persists the first document" do
+        it 'persists the first document' do
           expect(people.first).to be_persisted
         end
 
-        it "passes the block to the first document" do
+        it 'passes the block to the first document' do
           expect(people.first.age).to eq(36)
         end
 
-        it "creates the second document" do
-          expect(people.last.title).to eq("madam")
+        it 'creates the second document' do
+          expect(people.last.title).to eq('madam')
         end
 
-        it "persists the second document" do
+        it 'persists the second document' do
           expect(people.last).to be_persisted
         end
 
-        it "passes the block to the second document" do
+        it 'passes the block to the second document' do
           expect(people.last.age).to eq(36)
         end
       end
     end
 
-    context "when providing attributes" do
-
+    context 'when providing attributes' do
       let(:person) do
-        Person.create(title: "Sensei")
+        Person.create(title: 'Sensei')
       end
 
-      it "it saves the document" do
+      it 'saves the document' do
         expect(person).to be_persisted
       end
 
-      it "returns the document" do
-        expect(person).to be_a_kind_of(Person)
+      it 'returns the document' do
+        expect(person).to be_a(Person)
       end
 
-      context "when creating an embedded document" do
-
+      context 'when creating an embedded document' do
         let(:address) do
           Address.create(addressable: person)
         end
 
-        it "persists the document" do
+        it 'persists the document' do
           expect(address).to be_persisted
         end
       end
 
-      context "when creating an embedded document with store_as option" do
-
+      context 'when creating an embedded document with store_as option' do
         let(:user) do
           User.create
         end
+        let(:document) do
+          user.collection.find(_id: user.id).first
+        end
 
         before(:all) do
           User.embeds_many(
             :addresses,
-            class_name: "Address",
-            store_as: "user_adresses",
+            class_name: 'Address',
+            store_as: 'user_adresses',
             validate: false
           )
           Address.embedded_in :user
         end
 
         before do
-          user.addresses.create!(city: "nantes")
+          user.addresses.create!(city: 'nantes')
         end
 
-        let(:document) do
-          user.collection.find(_id: user.id).first
+        it 'does not persist in address key on User document' do
+          expect(document.keys).not_to include('addresses')
         end
 
-        it "should not persist in address key on User document" do
-          expect(document.keys).to_not include("addresses")
-        end
-
-        it "should persist on user_addesses key on User document" do
-          expect(document.keys).to include("user_adresses")
+        it 'persists on user_addesses key on User document' do
+          expect(document.keys).to include('user_adresses')
         end
       end
     end
 
-    context "when passing in a block" do
-
+    context 'when passing in a block' do
       let(:person) do
         Person.create do |peep|
-          peep.ssn = "666-66-6666"
+          peep.ssn = '666-66-6666'
         end
       end
 
-      it "sets the attributes" do
-        expect(person.ssn).to eq("666-66-6666")
+      it 'sets the attributes' do
+        expect(person.ssn).to eq('666-66-6666')
       end
 
-      it "persists the document" do
+      it 'persists the document' do
         expect(person).to be_persisted
       end
     end
 
-    context "when the document is a subclass of a root class" do
-      context "when using the default discriminator key" do
+    context 'when the document is a subclass of a root class' do
+      context 'when using the default discriminator key' do
         let!(:browser) do
-          Browser.create(version: 3, name: "Test")
+          Browser.create(version: 3, name: 'Test')
         end
 
         let(:collection) do
@@ -153,25 +142,25 @@ describe Mongoid::Persistable::Creatable do
         end
 
         let(:attributes) do
-          collection.find({ name: "Test"}).first
+          collection.find({ name: 'Test' }).first
         end
 
-        it "persists the versions" do
-          expect(attributes["version"]).to eq(3)
+        it 'persists the versions' do
+          expect(attributes['version']).to eq(3)
         end
 
-        it "persists the type" do
-          expect(attributes["_type"]).to eq("Browser")
+        it 'persists the type' do
+          expect(attributes['_type']).to eq('Browser')
         end
 
-        it "persists the attributes" do
-          expect(attributes["name"]).to eq("Test")
+        it 'persists the attributes' do
+          expect(attributes['name']).to eq('Test')
         end
       end
 
-      context "when using a custom discriminator key" do
+      context 'when using a custom discriminator key' do
         before do
-          Canvas.discriminator_key = "dkey"
+          Canvas.discriminator_key = 'dkey'
         end
 
         after do
@@ -179,7 +168,7 @@ describe Mongoid::Persistable::Creatable do
         end
 
         let!(:browser) do
-          Browser.create(version: 3, name: "Test")
+          Browser.create(version: 3, name: 'Test')
         end
 
         let(:collection) do
@@ -187,18 +176,18 @@ describe Mongoid::Persistable::Creatable do
         end
 
         let(:attributes) do
-          collection.find({ name: "Test"}).first
+          collection.find({ name: 'Test' }).first
         end
 
-        it "persists the new discriminator key" do
-          expect(attributes["dkey"]).to eq("Browser")
+        it 'persists the new discriminator key' do
+          expect(attributes['dkey']).to eq('Browser')
         end
       end
 
-      context "when using a custom discriminator key and discriminator value" do
+      context 'when using a custom discriminator key and discriminator value' do
         before do
-          Canvas.discriminator_key = "dkey"
-          Browser.discriminator_value = "dvalue"
+          Canvas.discriminator_key = 'dkey'
+          Browser.discriminator_value = 'dvalue'
         end
 
         after do
@@ -207,7 +196,7 @@ describe Mongoid::Persistable::Creatable do
         end
 
         let!(:browser) do
-          Browser.create(version: 3, name: "Test")
+          Browser.create(version: 3, name: 'Test')
         end
 
         let(:collection) do
@@ -215,19 +204,18 @@ describe Mongoid::Persistable::Creatable do
         end
 
         let(:attributes) do
-          collection.find({ name: "Test"}).first
+          collection.find({ name: 'Test' }).first
         end
 
-        it "persists the new discriminator key" do
-          expect(attributes["dkey"]).to eq("dvalue")
+        it 'persists the new discriminator key' do
+          expect(attributes['dkey']).to eq('dvalue')
         end
       end
     end
 
-    context "when the document is a subclass of a subclass" do
-
+    context 'when the document is a subclass of a subclass' do
       let!(:firefox) do
-        Firefox.create(version: 2, name: "Testy")
+        Firefox.create(version: 2, name: 'Testy')
       end
 
       let(:collection) do
@@ -235,64 +223,64 @@ describe Mongoid::Persistable::Creatable do
       end
 
       let(:attributes) do
-        collection.find({ name: "Testy" }).first
+        collection.find({ name: 'Testy' }).first
       end
 
       before do
         Browser.create(name: 'Safari', version: 4.0)
       end
 
-      it "persists the versions" do
-        expect(attributes["version"]).to eq(2)
+      it 'persists the versions' do
+        expect(attributes['version']).to eq(2)
       end
 
-      it "persists the type" do
-        expect(attributes["_type"]).to eq("Firefox")
+      it 'persists the type' do
+        expect(attributes['_type']).to eq('Firefox')
       end
 
-      it "persists the attributes" do
-        expect(attributes["name"]).to eq("Testy")
+      it 'persists the attributes' do
+        expect(attributes['name']).to eq('Testy')
       end
 
-      it "returns the document when querying for superclass" do
-        expect(Browser.where(name: "Testy").first).to eq(firefox)
+      it 'returns the document when querying for superclass' do
+        expect(Browser.where(name: 'Testy').first).to eq(firefox)
       end
 
-      it "returns the document when querying for root class" do
-        expect(Canvas.where(name: "Testy").first).to eq(firefox)
+      it 'returns the document when querying for root class' do
+        expect(Canvas.where(name: 'Testy').first).to eq(firefox)
       end
 
-      it "returns on of this subclasses if you find by _type" do
-        expect(Canvas.where(:_type.in => ['Firefox']).count).to eq(1)
+      it 'returns on of this subclasses if you find by _type' do
+        expect(Canvas.where(:_type.in => [ 'Firefox' ]).count).to eq(1)
       end
     end
 
-    context "when the document is subclassed" do
-
+    context 'when the document is subclassed' do
       let!(:firefox) do
-        Firefox.create(name: "firefox")
+        Firefox.create(name: 'firefox')
       end
 
-      it "finds the document with String args" do
+      it 'finds the document with String args' do
         expect(Firefox.find(firefox.id.to_s)).to eq(firefox)
       end
 
-      context "when querying for parent documents" do
-
+      context 'when querying for parent documents' do
         let(:canvas) do
-          Canvas.where(name: "firefox").first
+          Canvas.where(name: 'firefox').first
         end
 
-        it "returns matching subclasses" do
+        it 'returns matching subclasses' do
           expect(canvas).to eq(firefox)
         end
       end
     end
 
-    context "when document is a subclass and its parent is an embedded document" do
-
+    context 'when document is a subclass and its parent is an embedded document' do
       let!(:canvas) do
-        Canvas.create(name: "canvas")
+        Canvas.create(name: 'canvas')
+      end
+      let(:from_db) do
+        Canvas.find(canvas.id)
       end
 
       before do
@@ -301,17 +289,12 @@ describe Mongoid::Persistable::Creatable do
         canvas.palette.tools << Eraser.new
       end
 
-      let(:from_db) do
-        Canvas.find(canvas.id)
-      end
-
-      it "properly saves the subclasses" do
-        expect(from_db.palette.tools.map(&:class)).to eq([Pencil, Eraser])
+      it 'properly saves the subclasses' do
+        expect(from_db.palette.tools.map(&:class)).to eq([ Pencil, Eraser ])
       end
     end
 
-    context "when creating references_many documents from a parent association" do
-
+    context 'when creating references_many documents from a parent association' do
       let!(:container) do
         ShippingContainer.create
       end
@@ -320,168 +303,158 @@ describe Mongoid::Persistable::Creatable do
         Driver.create
       end
 
-      it "does not bleed relations from one subclass to another" do
-        expect(Truck.relations.keys).to eq(%w/ shipping_container driver crates seats bed /)
-        expect(Car.relations.keys).to eq(%w/ shipping_container driver crates seats /)
+      it 'does not bleed relations from one subclass to another' do
+        expect(Truck.relations.keys).to eq(%w[ shipping_container driver crates seats bed ])
+        expect(Car.relations.keys).to eq(%w[ shipping_container driver crates seats ])
       end
 
-      context "when appending new documents" do
-
+      context 'when appending new documents' do
         before do
           container.vehicles << Car.new
           container.vehicles << Truck.new
         end
 
-        it "allows STI from << using model.new" do
+        it 'allows STI from << using model.new' do
           expect(container.vehicles.map(&:class)).to eq([ Car, Truck ])
         end
       end
 
-      context "when appending persisted documents" do
-
+      context 'when appending persisted documents' do
         before do
           container.vehicles << Car.create
           container.vehicles << Truck.create
         end
 
-        it "allows STI from << using model.create" do
+        it 'allows STI from << using model.create' do
           expect(container.vehicles.map(&:class)).to eq([ Car, Truck ])
         end
       end
 
-      context "when building related documents" do
-
+      context 'when building related documents' do
         before do
           container.vehicles.build({}, Car).save!
           container.vehicles.build({}, Truck).save!
         end
 
-        it "allows STI from the build call" do
+        it 'allows STI from the build call' do
           expect(container.vehicles.map(&:class)).to eq([ Car, Truck ])
         end
       end
 
-      context "when building with a type attribute" do
-
+      context 'when building with a type attribute' do
         before do
-          container.vehicles.build({ "_type" => "Car" })
-          container.vehicles.build({ "_type" => "Truck" })
+          container.vehicles.build({ '_type' => 'Car' })
+          container.vehicles.build({ '_type' => 'Truck' })
         end
 
-        it "respects the _type attribute from the build call" do
+        it 'respects the _type attribute from the build call' do
           expect(container.vehicles.map(&:class)).to eq([ Car, Truck ])
         end
       end
 
-      context "when creating related documents" do
-
+      context 'when creating related documents' do
         before do
           container.vehicles.create({}, Car)
           container.vehicles.create({}, Truck)
         end
 
-        it "allows STI from the create call" do
+        it 'allows STI from the create call' do
           expect(container.vehicles.map(&:class)).to eq([ Car, Truck ])
         end
       end
 
-      context "when creating with a type attribute" do
-
+      context 'when creating with a type attribute' do
         before do
-          container.vehicles.create({ "_type" => "Car" })
-          container.vehicles.create({ "_type" => "Truck" })
+          container.vehicles.create({ '_type' => 'Car' })
+          container.vehicles.create({ '_type' => 'Truck' })
         end
 
-        it "respects the _type attribute from the create call" do
+        it 'respects the _type attribute from the create call' do
           expect(container.vehicles.map(&:class)).to eq([ Car, Truck ])
         end
       end
 
-      context "#find_or_initialize_by" do
-        context "when using the default discriminator key" do
+      describe '#find_or_initialize_by' do
+        context 'when using the default discriminator key' do
           before do
             container.vehicles.find_or_initialize_by({ driver_id: driver.id }, Car)
           end
 
-          it "initializes the given type document" do
+          it 'initializes the given type document' do
             expect(container.vehicles.map(&:class)).to eq([ Car ])
           end
 
-          it "initializes with the given attributes" do
+          it 'initializes with the given attributes' do
             expect(container.vehicles.map(&:driver)).to eq([ driver ])
           end
 
-          it "initializes with a type field that equals the class" do
+          it 'initializes with a type field that equals the class' do
             expect(
-              container.vehicles.first.attributes["_type"]
-            ).to eq("Car")
+              container.vehicles.first.attributes['_type']
+            ).to eq('Car')
           end
         end
 
-        context "when using a custom discriminator key" do
+        context 'when using a custom discriminator key' do
           before do
-            Vehicle.discriminator_key = "dkey"
+            Vehicle.discriminator_key = 'dkey'
             container.vehicles.find_or_initialize_by({ driver_id: driver.id }, Car)
           end
 
-          it "initializes the given type document" do
+          it 'initializes the given type document' do
             expect(container.vehicles.map(&:class)).to eq([ Car ])
           end
 
-          it "initializes with the given attributes" do
+          it 'initializes with the given attributes' do
             expect(container.vehicles.map(&:driver)).to eq([ driver ])
           end
 
-          it "initializes with a dkey field that equals the class" do
+          it 'initializes with a dkey field that equals the class' do
             expect(
-              container.vehicles.first.attributes["dkey"]
-            ).to eq("Car")
+              container.vehicles.first.attributes['dkey']
+            ).to eq('Car')
           end
         end
       end
 
-      context "#find_or_create_by" do
-
+      describe '#find_or_create_by' do
         before do
           container.vehicles.find_or_create_by({ driver_id: driver.id }, Car)
         end
 
-        it "creates the given type document" do
+        it 'creates the given type document' do
           expect(container.vehicles.map(&:class)).to eq([ Car ])
         end
 
-        it "creates with the given attributes" do
+        it 'creates with the given attributes' do
           expect(container.vehicles.map(&:driver)).to eq([ driver ])
         end
 
-        it "creates the correct number of documents" do
+        it 'creates the correct number of documents' do
           expect(container.vehicles.size).to eq(1)
         end
 
-        context "when executing with a found document" do
-
+        context 'when executing with a found document' do
           before do
             container.vehicles.find_or_create_by({ driver_id: driver.id }, Car)
           end
 
-          it "does not create an additional document" do
+          it 'does not create an additional document' do
             expect(container.vehicles.size).to eq(1)
           end
         end
 
-        context "when executing with an additional new document" do
-
+        context 'when executing with an additional new document' do
           before do
             container.vehicles.find_or_create_by({ driver_id: driver.id }, Truck)
           end
 
-          it "creates the new additional document" do
+          it 'creates the new additional document' do
             expect(container.vehicles.size).to eq(2)
           end
         end
 
         context 'when searching by a Time value' do
-
           let!(:account) do
             Account.create!(name: 'test', period_started_at: Time.now.utc)
           end
@@ -500,42 +473,39 @@ describe Mongoid::Persistable::Creatable do
         end
       end
 
-      context "#find_or_create_by!" do
-
+      describe '#find_or_create_by!' do
         before do
           container.vehicles.find_or_create_by!({ driver_id: driver.id }, Car)
         end
 
-        it "creates the given type document" do
+        it 'creates the given type document' do
           expect(container.vehicles.map(&:class)).to eq([ Car ])
         end
 
-        it "creates with the given attributes" do
+        it 'creates with the given attributes' do
           expect(container.vehicles.map(&:driver)).to eq([ driver ])
         end
 
-        it "creates the correct number of documents" do
+        it 'creates the correct number of documents' do
           expect(container.vehicles.size).to eq(1)
         end
 
-        context "when executing with a found document" do
-
+        context 'when executing with a found document' do
           before do
             container.vehicles.find_or_create_by!({ driver_id: driver.id }, Car)
           end
 
-          it "does not create an additional document" do
+          it 'does not create an additional document' do
             expect(container.vehicles.size).to eq(1)
           end
         end
 
-        context "when executing with an additional new document" do
-
+        context 'when executing with an additional new document' do
           before do
             container.vehicles.find_or_create_by!({ driver_id: driver.id }, Truck)
           end
 
-          it "creates the new additional document" do
+          it 'creates the new additional document' do
             expect(container.vehicles.size).to eq(2)
           end
         end
@@ -543,71 +513,65 @@ describe Mongoid::Persistable::Creatable do
     end
   end
 
-  describe ".create!" do
-
-    context "when provided an array of attributes" do
-
-      context "when no block is passed" do
-
+  describe '.create!' do
+    context 'when provided an array of attributes' do
+      context 'when no block is passed' do
         let(:people) do
-          Person.create!([{ title: "sir" }, { title: "madam" }])
+          Person.create!([ { title: 'sir' }, { title: 'madam' } ])
         end
 
-        it "creates the first document" do
-          expect(people.first.title).to eq("sir")
+        it 'creates the first document' do
+          expect(people.first.title).to eq('sir')
         end
 
-        it "persists the first document" do
+        it 'persists the first document' do
           expect(people.first).to be_persisted
         end
 
-        it "creates the second document" do
-          expect(people.last.title).to eq("madam")
+        it 'creates the second document' do
+          expect(people.last.title).to eq('madam')
         end
 
-        it "persists the second document" do
+        it 'persists the second document' do
           expect(people.last).to be_persisted
         end
       end
 
-      context "when no block is passed" do
-
+      context 'when no block is passed' do
         let(:people) do
-          Person.create!([{ title: "sir" }, { title: "madam" }]) do |person|
+          Person.create!([ { title: 'sir' }, { title: 'madam' } ]) do |person|
             person.age = 36
           end
         end
 
-        it "creates the first document" do
-          expect(people.first.title).to eq("sir")
+        it 'creates the first document' do
+          expect(people.first.title).to eq('sir')
         end
 
-        it "persists the first document" do
+        it 'persists the first document' do
           expect(people.first).to be_persisted
         end
 
-        it "passes the block to the first document" do
+        it 'passes the block to the first document' do
           expect(people.first.age).to eq(36)
         end
 
-        it "creates the second document" do
-          expect(people.last.title).to eq("madam")
+        it 'creates the second document' do
+          expect(people.last.title).to eq('madam')
         end
 
-        it "persists the second document" do
+        it 'persists the second document' do
           expect(people.last).to be_persisted
         end
 
-        it "passes the block to the second document" do
+        it 'passes the block to the second document' do
           expect(people.last.age).to eq(36)
         end
       end
     end
 
-    context "inserting with a field that is not unique" do
-
-      context "when a unique index exists" do
-
+    context 'inserting with a field that is not unique' do
+      context 'when a unique index exists' do
         before do
           Person.index({ ssn: 1 }, { unique: true })
           Person.create_indexes
@@ -617,45 +581,42 @@ describe Mongoid::Persistable::Creatable do
           Person.collection.drop
         end
 
-        it "raises an error" do
-          expect {
-            4.times { Person.create!(ssn: "555-55-1029") }
-          }.to raise_error(Mongo::Error::OperationFailure)
+        it 'raises an error' do
+          expect do
+            4.times { Person.create!(ssn: '555-55-1029') }
+          end.to raise_error(Mongo::Error::OperationFailure)
         end
       end
     end
 
-    context "when passing in a block" do
-
+    context 'when passing in a block' do
       let(:person) do
         Person.create! do |peep|
-          peep.ssn = "666-66-6666"
+          peep.ssn = '666-66-6666'
         end
       end
 
-      it "sets the attributes" do
-        expect(person.ssn).to eq("666-66-6666")
+      it 'sets the attributes' do
+        expect(person.ssn).to eq('666-66-6666')
       end
 
-      it "persists the document" do
+      it 'persists the document' do
         expect(person).to be_persisted
       end
     end
 
-    context "when setting the composite key" do
-
+    context 'when setting the composite key' do
       let(:account) do
-        Account.create!(name: "Hello")
+        Account.create!(name: 'Hello')
       end
 
-      it "saves the document" do
+      it 'saves the document' do
         expect(account).to be_persisted
       end
     end
 
-    context "when a callback aborts the chain" do
-
-      it "raises a callback error" do
+    context 'when a callback aborts the chain' do
+      it 'raises a callback error' do
         expect { Oscar.create! }.to raise_error(Mongoid::Errors::Callback)
       end
     end