mongoid 9.0.12 → 9.1.0

data/spec/mongoid/factory_spec.rb

@@ -1,111 +1,101 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Mongoid::Factory do
-
-  describe ".build" do
-
-    context "when the type attribute is present" do
-
+  describe '.build' do
+    context 'when the type attribute is present' do
       let(:attributes) do
-        { "_type" => "Person", "title" => "Sir" }
+        { '_type' => 'Person', 'title' => 'Sir' }
       end
 
-      context "when the type is a class" do
-
+      context 'when the type is a class' do
         let(:person) do
           described_class.build(Person, attributes)
         end
 
-        it "instantiates based on the type" do
-          expect(person.title).to eq("Sir")
+        it 'instantiates based on the type' do
+          expect(person.title).to eq('Sir')
         end
       end
 
-      context "when the type is a not a subclass" do
-
+      context 'when the type is a not a subclass' do
         let(:person) do
-          described_class.build(Person, { "_type" => "Canvas" })
+          described_class.build(Person, { '_type' => 'Canvas' })
         end
 
-        it "instantiates the provided class" do
+        it 'instantiates the provided class' do
           expect(person.class).to eq(Person)
         end
       end
 
-      context "when the type is a subclass of the provided" do
-
+      context 'when the type is a subclass of the provided' do
         let(:person) do
-          described_class.build(Person, { "_type" => "Doctor" })
+          described_class.build(Person, { '_type' => 'Doctor' })
         end
 
-        it "instantiates the subclass" do
+        it 'instantiates the subclass' do
           expect(person.class).to eq(Doctor)
         end
       end
 
-      context "when type is an empty string" do
-
+      context 'when type is an empty string' do
         let(:attributes) do
-          { "title" => "Sir", "_type" => "" }
+          { 'title' => 'Sir', '_type' => '' }
         end
 
         let(:person) do
           described_class.build(Person, attributes)
         end
 
-        it "instantiates based on the type" do
-          expect(person.title).to eq("Sir")
+        it 'instantiates based on the type' do
+          expect(person.title).to eq('Sir')
         end
       end
 
-      context "when type is the lower case class name" do
-
+      context 'when type is the lower case class name' do
         let(:attributes) do
-          { "title" => "Sir", "_type" => "person" }
+          { 'title' => 'Sir', '_type' => 'person' }
         end
 
         let(:person) do
           described_class.build(Person, attributes)
         end
 
-        it "instantiates based on the type" do
-          expect(person.title).to eq("Sir")
+        it 'instantiates based on the type' do
+          expect(person.title).to eq('Sir')
         end
       end
     end
 
-    context "when type is not preset" do
-      context "when using the default discriminator key" do
+    context 'when type is not preset' do
+      context 'when using the default discriminator key' do
         let(:attributes) do
-          { "title" => "Sir" }
+          { 'title' => 'Sir' }
         end
 
         let(:person) do
           described_class.build(Person, attributes)
         end
 
-        it "instantiates based on the provided class" do
-          expect(person.title).to eq("Sir")
+        it 'instantiates based on the provided class' do
+          expect(person.title).to eq('Sir')
         end
 
-        context "when the type is a symbol" do
-
+        context 'when the type is a symbol' do
           let(:person) do
-            described_class.build(Person, { :_type => "Doctor" })
+            described_class.build(Person, { _type: 'Doctor' })
           end
 
-          it "instantiates the subclass" do
+          it 'instantiates the subclass' do
             expect(person.class).to eq(Doctor)
           end
         end
       end
 
-      context "when using a custom discriminator key" do
+      context 'when using a custom discriminator key' do
         before do
-          Person.discriminator_key = "dkey"
+          Person.discriminator_key = 'dkey'
         end
 
         after do
@@ -113,33 +103,32 @@ describe Mongoid::Factory do
         end
 
         let(:attributes) do
-          { "title" => "Sir" }
+          { 'title' => 'Sir' }
         end
 
         let(:person) do
           described_class.build(Person, attributes)
         end
 
-        it "instantiates based on the provided class" do
-          expect(person.title).to eq("Sir")
+        it 'instantiates based on the provided class' do
+          expect(person.title).to eq('Sir')
         end
 
-        context "when the type is a symbol" do
-
+        context 'when the type is a symbol' do
           let(:person) do
