mongoid 9.0.11 → 9.1.0

data/spec/mongoid/association/embedded/embedded_in/proxy_spec.rb

@@ -1,13 +1,10 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 require_relative '../embeds_many_models'
 
 describe Mongoid::Association::Embedded::EmbeddedIn::Proxy do
-
-  describe "#===" do
-
+  describe '#===' do
     let(:base) do
       Name.new
     end
@@ -17,37 +14,31 @@ describe Mongoid::Association::Embedded::EmbeddedIn::Proxy do
     end
 
     let(:association) do
-      Name.relations["namable"]
+      Name.relations['namable']
     end
 
     let(:relation) do
       described_class.new(base, target, association)
     end
 
-    context "when the proxied document is same class" do
-
-      context "when the document is a different instance" do
-
-        it "returns false" do
-          expect((relation === Person.new)).to be false
+    context 'when the proxied document is same class' do
+      context 'when the document is a different instance' do
+        it 'returns false' do
+          expect(relation === Person.new).to be false
         end
       end
 
-      context "when the document is the same instance" do
-
-        it "returns true" do
-          expect((relation === target)).to be true
+      context 'when the document is the same instance' do
+        it 'returns true' do
+          expect(relation === target).to be true
         end
       end
     end
   end
 
-  describe "#=" do
-
-    context "when the inverse of an embeds one" do
-
-      context "when the child is a new record" do
-
+  describe '#=' do
+    context 'when the inverse of an embeds one' do
+      context 'when the child is a new record' do
         let(:person) do
           Person.new
         end
@@ -60,25 +51,24 @@ describe Mongoid::Association::Embedded::EmbeddedIn::Proxy do
           name.namable = person
         end
 
-        it "sets the target of the relation" do
+        it 'sets the target of the relation' do
           expect(name.namable).to eq(person)
         end
 
-        it "sets the base on the inverse relation" do
+        it 'sets the base on the inverse relation' do
           expect(person.name).to eq(name)
         end
 
-        it "sets the same instance on the inverse relation" do
+        it 'sets the same instance on the inverse relation' do
           expect(person.name).to eql(name)
         end
 
-        it "does not save the target" do
-          expect(person).to_not be_persisted
+        it 'does not save the target' do
+          expect(person).not_to be_persisted
         end
       end
 
-      context "when the parent is not a new record" do
-
+      context 'when the parent is not a new record' do
         let(:person) do
           Person.create!
         end
@@ -91,28 +81,26 @@ describe Mongoid::Association::Embedded::EmbeddedIn::Proxy do
           name.namable = person
         end
 
-        it "sets the target of the relation" do
+        it 'sets the target of the relation' do
           expect(name.namable).to eq(person)
         end
 
-        it "sets the base on the inverse relation" do
+        it 'sets the base on the inverse relation' do
           expect(person.name).to eq(name)
         end
 
-        it "sets the same instance on the inverse relation" do
+        it 'sets the same instance on the inverse relation' do
           expect(person.name).to eql(name)
         end
 
-        it "does not save the base" do
-          expect(name).to_not be_persisted
+        it 'does not save the base' do
+          expect(name).not_to be_persisted
         end
       end
     end
 
-    context "when the inverse of an embeds many" do
-
-      context "when the child is a new record" do
-
+    context 'when the inverse of an embeds many' do
+      context 'when the child is a new record' do
         let(:person) do
           Person.new
         end
@@ -125,25 +113,24 @@ describe Mongoid::Association::Embedded::EmbeddedIn::Proxy do
           address.addressable = person
         end
 
-        it "sets the target of the relation" do
+        it 'sets the target of the relation' do
           expect(address.addressable).to eq(person)
         end
 
-        it "appends the base on the inverse relation" do
+        it 'appends the base on the inverse relation' do
           expect(person.addresses).to eq([ address ])
         end
 
-        it "sets the same instance in the inverse relation" do
+        it 'sets the same instance in the inverse relation' do
           expect(person.addresses.first).to eql(address)
         end
 
-        it "does not save the target" do
-          expect(person).to_not be_persisted
+        it 'does not save the target' do
+          expect(person).not_to be_persisted
         end
       end
 
