mongoid 3.1.7 → 4.0.2

data/spec/mongoid/relations/eager/has_and_belongs_to_many_spec.rb

@@ -0,0 +1,117 @@
+require "spec_helper"
+
+describe Mongoid::Relations::Eager::HasAndBelongsToMany do
+
+  describe ".keys_from_docs" do
+
+    let(:docs) do
+      Person.all.to_a
+    end
+
+    let!(:person) do
+      Person.create!(houses: [house])
+    end
+
+    let!(:house) do
+      House.create!
+    end
+
+    let(:metadata) do
+      Person.reflect_on_association(:houses)
+    end
+
+    let(:eager) do
+      described_class.new([metadata], docs).tap do |b|
+        b.shift_metadata
+      end
+    end
+
+    it "aggregates by the foreign key" do
+      expect(eager.keys_from_docs).to eq([house.id])
+    end
+  end
+
+  describe ".includes" do
+
+    let(:person) do
+      Person.create!
+    end
+
+    before do
+      Person.create!(houses: 3.times.map { House.create! })
+    end
+
+    context "when including the has_and_belongs_to_many relation" do
+
+      it "queries twice" do
+        expect_query(2) do
+          Person.all.includes(:houses).each do |person|
+            expect(person.houses).to_not be_nil
+
+            expect(person.houses.length).to be(3)
+          end
+        end
+      end
+
+      it "has all items" do
+        Person.all.includes(:houses).each do |person|
+          expect(person.ivar(:houses).length).to be(3)
+        end
+      end
+    end
+
+    context "when the relation is not polymorphic" do
+
+      let(:eager) do
+        Person.includes(:preferences).last
+      end
+
+      context "when the eager load has returned documents" do
+
+        let!(:preference) do
+          person.preferences.create(name: "testing")
+        end
+
+        before { eager }
+
+        it "puts the documents in the parent document" do
+          expect(eager.ivar(:preferences)).to eq([ preference ])
+        end
+
+        it "does not query when touching the association" do
+          expect_query(0) do
+            expect(eager.preferences).to eq([ preference ])
+          end
+        end
+
+        it "does not query when updating the association" do
+          expect_query(0) do
+            eager.preferences.first.name = "new pref"
+            expect(eager.preferences.first.name).to eq("new pref")
+          end
+        end
+      end
+
+      context "when the eager load has not returned documents" do
+
+        before { eager }
+
+        it "has an empty proxy" do
+          expect(eager.preferences).to eq []
+        end
+
+        it "does not query when touching the association" do
+          expect_query(0) do
+            eager.preferences.entries
+          end
+        end
+
+        it "returns the proxy" do
+          expect do
+            eager.preferences.create(name: "testing")
+          end.to_not raise_error
+        end
+      end
+    end
+  end
+end

data/spec/mongoid/relations/eager/has_many_spec.rb

