mongoid 9.1.0 → 9.1.2

data/spec/mongoid/criteria/includable_spec.rb

@@ -126,8 +126,11 @@ describe Mongoid::Criteria::Includable do
       end
 
       after(:all) do
+        Mongoid.deregister_model(A)
         Object.send(:remove_const, :A)
+        Mongoid.deregister_model(B)
         Object.send(:remove_const, :B)
+        Mongoid.deregister_model(C)
         Object.send(:remove_const, :C)
       end
 
@@ -186,9 +189,13 @@ describe Mongoid::Criteria::Includable do
         end
 
         after(:all) do
+          Mongoid.deregister_model(A)
           Object.send(:remove_const, :A)
+          Mongoid.deregister_model(B)
           Object.send(:remove_const, :B)
+          Mongoid.deregister_model(C)
           Object.send(:remove_const, :C)
+          Mongoid.deregister_model(D)
           Object.send(:remove_const, :D)
         end
 
@@ -255,9 +262,13 @@ describe Mongoid::Criteria::Includable do
         end
 
         after(:all) do
+          Mongoid.deregister_model(A)
           Object.send(:remove_const, :A)
+          Mongoid.deregister_model(B)
           Object.send(:remove_const, :B)
+          Mongoid.deregister_model(C)
           Object.send(:remove_const, :C)
+          Mongoid.deregister_model(D)
           Object.send(:remove_const, :D)
         end
 
@@ -1121,9 +1132,13 @@ describe Mongoid::Criteria::Includable do
         end
 
         after(:all) do
+          Mongoid.deregister_model(A)
           Object.send(:remove_const, :A)
+          Mongoid.deregister_model(B)
           Object.send(:remove_const, :B)
+          Mongoid.deregister_model(C)
           Object.send(:remove_const, :C)
+          Mongoid.deregister_model(D)
           Object.send(:remove_const, :D)
         end
 
@@ -1408,12 +1423,1218 @@ describe Mongoid::Criteria::Includable do
 
   describe '#includes' do
     it_behaves_like 'eager loading', :includes
+
+    context 'when a nested association sits behind a parent whose class_name is not the resolved class name' do
+      before(:all) do
+        class IncEagerGallery
+          include Mongoid::Document
+
+          has_many :rooted_photos, class_name: '::IncEagerPhoto', inverse_of: :gallery
+        end
+
+        class IncEagerPhoto
+          include Mongoid::Document
+
+          belongs_to :gallery, class_name: 'IncEagerGallery', inverse_of: :rooted_photos
+          belongs_to :author, class_name: '::IncEagerAuthor'
+        end
+
+        class IncEagerAuthor
+          include Mongoid::Document
+        end
+
+        module IncEagerShop
+          class Order
+            include Mongoid::Document
+
+            has_many :items, class_name: 'Item', inverse_of: :order
+          end
+
+          class Item
+            include Mongoid::Document
+
+            belongs_to :order, class_name: 'Order', inverse_of: :items
+            belongs_to :author, class_name: '::IncEagerAuthor'
+          end
+        end
+
+        class IncEagerAlbum
+          include Mongoid::Document
+
+          has_many :poly_photos, class_name: '::IncEagerPolyPhoto', as: :imageable, inverse_of: :imageable
+        end
+
+        class IncEagerPolyPhoto
+          include Mongoid::Document
+
+          belongs_to :imageable, polymorphic: true, inverse_of: :poly_photos
+          belongs_to :author, class_name: '::IncEagerAuthor'
+        end
+      end
+
+      after(:all) do
+        Mongoid.deregister_model(IncEagerAlbum)
+        Object.send(:remove_const, :IncEagerAlbum)
+        Mongoid.deregister_model(IncEagerPolyPhoto)
+        Object.send(:remove_const, :IncEagerPolyPhoto)
+        Mongoid.deregister_model(IncEagerShop::Order)
+        Mongoid.deregister_model(IncEagerShop::Item)
+        Object.send(:remove_const, :IncEagerShop)
+        Mongoid.deregister_model(IncEagerAuthor)
+        Object.send(:remove_const, :IncEagerAuthor)
+        Mongoid.deregister_model(IncEagerPhoto)
+        Object.send(:remove_const, :IncEagerPhoto)
+        Mongoid.deregister_model(IncEagerGallery)
+        Object.send(:remove_const, :IncEagerGallery)
+      end
+
+      let!(:gallery) { IncEagerGallery.create! }
+      let!(:order) { IncEagerShop::Order.create! }
+
+      before do
+        IncEagerPhoto.create!(gallery: gallery, author: IncEagerAuthor.create!)
+        IncEagerShop::Item.create!(order: order, author: IncEagerAuthor.create!)
+      end
+
+      it 'eager loads a nested association behind a class_name with a leading ::' do
+        result = IncEagerGallery.includes(rooted_photos: :author).first
+
+        expect_query(0) do
+          expect(result.rooted_photos.first.author).to be_a(IncEagerAuthor)
+        end
+      end
+
+      it 'eager loads a nested association behind a module-relative class_name' do
+        result = IncEagerShop::Order.includes(items: :author).first
+
+        expect_query(0) do
+          expect(result.items.first.author).to be_a(IncEagerAuthor)
+        end
+      end
+
+      it 'eager loads a nested association behind a polymorphic parent with a leading ::' do
+        album = IncEagerAlbum.create!
+        IncEagerPolyPhoto.create!(imageable: album, author: IncEagerAuthor.create!)
+
+        result = IncEagerAlbum.includes(poly_photos: :author).first
+
+        expect_query(0) do
+          expect(result.poly_photos.first.author).to be_a(IncEagerAuthor)
+        end
+      end
+    end
   end
 
   describe '#eager_load' do
     # 4.4 lookup does not support the lookup pipeline as it is currently written
     min_server_version '5.0'
     it_behaves_like 'eager loading', :eager_load