-      context "when the parent is not a new record" do
-
+      context 'when the parent is not a new record' do
         let!(:person) do
           Person.create!
         end
@@ -156,27 +143,24 @@ describe Mongoid::Association::Embedded::EmbeddedIn::Proxy do
           address.addressable = person
         end
 
-        it "sets the target of the relation" do
+        it 'sets the target of the relation' do
           expect(address.addressable).to eq(person)
         end
 
-        it "sets the same instance in the inverse relation" do
+        it 'sets the same instance in the inverse relation' do
           expect(person.addresses.first).to eql(address)
         end
 
-        it "appends the base on the inverse relation" do
+        it 'appends the base on the inverse relation' do
           expect(person.addresses).to eq([ address ])
         end
       end
     end
   end
 
-  describe "#= nil" do
-
-    context "when the inverse of an embeds one" do
-
-      context "when the parent is a new record" do
-
+  describe '#= nil' do
+    context 'when the inverse of an embeds one' do
+      context 'when the parent is a new record' do
         let(:person) do
           Person.new
         end
@@ -190,17 +174,16 @@ describe Mongoid::Association::Embedded::EmbeddedIn::Proxy do
           name.namable = nil
         end
 
-        it "sets the relation to nil" do
+        it 'sets the relation to nil' do
           expect(name.namable).to be_nil
         end
 
-        it "removes the inverse relation" do
+        it 'removes the inverse relation' do
           expect(person.name).to be_nil
         end
       end
 
-      context "when the inverse is already nil" do
-
+      context 'when the inverse is already nil' do
         let(:person) do
           Person.new
         end
@@ -213,17 +196,16 @@ describe Mongoid::Association::Embedded::EmbeddedIn::Proxy do
           name.namable = nil
         end
 
-        it "sets the relation to nil" do
+        it 'sets the relation to nil' do
           expect(name.namable).to be_nil
         end
 
-        it "removes the inverse relation" do
+        it 'removes the inverse relation' do
           expect(person.name).to be_nil
         end
       end
 
-      context "when the documents are not new records" do
-
+      context 'when the documents are not new records' do
         let(:person) do
           Person.create!
         end
@@ -237,24 +219,22 @@ describe Mongoid::Association::Embedded::EmbeddedIn::Proxy do
           name.namable = nil
         end
 
-        it "sets the relation to nil" do
+        it 'sets the relation to nil' do
           expect(name.namable).to be_nil
         end
 
-        it "removed the inverse relation" do
+        it 'removed the inverse relation' do
           expect(person.name).to be_nil
         end
 
-        it "deletes the child document" do
+        it 'deletes the child document' do
           expect(name).to be_destroyed
         end
       end
     end
 
-    context "when the inverse of an embeds many" do
-
-      context "when the parent is a new record" do
-
+    context 'when the inverse of an embeds many' do
+      context 'when the parent is a new record' do
         let(:person) do
           Person.new
         end
@@ -268,17 +248,16 @@ describe Mongoid::Association::Embedded::EmbeddedIn::Proxy do
           address.addressable = nil
         end
 
-        it "sets the relation to nil" do
+        it 'sets the relation to nil' do
           expect(address.addressable).to be_nil
         end
 
-        it "removes the inverse relation" do
+        it 'removes the inverse relation' do
           expect(person.addresses).to be_empty
         end
       end
 
-      context "when the inverse is already nil" do
-
+      context 'when the inverse is already nil' do
         let(:address) do
           Address.new
         end
@@ -287,13 +266,12 @@ describe Mongoid::Association::Embedded::EmbeddedIn::Proxy do
           address.addressable = nil
         end
 
-        it "sets the relation to nil" do
+        it 'sets the relation to nil' do
           expect(address.addressable).to be_nil
         end
       end
 
-      context "when the documents are not new records" do
-
+      context 'when the documents are not new records' do
         let(:person) do
           Person.create!
         end
@@ -307,31 +285,30 @@ describe Mongoid::Association::Embedded::EmbeddedIn::Proxy do
           address.addressable = nil
         end
 
-        it "sets the relation to nil" do
+        it 'sets the relation to nil' do
           expect(address.addressable).to be_nil
         end
 
