mongoid 9.0.11 → 9.1.1

data/spec/mongoid/association/referenced/belongs_to/eager_spec.rb

@@ -1,14 +1,11 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "spec_helper"
+require 'spec_helper'
 require_relative '../has_many_models'
 require_relative '../has_one_models'
 
 describe Mongoid::Association::Referenced::BelongsTo::Eager do
-
-  describe ".grouped_docs" do
-
+  describe '.grouped_docs' do
     let(:docs) do
       Post.all.to_a
     end
@@ -22,7 +19,7 @@ describe Mongoid::Association::Referenced::BelongsTo::Eager do
     end
 
     let(:eager) do
-      described_class.new([association], docs).tap do |b|
+      described_class.new([ association ], docs).tap do |b|
         b.send(:shift_association)
       end
     end
@@ -31,13 +28,12 @@ describe Mongoid::Association::Referenced::BelongsTo::Eager do
       Post.create!(person: person)
     end
 
-    it "aggregates by the parent id" do
-      expect(eager.send(:grouped_docs).keys).to eq([person.id])
+    it 'aggregates by the parent id' do
+      expect(eager.send(:grouped_docs).keys).to eq([ person.id ])
     end
   end
 
-  describe ".set_on_parent" do
-
+  describe '.set_on_parent' do
     let(:docs) do
       Post.all.to_a
     end
@@ -51,7 +47,7 @@ describe Mongoid::Association::Referenced::BelongsTo::Eager do
     end
 
     let(:eager) do
-      described_class.new([association], docs).tap do |b|
+      described_class.new([ association ], docs).tap do |b|
         b.send(:shift_association)
       end
     end
@@ -60,16 +56,13 @@ describe Mongoid::Association::Referenced::BelongsTo::Eager do
       Post.create!(person: person)
     end
 
-    it "sets the association into the parent" do
-      docs.each do |doc|
-        expect(doc).to receive(:set_relation).with(:person, :foo)
-      end
+    it 'sets the association into the parent' do
+      expect(docs).to all(receive(:set_relation).with(:person, :foo))
       eager.send(:set_on_parent, person.id, :foo)
     end
   end
 
-  describe ".includes" do
-
+  describe '.includes' do
     let(:person) do
       Person.create!
     end
@@ -78,22 +71,21 @@ describe Mongoid::Association::Referenced::BelongsTo::Eager do
       3.times { |i| Account.create!(person: person, name: "savings#{i}") }
     end
 
-    context "when including the belongs_to association" do
+    context 'when including the belongs_to association' do
       # Query count assertions require that all queries are sent using the
       # same connection object.
       require_no_multi_shard
 
-      it "queries twice" do
-
+      it 'queries twice' do
         expect_query(2) do
           Account.all.includes(:person).each do |account|
-            expect(account.person).to_not be_nil
+            expect(account.person).not_to be_nil
           end
         end
       end
     end
 
-    context "when the association is not polymorphic" do
+    context 'when the association is not polymorphic' do
       # Query count assertions require that all queries are sent using the
       # same connection object.
       require_no_multi_shard
@@ -102,59 +94,55 @@ describe Mongoid::Association::Referenced::BelongsTo::Eager do
         Post.includes(:person).last
       end
 
-      context "when the eager load has returned documents" do
-
+      context 'when the eager load has returned documents' do
         let!(:post) do
-          person.posts.create!(title: "testing")
+          person.posts.create!(title: 'testing')
         end
 
         before { eager }
 
-        it "puts the documents in the parent document" do
+        it 'puts the documents in the parent document' do
           expect(eager.ivar(:person)).to eq(person)
         end
 
-        it "does not query when touching the association" do
+        it 'does not query when touching the association' do
           expect_no_queries do
             expect(eager.person).to eq(person)
           end
         end
 
-        it "does not query when updating the association" do
+        it 'does not query when updating the association' do
           expect_no_queries do
-            eager.person.username = "arthurnn"
+            eager.person.username = 'arthurnn'
           end
         end
       end
 
-      context "when the eager load has not returned documents" do
-
+      context 'when the eager load has not returned documents' do
         let!(:post) do
-          Post.create!(title: "testing")
+          Post.create!(title: 'testing')
         end
 
         before { eager }
 
-        it "does not set anything on the parent" do
-          expect(eager.ivar(:person)).to be nil
+        it 'does not set anything on the parent' do
+          expect(eager.ivar(:person)).to be_nil
         end
 
-        it "has a nil association" do
-          expect(eager.person).to be nil
+        it 'has a nil association' do
+          expect(eager.person).to be_nil
         end
       end
     end
 
-    context "when the association is polymorphic" do
-
-      context "without namespaces" do
-
+    context 'when the association is polymorphic' do
+      context 'without namespaces' do
         let!(:stand_alone_rating) do
           Rating.create!(value: 7)
         end
 
         let!(:bar) do
