mongoid 7.1.0 → 7.1.6

data/spec/mongoid/association/embedded/embeds_many_models.rb

@@ -18,6 +18,25 @@ class EmmLegislator
   field :b, type: Integer, default: 0
 end
 
+# Models with associations with :class_name as a :: prefixed string
+
+class EmmCcCongress
+  include Mongoid::Document
+
+  embeds_many :legislators, class_name: '::EmmCcLegislator'
+
+  field :name, type: String
+end
+
+class EmmCcLegislator
+  include Mongoid::Document
+
+  embedded_in :congress, class_name: '::EmmCcCongress'
+
+  field :a, type: Integer, default: 0
+  field :b, type: Integer, default: 0
+end
+
 class EmmManufactory
   include Mongoid::Document
 

data/spec/mongoid/association/embedded/embeds_many_spec.rb

@@ -649,6 +649,16 @@ describe Mongoid::Association::Embedded::EmbedsMany do
       it 'returns the class name option' do
         expect(association.klass).to eq(_class)
       end
+
+      context 'when the class name is prefixed with ::' do
+        let(:options) do
+          { class_name: '::OtherEmbeddedObject' }
+        end
+
+        it 'returns the class name option' do
+          expect(association.klass).to eq(_class)
+        end
+      end
     end
 
     context 'when the class_name option is not specified' do

data/spec/mongoid/association/embedded/embeds_one_spec.rb

@@ -456,8 +456,6 @@ describe Mongoid::Association::Embedded::EmbedsOne do
             end
 
             it 'returns the inverse in an array' do
-              pending 'MONGOID-4751'
-
               inverses = association.inverses
               expect(inverses).to eq([:parent])
             end

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

@@ -114,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
@@ -146,18 +146,201 @@ 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
+
+      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
 
-      let!(:rating) do
-        movie.ratings.create(value: 10)
+      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
 
-      it "raises an error" do
-        expect {
-          Rating.includes(:ratable).last
-        }.to raise_error(Mongoid::Errors::EagerLoad)
+      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
 

data/spec/mongoid/association/referenced/has_and_belongs_to_many/proxy_spec.rb

@@ -1757,6 +1757,43 @@ describe Mongoid::Association::Referenced::HasAndBelongsToMany::Proxy do
       end
     end
 
+    describe "#any?" do
+
+      let(:person) do
+        Person.create
+      end
+
+      context "when nothing exists on the relation" do
+
+        context "when no document is added" do
+
+          let!(:sandwich) do
+            Sandwich.create!
+          end
+
+          it "returns false" do
+            expect(sandwich.meats.any?).to be false
+          end
+        end
+
+        context "when the document is destroyed" do
+
+          before do
+            Meat.create!
+          end
+
+          let!(:sandwich) do
+            Sandwich.create!
+          end
+
+          it "returns false" do
+            sandwich.destroy
+            expect(sandwich.meats.any?).to be false
+          end
+        end
+      end
+    end
+
     context "when documents have been persisted" do
 
       let!(:preference) do
@@ -1846,6 +1883,107 @@ describe Mongoid::Association::Referenced::HasAndBelongsToMany::Proxy do
     end
   end
 