-        it "removed the inverse relation" do
+        it 'removed the inverse relation' do
           expect(person.addresses).to be_empty
         end
 
-        it "deletes the child document" do
+        it 'deletes the child document' do
           expect(address).to be_destroyed
         end
       end
 
-      context "when a child already exists on the parent" do
-
+      context 'when a child already exists on the parent' do
         let(:person) do
           Person.create!
         end
 
         let(:address_one) do
-          Address.new(street: "first")
+          Address.new(street: 'first')
         end
 
         let(:address_two) do
-          Address.new(street: "second")
+          Address.new(street: 'second')
         end
 
         before do
@@ -339,40 +316,38 @@ describe Mongoid::Association::Embedded::EmbeddedIn::Proxy do
           address_one.addressable = nil
         end
 
-        it "sets the relation to nil" do
+        it 'sets the relation to nil' do
           expect(address_one.addressable).to be_nil
         end
 
-        it "removed the inverse relation" do
+        it 'removed the inverse relation' do
           expect(person.addresses).to eq([ address_two ])
         end
 
-        it "deletes the child document" do
+        it 'deletes the child document' do
           expect(address_one).to be_destroyed
         end
 
-        it "reindexes the children" do
+        it 'reindexes the children' do
           expect(address_two._index).to eq(0)
         end
       end
     end
   end
 
-  describe ".embedded?" do
-
-    it "returns true" do
+  describe '.embedded?' do
+    it 'returns true' do
       expect(described_class).to be_embedded
     end
   end
 
-  describe "#respond_to?" do
-
+  describe '#respond_to?' do
     let(:person) do
       Person.new
     end
 
     let!(:name) do
-      person.build_name(first_name: "Tony")
+      person.build_name(first_name: 'Tony')
     end
 
     let(:document) do
@@ -380,18 +355,15 @@ describe Mongoid::Association::Embedded::EmbeddedIn::Proxy do
     end
 
     Mongoid::Document.public_instance_methods(true).each do |method|
-
       context "when checking #{method}" do
-
-        it "returns true" do
+        it 'returns true' do
           expect(document.respond_to?(method)).to be true
         end
       end
     end
   end
 
-  context "when creating the tree through initialization" do
-
+  context 'when creating the tree through initialization' do
     let!(:person) do
       Person.create!
     end
@@ -408,31 +380,30 @@ describe Mongoid::Association::Embedded::EmbeddedIn::Proxy do
       Location.create!(address: address)
     end
 
-    it "saves the child" do
+    it 'saves the child' do
       expect(Person.last.addresses.last).to eq(address)
     end
 
-    it "indexes the child" do
+    it 'indexes the child' do
       expect(address._index).to eq(0)
     end
 
-    it "saves the first location with the correct index" do
+    it 'saves the first location with the correct index' do
       expect(first_location._index).to eq(0)
     end
 
-    it "saves the second location with the correct index" do
+    it 'saves the second location with the correct index' do
       expect(second_location._index).to eq(1)
     end
 
-    it "has the locations in the association array" do
+    it 'has the locations in the association array' do
       expect(Person.last.addresses.last.locations).to eq(
-                                                          [first_location, second_location]
-                                                      )
+        [ first_location, second_location ]
+      )
     end
   end
 
-  context "when instantiating a new child with a persisted parent" do
-
+  context 'when instantiating a new child with a persisted parent' do
     let!(:person) do
       Person.create!
     end
@@ -445,17 +416,16 @@ describe Mongoid::Association::Embedded::EmbeddedIn::Proxy do
       Location.new(address: address)
     end
 
-    it "does not save the child" do
-      expect(address).to_not be_persisted
+    it 'does not save the child' do
+      expect(address).not_to be_persisted
     end
 
-    it "does not save the deeply embedded children" do
-      expect(address.locations.first).to_not be_persisted
+    it 'does not save the deeply embedded children' do
+      expect(address.locations.first).not_to be_persisted
     end
   end
 
-  context "when replacing the relation with another" do
-
+  context 'when replacing the relation with another' do
     let!(:person) do
       Person.create!
     end
@@ -465,11 +435,11 @@ describe Mongoid::Association::Embedded::EmbeddedIn::Proxy do
     end
 
     let!(:address) do