-          Bar.create!(name: "FooBar")
+          Bar.create!(name: 'FooBar')
         end
 
         let(:bar_rating) do
@@ -162,7 +150,7 @@ describe Mongoid::Association::Referenced::BelongsTo::Eager do
         end
 
         let!(:movie) do
-          Movie.create!(name: "Bladerunner")
+          Movie.create!(name: 'Bladerunner')
         end
 
         let(:movie_rating) do
@@ -173,118 +161,113 @@ describe Mongoid::Association::Referenced::BelongsTo::Eager do
           Rating.includes(:ratable).entries
         end
 
-        context "when the eager load has returned documents" do
-
+        context 'when the eager load has returned documents' do
           before do
             bar_rating
             movie_rating
             eager
           end
 
-          it "puts the documents in the parent document" do
-            expect(eager.map { |e| e.ivar(:ratable) }).to eq([nil, bar, movie])
+          it 'puts the documents in the parent document' do
+            expect(eager.map { |e| e.ivar(:ratable) }).to eq([ nil, bar, movie ])
           end
 
-          it "does not query when touching the association" do
+          it 'does not query when touching the association' do
             expect_no_queries do
-              expect(eager.map(&:ratable)).to eq([nil, bar, movie])
+              expect(eager.map(&:ratable)).to eq([ nil, bar, movie ])
             end
           end
 
-          it "does not query when updating the association" do
+          it 'does not query when updating the association' do
             expect_no_queries do
-              eager.last.ratable.name = "Easy rider"
+              eager.last.ratable.name = 'Easy rider'
             end
           end
         end
 
-        context "when the eager load has not returned documents" do
-
+        context 'when the eager load has not returned documents' do
           before { eager }
 
-          it "does not set anything on the parent" do
-            expect(eager.map { |e| e.ivar(:ratable) }).to all(be nil)
+          it 'does not set anything on the parent' do
+            expect(eager.map { |e| e.ivar(:ratable) }).to all(be_nil)
           end
 
-          it "has a nil association" do
-            expect(eager.map(&:ratable)).to all(be nil)
+          it 'has a nil association' do
+            expect(eager.map(&:ratable)).to all(be_nil)
           end
         end
       end
 
-      context "with namespaces" do
-
+      context 'with namespaces' do
         let!(:stand_alone_review) do
-          Publication::Review.create!(summary: "awful")
+          Publication::Review.create!(summary: 'awful')
         end
 
         let!(:encyclopedia) do
-          Publication::Encyclopedia.create!(title: "Encyclopedia Britannica")
+          Publication::Encyclopedia.create!(title: 'Encyclopedia Britannica')
         end
 
         let(:encyclopedia_review) do
-          encyclopedia.reviews.create!(summary: "inspiring")
+          encyclopedia.reviews.create!(summary: 'inspiring')
         end
 
         let!(:pull_request) do
-          Coding::PullRequest.create!(title: "Add eager loading for polymorphic belongs_to associations")
+          Coding::PullRequest.create!(title: 'Add eager loading for polymorphic belongs_to associations')
         end
 
         let(:pull_request_review) do
-          pull_request.reviews.create!(summary: "Looks good to me")
+          pull_request.reviews.create!(summary: 'Looks good to me')
         end
 
         let(:eager) do
           Publication::Review.includes(:reviewable).entries
         end
 
-        context "when the eager load has returned documents" do
-
+        context 'when the eager load has returned documents' do
           before do
             encyclopedia_review
             pull_request_review
             eager
           end
 
-          it "puts the documents in the parent document" do
-            expect(eager.map { |e| e.ivar(:reviewable) }).to eq([nil, encyclopedia, pull_request])
+          it 'puts the documents in the parent document' do
+            expect(eager.map { |e| e.ivar(:reviewable) }).to eq([ nil, encyclopedia, pull_request ])
           end
 
-          it "does not query when touching the association" do
+          it 'does not query when touching the association' do
             expect_no_queries do
-              expect(eager.map(&:reviewable)).to eq([nil, encyclopedia, pull_request])
+              expect(eager.map(&:reviewable)).to eq([ nil, encyclopedia, pull_request ])
             end
           end
 
-          it "does not query when updating the association" do
+          it 'does not query when updating the association' do
             expect_no_queries do
-              eager.last.reviewable.title = "Load stuff eagerly"
+              eager.last.reviewable.title = 'Load stuff eagerly'
             end
           end
         end
 
-        context "when the eager load has not returned documents" do
-
+        context 'when the eager load has not returned documents' do
           before { eager }
 
-          it "does not set anything on the parent" do
-            expect(eager.map { |e| e.ivar(:reviewable) }).to all(be nil)
+          it 'does not set anything on the parent' do
+            expect(eager.map { |e| e.ivar(:reviewable) }).to all(be_nil)
           end
 