-            described_class.build(Person, { :dkey => "Doctor" })
+            described_class.build(Person, { dkey: 'Doctor' })
           end
 
-          it "instantiates the subclass" do
+          it 'instantiates the subclass' do
             expect(person.class).to eq(Doctor)
           end
         end
       end
 
-      context "when using a custom discriminator key and value" do
+      context 'when using a custom discriminator key and value' do
         before do
-          Person.discriminator_key = "dkey"
-          Doctor.discriminator_value = "dvalue"
+          Person.discriminator_key = 'dkey'
+          Doctor.discriminator_value = 'dvalue'
         end
 
         after do
@@ -148,36 +137,34 @@ describe Mongoid::Factory do
         end
 
         let(:attributes) do
-          { "title" => "Sir", "dkey" => "dvalue" }
+          { 'title' => 'Sir', 'dkey' => 'dvalue' }
         end
 
         let(:doctor) do
           described_class.build(Person, attributes)
         end
 
-        it "instantiates based on the provided class" do
-          expect(doctor.title).to eq("Sir")
+        it 'instantiates based on the provided class' do
+          expect(doctor.title).to eq('Sir')
         end
 
-        it "generates based on the provided class" do
+        it 'generates based on the provided class' do
           expect(doctor).to be_a(Person)
         end
 
-        it "sets the attributes" do
-          expect(doctor.title).to eq("Sir")
+        it 'sets the attributes' do
+          expect(doctor.title).to eq('Sir')
         end
 
-        it "has the correct discriminator key/value" do
-          expect(doctor.dkey).to eq("dvalue")
+        it 'has the correct discriminator key/value' do
+          expect(doctor.dkey).to eq('dvalue')
         end
       end
     end
   end
 
-  describe ".from_db" do
-
-    context "when the attributes are nil" do
-
+  describe '.from_db' do
+    context 'when the attributes are nil' do
       let(:document) do
         described_class.from_db(model_cls, nil)
       end
@@ -186,11 +173,11 @@ describe Mongoid::Factory do
         context 'when model overwrites _id field to not have a default' do
           let(:model_cls) { Idnodef }
 
-          it "generates based on the provided class" do
+          it 'generates based on the provided class' do
             expect(document).to be_a(model_cls)
           end
 
-          it "sets the attributes to empty" do
+          it 'sets the attributes to empty' do
             expect(document.attributes).to be_empty
           end
         end
@@ -198,12 +185,12 @@ describe Mongoid::Factory do
         context 'with default _id auto-assignment behavior' do
           let(:model_cls) { Agency }
 
-          it "generates based on the provided class" do
+          it 'generates based on the provided class' do
             expect(document).to be_a(model_cls)
           end
 
-          it "sets the attributes to generated _id only" do
-            document.attributes.should == {'_id' => document.id}
+          it 'sets the attributes to generated _id only' do
+            document.attributes.should eq({ '_id' => document.id })
           end
         end
       end
@@ -216,110 +203,105 @@ describe Mongoid::Factory do
           ShipmentAddress.superclass.should be model_cls
         end
 
-        it "generates based on the provided class" do
+        it 'generates based on the provided class' do
           expect(document).to be_a(model_cls)
         end
 
-        it "sets the attributes to _type only" do
+        it 'sets the attributes to _type only' do
           skip 'https://jira.mongodb.org/browse/MONGOID-5179'
           # Note that Address provides the _id override.
-          document.attributes.should == {'_type' => 'Address'}
+          document.attributes.should eq({ '_type' => 'Address' })
         end
       end
 
       context 'when model class is an inheritance leaf' do
         let(:model_cls) { ShipmentAddress }
 
-        it "generates based on the provided class" do
+        it 'generates based on the provided class' do
           expect(document).to be_a(model_cls)
         end
 
-        it "sets the attributes to empty" do
+        it 'sets the attributes to empty' do
           # Note that Address provides the _id override.
-          document.attributes.should == {'_type' => 'ShipmentAddress'}
+          document.attributes.should eq({ '_type' => 'ShipmentAddress' })
         end
       end
     end
 
-    context "when a type is in the attributes" do
-
-      context "when the type is a class" do
-
+    context 'when a type is in the attributes' do
+      context 'when the type is a class' do
         let(:attributes) do
-          { "_type" => "Person", "title" => "Sir" }
+          { '_type' => 'Person', 'title' => 'Sir' }
         end
 
         let(:document) do
           described_class.from_db(Address, attributes)
         end
 