-      person.addresses.create!(street: "Kotbusser Damm")
+      person.addresses.create!(street: 'Kotbusser Damm')
     end
 
     let!(:name) do
-      person_two.create_name(first_name: "Syd")
+      person_two.create_name(first_name: 'Syd')
     end
 
     before do
@@ -477,76 +447,71 @@ describe Mongoid::Association::Embedded::EmbeddedIn::Proxy do
       name.namable.save!
     end
 
-    it "sets the new parent" do
+    it 'sets the new parent' do
       expect(name.namable).to eq(person)
     end
 
-    it "removes the previous parent relation" do
+    it 'removes the previous parent relation' do
       expect(person_two.name).to be_nil
     end
 
-    it "sets the new child relation" do
+    it 'sets the new child relation' do
       expect(person.name).to eq(name)
     end
 
-    context "when reloading" do
-
+    context 'when reloading' do
       before do
         person.reload
       end
 
-      it "sets the new parent" do
+      it 'sets the new parent' do
         expect(name.namable).to eq(person)
       end
 
-      it "removes the previous parent relation" do
+      it 'removes the previous parent relation' do
         expect(person_two.name).to be_nil
       end
 
-      it "sets the new child relation" do
+      it 'sets the new child relation' do
         expect(person.name).to eq(name)
       end
     end
   end
 
-  context "when the same class is embedded multiple times; embeds_one" do
-
+  context 'when the same class is embedded multiple times; embeds_one' do
     let(:customer) do
       Customer.new
     end
 
-    context "assignment after saving" do
-
-      it "correctly sets the association for the embedded class" do
-
+    context 'assignment after saving' do
+      it 'correctly sets the association for the embedded class' do
         customer.home_address = CustomerAddress.new
         customer.work_address = CustomerAddress.new
 
-        expect(customer.home_address._association.store_as).to eq("home_address")
-        expect(customer.work_address._association.store_as).to eq("work_address")
+        expect(customer.home_address._association.store_as).to eq('home_address')
+        expect(customer.work_address._association.store_as).to eq('work_address')
 
-        expect(customer.home_address.instance_eval { _association.store_as }).to eq("home_address")
-        expect(customer.work_address.instance_eval { _association.store_as }).to eq("work_address")
+        expect(customer.home_address.instance_eval { _association.store_as }).to eq('home_address')
+        expect(customer.work_address.instance_eval { _association.store_as }).to eq('work_address')
 
         customer.save!
 
         customer.home_address = CustomerAddress.new
         customer.work_address = CustomerAddress.new
 
-        expect(customer.home_address._association.store_as).to eq("home_address")
-        expect(customer.work_address._association.store_as).to eq("work_address")
+        expect(customer.home_address._association.store_as).to eq('home_address')
+        expect(customer.work_address._association.store_as).to eq('work_address')
 
-        expect(customer.home_address.instance_eval { _association.store_as }).to eq("home_address")
-        expect(customer.work_address.instance_eval { _association.store_as }).to eq("work_address")
+        expect(customer.home_address.instance_eval { _association.store_as }).to eq('home_address')
+        expect(customer.work_address.instance_eval { _association.store_as }).to eq('work_address')
 
         expect(customer.home_address.addressable).to eq(customer)
         expect(customer.work_address.addressable).to eq(customer)
       end
     end
 
-    context "inverse assignment" do
-
-      it "raises an error when trying to set the association" do
+    context 'inverse assignment' do
+      it 'raises an error when trying to set the association' do
         customer.work_address = CustomerAddress.new
 
         expect do
@@ -555,61 +520,56 @@ describe Mongoid::Association::Embedded::EmbeddedIn::Proxy do
       end
     end
 
-    context "when there is an explicit inverse_of" do
-
+    context 'when there is an explicit inverse_of' do
       let(:customer) { EmmCustomer.new }
 
-      it "correctly sets the association for the embedded class" do
+      it 'correctly sets the association for the embedded class' do
         customer.work_address = EmmCustomerAddress.new
 
         expect do
           customer.work_address.addressable = customer