-          it "has a nil association" do
-            expect(eager.map(&:reviewable)).to all(be nil)
+          it 'has a nil association' do
+            expect(eager.map(&:reviewable)).to all(be_nil)
           end
         end
       end
 
       context 'when eager loading multiple associations' do
         let(:reviewable) do
-          Publication::Encyclopedia.create!(title: "Encyclopedia Britannica")
+          Publication::Encyclopedia.create!(title: 'Encyclopedia Britannica')
         end
 
         let!(:reviewable_review) do
-          Publication::Review.create!(summary: "awful",
-            reviewable: reviewable)
+          Publication::Review.create!(summary: 'awful',
+                                      reviewable: reviewable)
         end
 
         let(:reviewer) do
@@ -292,8 +275,8 @@ describe Mongoid::Association::Referenced::BelongsTo::Eager do
         end
 
         let!(:reviewer_review) do
-          Publication::Review.create!(summary: "okay",
-            reviewer: reviewer)
+          Publication::Review.create!(summary: 'okay',
+                                      reviewer: reviewer)
         end
 
         let(:template) do
@@ -301,8 +284,8 @@ describe Mongoid::Association::Referenced::BelongsTo::Eager do
         end
 
         let!(:template_review) do
-          Publication::Review.create!(summary: "Looks good to me",
-            template: template)
+          Publication::Review.create!(summary: 'Looks good to me',
+                                      template: template)
         end
 
         let(:eager) do
@@ -310,29 +293,28 @@ describe Mongoid::Association::Referenced::BelongsTo::Eager do
         end
 
         it 'loads all associations eagerly' do
-          loaded = expect_query(4) do
+          expect_query(4) do
             eager
           end
 
           expect_no_queries do
-            eager.map(&:reviewable).compact.should == [reviewable]
+            eager.map(&:reviewable).compact.should eq [ reviewable ]
           end
 
           expect_no_queries do
-            eager.map(&:reviewer).compact.should == [reviewer]
+            eager.map(&:reviewer).compact.should eq [ reviewer ]
           end
 
           expect_no_queries do
-            eager.map(&:template).compact.should == [template]
+            eager.map(&:template).compact.should eq [ template ]
           end
         end
       end
 
       context 'when eager loading an association that has type but not value set' do
-
         let!(:reviewer_review) do
-          Publication::Review.create!(summary: "okay",
-            reviewer_type: 'Dog')
+          Publication::Review.create!(summary: 'okay',
+                                      reviewer_type: 'Dog')
         end
 
         let(:eager) do
@@ -340,13 +322,29 @@ describe Mongoid::Association::Referenced::BelongsTo::Eager do
         end
 
         it 'does not error' do
-          eager.map(&:reviewer).should == [nil]
+          eager.map(&:reviewer).should eq [ nil ]
         end
       end
-    end
 
-    context "when the association has scope" do
+      context 'when the *_type field has not been registered with the resolver' do
+        before do
+          Publication::Review.collection.insert_one(
+            _id: BSON::ObjectId.new,
+            summary: 'tampered',
+            reviewer_id: BSON::ObjectId.new,
+            reviewer_type: 'Kernel'
+          )
+        end
 
+        it 'raises UnrecognizedModelAlias' do
+          expect do
+            Publication::Review.includes(:reviewer).entries
+          end.to raise_error(Mongoid::Errors::UnrecognizedModelAlias)
+        end
+      end
+    end
+
+    context 'when the association has scope' do
       context 'when inverse of has_many' do
         let!(:trainer1) { HmmTrainer.create!(name: 'Dave') }
         let!(:trainer2) { HmmTrainer.create!(name: 'Ash') }
@@ -380,25 +378,24 @@ describe Mongoid::Association::Referenced::BelongsTo::Eager do
       end
     end
 
-    context "when setting the foreign key id directly" do
-
-      it "works" do
+    context 'when setting the foreign key id directly' do
+      it 'works' do
         id = BSON::ObjectId.new
-        game = Game.new(:person_id => id)
+        game = Game.new(person_id: id)
         expect(game.person_id).to eql(id)
       end
     end
 
-    context "when all the values for the belongs_to association are nil" do
+    context 'when all the values for the belongs_to association are nil' do
       # Query count assertions require that all queries are sent using the
       # same connection object.
       require_no_multi_shard
 
       before do
-        2.times { |i| HmmTicket.create!(person: nil) }
+        2.times { |_i| HmmTicket.create!(person: nil) }
       end
 
-      it "only queries once for the parent documents" do
+      it 'only queries once for the parent documents' do
         found_ticket = false
         expect_query(1) do
           HmmTicket.all.includes(:person).each do |ticket|