mongoid 6.4.4 → 7.1.7

data/spec/mongoid/{relations → association}/polymorphic_spec.rb

@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require "spec_helper"
 
-describe Mongoid::Relations::Polymorphic do
+describe "Polymorphic Associations" do
 
   describe "#polymorph" do
 
@@ -12,16 +15,8 @@ describe Mongoid::Relations::Polymorphic do
 
       context "when the relation stores a foreign key" do
 
-        let(:metadata) do
-          Mongoid::Relations::Metadata.new(
-            name: :ratable,
-            polymorphic: true,
-            relation: Mongoid::Relations::Referenced::In
-          )
-        end
-
-        let!(:polymorphed) do
-          klass.polymorph(metadata)
+        let!(:association) do
+          klass.belongs_to :ratable, polymorphic: true
         end
 
         it "sets polymorphic to true" do
@@ -31,24 +26,12 @@ describe Mongoid::Relations::Polymorphic do
         it "adds the foreign key type field" do
           expect(klass.fields["ratable_type"]).to_not be_nil
         end
-
-        it "returns self" do
-          expect(polymorphed).to eq(klass)
-        end
       end
 
       context "when the relation does not store a foreign key" do
 
-        let(:metadata) do
-          Mongoid::Relations::Metadata.new(
-            name: :ratings,
-            as: :ratable,
-            relation: Mongoid::Relations::Referenced::Many
-          )
-        end
-
-        before do
-          klass.polymorph(metadata)
+        let!(:association) do
+          klass.has_many :ratings, as: :ratable
         end
 
         it "sets polymorphic to true" do
@@ -67,15 +50,8 @@ describe Mongoid::Relations::Polymorphic do
 
     context "when the relation is not polymorphic" do
 
-      let(:metadata) do
-        Mongoid::Relations::Metadata.new(
-          name: :ratings,
-          relation: Mongoid::Relations::Referenced::Many
-        )
-      end
-
-      before do
-        klass.polymorph(metadata)
+      let!(:association) do
+        klass.has_many :ratings
       end
 
       it "sets polymorphic to false" do
@@ -125,4 +101,63 @@ describe Mongoid::Relations::Polymorphic do
       end
     end
   end
+
+  context 'when the relation is touchable' do
+
+    context 'when the relation is embedded' do
+
+      let(:define_classes) do
+
+        class FirstOwner
+          include Mongoid::Document
+
+          embeds_one :owned, class_name: 'Owned', as: :embedded_relation_polymorphic_touch_owner
+        end
+
+        class SecondOwner
+          include Mongoid::Document
+
+          embeds_one :owned, class_name: 'Owned', as: :embedded_relation_polymorphic_touch_owner
+        end
+
+        class Owned
+          include Mongoid::Document
+
+          embedded_in :embedded_relation_polymorphic_touch_owner, polymorphic: true, touch: true
+        end
+      end
+
+      it 'successfully defines the touch method' do
+       expect { define_classes }.not_to raise_error
+      end
+    end
+
+    context 'when the relation is not embedded' do
+
+      let(:define_classes) do
+
+        class FirstOwner
+          include Mongoid::Document
+
+          has_one :owned, class_name: 'Owned', as: :belongs_relation_polymorphic_touch_owner
+        end
+
+        class SecondOwner
+          include Mongoid::Document
+
+          has_one :owned, class_name: 'Owned', as: :belongs_relation_polymorphic_touch_owner
+        end
+
+        class Owned
+          include Mongoid::Document
+
+          belongs_to :belongs_relation_polymorphic_touch_owner, polymorphic: true, touch: true
+        end
+      end
+
+      it 'successfully defines the touch method' do
+       expect { define_classes }.not_to raise_error
+      end
+    end
+  end
 end

data/spec/mongoid/{relations/bindings/referenced/in_spec.rb → association/referenced/belongs_to/binding_spec.rb}

@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require "spec_helper"
 
-describe Mongoid::Relations::Bindings::Referenced::In do
+describe Mongoid::Association::Referenced::BelongsTo::Binding do
 
   let(:person) do
     Person.new
@@ -14,11 +17,11 @@ describe Mongoid::Relations::Bindings::Referenced::In do
     Post.new
   end
 