-        it "generates based on the type" do
+        it 'generates based on the type' do
           expect(document).to be_a(Person)
         end
 
-        it "sets the attributes" do
-          expect(document.title).to eq("Sir")
+        it 'sets the attributes' do
+          expect(document.title).to eq('Sir')
         end
       end
 
-      context "when the type is empty" do
-
+      context 'when the type is empty' do
         let(:attributes) do
-          { "_type" => "", "title" => "Sir" }
+          { '_type' => '', 'title' => 'Sir' }
         end
 
         let(:document) do
           described_class.from_db(Person, attributes)
         end
 
-        it "generates based on the provided class" do
+        it 'generates based on the provided class' do
           expect(document).to be_a(Person)
         end
 
-        it "sets the attributes" do
-          expect(document.title).to eq("Sir")
+        it 'sets the attributes' do
+          expect(document.title).to eq('Sir')
         end
       end
 
-      context "when type is the lower case class name" do
-
+      context 'when type is the lower case class name' do
         let(:attributes) do
-          { "title" => "Sir", "_type" => "person" }
+          { 'title' => 'Sir', '_type' => 'person' }
         end
 
         let(:person) do
           described_class.from_db(Person, attributes)
         end
 
-        it "instantiates based on the type" do
-          expect(person.title).to eq("Sir")
+        it 'instantiates based on the type' do
+          expect(person.title).to eq('Sir')
         end
       end
     end
 
-    context "when a type is not in the attributes" do
-
-      context "when using the default discriminator key" do
+    context 'when a type is not in the attributes' do
+      context 'when using the default discriminator key' do
         let(:attributes) do
-          { "title" => "Sir" }
+          { 'title' => 'Sir' }
         end
 
         let(:document) do
           described_class.from_db(Person, attributes)
         end
 
-        it "generates based on the provided class" do
+        it 'generates based on the provided class' do
           expect(document).to be_a(Person)
         end
 
-        it "sets the attributes" do
-          expect(document.title).to eq("Sir")
+        it 'sets the attributes' do
+          expect(document.title).to eq('Sir')
         end
       end
 
-      context "when using a custom discriminator key" do
+      context 'when using a custom discriminator key' do
         before do
-          Person.discriminator_key = "dkey"
+          Person.discriminator_key = 'dkey'
         end
 
         after do
@@ -327,26 +309,26 @@ describe Mongoid::Factory do
         end
 
         let(:attributes) do
-          { "title" => "Sir" }
+          { 'title' => 'Sir' }
         end
 
         let(:document) do
           described_class.from_db(Person, attributes)
         end
 
-        it "generates based on the provided class" do
+        it 'generates based on the provided class' do
           expect(document).to be_a(Person)
         end
 
-        it "sets the attributes" do
-          expect(document.title).to eq("Sir")
+        it 'sets the attributes' do
+          expect(document.title).to eq('Sir')
         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
-          Person.discriminator_key = "dkey"
-          Person.discriminator_value = "dvalue"
+          Person.discriminator_key = 'dkey'
+          Person.discriminator_value = 'dvalue'
         end
 
         after do
@@ -355,31 +337,30 @@ describe Mongoid::Factory do
         end
 
         let(:attributes) do
-          { "title" => "Sir" }
+          { 'title' => 'Sir' }
         end
 
         let(:document) do
           described_class.from_db(Person, attributes)
         end
 
-        it "generates based on the provided class" do
+        it 'generates based on the provided class' do
           expect(document).to be_a(Person)
         end
 
-        it "sets the attributes" do
-          expect(document.title).to eq("Sir")
+        it 'sets the attributes' do
+          expect(document.title).to eq('Sir')
         end
 
-        it "has the correct discriminator key/value" do
-          expect(document.dkey).to eq("dvalue")
+        it 'has the correct discriminator key/value' do
+          expect(document.dkey).to eq('dvalue')
         end
       end
     end
 
     context 'when type does not correspond to a Class name' do
-
       let(:attributes) do
-        { "title" => "Sir", "_type" => "invalid_class_name" }
+        { 'title' => 'Sir', '_type' => 'invalid_class_name' }
       end
 
       let(:person) do
@@ -387,16 +368,15 @@ describe Mongoid::Factory do
       end
 
       it 'raises a exception' do