@@ -0,0 +1,207 @@
+require "spec_helper"
+
+describe Mongoid::Relations::Eager::HasMany do
+
+  describe ".grouped_docs" do
+
+    let(:docs) do
+      Person.all.to_a
+    end
+
+    let(:person) do
+      Person.create!
+    end
+
+    let(:metadata) do
+      Person.reflect_on_association(:posts)
+    end
+
+    let(:eager) do
+      described_class.new([metadata], docs).tap do |b|
+        b.shift_metadata
+      end
+    end
+
+    before do
+      Post.create!(person: person)
+    end
+
+    it "aggregates by the parent primary key" do
+      expect(eager.grouped_docs.keys).to eq([person.id])
+    end
+  end
+
+  describe ".set_on_parent" do
+
+    let(:docs) do
+      Person.all.to_a
+    end
+
+    let(:person) do
+      Person.create!
+    end
+
+    let(:metadata) do
+      Person.reflect_on_association(:posts)
+    end
+
+    let(:eager) do
+      described_class.new([metadata], docs).tap do |b|
+        b.shift_metadata
+      end
+    end
+
+    before do
+      Post.create!(person: person)
+      eager
+    end
+
+    it "sets the relation into the parent" do
+      docs.each do |doc|
+        expect(doc).to receive(:__build__).once.with(:posts, :foo, metadata)
+      end
+      eager.set_on_parent(person.id, :foo)
+    end
+
+    it "doesnt call an extra query" do
+      expect_query(0) do
+        eager.set_on_parent(person.id, :foo)
+      end
+    end
+  end
+
+  describe ".includes" do
+
+    let(:person) do
+      Person.create!
+    end
+
+    context "when including the has_many relation" do
+
+      before do
+        3.times { Drug.create!(person: person) }
+        Drug.create!(person: Person.create!)
+      end
+
+      it "queries twice" do
+
+         expect_query(2) do
+          Person.all.includes(:drugs).each do |person|
+            expect(person.drugs.entries).to_not be_empty
+          end
+        end
+      end
+    end
+
+    context "when the relation is not polymorphic" do
+
+      context "when the eager load has returned documents" do
+
+        let!(:post) do
+          person.posts.create(title: "testing")
+        end
+
+        let!(:eager) do
+          Person.includes(:posts).last
+        end
+
+        it "puts the documents in the parent document" do
+          expect(eager.ivar(:posts)).to eq([post])
+        end
+
+        it "does not query when touching the association" do
+          expect_query(0) do
+            expect(eager.posts).to eq([post])
+          end
+        end
+
+        it "does not query when updating the association" do
+          expect_query(0) do
+            eager.posts.first.title = "New title"
+          end
+        end
+      end
+
+      context "when the eager load has not returned documents" do
+
+        before { person }
+
+        let!(:eager) do
+          Person.includes(:posts).last
+        end
+
+        it "does not set anything on the parent" do
+          expect(eager.ivar(:posts)).to be_empty
+        end
+
+        it "has an empty proxy" do
+          expect(eager.posts).to eq([])
+        end
+
+        it "does not query when touching the association" do
+          expect_query(0) do
+            eager.posts.entries
+          end
+        end
+
+        it "returns the proxy" do
+          expect do
+            eager.posts.create(title: "testing")
+          end.to_not raise_error
+        end
+      end
+
+      context "when the eager load has not returned documents for some" do
+
+        let!(:person_one) do
+          person
+        end
+
+        let!(:person_two) do
+          Person.create(username: "durran")
+        end
+
+        let!(:post) do
+          person_one.posts.create(title: "testing")
+        end
+
+        let!(:eager) do
+          Person.includes(:posts).asc(:username).to_a
+        end
+
+        it "puts the found documents in the parent document" do
+          expect(eager.first.ivar(:posts)).to eq([post])
+        end
+
+        it "does not set documents not found" do
+          expect(eager.last.ivar(:posts)).to be_empty
+        end
+      end
+    end
+
+    context "when the relation is polymorphic" do
+
+      let!(:movie) do
+        Movie.create(name: "Bladerunner")
+      end
+
+      let!(:rating) do
+        movie.ratings.create(value: 10)
+      end
+
+      let!(:eager) do
+        Movie.includes(:ratings).first
+      end
+
+      it "puts the found documents in the parent document" do
+        expect(eager.ivar(:ratings)).to eq([rating])
+      end
+
+      it "does not query when touching the association" do
+        expect_query(0) do
+          expect(eager.ratings).to eq([rating])
+        end
+      end
+    end
+  end
+end

data/spec/mongoid/relations/eager/has_one_spec.rb