+  describe "#any?" do
+
+    let(:sandwich) do
+      Sandwich.create
+    end
+
+    context "when nothing exists on the relation" do
+
+      context "when no document is added" do
+
+        let!(:sandwich) do
+          Sandwich.create!
+        end
+
+        it "returns false" do
+          expect(sandwich.meats.any?).to be false
+        end
+      end
+
+      context "when the document is destroyed" do
+
+        before do
+          Meat.create!
+        end
+
+        let!(:sandwich) do
+          Sandwich.create!
+        end
+
+        it "returns false" do
+          sandwich.destroy
+          expect(sandwich.meats.any?).to be false
+        end
+      end
+    end
+
+    context "when appending to a relation and _loaded/_unloaded are empty" do
+
+      let!(:sandwich) do
+        Sandwich.create!
+      end
+
+      before do
+        sandwich.meats << Meat.new
+      end
+
+      it "returns true" do
+        expect(sandwich.meats.any?).to be true
+      end
+    end
+
+    context "when appending to a relation in a transaction" do
+      require_transaction_support
+
+      let!(:sandwich) do
+        Sandwich.create!
+      end
+
+      it "returns true" do
+        sandwich.with_session do |session|
+          session.with_transaction do
+            expect{ sandwich.meats << Meat.new }.to_not raise_error
+            expect(sandwich.meats.any?).to be true
+          end
+        end
+      end
+    end
+
+    context "when documents have been persisted" do
+
+      let!(:meat) do
+        sandwich.meats.create
+      end
+
+      it "returns true" do
+        expect(sandwich.meats.any?).to be true
+      end
+    end
+
+    context "when documents have not been persisted" do
+
+      let!(:meat) do
+        sandwich.meats.build
+      end
+
+      it "returns false" do
+        expect(sandwich.meats.any?).to be true
+      end
+    end
+
+    context "when new documents exist in the database" do
+      before do
+        Meat.create(sandwiches: [sandwich])
+      end
+
+      it "returns true" do
+        expect(sandwich.meats.any?).to be true
+      end
+    end
+  end
+
   [ :create, :create! ].each do |method|
 
     describe "##{method}" do
@@ -2689,7 +2827,8 @@ describe Mongoid::Association::Referenced::HasAndBelongsToMany::Proxy do
         expect(preferences).to eq([ preference_one ])
       end
 
-      context 'when providing a collation', if: collation_supported? do
+      context 'when providing a collation' do
+        min_server_version '3.4'
 
         let(:preferences) do
           person.preferences.where(name: "FIRST").collation(locale: 'en_US', strength: 2).to_a

data/spec/mongoid/association/referenced/has_many/enumerable_spec.rb

@@ -256,6 +256,111 @@ describe Mongoid::Association::Referenced::HasMany::Targets::Enumerable do
         end
       end
     end
+
+    context "when the documents have been loaded" do
+      let(:criteria) do
+        Post.where(person_id: person.id)
+      end
+
+      let!(:enumerable) do
+        described_class.new(criteria)
+      end
+
+      before do
+        enumerable.load_all!
+      end
+
+      it "is _loaded" do
+        expect(enumerable._loaded?).to be true
+      end
+
+      context "when a block is given" do
+        it "returns true when the predicate is true" do
+          expect(
+            enumerable.any? { |doc| true }
+          ).to be true
+        end
+
+        it "returns false when the predicate is false" do
+          expect(
+            enumerable.any? { |doc| false }
+          ).to be false
+        end
+      end
+
+      context "when an argument is given" do
+        ruby_version_gte '2.5'
+
+        it "returns true when the argument is true" do
+          expect(enumerable.any?(Post)).to be true
+        end
+
+        it "returns false when the argument is false" do
+          expect(enumerable.any?(Sandwich)).to be false
+        end
+      end
+
+      context "when both an argument and a block are given" do
+        ruby_version_gte '2.5'
+
+        it "gives precedence to the pattern" do
+          expect(
+            enumerable.any?(Post) { |doc| false }
+          ).to be true
+        end
+      end
+    end
+
+    context "when the documents are not loaded" do
+
+      let(:criteria) do
+        Post.where(person_id: person.id)
+      end
+
+      let!(:enumerable) do
+        described_class.new(criteria)
+      end
+
+      it "is not _loaded" do
+        expect(enumerable._loaded?).to be false
+      end
+
+      context "when a block is given" do
+        it "returns true when the predicate is true" do
+          expect(
+            enumerable.any? { |doc| true }
+          ).to be true
+        end
+
+        it "returns false when the predicate is false" do
+          expect(
+            enumerable.any? { |doc| false }
+          ).to be false
+        end
+      end
+
+      context "when an argument is given" do
+        ruby_version_gte '2.5'
+
+        it "returns true when the argument is true" do
+          expect(enumerable.any?(Post)).to be true
+        end
+
+        it "returns false when the argument is false" do
+          expect(enumerable.any?(Sandwich)).to be false
+        end
+      end
+
+      context "when both an argument and a block are given" do
+        ruby_version_gte '2.5'
+
+        it "gives precedence to the pattern" do
+          expect(
+            enumerable.any?(Post) { |doc| false }
+          ).to be true
+        end
+      end
+    end
   end
 
   describe "#clear" do