mongoid 7.0.10 → 7.4.0

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

@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 require_relative '../has_many_models'
+require_relative '../has_one_models'
 
 describe Mongoid::Association::Referenced::BelongsTo::Eager do
 
@@ -75,6 +78,9 @@ describe Mongoid::Association::Referenced::BelongsTo::Eager do
     end
 
     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
 
@@ -87,6 +93,9 @@ describe Mongoid::Association::Referenced::BelongsTo::Eager do
     end
 
     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
 
       let(:eager) do
         Post.includes(:person).last
@@ -95,7 +104,7 @@ describe Mongoid::Association::Referenced::BelongsTo::Eager 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 }
@@ -105,13 +114,13 @@ describe Mongoid::Association::Referenced::BelongsTo::Eager do
         end
 
         it "does not query when touching the association" do
-          expect_query(0) do
+          expect_no_queries do
             expect(eager.person).to eq(person)
           end
         end
 
         it "does not query when updating the association" do
-          expect_query(0) do
+          expect_no_queries do
             eager.person.username = "arthurnn"
           end
         end
@@ -120,7 +129,7 @@ describe Mongoid::Association::Referenced::BelongsTo::Eager 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 }
@@ -137,18 +146,236 @@ describe Mongoid::Association::Referenced::BelongsTo::Eager do
 
     context "when the association is polymorphic" do
 
-      let!(:movie) do
-        Movie.create(name: "Bladerunner")
+      context "without namespaces" do
+
+        let!(:stand_alone_rating) do
+          Rating.create!(value: 7)
+        end
+
+        let!(:bar) do
+          Bar.create!(name: "FooBar")
+        end
+
+        let(:bar_rating) do
+          bar.create_rating(value: 5)
+        end
+
+        let!(:movie) do
+          Movie.create!(name: "Bladerunner")
+        end
+
+        let(:movie_rating) do
+          movie.ratings.create!(value: 10)
+        end
+
+        let(:eager) do
+          Rating.includes(:ratable).entries
+        end
+
+        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])
+          end
+
+          it "does not query when touching the association" do
+            expect_no_queries do
+              expect(eager.map(&:ratable)).to eq([nil, bar, movie])
+            end
+          end
+
+          it "does not query when updating the association" do
+            expect_no_queries do
+              eager.last.ratable.name = "Easy rider"
+            end
+          end
+        end
+
+        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)
+          end
+
+          it "has a nil association" do
+            expect(eager.map(&:ratable)).to all(be nil)
+          end
+        end
       end
 
-      let!(:rating) do
-        movie.ratings.create(value: 10)
+      context "with namespaces" do
+
+        let!(:stand_alone_review) do
+          Publication::Review.create!(summary: "awful")
+        end
+
+        let!(:encyclopedia) do
+          Publication::Encyclopedia.create!(title: "Encyclopedia Britannica")
+        end
+
+        let(:encyclopedia_review) do
+          encyclopedia.reviews.create!(summary: "inspiring")
+        end
+
+        let!(:pull_request) do
+          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")
+        end
+
+        let(:eager) do
+          Publication::Review.includes(:reviewable).entries
+        end
+
+        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])
+          end
+
+          it "does not query when touching the association" do
+            expect_no_queries do
+              expect(eager.map(&:reviewable)).to eq([nil, encyclopedia, pull_request])
+            end
+          end
+
+          it "does not query when updating the association" do
+            expect_no_queries do
+              eager.last.reviewable.title = "Load stuff eagerly"
+            end
+          end
+        end
+
+        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)
+          end
+
+          it "has a nil association" do
+            expect(eager.map(&:reviewable)).to all(be nil)
+          end
+        end
       end
 
-      it "raises an error" do
-        expect {
-          Rating.includes(:ratable).last
-        }.to raise_error(Mongoid::Errors::EagerLoad)
+      context 'when eager loading multiple associations' do
+        let(:reviewable) do
+          Publication::Encyclopedia.create!(title: "Encyclopedia Britannica")
+        end
+
+        let!(:reviewable_review) do
+          Publication::Review.create!(summary: "awful",
+            reviewable: reviewable)
+        end
+
+        let(:reviewer) do
+          Dog.create!
+        end
+
+        let!(:reviewer_review) do
+          Publication::Review.create!(summary: "okay",
+            reviewer: reviewer)
+        end
+
+        let(:template) do
+          Template.create!
+        end
+
+        let!(:template_review) do
+          Publication::Review.create!(summary: "Looks good to me",
+            template: template)
+        end
+
+        let(:eager) do
+          Publication::Review.includes(:reviewable, :reviewer, :template).entries
+        end
+
+        it 'loads all associations eagerly' do
+          loaded = expect_query(4) do
+            eager
+          end
+
+          expect_no_queries do
+            eager.map(&:reviewable).compact.should == [reviewable]
+          end
+
+          expect_no_queries do
+            eager.map(&:reviewer).compact.should == [reviewer]
+          end
+
+          expect_no_queries do
+            eager.map(&:template).compact.should == [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')
+        end
+
+        let(:eager) do
+          Publication::Review.includes(:reviewable, :reviewer, :template).entries
+        end
+
+        it 'does not error' do
+          eager.map(&:reviewer).should == [nil]
+        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') }
+        let!(:animal1) { HmmAnimal.create!(taxonomy: 'reptile', trainer: trainer1) }
+        let!(:animal2) { HmmAnimal.create!(taxonomy: 'bird', trainer: trainer2) }
+
+        let(:eager) do
+          HmmAnimal.includes(:trainer).to_a
+        end
+
+        it 'eager loads the included docs' do
+          expect(eager[0].trainer).to eq trainer1
+          expect(eager[1].trainer).to be_nil
+        end
+      end
+
+      context 'when inverse of has_one' do
+        let!(:trainer1) { HomTrainer.create!(name: 'Dave') }
+        let!(:trainer2) { HomTrainer.create!(name: 'Ash') }
+        let!(:animal1) { HomAnimal.create!(taxonomy: 'reptile', trainer: trainer1) }
+        let!(:animal2) { HomAnimal.create!(taxonomy: 'bird', trainer: trainer2) }
+
+        let(:eager) do
+          HomAnimal.includes(:trainer).to_a
+        end
+
+        it 'eager loads the included docs' do
+          expect(eager[0].trainer).to eq trainer1
+          expect(eager[1].trainer).to be_nil
+        end
       end
     end
 
@@ -162,6 +389,9 @@ describe Mongoid::Association::Referenced::BelongsTo::Eager do
     end
 
     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) }