-  let(:game_metadata) do
+  let(:game_association) do
     Game.relations["person"]
   end
 
-  let(:post_metadata) do
+  let(:post_association) do
     Post.relations["person"]
   end
 
@@ -27,7 +30,7 @@ describe Mongoid::Relations::Bindings::Referenced::In do
     context "when the child of an references one" do
 
       let(:binding) do
-        described_class.new(game, person, game_metadata)
+        described_class.new(game, person, game_association)
       end
 
       context "when the document is bindable with default pk" do
@@ -90,7 +93,7 @@ describe Mongoid::Relations::Bindings::Referenced::In do
     context "when the child of an references many" do
 
       let(:binding) do
-        described_class.new(post, person, post_metadata)
+        described_class.new(post, person, post_association)
       end
 
       context "when the document is bindable" do
@@ -129,7 +132,7 @@ describe Mongoid::Relations::Bindings::Referenced::In do
     context "when the child of an references one" do
 
       let(:binding) do
-        described_class.new(game, person, game_metadata)
+        described_class.new(game, person, game_association)
       end
 
       context "when the document is unbindable" do
@@ -162,7 +165,7 @@ describe Mongoid::Relations::Bindings::Referenced::In do
     context "when the child of an references many" do
 
       let(:binding) do
-        described_class.new(post, person, post_metadata)
+        described_class.new(post, person, post_association)
       end
 
       context "when the document is unbindable" do

data/spec/mongoid/{relations/builders/referenced/in_spec.rb → association/referenced/belongs_to/buildable_spec.rb}

@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require "spec_helper"
 
-describe Mongoid::Relations::Builders::Referenced::In do
+describe Mongoid::Association::Referenced::BelongsTo::Buildable do
 
   let(:base) do
     double
@@ -8,45 +11,28 @@ describe Mongoid::Relations::Builders::Referenced::In do
 
   describe "#build" do
 
-    let(:criteria) do
-      Person.where(_id: object_id)
-    end
-
-    let(:metadata) do
-      double(
-        klass: Person,
-        name: :person,
-        foreign_key: "person_id",
-        criteria: criteria
-      )
+    let(:document) do
+      association.build(base, object)
     end
 
-    let(:builder) do
-      described_class.new(base, metadata, object)
+    let(:association) do
+      Post.relations['person']
     end
 
     context "when provided an id" do
 
       context "when the object is an object id" do
 
-        let(:object_id) do
-          BSON::ObjectId.new
+        let!(:person) do
+          Person.create(_id: object)
         end
 
         let(:object) do
-          object_id
-        end
-
-        let(:person) do
-          double
+          BSON::ObjectId.new
         end
 
         before do
-          expect(criteria).to receive(:first).and_return(person)
-        end
-
-        let!(:document) do
-          builder.build
+          expect(Person).to receive(:where).with(association.primary_key => object).and_call_original
         end
 
         it "sets the document" do
@@ -54,40 +40,52 @@ describe Mongoid::Relations::Builders::Referenced::In do
         end
       end
 
-      context "when the object is an integer" do
+      context 'when the id is nil' do
+
+        let(:object) do
+          nil
+        end
 
         before do
-          Person.field :_id, overwrite: true, type: Integer
+          expect(Person).not_to receive(:where)
         end
 
-        after do
-          Person.field(
-            :_id,
-            overwrite: true,
-            type: BSON::ObjectId,
-            pre_processed: true,
-            default: ->{ BSON::ObjectId.new }
-          )
+        it 'returns nil' do
+          expect(document).to be_nil
         end
+      end
 
-        let(:object_id) do
-          666
+      context "when the id does not correspond to a document in the database" do
+
+        let!(:person) do
+          Person.create
         end
 
         let(:object) do
-          object_id
+          BSON::ObjectId.new
         end
 
-        let(:person) do
-          double
+        before do
+          expect(Person).to receive(:where).with(association.primary_key => object).and_call_original
         end
 
-        before do
-          expect(criteria).to receive(:first).and_return(person)
+        it 'returns nil' do
+          expect(document).to be_nil
+        end
+      end
+
+      context "when the object is an integer" do
+
+        let!(:person) do
+          Person.create(_id: object)
         end
 