-        expect {
+        expect do
           person
-        }.to raise_exception(Mongoid::Errors::UnknownModel)
+        end.to raise_exception(Mongoid::Errors::UnknownModel)
       end
     end
 
     context 'when type does not correspond to a Class name with custom discriminator key' do
-
       before do
-        Person.discriminator_key = "dkey"
+        Person.discriminator_key = 'dkey'
       end
 
       after do
@@ -404,7 +384,7 @@ describe Mongoid::Factory do
       end
 
       let(:attributes) do
-        { "title" => "Sir", "dkey" => "invalid_class_name" }
+        { 'title' => 'Sir', 'dkey' => 'invalid_class_name' }
       end
 
       let(:person) do
@@ -412,15 +392,15 @@ describe Mongoid::Factory do
       end
 
       it 'raises a exception' do
-        expect {
+        expect do
           person
-        }.to raise_exception(Mongoid::Errors::UnknownModel)
+        end.to raise_exception(Mongoid::Errors::UnknownModel)
       end
     end
 
     context 'when type does not correspond to a custom discriminator_value' do
       before do
-        Person.discriminator_value = "dvalue"
+        Person.discriminator_value = 'dvalue'
       end
 
       after do
@@ -428,23 +408,23 @@ describe Mongoid::Factory do
       end
 
       let(:attributes) do
-        { "title" => "Sir", "_type" => "dvalue" }
+        { 'title' => 'Sir', '_type' => 'dvalue' }
       end
 
       let(:person) do
         described_class.from_db(Person, attributes)
       end
 
-      it "generates based on the provided class" do
+      it 'generates based on the provided class' do
         expect(person).to be_a(Person)
       end
 
-      it "sets the attributes" do
-        expect(person.title).to eq("Sir")
+      it 'sets the attributes' do
+        expect(person.title).to eq('Sir')
       end
 
-      it "has the correct discriminator key/value" do
-        expect(person._type).to eq("dvalue")
+      it 'has the correct discriminator key/value' do
+        expect(person._type).to eq('dvalue')
       end
     end
 
@@ -457,7 +437,7 @@ describe Mongoid::Factory do
       end
 
       let(:attributes) do
-        { "title" => "Sir", "_type" => "BadPerson" }
+        { 'title' => 'Sir', '_type' => 'BadPerson' }
       end
 
       let(:person) do
@@ -465,22 +445,20 @@ describe Mongoid::Factory do
       end
 
       it 'raises a exception' do
-        expect {
+        expect do
           person
-        }.to raise_exception(NoMethodError)
+        end.to raise_exception(NoMethodError)
       end
-
     end
 
-    context "when not deferring callbacks" do
-
+    context 'when not deferring callbacks' do
       let(:person) do
         described_class.execute_from_db(Person, {}, execute_callbacks: true)
       end
 
       before do
         Person.set_callback :initialize, :after do |doc|
-          doc.title = "Madam"
+          doc.title = 'Madam'
         end
 
         Person.set_callback :find, :after do |doc|
@@ -493,24 +471,23 @@ describe Mongoid::Factory do
         Person.reset_callbacks(:find)
       end
 
-      it "runs the initialize callbacks" do
-        expect(person.title).to eq("Madam")
+      it 'runs the initialize callbacks' do
+        expect(person.title).to eq('Madam')
       end
 
-      it "runs the find callbacks" do
+      it 'runs the find callbacks' do
         expect(person.ssn).to eq(1234)
       end
     end
 
-    context "when deferring callbacks" do
-
+    context 'when deferring callbacks' do
       let(:person) do
         described_class.execute_from_db(Person, {}, nil, nil, execute_callbacks: false)
       end
 
       before do
         Person.set_callback :initialize, :after do |doc|
-          doc.title = "Madam"
+          doc.title = 'Madam'
         end
 
         Person.set_callback :find, :after do |doc|
@@ -523,12 +500,12 @@ describe Mongoid::Factory do
         Person.reset_callbacks(:find)
       end
 
-      it "runs the initialize callbacks" do
-        expect(person.title).to be nil
+      it 'runs the initialize callbacks' do
+        expect(person.title).to be_nil
       end
 
-      it "runs the find callbacks" do
-        expect(person.ssn).to be nil
+      it 'runs the find callbacks' do
+        expect(person.ssn).to be_nil
       end
     end
   end