+
+    context 'when the inclusion list is empty' do
+      let!(:band) { Band.create! }
+
+      it 'returns the documents without eager loading' do
+        expect(Band.eager_load([]).first).to eq(band)
+      end
+    end
+
+    context 'when the association is defined on a subclass of the queried class' do
+      before(:all) do
+        class Machine
+          include Mongoid::Document
+        end
+
+        class Peripheral
+          include Mongoid::Document
+        end
+
+        class Webcam < Peripheral
+        end
+
+        class Mouse < Peripheral
+          belongs_to :machine
+        end
+      end
+
+      after(:all) do
+        Mongoid.deregister_model(Mouse)
+        Object.send(:remove_const, :Mouse)
+        Mongoid.deregister_model(Webcam)
+        Object.send(:remove_const, :Webcam)
+        Mongoid.deregister_model(Peripheral)
+        Object.send(:remove_const, :Peripheral)
+        Mongoid.deregister_model(Machine)
+        Object.send(:remove_const, :Machine)
+      end
+
+      let!(:machine) { Machine.create! }
+      let!(:webcam) { Webcam.create! }
+      let!(:mouse) { Mouse.create!(machine: machine) }
+
+      it 'eager-loads it through the queried superclass' do
+        expect_query(1) do
+          loaded = Peripheral.eager_load(:machine).detect { |doc| doc.is_a?(Mouse) }
+          expect(loaded.machine).to eq(machine)
+        end
+      end
+    end
+
+    context 'when the association is defined on a subclass of an associated class' do
+      before(:all) do
+        class Brand
+          include Mongoid::Document
+        end
+
+        class Machine
+          include Mongoid::Document
+        end
+
+        class Laptop < Machine
+          belongs_to :brand
+        end
+
+        class Peripheral
+          include Mongoid::Document
+        end
+
+        class Mouse < Peripheral
+          belongs_to :machine
+        end
+      end
+
+      after(:all) do
+        Mongoid.deregister_model(Mouse)
+        Object.send(:remove_const, :Mouse)
+        Mongoid.deregister_model(Peripheral)
+        Object.send(:remove_const, :Peripheral)
+        Mongoid.deregister_model(Laptop)
+        Object.send(:remove_const, :Laptop)
+        Mongoid.deregister_model(Machine)
+        Object.send(:remove_const, :Machine)
+        Mongoid.deregister_model(Brand)
+        Object.send(:remove_const, :Brand)
+      end
+
+      let!(:brand) { Brand.create! }
+      let!(:laptop) { Laptop.create!(brand: brand) }
+      let!(:mouse) { Mouse.create!(machine: laptop) }
+
+      it 'eager-loads it through the parent association' do
+        expect_query(1) do
+          loaded = Peripheral.eager_load(machine: :brand).first
+          expect(loaded.machine).to eq(laptop)
+          expect(loaded.machine.brand).to eq(brand)
+        end
+      end
+    end
+
+    context 'when a has_many is defined only on a subclass' do
+      before(:all) do
+        class Gadget
+          include Mongoid::Document
+        end
+
+        class Speaker < Gadget
+          has_many :cables
+        end
+
+        class Cable
+          include Mongoid::Document
+
+          belongs_to :speaker
+        end
+      end
+
+      after(:all) do
+        Mongoid.deregister_model(Cable)
+        Object.send(:remove_const, :Cable)
+        Mongoid.deregister_model(Speaker)
+        Object.send(:remove_const, :Speaker)
+        Mongoid.deregister_model(Gadget)
+        Object.send(:remove_const, :Gadget)
+      end
+
+      let!(:speaker) { Speaker.create! }
+      let!(:cable) { Cable.create!(speaker: speaker) }
+
+      it 'eager-loads it through the queried superclass' do
+        expect_query(1) do
+          loaded = Gadget.eager_load(:cables).first
+          expect(loaded.cables).to eq([ cable ])
+        end
+      end
+    end
+
+    context 'when a has_one is defined only on a subclass' do
+      before(:all) do
+        class Gadget
+          include Mongoid::Document
+        end
+
+        class Speaker < Gadget
+          has_one :cable
+        end
+
+        class Cable
+          include Mongoid::Document
+
+          belongs_to :speaker
+        end
+      end
+
+      after(:all) do
+        Mongoid.deregister_model(Cable)
+        Object.send(:remove_const, :Cable)
+        Mongoid.deregister_model(Speaker)
+        Object.send(:remove_const, :Speaker)
+        Mongoid.deregister_model(Gadget)
+        Object.send(:remove_const, :Gadget)
+      end
+
+      let!(:speaker) { Speaker.create! }
+      let!(:cable) { Cable.create!(speaker: speaker) }
+
+      it 'eager-loads it through the queried superclass' do
+        expect_query(1) do
+          loaded = Gadget.eager_load(:cable).first
+          expect(loaded.cable).to eq(cable)
+        end
+      end
+    end
+
+    context 'when a has_and_belongs_to_many is defined only on a subclass' do
+      before(:all) do
+        class Cable
+          include Mongoid::Document
+
+          has_and_belongs_to_many :speakers
+        end
+
+        class Gadget
+          include Mongoid::Document
+        end
+
+        class Speaker < Gadget
+          has_and_belongs_to_many :cables
+        end
+      end
+
+      after(:all) do
+        Mongoid.deregister_model(Speaker)
+        Object.send(:remove_const, :Speaker)
+        Mongoid.deregister_model(Gadget)
+        Object.send(:remove_const, :Gadget)
+        Mongoid.deregister_model(Cable)
+        Object.send(:remove_const, :Cable)
+      end
+
+      let!(:cable) { Cable.create! }
+      let!(:speaker) { Speaker.create!(cables: [ cable ]) }
+
+      it 'eager-loads it through the queried superclass' do
+        expect_query(1) do
+          loaded = Gadget.eager_load(:cables).first
+          expect(loaded.cables).to eq([ cable ])
+        end
+      end
+    end
+
+    context 'when a belongs_to lives inside an embedded document' do
+      before(:all) do
+        class Device
+          include Mongoid::Document
+        end
+
+        class Port
+          include Mongoid::Document
+
+          embedded_in :computer
+          belongs_to :device
+        end
+
+        class Computer
+          include Mongoid::Document
+
+          embeds_one :port
+        end
+      end
+
+      after(:all) do
+        Mongoid.deregister_model(Computer)
+        Object.send(:remove_const, :Computer)
+        Mongoid.deregister_model(Port)
+        Object.send(:remove_const, :Port)
+        Mongoid.deregister_model(Device)
+        Object.send(:remove_const, :Device)
+      end
+
+      let!(:device) { Device.create! }
+      let!(:computer) { Computer.create!(port: Port.new(device: device)) }
+
+      it 'eager-loads it through the embedded document' do
+        expect_query(1) do
+          loaded = Computer.eager_load(port: :device).first
+          expect(loaded.port.device).to eq(device)
+        end
+      end
+
+      it 'leaves the embedded document absent instead of synthesizing it' do
+        without_port = Computer.create!
+        loaded = expect_query(1) do
+          Computer.eager_load(port: :device).to_a.index_by(&:id)
+        end
+        expect_no_queries do
+          expect(loaded[without_port.id].port).to be_nil
+        end
+      end
+    end
+
+    context 'when two embeds_one associations of the same class are eager-loaded' do
+      before(:all) do
+        class Device
+          include Mongoid::Document
+        end
+
+        class Port
+          include Mongoid::Document
+
+          embedded_in :computer
+          belongs_to :device
+        end
+
+        class Computer
+          include Mongoid::Document
+
+          embeds_one :left_port, class_name: 'Port'
+          embeds_one :right_port, class_name: 'Port'
+        end
+      end
+
+      after(:all) do
+        Mongoid.deregister_model(Computer)
+        Object.send(:remove_const, :Computer)
+        Mongoid.deregister_model(Port)
+        Object.send(:remove_const, :Port)
+        Mongoid.deregister_model(Device)
+        Object.send(:remove_const, :Device)
+      end
+
+      let!(:device1) { Device.create! }
+      let!(:device2) { Device.create! }
+      let!(:computer) do
+        Computer.create!(
+          left_port: Port.new(device: device1),
+          right_port: Port.new(device: device2)
+        )
+      end
+
+      it 'eager-loads the belongs_to in both embedded documents' do
+        expect_query(1) do
+          loaded = Computer.eager_load(left_port: :device, right_port: :device).first
+          expect(loaded.left_port.device).to eq(device1)
+          expect(loaded.right_port.device).to eq(device2)
+        end
+      end
+    end
+
+    context 'when a belongs_to lives inside a doubly embedded document' do
+      before(:all) do
+        class Device
+          include Mongoid::Document
+        end
+
+        class Port
+          include Mongoid::Document
+
+          embedded_in :panel
+          belongs_to :device
+        end
+
+        class Panel
+          include Mongoid::Document
+
+          embedded_in :computer
+          embeds_one :port
+        end
+
+        class Computer
+          include Mongoid::Document
+
+          embeds_one :panel
+        end
+      end
+
+      after(:all) do
+        Mongoid.deregister_model(Computer)
+        Object.send(:remove_const, :Computer)
+        Mongoid.deregister_model(Panel)
+        Object.send(:remove_const, :Panel)
+        Mongoid.deregister_model(Port)
+        Object.send(:remove_const, :Port)
+        Mongoid.deregister_model(Device)
+        Object.send(:remove_const, :Device)
+      end
+
+      let!(:device) { Device.create! }
+      let!(:computer) { Computer.create!(panel: Panel.new(port: Port.new(device: device))) }
+
+      it 'eager-loads it through both embedded documents' do
+        expect_query(1) do
+          loaded = Computer.eager_load(panel: { port: :device }).first
+          expect(loaded.panel.port.device).to eq(device)
+        end
+      end
+    end
+
+    context 'when a belongs_to is defined only on a subclass of an embedded document' do
+      before(:all) do
+        class Device
+          include Mongoid::Document
+        end
+
+        class Port
+          include Mongoid::Document
+
+          embedded_in :computer
+        end
+
+        class UsbPort < Port
+          belongs_to :device
+        end
+
+        class Computer
+          include Mongoid::Document
+
+          embeds_one :port
+        end
+      end
+
+      after(:all) do
+        Mongoid.deregister_model(Computer)
+        Object.send(:remove_const, :Computer)
+        Mongoid.deregister_model(UsbPort)
+        Object.send(:remove_const, :UsbPort)
+        Mongoid.deregister_model(Port)
+        Object.send(:remove_const, :Port)
+        Mongoid.deregister_model(Device)
+        Object.send(:remove_const, :Device)
+      end
+
+      let!(:device) { Device.create! }
+      let!(:computer) { Computer.create!(port: UsbPort.new(device: device)) }
+
+      it 'eager-loads it through the embedded subclass' do
+        expect_query(1) do
+          loaded = Computer.eager_load(port: :device).first
+          expect(loaded.port.device).to eq(device)
+        end
+      end
+    end
+
+    context 'when a belongs_to lives inside an embeds_many' do
+      before(:all) do
+        class Device
+          include Mongoid::Document
+        end
+
+        class Port
+          include Mongoid::Document
+
+          embedded_in :computer
+          belongs_to :device
+        end
+
+        class Computer
+          include Mongoid::Document
+
+          embeds_many :ports
+        end
+      end
+
+      after(:all) do
+        Mongoid.deregister_model(Computer)
+        Object.send(:remove_const, :Computer)
+        Mongoid.deregister_model(Port)
+        Object.send(:remove_const, :Port)
+        Mongoid.deregister_model(Device)
+        Object.send(:remove_const, :Device)
+      end
+
+      let!(:device1) { Device.create! }
+      let!(:device2) { Device.create! }
+      let!(:computer) { Computer.create!(ports: [ Port.new(device: device1), Port.new(device: device2) ]) }
+
+      it 'eager-loads each embedded belongs_to without extra queries' do
+        expect_query(1) do
+          loaded = Computer.eager_load(ports: :device).first
+          expect(loaded.ports.map(&:device)).to eq([ device1, device2 ])
+        end
+      end
+    end
+
+    context 'when a has_and_belongs_to_many lives inside an embedded document' do
+      before(:all) do
+        class Device
+          include Mongoid::Document
+        end
+
+        class Port
+          include Mongoid::Document
+
+          embedded_in :computer
+          has_and_belongs_to_many :devices
+        end
+
+        class Computer
+          include Mongoid::Document
+
+          embeds_one :port
+        end
+      end
+
+      after(:all) do
+        Mongoid.deregister_model(Computer)
+        Object.send(:remove_const, :Computer)
+        Mongoid.deregister_model(Port)
+        Object.send(:remove_const, :Port)
+        Mongoid.deregister_model(Device)
+        Object.send(:remove_const, :Device)
+      end
+
+      let!(:device1) { Device.create! }
+      let!(:device2) { Device.create! }
+      let!(:computer) { Computer.create!(port: Port.new(devices: [ device1, device2 ])) }
+
+      it 'eager-loads the devices referenced by the embedded port' do
+        expect_query(1) do
+          loaded = Computer.eager_load(port: :devices).first
+          expect(loaded.port.devices).to eq([ device1, device2 ])
+        end
+      end
+    end
+
+    context 'when an embedded belongs_to targets a superclass of the queried subclass' do
+      before(:all) do
+        class Device
+          include Mongoid::Document
+        end
+
+        class Computer < Device
+          embeds_one :port
+        end
+
+        class Port
+          include Mongoid::Document
+
+          embedded_in :computer
+          belongs_to :device
+        end
+      end
+
+      after(:all) do
+        Mongoid.deregister_model(Port)
+        Object.send(:remove_const, :Port)
+        Mongoid.deregister_model(Computer)
+        Object.send(:remove_const, :Computer)
+        Mongoid.deregister_model(Device)
+        Object.send(:remove_const, :Device)
+      end
+
+      let!(:device) { Device.create! }
+      let!(:computer) { Computer.create!(port: Port.new(device: device)) }
+
+      it 'eager-loads the embedded belongs_to through the queried subclass' do
+        expect_query(1) do
+          loaded = Computer.eager_load(port: :device).first
+          expect(loaded.port.device).to eq(device)
+        end
+      end
+    end
+
+    context 'when an embedded association is nested under a referenced one' do
+      before(:all) do
+        class Device
+          include Mongoid::Document
+        end
+
+        class Port
+          include Mongoid::Document
+
+          embedded_in :computer
+          belongs_to :device
+        end
+
+        class Computer
+          include Mongoid::Document
+
+          embeds_one :port
+        end
+
+        class Desk
+          include Mongoid::Document
+
+          belongs_to :computer
+        end
+      end
+
+      after(:all) do
+        Mongoid.deregister_model(Desk)
+        Object.send(:remove_const, :Desk)
+        Mongoid.deregister_model(Computer)
+        Object.send(:remove_const, :Computer)
+        Mongoid.deregister_model(Port)
+        Object.send(:remove_const, :Port)
+        Mongoid.deregister_model(Device)
+        Object.send(:remove_const, :Device)
+      end
+
+      let!(:device) { Device.create! }
+      let!(:computer) { Computer.create!(port: Port.new(device: device)) }
+      let!(:desk) { Desk.create!(computer: computer) }
+
+      it 'eager-loads the embedded association together with its referenced child' do
+        expect_query(1) do
+          loaded = Desk.eager_load(computer: { port: :device }).first
+          expect(loaded.computer.port.device).to eq(device)
+        end
+      end
+    end
+
+    context 'when an embedded association is nested two levels under a referenced one' do
+      before(:all) do
+        class Device
+          include Mongoid::Document
+        end
+
+        class Pin
+          include Mongoid::Document
+
+          embedded_in :port
+          belongs_to :device
+        end
+
+        class Port
+          include Mongoid::Document
+
+          embedded_in :computer
+          embeds_one :pin
+        end
+
+        class Computer
+          include Mongoid::Document
+
+          embeds_one :port
+        end
+
+        class Desk
+          include Mongoid::Document
+
+          belongs_to :computer
+        end
+      end
+
+      after(:all) do
+        Mongoid.deregister_model(Desk)
+        Object.send(:remove_const, :Desk)
+        Mongoid.deregister_model(Computer)
+        Object.send(:remove_const, :Computer)
+        Mongoid.deregister_model(Port)
+        Object.send(:remove_const, :Port)
+        Mongoid.deregister_model(Pin)
+        Object.send(:remove_const, :Pin)
+        Mongoid.deregister_model(Device)
+        Object.send(:remove_const, :Device)
+      end
+
+      let!(:device) { Device.create! }
+      let!(:computer) { Computer.create!(port: Port.new(pin: Pin.new(device: device))) }
+      let!(:desk) { Desk.create!(computer: computer) }
+
+      it 'eager-loads the doubly embedded association together with its referenced child' do
+        expect_query(1) do
+          loaded = Desk.eager_load(computer: { port: { pin: :device } }).first
+          expect(loaded.computer.port.pin.device).to eq(device)
+        end
+      end
+    end
+
+    context 'when an embeds_many is nested inside another embeds_many under a referenced one' do
+      before(:all) do
+        class Device
+          include Mongoid::Document
+        end
+
+        class Port
+          include Mongoid::Document
+
+          embedded_in :card
+          belongs_to :device
+        end
+
+        class Card
+          include Mongoid::Document
+
+          embedded_in :computer
+          embeds_many :ports
+        end
+
+        class Computer
+          include Mongoid::Document
+
+          embeds_many :cards
+        end
+
+        class Desk
+          include Mongoid::Document
+
+          belongs_to :computer
+        end
+      end
+
+      after(:all) do
+        Mongoid.deregister_model(Desk)
+        Object.send(:remove_const, :Desk)
+        Mongoid.deregister_model(Computer)
+        Object.send(:remove_const, :Computer)
+        Mongoid.deregister_model(Card)
+        Object.send(:remove_const, :Card)
+        Mongoid.deregister_model(Port)
+        Object.send(:remove_const, :Port)
+        Mongoid.deregister_model(Device)
+        Object.send(:remove_const, :Device)
+      end
+
+      let!(:devices) { Array.new(4) { Device.create! } }
+      let!(:computer) do
+        Computer.create!(
+          cards: [
+            Card.new(ports: [ Port.new(device: devices[0]), Port.new(device: devices[1]) ]),
+            Card.new(ports: [ Port.new(device: devices[2]), Port.new(device: devices[3]) ])
+          ]
+        )
+      end
+      let!(:desk) { Desk.create!(computer: computer) }
+
+      it 'eager-loads each deeply embedded belongs_to correlated to its own element' do
+        expect_query(1) do
+          loaded = Desk.eager_load(computer: { cards: { ports: :device } }).first
+          got = loaded.computer.cards.flat_map { |card| card.ports.map(&:device) }
+          expect(got).to eq(devices)
+        end
+      end
+    end
+
+    context 'when a polymorphic belongs_to is eager-loaded' do
+      before(:all) do
+        class Printer
+          include Mongoid::Document
+        end
+
+        class Scanner
+          include Mongoid::Document
+        end
+
+        class Cartridge
+          include Mongoid::Document
+
+          belongs_to :device, polymorphic: true
+        end
+      end
+
+      after(:all) do
+        Mongoid.deregister_model(Cartridge)
+        Object.send(:remove_const, :Cartridge)
+        Mongoid.deregister_model(Scanner)
+        Object.send(:remove_const, :Scanner)
+        Mongoid.deregister_model(Printer)
+        Object.send(:remove_const, :Printer)
+      end
+
+      let!(:printer) { Printer.create! }
+      let!(:scanner) { Scanner.create! }
+      let!(:printer_cartridge) { Cartridge.create!(device: printer) }
+      let!(:scanner_cartridge) { Cartridge.create!(device: scanner) }
+
+      it 'eager-loads polymorphic targets of different types in a single extra query' do
+        expect_query(2) do
+          loaded = Cartridge.eager_load(:device).to_a.index_by(&:id)
+          expect(loaded[printer_cartridge.id].device).to eq(printer)
+          expect(loaded[scanner_cartridge.id].device).to eq(scanner)
+        end
+      end
+    end
+
+    context 'when a polymorphic target is stored in another database' do
+      before(:all) do
+        class LocalDevice
+          include Mongoid::Document
+        end
+
+        class RemoteDevice
+          include Mongoid::Document
+
+          store_in database: 'secondary'
+        end
+
+        class Accessory
+          include Mongoid::Document
+
+          belongs_to :device, polymorphic: true
+        end
+      end
+
+      after(:all) do
+        Mongoid.deregister_model(Accessory)
+        Object.send(:remove_const, :Accessory)
+        Mongoid.deregister_model(RemoteDevice)
+        Object.send(:remove_const, :RemoteDevice)
+        Mongoid.deregister_model(LocalDevice)
+        Object.send(:remove_const, :LocalDevice)
+      end
+
+      # RemoteDevice lives in its own database, which the global cleanup hook
+      # (default database only) does not touch, so drop it here.
+      after { RemoteDevice.collection.drop }
+
+      let!(:local_device) { LocalDevice.create! }
+      let!(:remote_device) { RemoteDevice.create! }
+      let!(:local_accessory) { Accessory.create!(device: local_device) }
+      let!(:remote_accessory) { Accessory.create!(device: remote_device) }
+
+      it 'eager-loads the target stored in the other database' do
+        # One query materializes the roots, one $facet fetches the same-database
+        # target, and one direct query fetches the target in the other database.
+        loaded = expect_query(3) do
+          Accessory.eager_load(:device).to_a.index_by(&:id)
+        end
+
+        expect_no_queries do
+          expect(loaded[local_accessory.id].device).to eq(local_device)
+          expect(loaded[remote_accessory.id].device).to eq(remote_device)
+        end
+      end
+    end
+
+    context 'when a non-polymorphic target is stored in another database' do
+      before(:all) do
+        class RemoteServer
+          include Mongoid::Document
+
+          store_in database: 'secondary'
+        end
+
+        class Workstation
+          include Mongoid::Document
+
+          belongs_to :server, class_name: 'RemoteServer', optional: true
+        end
+      end
+
+      after(:all) do
+        Mongoid.deregister_model(Workstation)
+        Object.send(:remove_const, :Workstation)
+        Mongoid.deregister_model(RemoteServer)
+        Object.send(:remove_const, :RemoteServer)
+      end
+
+      # RemoteServer lives in its own database, which the global cleanup hook
+      # (default database only) does not touch, so drop it here.
+      after { RemoteServer.collection.drop }
+
+      let!(:server) { RemoteServer.create! }
+      let!(:workstation) { Workstation.create!(server: server) }
+
+      it 'eager-loads the target stored in the other database' do
+        # A $lookup cannot reach another database, so this falls back to
+        # separate-query loading: one query materializes the roots and one fetches
+        # the targets, instead of silently returning nothing.
+        loaded = expect_query(2) do
+          Workstation.eager_load(:server).to_a
+        end
+
+        expect_no_queries do
+          expect(loaded.first.server).to eq(server)
+        end
+      end
+    end
+
+    context 'when a has_many of the same name is defined on more than one subclass' do
+      before(:all) do
+        class Supplier
+          include Mongoid::Document
+        end
+
+        class Cog
+          include Mongoid::Document
+
+          belongs_to :machine, optional: true
+          belongs_to :supplier, optional: true
+        end
+
+        class Belt
+          include Mongoid::Document
+
+          belongs_to :machine, optional: true
+          belongs_to :supplier, optional: true
+        end
+
+        class Machine
+          include Mongoid::Document
+        end
+
+        class Lathe < Machine
+          has_many :widgets, class_name: 'Cog', inverse_of: :machine
+        end
+
+        class Press < Machine
+          has_many :widgets, class_name: 'Belt', inverse_of: :machine
+        end
+      end
+
+      after(:all) do
+        Mongoid.deregister_model(Press)
+        Object.send(:remove_const, :Press)
+        Mongoid.deregister_model(Lathe)
+        Object.send(:remove_const, :Lathe)
+        Mongoid.deregister_model(Machine)
+        Object.send(:remove_const, :Machine)
+        Mongoid.deregister_model(Belt)
+        Object.send(:remove_const, :Belt)
+        Mongoid.deregister_model(Cog)
+        Object.send(:remove_const, :Cog)
+        Mongoid.deregister_model(Supplier)
+        Object.send(:remove_const, :Supplier)
+      end
+
+      let!(:cog_supplier) { Supplier.create! }
+      let!(:belt_supplier) { Supplier.create! }
+      let!(:lathe) { Lathe.create! }
+      let!(:press) { Press.create! }
+      let!(:cog) { Cog.create!(machine: lathe, supplier: cog_supplier) }
+      let!(:belt) { Belt.create!(machine: press, supplier: belt_supplier) }
+
+      it 'loads each subclass association without one overwriting the other' do
+        loaded = expect_query(1) do
+          Machine.eager_load(:widgets).to_a.index_by(&:id)
+        end
+        expect_no_queries do
+          expect(loaded[lathe.id].widgets).to eq([ cog ])
+          expect(loaded[press.id].widgets).to eq([ belt ])
+        end
+      end
+
+      it 'eager-loads inclusions nested under each subclass association' do
+        loaded = expect_query(1) do
+          Machine.eager_load(widgets: :supplier).to_a.index_by(&:id)
+        end
+        expect_no_queries do
+          expect(loaded[lathe.id].widgets.first.supplier).to eq(cog_supplier)
+          expect(loaded[press.id].widgets.first.supplier).to eq(belt_supplier)
+        end
+      end
+    end
+
+    context 'when a has_many targets a class sharing its collection with sibling subclasses' do
+      before(:all) do
+        class Part
+          include Mongoid::Document
+        end
+
+        class Chip < Part
+          belongs_to :board, class_name: 'Board', optional: true
+        end
+
+        class Cable < Part
+          belongs_to :board, class_name: 'Board', optional: true
+        end
+
+        class Board
+          include Mongoid::Document
+
+          has_many :chips, class_name: 'Chip', inverse_of: :board
+        end
+      end
+
+      after(:all) do
+        Mongoid.deregister_model(Board)
+        Object.send(:remove_const, :Board)
+        Mongoid.deregister_model(Cable)
+        Object.send(:remove_const, :Cable)
+        Mongoid.deregister_model(Chip)
+        Object.send(:remove_const, :Chip)
+        Mongoid.deregister_model(Part)
+        Object.send(:remove_const, :Part)
+      end
+
+      let!(:board) { Board.create! }
+      let!(:chip) { Chip.create!(board: board) }
+      let!(:cable) { Cable.create!(board: board) }
+
+      it 'eager-loads only the chips, not the sibling subclass' do
+        expect_query(1) do
+          loaded = Board.eager_load(:chips).first
+          expect(loaded.chips.to_a).to eq([ chip ])
+        end
+      end
+    end
+
+    context 'when a document is saved after eager loading' do
+      context 'when the reference lives inside an embedded document' do
+        before(:all) do
+          class Device
+            include Mongoid::Document
+          end
+
+          class Port
+            include Mongoid::Document
+
+            embedded_in :computer
+            belongs_to :device
+          end
+
+          class Computer
+            include Mongoid::Document
+
+            embeds_many :ports
+          end
+        end
+
+        after(:all) do
+          Object.send(:remove_const, :Computer)
+          Object.send(:remove_const, :Port)
+          Object.send(:remove_const, :Device)
+        end
+
+        let!(:device) { Device.create! }
+        let!(:computer) { Computer.create!(ports: [ Port.new(device: device) ]) }
+
+        it 'does not persist the eager-loaded association data' do
+          loaded = Computer.eager_load(ports: :device).first
+
+          # Reassigning the collection makes the save rewrite the whole array,
+          # serializing each already-hydrated port.
+          loaded.ports = loaded.ports.to_a + [ Port.new(device: Device.create!) ]
+          loaded.save!
+
+          # With the bug present, the persisted port comes back as:
+          #
+          #   {
+          #     '_id' => ...,
+          #     'device_id' => ...,
+          #     'device' => [ { ...the whole device document... } ]  # <-- the $lookup left this
+          #   }
+          raw_ports = Computer.collection.find(_id: computer.id).first['ports']
+          expect(raw_ports.first).to eq('_id' => computer.ports.first.id, 'device_id' => device.id)
+        end
+      end
+
+      context 'when the reference lives on a referenced document' do
+        before(:all) do
+          class Device
+            include Mongoid::Document
+          end
+
+          class Port
+            include Mongoid::Document
+
+            belongs_to :computer
+            belongs_to :device
+          end
+
+          class Computer
+            include Mongoid::Document
+
+            has_many :ports
+          end
+        end
+
+        after(:all) do
+          Object.send(:remove_const, :Computer)
+          Object.send(:remove_const, :Port)
+          Object.send(:remove_const, :Device)
+        end
+
+        let!(:device) { Device.create! }
+        let!(:computer) { Computer.create!(ports: [ Port.new(device: device) ]) }
+
+        it 'does not persist the eager-loaded association data' do
+          loaded = Computer.eager_load(ports: :device).first
+          port = loaded.ports.first
+
+          # An upsert rewrites the whole document, so everything the port
+          # carries gets serialized.
+          port.upsert
+
+          # With the bug present, the persisted port comes back as:
+          #
+          #   {
+          #     '_id' => ...,
+          #     'computer_id' => ...,
+          #     'device_id' => ...,
+          #     'device' => [ { ...the whole device document... } ]  # <-- the $lookup left this
+          #   }
+          expect(Port.collection.find(_id: port.id).first)
+            .to eq('_id' => port.id, 'computer_id' => computer.id, 'device_id' => device.id)
+        end
+      end
+
+      context 'when more than one subclass defines the association' do
+        before(:all) do
+          class Cog
+            include Mongoid::Document
+
+            belongs_to :machine, optional: true
+          end
+
+          class Belt
+            include Mongoid::Document
+
+            belongs_to :machine, optional: true
+          end
+
+          class Machine
+            include Mongoid::Document
+          end
+
+          class Lathe < Machine
+            has_many :widgets, class_name: 'Cog', inverse_of: :machine
+          end
+
+          class Press < Machine
+            has_many :widgets, class_name: 'Belt', inverse_of: :machine
+          end
+        end
+
+        after(:all) do
+          Object.send(:remove_const, :Press)
+          Object.send(:remove_const, :Lathe)
+          Object.send(:remove_const, :Machine)
+          Object.send(:remove_const, :Belt)
+          Object.send(:remove_const, :Cog)
+        end
+
+        let!(:lathe) { Lathe.create! }
+        let!(:cog) { Cog.create!(machine: lathe) }
+
+        it 'does not persist the eager-loaded association data' do
+          loaded = Machine.eager_load(:widgets).first
+
+          # An upsert rewrites the whole document, so everything the lathe
+          # carries gets serialized.
+          loaded.upsert
+
+          # With the bug present, the persisted lathe comes back as:
+          #
+          #   {
+          #     '_id' => ...,
+          #     '_type' => 'Lathe',
+          #     'widgets' => [ { '_id' => ..., 'machine_id' => ... } ]  # <-- the $lookup left this
+          #   }
+          expect(Machine.collection.find(_id: lathe.id).first)
+            .to eq('_id' => lathe.id, '_type' => 'Lathe')
+        end
+      end
+    end
   end
 
   describe '#inclusions' do