mongoid 6.4.8 → 7.5.4

data/spec/mongoid/association/eager_spec.rb

@@ -0,0 +1,281 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Mongoid::Association::EagerLoadable 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_association) do
+        Person.reflect_on_association(:posts)
+      end
+
+      it "runs the has_many preload" do
+        expect(Mongoid::Association::Referenced::HasMany::Eager).to receive(:new).with([posts_association], docs).once.and_call_original
+
+        context.eager_load(docs)
+      end
+
+      context 'when combined with a #find_by' do
+
+        let!(:person) do
+          Person.create!(title: 'manager')
+        end
+
+        it 'executes the find_by' do
+          expect(criteria.find_by(title: 'manager')).to eq(person)
+        end
+      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_association) do
+        Person.reflect_on_association(:posts)
+      end
+
+      let(:houses_association) do
+        Person.reflect_on_association(:houses)
+      end
+
+      let(:cat_association) do
+        Person.reflect_on_association(:cat)
+      end
+
+      it "runs the has_many preload" do
+        expect(Mongoid::Association::Referenced::HasMany::Eager).to receive(:new).with([posts_association], docs).once.and_call_original
+
+        context.eager_load(docs)
+      end
+
+      it "runs the has_one preload" do
+        expect(Mongoid::Association::Referenced::HasOne::Eager).to receive(:new).with([cat_association], docs).once.and_call_original
+        context.eager_load(docs)
+      end
+
+      it "runs the has_and_belongs_to_many preload" do
+        expect(Mongoid::Association::Referenced::HasAndBelongsToMany::Eager).to receive(:new).with([houses_association], docs).once.and_call_original
+        context.eager_load(docs)
+      end
+
+      context 'when one of the eager loading definitions is nested' do
+
+        before do
+          class User
+            include Mongoid::Document
+          end
+
+          class Unit
+            include Mongoid::Document
+          end
+
+          class Booking
+            include Mongoid::Document
+            belongs_to :unit
+            has_many :vouchers
+          end
+
+          class Voucher
+            include Mongoid::Document
+            belongs_to :booking
+            belongs_to :created_by, class_name: 'User'
+          end
+        end
+
+        it 'successfully loads all relations' do
+          user = User.create!
+          unit = Unit.create!
+          booking = Booking.create!(unit: unit)
+          Voucher.create!(booking: booking, created_by: user)
+
+          vouchers = Voucher.includes(:created_by, booking: [:unit])
+
+          vouchers.each do |voucher|
+            expect(voucher.created_by).to eql(user)
+            expect(voucher.booking).to eql(booking)
+            expect(voucher.booking.unit).to eql(unit)
+          end
+        end
+      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_association) do
+        Person.reflect_on_association(:book)
+      end
+
+      let(:cat_association) do
+        Person.reflect_on_association(:cat)
+      end
+
+      it "runs the has_one preload" do
+        expect(Mongoid::Association::Referenced::HasOne::Eager).to receive(:new).with([book_association, cat_association], 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/association/embedded/cyclic_spec.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Mongoid::Association::Embedded::Cyclic do
+
+  describe ".recursively_embeds_many" do
+
+    context "when the name is inflected easily" do
+
+      let(:document) do
+        Role.new
+      end
+
+      it "creates the parent relation" do
+        expect(document).to respond_to(:parent_role)
+      end
+
+      it "creates the child relation" do
+        expect(document).to respond_to(:child_roles)
+      end
+
+      it "sets cyclic to true" do
+        expect(document.cyclic).to be true
+      end
+
+      context "when a query is executed" do
+
+        before do
+          document.save!
+        end
+
+        it "queries the database, not memory" do
+          expect(Role.first).to be_a(Role)
+        end
+      end
+    end
+
+    context "when the name is not inflected easily" do
+
+      let(:document) do
+        Entry.new
+      end
+
+      it "creates the parent relation" do
+        expect(document).to respond_to(:parent_entry)
+      end
+
+      it "creates the child relation" do
+        expect(document).to respond_to(:child_entries)
+      end
+
+      it "sets cyclic to true" do
+        expect(document.cyclic).to be true
+      end
+    end
+
+    context "when the document is namespaced" do
+
+      module Trees
+        class Node
+          include Mongoid::Document
+          recursively_embeds_many
+
+          field :name, type: String
+
+          def is_root?
+            parent_node.nil?
+          end
+        end
+      end
+
+      let(:document) do
+        Trees::Node.new
+      end
+
+      it "creates the parent relation" do
+        expect(document).to respond_to(:parent_node)
+      end
+
+      it "creates the child relation" do
+        expect(document).to respond_to(:child_nodes)
+      end
+
+      it "sets cyclic to true" do
+        expect(document.cyclic).to be true
+      end
+    end
+
+    context "when the classes are namespaced" do
+
+      let(:document) do
+        Fruits::Apple.new
+      end
+
+      it "creates the parent relation" do
+        expect(document).to respond_to(:parent_apple)
+      end
+
+      it "creates the child relation" do
+        expect(document).to respond_to(:child_apples)
+      end
+
+      it "sets cyclic to true" do
+        expect(document.cyclic).to be true
+      end
+    end
+
+    context "when cascading callbacks are enabled" do
+
+      let(:document) do
+        Fruits::Pineapple.new
+      end
+
+      it "creates relation with cascading callbacks enabled" do
+        expect(document.class.relations['child_pineapples']).to be_cascading_callbacks
+      end
+    end
+  end
+
+  describe ".recursively_embeds_one" do
+
+    let(:document) do
+      Shelf.new
+    end
+
+    it "creates the parent relation" do
+      expect(document).to respond_to(:parent_shelf)
+    end
+
+    it "creates the child relation" do
+      expect(document).to respond_to(:child_shelf)
+    end
+
+    it "sets cyclic to true" do
+      expect(document.cyclic).to be true
+    end
+
+    context "when cascading callbacks are enabled" do
+
+      let(:document) do
+        Fruits::Mango.new
+      end
+
+      it "creates relation with cascading callbacks enabled" do
+        expect(document.class.relations['child_mango']).to be_cascading_callbacks
+      end
+    end
+
+    context "when a query is executed" do
+
+      before do
+        document.save!
+      end
+
+      it "queries the database, not memory" do
+        expect(Shelf.first).to be_a(Shelf)
+      end
+    end
+  end
+
+  context "when building a namespaced hierarchy" do
+
+    let(:root) do
+      Trees::Node.new(name: "root")
+    end
+
+    let!(:child_one) do
+      root.child_nodes.build(name: "first_child")
+    end
+
+    let!(:child_two) do
+      root.child_nodes.build(name: "second_child")
+    end
+
+    it "sets the parent node" do
+      expect(child_one.parent_node).to eq(root)
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe "when initialize a model with an embedded model" do
+
+  let(:person) do
+    Person.new(pet: Pet.new)
+  end
+
+  it "has changes in the embedded model" do
+    expect(person.pet.changes).to_not be_empty
+  end
+
+  it "does not have previous_changes in the embedded model" do
+    expect(person.pet.previous_changes).to be_empty
+  end
+end
+
+describe "when creating a model with an embedded model" do
+
+  let(:person) do
+    Person.create!(pet: Pet.new)
+  end
+
+  it "does not have changes in the embedded model" do
+    expect(person.pet.changes).to be_empty
+  end
+
+  it "has previous_changes in the embedded model" do
+    expect(person.pet.previous_changes).to_not be_empty
+  end
+end
+
+describe "when embedding a model on an already saved model" do
+
+  let(:person) do
+    Person.create!
+  end
+
+  before do
+    person.pet = Pet.new
+  end
+
+  it "has not changes on the embedded model" do
+    expect(person.pet.changes).to be_empty
+  end
+
+  it "has previous changes on the embedded model" do
+    expect(person.pet.previous_changes).to_not be_empty
+  end
+
+  describe "and saving the model" do
+
+    before do
+      person.save!
+    end
+
+    it "does not have changes on the embedded model" do
+      expect(person.pet.changes).to be_empty
+    end
+
+    it "does not have previous changes on the embedded model" do
+      expect(person.pet.previous_changes).to be_empty
+    end
+  end
+end

data/spec/mongoid/association/embedded/embedded_in/binding_spec.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Mongoid::Association::Embedded::EmbeddedIn::Binding do
+
+  let(:person) do
+    Person.new
+  end
+
+  let(:name) do
+    Name.new
+  end
+
+  let(:address) do
+    Address.new
+  end
+
+  let(:name_association) do
+    Name.relations["namable"]
+  end
+
+  let(:address_association) do
+    Address.relations["addressable"]
+  end
+
+  let(:person_association) do
+    Person.relations["addresses"]
+  end
+
+  describe "#bind_one" do
+
+    context "when the child of an embeds one" do
+
+      let(:binding) do
+        described_class.new(name, person, name_association)
+      end
+
+      context "when the document is bindable" do
+
+        before do
+          binding.bind_one
+        end
+
+        it "parentizes the documents" do
+          expect(name._parent).to eq(person)
+        end
+
+        it "sets the inverse relation" do
+          expect(person.name).to eq(name)
+        end
+      end
+
+      context "when the document is not bindable" do
+
+        before do
+          person.name = name
+        end
+
+        it "does nothing" do
+          expect(name).to receive(:namable=).never
+          binding.bind_one
+        end
+      end
+    end
+
+    context "when the child of an embeds many" do
+
+      let(:binding) do
+        described_class.new(address, person, address_association)
+      end
+
+      context "when the document is bindable" do
+
+        context "when the base has no association" do
+
+          before do
+            binding.bind_one
+          end
+
+          it "parentizes the documents" do
+            expect(address._parent).to eq(person)
+          end
+
+          it "sets the inverse relation" do
+            expect(person.addresses).to include(address)
+          end
+        end
+
+        context "when the base has an association" do
+
+          before do
+            address._association = person_association
+          end
+
+          it "does not overwrite the existing association" do
+            expect(address).to receive(:_association=).never
+            binding.bind_one
+          end
+        end
+      end
+
+      context "when the document is not bindable" do
+
+        before do
+          person.addresses = [ address ]
+        end
+
+        it "does nothing" do
+          expect(address).to receive(:addressable=).never
+          binding.bind_one
+        end
+      end
+    end
+  end
+
+  describe "#unbind_one" do
+
+    context "when the child of an embeds one" do
+
+      let(:binding) do
+        described_class.new(name, person, name_association)
+      end
+
+      context "when the document is unbindable" do
+
+        before do
+          binding.bind_one
+          binding.unbind_one
+        end
+
+        it "removes the inverse relation" do
+          expect(person.name).to be_nil
+        end
+      end
+
+      context "when the document is not unbindable" do
+
+        it "does nothing" do
+          expect(name).to receive(:namable=).never
+          binding.unbind_one
+        end
+      end
+    end
+
+    context "when the child of an embeds many" do
+
+      let(:binding) do
+        described_class.new(address, person, address_association)
+      end
+
+      context "when the document is unbindable" do
+
+        before do
+          binding.bind_one
+          binding.unbind_one
+        end
+
+        it "removes the inverse relation" do
+          expect(person.addresses).to be_empty
+        end
+      end
+
+      context "when the document is not unbindable" do
+
+        it "does nothing" do
+          expect(address).to receive(:addressable=).never
+          binding.unbind_one
+        end
+      end
+    end
+  end
+end