@@ -0,0 +1,163 @@
+require "spec_helper"
+
+describe Mongoid::Relations::Eager::HasOne do
+
+  describe ".grouped_doc" do
+
+    let(:person) do
+      Person.create!
+    end
+
+    let(:docs) do
+      Person.all.to_a
+    end
+
+    let(:metadata) do
+      Person.reflect_on_association(:cat)
+    end
+
+    let(:eager) do
+      described_class.new([metadata], docs).tap do |b|
+        b.shift_metadata
+      end
+    end
+
+    before do
+      Cat.create!(person: person)
+    end
+
+    it "aggregates by the relation primary key" do
+      expect(eager.grouped_docs.keys).to eq([person.username])
+    end
+  end
+
+  describe ".set_on_parent" do
+
+    let(:person) do
+      Person.create!
+    end
+
+    let(:docs) do
+      Person.all.to_a
+    end
+
+    let(:metadata) do
+      Person.reflect_on_association(:cat)
+    end
+
+    let(:eager) do
+      described_class.new([metadata], docs).tap do |b|
+        b.shift_metadata
+      end
+    end
+
+    before do
+      Cat.create!(person: person)
+      eager
+    end
+
+    it "sets the relation into the parent" do
+      docs.each do |doc|
+        expect(doc).to receive(:set_relation).once.with(:cat, :foo)
+      end
+      eager.set_on_parent(person.username, :foo)
+    end
+
+    it "doesnt call an extra query" do
+      expect_query(0) do
+        eager.set_on_parent(person.username, :foo)
+      end
+    end
+  end
+
+  describe ".includes" do
+
+    let(:person) do
+      Person.create!
+    end
+
+    before do
+      3.times { Cat.create!(person: person) }
+      Cat.create!(person: Person.create!)
+    end
+
+    context "when including the has_one relation" do
+
+      it "queries twice" do
+
+        expect_query(2) do
+
+          Person.all.includes(:cat).each do |person|
+            expect(person.cat).to_not be_nil
+          end
+        end
+      end
+    end
+
+    context "when including more than one has_one relation" do
+
+      it "queries 3 times" do
+
+        expect_query(3) do
+
+          Person.all.includes(:cat, :account).each do |person|
+            expect(person.cat).to_not be_nil
+          end
+        end
+      end
+    end
+
+    context "when the relation is not polymorphic" do
+
+      let!(:game) do
+        person.create_game(name: "Tron")
+      end
+
+      let!(:eager) do
+        Person.where(_id: person.id).includes(:game).first
+      end
+
+      it "puts the documents in the parent document" do
+        expect(eager.ivar(:game)).to eq(game)
+      end
+
+      it "does not query when touching the association" do
+        expect_query(0) do
+          expect(eager.game).to eq(game)
+        end
+      end
+
+      it "does not query when updating the association" do
+        expect_query(0) do
+          eager.game.name = "Revenge of Racing of Magic"
+          expect(eager.game.name).to eq("Revenge of Racing of Magic")
+        end
+      end
+    end
+
+    context "when the relation is polymorphic" do
+
+      let!(:book) do
+        Book.create(name: "Game of Thrones")
+      end
+
+      let!(:rating) do
+        book.create_rating(value: 10)
+      end
+
+      let!(:eager) do
+        Book.all.includes(:rating).first
+      end
+
+      it "puts the found documents in the parent document" do
+        expect(eager.ivar(:rating)).to eq(rating)
+      end
+
+      it "does not query when touching the association" do
+        expect_query(0) do
+          expect(eager.rating).to eq(rating)
+        end
+      end
+    end
+  end
+end

data/spec/mongoid/relations/eager_spec.rb

