mongoid 7.1.0.rc0 → 7.2.0.rc1

data/spec/mongoid/association/depending_spec.rb

@@ -489,7 +489,7 @@ describe Mongoid::Association::Depending do
           end
         end
 
-        context "when dependent is restrict_with_error" do
+        context "when dependent is restrict_with_exception" do
 
           context "when restricting a references many" do
 
@@ -825,44 +825,96 @@ describe Mongoid::Association::Depending do
 
   context 'when the strategy is :restrict_with_error' do
 
-    let(:person) do
-      Person.new
-    end
+    context "when restricting a one-to-many" do
+      
+      let(:person) do
+        Person.new
+      end
+  
+      let(:post) do
+        Post.new
+      end
 
-    let(:post) do
-      Post.new
-    end
+      let!(:association) do
+        Person.has_many :restrictable_posts, class_name: "Post", dependent: :restrict_with_error
+      end
 
-    let!(:association) do
-      Person.has_many :restrictable_posts, class_name: "Post", dependent: :restrict_with_error
-    end
+      after do
+        Person.dependents.delete(association)
+      end
 
-    after do
-      Person.dependents.delete(association)
-    end
+      context 'when there are related objects' do
 
-    context 'when there are related objects' do
+        before do
+          person.restrictable_posts << post
+        end
 
-      before do
-        person.restrictable_posts << post
+        it 'adds an error to the parent object' do
+          expect(person.delete).to be(false)
+  
+          person.errors[:restrictable_posts].first.should ==
+            "is not empty and prevents the document from being destroyed"
+        end
       end
 
-      it 'adds an error to the parent object' do
-        expect(person.delete).to be(false)
-        expect(person.errors[:restrictable_posts].first).to be(
-          Mongoid::Association::Depending::RESTRICT_ERROR_MSG)
+      context 'when there are no related objects' do
+
+        before do
+          expect(post).to receive(:delete).never
+          expect(post).to receive(:destroy).never
+        end
+
+        it 'deletes the object and leaves the other one intact' do
+          expect(person.delete).to be(true)
+        end
+      end
+
+      context 'when deleted inside a transaction' do
+        require_transaction_support
+        
+        before do
+          person.restrictable_posts << post
+        end
+
+        it 'doesn\'t raise an exception' do
+          person.with_session do |session|
+            session.with_transaction do 
+              expect { person.destroy }.to_not raise_error
+            end
+          end
+        end
       end
     end
 
-    context 'when there are no related objects' do
+    context "when restricting a many to many" do
 
-      before do
-        expect(post).to receive(:delete).never
-        expect(post).to receive(:destroy).never
+      let!(:association) do
+        Person.has_and_belongs_to_many :houses, dependent: :restrict_with_error
       end
 
-      it 'deletes the object and leaves the other one intact' do
-        expect(person.delete).to be(true)
+      after do
+        Person.dependents.delete(association)
+        Person.has_and_belongs_to_many :houses, validate: false
+      end
+
+      let(:person) do
+        Person.new houses: [House.new]
+      end
+
+      it "returns false" do
+        expect(person.destroy).to be false
+      end
+
+      context "when inside a transaction" do
+        require_transaction_support
+        
+        it 'doesn\'t raise an exception inside a transaction' do
+          person.with_session do |session|
+            session.with_transaction do
+              expect { person.destroy }.to_not raise_error
+            end
+          end
+        end
       end
     end
   end

data/spec/mongoid/association/embedded/embeds_many/proxy_spec.rb

@@ -1402,6 +1402,39 @@ describe Mongoid::Association::Embedded::EmbedsMany::Proxy do
     end
   end
 
+  describe "#any?" do
+
+    let(:person) do
+      Person.create
+    end
+
+    context "when documents are persisted" do
+      before do
+        person.addresses.create(street: "Upper")
+      end
+
+      it "returns true" do
+        expect(person.addresses.any?).to be true
+      end
+    end
+    
+    context "when documents are not persisted" do
+      before do
+        person.addresses.build(street: "Bond")
+      end
+      
+      it "returns true" do
+        expect(person.addresses.any?).to be true
+      end
+    end
+
+    context "when documents are not created" do
+      it "returns false" do
+        expect(person.addresses.any?).to be false
+      end
+    end
+  end
+
   describe "#create" do
 
     context "when providing multiple attributes" do

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

@@ -3,6 +3,7 @@
 
 class EmmCongress
   include Mongoid::Document
+  include Mongoid::Timestamps
 
   embeds_many :legislators, class_name: 'EmmLegislator'
 
@@ -18,6 +19,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_models.rb

@@ -3,6 +3,7 @@
 
 class EomParent
   include Mongoid::Document
+  include Mongoid::Timestamps
 
   embeds_one :child, class_name: 'EomChild'
 

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