-        let!(:document) do
-          builder.build
+        let(:object) do
+          666
+        end
+
+        before do
+          expect(Person).to receive(:where).with(association.primary_key => object).and_call_original
         end
 
         it "sets the document" do
@@ -98,50 +96,22 @@ describe Mongoid::Relations::Builders::Referenced::In do
 
     context "when provided a object" do
 
-      let(:object) do
-        Person.new
+      let!(:person) do
+        Person.create
       end
 
-      let(:builder) do
-        described_class.new(base, nil, object)
+      let(:object) do
+        Person.new
       end
 
-      let(:document) do
-        builder.build
+      before do
+        expect(Person).not_to receive(:where)
       end
 
       it "returns the object" do
         expect(document).to eq(object)
       end
     end
-  end
-
-  describe "#build" do
-
-    let(:game) do
-      Game.new
-    end
-
-    context "when no document found in the database" do
-
-      context "when the id is nil" do
-
-        it "returns nil" do
-          expect(game.person).to be_nil
-        end
-      end
-
-      context "when the id is incorrect" do
-
-        before do
-          game.person_id = BSON::ObjectId.new
-        end
-
-        it "returns nil" do
-          expect(game.person).to be_nil
-        end
-      end
-    end
 
     context "when the document is persisted" do
 

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

@@ -0,0 +1,377 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require "spec_helper"
+require_relative '../has_many_models'
+
+describe Mongoid::Association::Referenced::BelongsTo::Eager do
+
+  describe ".grouped_docs" do
+
+    let(:docs) do
+      Post.all.to_a
+    end
+
+    let(:person) do
+      Person.create!
+    end
+
+    let(:association) do
+      Post.reflect_on_association(:person)
+    end
+
+    let(:eager) do
+      described_class.new([association], docs).tap do |b|
+        b.send(:shift_association)
+      end
+    end
+
+    before do
+      Post.create!(person: person)
+    end
+
+    it "aggregates by the parent id" do
+      expect(eager.send(:grouped_docs).keys).to eq([person.id])
+    end
+  end
+
+  describe ".set_on_parent" do
+
+    let(:docs) do
+      Post.all.to_a
+    end
+
+    let(:person) do
+      Person.create!
+    end
+
+    let(:association) do
+      Post.reflect_on_association(:person)
+    end
+
+    let(:eager) do
+      described_class.new([association], docs).tap do |b|
+        b.send(:shift_association)
+      end
+    end
+
+    before 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
+      eager.send(:set_on_parent, person.id, :foo)
+    end
+  end
+
+  describe ".includes" do
+
+    let(:person) do
+      Person.create!
+    end
+
+    before do
+      3.times { |i| Account.create!(person: person, name: "savings#{i}") }
+    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
+
+        expect_query(2) do
+          Account.all.includes(:person).each do |account|
+            expect(account.person).to_not be_nil
+          end
+        end
+      end
+    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
+      end
+
+      context "when the eager load has returned documents" do
+
+        let!(:post) do
+          person.posts.create(title: "testing")
+        end
+
+        before { eager }
+
+        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
+          expect_no_queries do
+            expect(eager.person).to eq(person)
+          end
+        end
+
+        it "does not query when updating the association" do
+          expect_no_queries do
+            eager.person.username = "arthurnn"
+          end
+        end
+      end
+
+      context "when the eager load has not returned documents" do
+
+        let!(:post) do
+          Post.create(title: "testing")
+        end
+
+        before { eager }
+
+        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
+        end
+      end
+    end
+
+    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")
+        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
+
+      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
+
+      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 setting the foreign key id directly" do
+
+      it "works" do
+        id = BSON::ObjectId.new
+        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
+      # 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) }
+      end
+
+      it "only queries once for the parent documents" do
+        found_ticket = false
+        expect_query(1) do
+          HmmTicket.all.includes(:person).each do |ticket|
+            expect(ticket.person).to eq nil
+            found_ticket = true
+          end
+        end
+        expect(found_ticket).to be true
+      end
+    end
+  end
+end