mongoid 3.1.6 → 4.0.2

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

data/spec/mongoid/relations/embedded/dirty_spec.rb

@@ -7,11 +7,11 @@ describe "when initialize a model with an embedded model" do
   end
 
   it "has changes in the embedded model" do
-    person.pet.changes.should_not be_empty
+    expect(person.pet.changes).to_not be_empty
   end
 
   it "does not have previous_changes in the embedded model" do
-    person.pet.previous_changes.should be_empty
+    expect(person.pet.previous_changes).to be_empty
   end
 end
 
@@ -22,11 +22,11 @@ describe "when creating a model with an embedded model" do
   end
 
   it "does not have changes in the embedded model" do
-    person.pet.changes.should be_empty
+    expect(person.pet.changes).to be_empty
   end
 
   it "has previous_changes in the embedded model" do
-    person.pet.previous_changes.should_not be_empty
+    expect(person.pet.previous_changes).to_not be_empty
   end
 end
 
@@ -41,11 +41,11 @@ describe "when embedding a model on an already saved model" do
   end
 
   it "has not changes on the embedded model" do
-    person.pet.changes.should be_empty
+    expect(person.pet.changes).to be_empty
   end
 
   it "has previous changes on the embedded model" do
-    person.pet.previous_changes.should_not be_empty
+    expect(person.pet.previous_changes).to_not be_empty
   end
 
   describe "and saving the model" do
@@ -55,11 +55,11 @@ describe "when embedding a model on an already saved model" do
     end
 
     it "does not have changes on the embedded model" do
-      person.pet.changes.should be_empty
+      expect(person.pet.changes).to be_empty
     end
 
     it "does not have previous changes on the embedded model" do
-      person.pet.previous_changes.should be_empty
+      expect(person.pet.previous_changes).to be_empty
     end
   end
 end

data/spec/mongoid/relations/embedded/in_spec.rb

@@ -25,14 +25,14 @@ describe Mongoid::Relations::Embedded::In do
       context "when the document is a different instance" do
 
         it "returns false" do
-          (relation === Person.new).should be_false
+          expect((relation === Person.new)).to be false
         end
       end
 
       context "when the document is the same instance" do
 
         it "returns true" do
-          (relation === target).should be_true
+          expect((relation === target)).to be true
         end
       end
     end
@@ -57,19 +57,19 @@ describe Mongoid::Relations::Embedded::In do
         end
 
         it "sets the target of the relation" do
-          name.namable.should eq(person)
+          expect(name.namable).to eq(person)
         end
 
         it "sets the base on the inverse relation" do
-          person.name.should eq(name)
+          expect(person.name).to eq(name)
         end
 
         it "sets the same instance on the inverse relation" do
-          person.name.should eql(name)
+          expect(person.name).to eql(name)
         end
 
         it "does not save the target" do
-          person.should_not be_persisted
+          expect(person).to_not be_persisted
         end
       end
 
@@ -88,19 +88,19 @@ describe Mongoid::Relations::Embedded::In do
         end
 
         it "sets the target of the relation" do
-          name.namable.should eq(person)
+          expect(name.namable).to eq(person)
         end
 
         it "sets the base on the inverse relation" do
-          person.name.should eq(name)
+          expect(person.name).to eq(name)
         end
 
         it "sets the same instance on the inverse relation" do
-          person.name.should eql(name)
+          expect(person.name).to eql(name)
         end
 
         it "does not save the base" do
-          name.should_not be_persisted
+          expect(name).to_not be_persisted
         end
       end
     end
@@ -122,19 +122,19 @@ describe Mongoid::Relations::Embedded::In do
         end
 
         it "sets the target of the relation" do
-          address.addressable.should eq(person)
+          expect(address.addressable).to eq(person)
         end
 
         it "appends the base on the inverse relation" do
-          person.addresses.should eq([ address ])
+          expect(person.addresses).to eq([ address ])
         end
 
         it "sets the same instance in the inverse relation" do