-        end.to_not raise_error
+        end.not_to raise_error
 
         expect(customer.work_address.addressable).to eq(customer)
       end
     end
   end
 
-  context "when the same class is embedded multiple times; embeds_many" do
-
+  context 'when the same class is embedded multiple times; embeds_many' do
     let(:customer) do
       EmmCustomer.new
     end
 
-    context "assignment after saving" do
-
-      it "correctly sets the association for the embedded class" do
+    context 'assignment after saving' do
+      it 'correctly sets the association for the embedded class' do
+        customer.close_friends = [ EmmFriend.new ]
+        customer.acquaintances = [ EmmFriend.new ]
 
-        customer.close_friends = [EmmFriend.new]
-        customer.acquaintances = [EmmFriend.new]
+        expect(customer.close_friends._association.store_as).to eq('close_friends')
+        expect(customer.acquaintances._association.store_as).to eq('acquaintances')
 
-        expect(customer.close_friends._association.store_as).to eq("close_friends")
-        expect(customer.acquaintances._association.store_as).to eq("acquaintances")
-
-        expect(customer.close_friends[0].instance_eval { _association.store_as }).to eq("close_friends")
-        expect(customer.acquaintances[0].instance_eval { _association.store_as }).to eq("acquaintances")
+        expect(customer.close_friends[0].instance_eval { _association.store_as }).to eq('close_friends')
+        expect(customer.acquaintances[0].instance_eval { _association.store_as }).to eq('acquaintances')
 
         customer.save!
 
-        customer.close_friends = [EmmFriend.new]
-        customer.acquaintances = [EmmFriend.new]
+        customer.close_friends = [ EmmFriend.new ]
+        customer.acquaintances = [ EmmFriend.new ]
 
-        expect(customer.close_friends._association.store_as).to eq("close_friends")
-        expect(customer.acquaintances._association.store_as).to eq("acquaintances")
+        expect(customer.close_friends._association.store_as).to eq('close_friends')
+        expect(customer.acquaintances._association.store_as).to eq('acquaintances')
 
-        expect(customer.close_friends[0].instance_eval { _association.store_as }).to eq("close_friends")
-        expect(customer.acquaintances[0].instance_eval { _association.store_as }).to eq("acquaintances")
+        expect(customer.close_friends[0].instance_eval { _association.store_as }).to eq('close_friends')
+        expect(customer.acquaintances[0].instance_eval { _association.store_as }).to eq('acquaintances')
 
         expect(customer.close_friends[0].befriendable).to eq(customer)
         expect(customer.acquaintances[0].befriendable).to eq(customer)
       end
     end
 
-    context "inverse assignment" do
-
-      it "raises an error when trying to set the association" do
-        customer.acquaintances = [EmmFriend.new]
+    context 'inverse assignment' do
+      it 'raises an error when trying to set the association' do
+        customer.acquaintances = [ EmmFriend.new ]
 
         expect do
           customer.acquaintances[0].befriendable = customer
@@ -618,30 +578,30 @@ describe Mongoid::Association::Embedded::EmbeddedIn::Proxy do
     end
   end
 
-  context "when assigning a hash" do
+  context 'when assigning a hash' do
     let(:building_address) { BuildingAddress.new }
 
     before do
-      building_address.building = { name: "Chrysler" }
+      building_address.building = { name: 'Chrysler' }
     end
 
-    it "creates the objects correctly" do
+    it 'creates the objects correctly' do
       expect(building_address.building).to be_a(Building)
-      expect(building_address.building.name).to eq("Chrysler")
+      expect(building_address.building.name).to eq('Chrysler')
     end
   end
 
-  context "when replacing an association with a hash" do
+  context 'when replacing an association with a hash' do
     let(:building_address) { BuildingAddress.new }
 
     before do
-      building_address.building = { name: "Chrysler" }
-      building_address.building = { name: "Empire State" }
+      building_address.building = { name: 'Chrysler' }
+      building_address.building = { name: 'Empire State' }
     end
 
-    it "creates the objects correctly" do
+    it 'creates the objects correctly' do
       expect(building_address.building).to be_a(Building)
-      expect(building_address.building.name).to eq("Empire State")
+      expect(building_address.building.name).to eq('Empire State')
     end
   end
 end