@@ -0,0 +1,228 @@
+require "spec_helper"
+
+describe Mongoid::Relations::Eager do
+
+  describe ".preload" do
+
+    let(:criteria) do
+      Account.where(name: 'savings')
+    end
+
+    let(:context) do
+      Mongoid::Contextual::Mongo.new(criteria)
+    end
+
+    let(:inclusions) do
+      includes.map do |key|
+        Account.reflect_on_association(key)
+      end
+    end
+
+    let(:doc) { criteria.first }
+
+    context "when belongs_to" do
+
+      let!(:account) do
+        Account.create!(person: person, name: 'savings')
+      end
+
+      let(:person) do
+        Person.create!
+      end
+
+      let(:includes) { [:person] }
+
+      it "groups by foreign_key" do
+        expect(doc).to receive(:person_id).once
+        context.preload(inclusions, [doc])
+      end
+
+      it "preloads the parent" do
+        expect(doc.ivar(:person)).to be false
+        context.preload(inclusions, [doc])
+        expect(doc.ivar(:person)).to eq(doc.person)
+      end
+    end
+
+    context "when has_one" do
+
+      let(:account) do
+        Account.create!(name: 'savings')
+      end
+
+      let!(:comment) do
+        Comment.create!(title: 'my account comment', account: account)
+      end
+
+      let(:includes) { [:comment] }
+
+      it "preloads the child" do
+        expect(doc.ivar(:comment)).to be false
+        context.preload(inclusions, [doc])
+        expect(doc.ivar(:comment)).to eq(doc.comment)
+      end
+    end
+
+    context "when has_many" do
+
+      let(:account) do
+        Account.create!(name: 'savings')
+      end
+
+      let!(:alert) do
+        Alert.create!(account: account)
+      end
+
+      let(:includes) { [:alerts] }
+
+      it "preloads the child" do
+        expect(doc.ivar(:alerts)).to be false
+        context.preload(inclusions, [doc])
+        expect(doc.ivar(:alerts)).to eq(doc.alerts)
+      end
+    end
+
+    context "when has_and_belongs_to_many" do
+
+      let(:account) do
+        Account.create!(name: 'savings')
+      end
+
+      let!(:agent) do
+        Agent.create!(accounts: [account])
+      end
+
+      let(:includes) { [:agents] }
+
+      it "preloads the child" do
+        expect(doc.ivar(:agents)).to be false
+        context.preload(inclusions, [doc])
+        expect(doc.ivar(:agents)).to eq(doc.agents)
+      end
+    end
+  end
+
+  describe ".eager_load" do
+
+    before do
+      Person.create!
+    end
+
+    let(:context) do
+      Mongoid::Contextual::Mongo.new(criteria)
+    end
+
+    context "when including one has_many relation" do
+
+      let(:criteria) do
+        Person.includes(:posts)
+      end
+
+      let(:docs) do
+        Person.all.to_a
+      end
+
+      let(:posts_metadata) do
+        Person.reflect_on_association(:posts)
+      end
+
+      it "runs the has_many preload" do
+        expect(Mongoid::Relations::Eager::HasMany).to receive(:new).with([posts_metadata], docs).once.and_call_original
+
+        context.eager_load(docs)
+      end
+    end
+
+    context "when including multiple relations" do
+
+      let(:criteria) do
+        Person.includes(:posts, :houses, :cat)
+      end
+
+      let(:docs) do
+        Person.all.to_a
+      end
+
+      let(:posts_metadata) do
+        Person.reflect_on_association(:posts)
+      end
+
+      let(:houses_metadata) do
+        Person.reflect_on_association(:houses)
+      end
+
+      let(:cat_metadata) do
+        Person.reflect_on_association(:cat)
+      end
+
+      it "runs the has_many preload" do
+        expect(Mongoid::Relations::Eager::HasMany).to receive(:new).with([posts_metadata], docs).once.and_call_original
+
+        context.eager_load(docs)
+      end
+
+      it "runs the has_one preload" do
+        expect(Mongoid::Relations::Eager::HasOne).to receive(:new).with([cat_metadata], docs).once.and_call_original
+        context.eager_load(docs)
+      end
+
+      it "runs the has_and_belongs_to_many preload" do
+        expect(Mongoid::Relations::Eager::HasAndBelongsToMany).to receive(:new).with([houses_metadata], docs).once.and_call_original
+        context.eager_load(docs)
+      end
+    end
+
+    context "when including two of the same relation type" do
+
+      let(:criteria) do
+        Person.includes(:book, :cat)
+      end
+
+      let(:docs) do
+        Person.all.to_a
+      end
+
+      let(:book_metadata) do
+        Person.reflect_on_association(:book)
+      end
+
+      let(:cat_metadata) do
+        Person.reflect_on_association(:cat)
+      end
+
+      it "runs the has_one preload" do
+        expect(Mongoid::Relations::Eager::HasOne).to receive(:new).with([book_metadata, cat_metadata], docs).once.and_call_original
+        context.eager_load(docs)
+      end
+    end
+  end
+
+  describe ".eager_loadable?" do
+
+    let(:context) do
+      Mongoid::Contextual::Mongo.new(criteria)
+    end
+
+    context "when criteria has multiple includes" do
+
+      let(:criteria) do
+        Post.includes(:person, :roles)
+      end
+
+      it "is eager_loadable" do
+        expect(context.eager_loadable?).to be true
+      end
+    end
+
+    context "when criteria has no includes" do
+
+      let(:criteria) do
+        Post.all
+      end
+
+      it "is not eager_loadable" do
+        expect(context.eager_loadable?).to be false
+      end
+    end
+  end
+end