-          person.addresses.first.should eql(address)
+          expect(person.addresses.first).to eql(address)
         end
 
         it "does not save the target" do
-          person.should_not be_persisted
+          expect(person).to_not be_persisted
         end
       end
 
@@ -153,15 +153,15 @@ describe Mongoid::Relations::Embedded::In do
         end
 
         it "sets the target of the relation" do
-          address.addressable.should eq(person)
+          expect(address.addressable).to eq(person)
         end
 
         it "sets the same instance in the inverse relation" do
-          person.addresses.first.should eql(address)
+          expect(person.addresses.first).to eql(address)
         end
 
         it "appends the base on the inverse relation" do
-          person.addresses.should eq([ address ])
+          expect(person.addresses).to eq([ address ])
         end
       end
     end
@@ -187,11 +187,11 @@ describe Mongoid::Relations::Embedded::In do
         end
 
         it "sets the relation to nil" do
-          name.namable.should be_nil
+          expect(name.namable).to be_nil
         end
 
         it "removes the inverse relation" do
-          person.name.should be_nil
+          expect(person.name).to be_nil
         end
       end
 
@@ -210,11 +210,11 @@ describe Mongoid::Relations::Embedded::In do
         end
 
         it "sets the relation to nil" do
-          name.namable.should be_nil
+          expect(name.namable).to be_nil
         end
 
         it "removes the inverse relation" do
-          person.name.should be_nil
+          expect(person.name).to be_nil
         end
       end
 
@@ -234,15 +234,15 @@ describe Mongoid::Relations::Embedded::In do
         end
 
         it "sets the relation to nil" do
-          name.namable.should be_nil
+          expect(name.namable).to be_nil
         end
 
         it "removed the inverse relation" do
-          person.name.should be_nil
+          expect(person.name).to be_nil
         end
 
         it "deletes the child document" do
-          name.should be_destroyed
+          expect(name).to be_destroyed
         end
       end
     end
@@ -265,11 +265,11 @@ describe Mongoid::Relations::Embedded::In do
         end
 
         it "sets the relation to nil" do
-          address.addressable.should be_nil
+          expect(address.addressable).to be_nil
         end
 
         it "removes the inverse relation" do
-          person.addresses.should be_empty
+          expect(person.addresses).to be_empty
         end
       end
 
@@ -284,7 +284,7 @@ describe Mongoid::Relations::Embedded::In do
         end
 
         it "sets the relation to nil" do
-          address.addressable.should be_nil
+          expect(address.addressable).to be_nil
         end
       end
 
@@ -304,15 +304,15 @@ describe Mongoid::Relations::Embedded::In do
         end
 
         it "sets the relation to nil" do
-          address.addressable.should be_nil
+          expect(address.addressable).to be_nil
         end
 
         it "removed the inverse relation" do
-          person.addresses.should be_empty
+          expect(person.addresses).to be_empty
         end
 
         it "deletes the child document" do
-          address.should be_destroyed
+          expect(address).to be_destroyed
         end
       end
 
@@ -336,19 +336,19 @@ describe Mongoid::Relations::Embedded::In do
         end
 
         it "sets the relation to nil" do
-          address_one.addressable.should be_nil
+          expect(address_one.addressable).to be_nil
         end
 
         it "removed the inverse relation" do
-          person.addresses.should eq([ address_two ])
+          expect(person.addresses).to eq([ address_two ])
         end
 
         it "deletes the child document" do
-          address_one.should be_destroyed
+          expect(address_one).to be_destroyed
         end
 
         it "reindexes the children" do
-          address_two._index.should eq(0)
+          expect(address_two._index).to eq(0)
         end
       end
     end
@@ -373,28 +373,28 @@ describe Mongoid::Relations::Embedded::In do
     end
 
     it "returns the embedded one builder" do
-      described_class.builder(base, metadata, target).should be_a(builder_klass)
+      expect(described_class.builder(base, metadata, target)).to be_a(builder_klass)
     end
   end
 
   describe ".embedded?" do
 
     it "returns true" do
-      described_class.should be_embedded
+      expect(described_class).to be_embedded
     end
   end
 
   describe ".foreign_key_suffix" do
 
     it "returns nil" do
-      described_class.foreign_key_suffix.should be_nil
+      expect(described_class.foreign_key_suffix).to be_nil
     end
   end
 
   describe ".macro" do
 
     it "returns embeds_one" do
-      described_class.macro.should eq(:embedded_in)
+      expect(described_class.macro).to eq(:embedded_in)
     end
   end
 
@@ -413,8 +413,7 @@ describe Mongoid::Relations::Embedded::In do
     end
 
     it "returns the single nested builder" do
-      described_class.nested_builder(metadata, attributes, {}).should
-        be_a(nested_builder_klass)
+      expect(described_class.nested_builder(metadata, attributes, {})).to be_a(nested_builder_klass)
     end
   end
 
@@ -437,7 +436,7 @@ describe Mongoid::Relations::Embedded::In do
       context "when checking #{method}" do
 
         it "returns true" do
-          document.respond_to?(method).should be_true
+          expect(document.respond_to?(method)).to be true
         end
       end
     end
@@ -446,8 +445,8 @@ describe Mongoid::Relations::Embedded::In do
   describe ".valid_options" do
 
     it "returns the valid options" do
-      described_class.valid_options.should eq(
-        [ :autobuild, :cyclic, :polymorphic ]
+      expect(described_class.valid_options).to eq(
+        [ :autobuild, :cyclic, :polymorphic, :touch ]
       )
     end
   end
@@ -455,7 +454,7 @@ describe Mongoid::Relations::Embedded::In do
   describe ".validation_default" do
 
     it "returns false" do
-      described_class.validation_default.should be_false
+      expect(described_class.validation_default).to be false
     end
   end
 
@@ -478,23 +477,23 @@ describe Mongoid::Relations::Embedded::In do
     end
 
     it "saves the child" do
-      Person.last.addresses.last.should eq(address)
+      expect(Person.last.addresses.last).to eq(address)
     end
 
     it "indexes the child" do
-      address._index.should eq(0)
+      expect(address._index).to eq(0)
     end
 
     it "saves the first location with the correct index" do
-      first_location._index.should eq(0)
+      expect(first_location._index).to eq(0)
     end
 
     it "saves the second location with the correct index" do
-      second_location._index.should eq(1)
+      expect(second_location._index).to eq(1)
     end
 
     it "has the locations in the association array" do
-      Person.last.addresses.last.locations.should eq(
+      expect(Person.last.addresses.last.locations).to eq(
         [first_location, second_location]
       )
     end
@@ -515,11 +514,11 @@ describe Mongoid::Relations::Embedded::In do
     end
 
     it "does not save the child" do
-      address.should_not be_persisted
+      expect(address).to_not be_persisted
     end
 
     it "does not save the deeply embedded children" do
-      address.locations.first.should_not be_persisted
+      expect(address.locations.first).to_not be_persisted
     end
   end
 
@@ -547,15 +546,15 @@ describe Mongoid::Relations::Embedded::In do
     end
 
     it "sets the new parent" do
-      name.namable.should eq(person)
+      expect(name.namable).to eq(person)
     end
 
     it "removes the previous parent relation" do
-      person_two.name.should be_nil
+      expect(person_two.name).to be_nil
     end
 
     it "sets the new child relation" do
-      person.name.should eq(name)
+      expect(person.name).to eq(name)
     end
 
     context "when reloading" do
@@ -565,15 +564,15 @@ describe Mongoid::Relations::Embedded::In do
       end
 
       it "sets the new parent" do
-        name.namable.should eq(person)
+        expect(name.namable).to eq(person)
       end
 
       it "removes the previous parent relation" do
-        person_two.name.should be_nil
+        expect(person_two.name).to be_nil
       end
 
       it "sets the new child relation" do
-        person.name.should eq(name)
+        expect(person.name).to eq(name)
       end
     end
   end