mongoid 6.4.4 → 7.3.2

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+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,174 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+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

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require "spec_helper"
+
+describe Mongoid::Association::Embedded::EmbeddedIn::Buildable do
+
+  describe "#build" do
+
+    let(:base) do
+      double
+    end
+
+    let(:options) do
+      { }
+    end
+
+    let(:association) do
+      Mongoid::Association::Embedded::EmbeddedIn.new(Person, :addresses, options)
+    end
+
+    context "when a document is provided" do
+
+      let(:object) do
+        double
+      end
+
+      let(:document) do
+        association.build(base, object)
+      end
+
+      it "returns the document" do
+        expect(document).to eq(object)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,560 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require "spec_helper"
+
+describe Mongoid::Association::Embedded::EmbeddedIn::Proxy do
+
+  describe "#===" do
+
+    let(:base) do
+      Name.new
+    end
+
+    let(:target) do
+      Person.new
+    end
+
+    let(:association) do
+      Name.relations["namable"]
+    end
+
+    let(:relation) do
+      described_class.new(base, target, association)
+    end
+
+    context "when the proxied document is same class" do
+
+      context "when the document is a different instance" do
+
+        it "returns false" do
+          expect((relation === Person.new)).to be false
+        end
+      end
+
+      context "when the document is the same instance" do
+
+        it "returns true" do
+          expect((relation === target)).to be true
+        end
+      end
+    end
+  end
+
+  describe "#=" do
+
+    context "when the inverse of an embeds one" do
+
+      context "when the child is a new record" do
+
+        let(:person) do
+          Person.new
+        end
+
+        let(:name) do
+          Name.new
+        end
+
+        before do
+          name.namable = person
+        end
+
+        it "sets the target of the relation" do
+          expect(name.namable).to eq(person)
+        end
+
+        it "sets the base on the inverse relation" do
+          expect(person.name).to eq(name)
+        end
+
+        it "sets the same instance on the inverse relation" do
+          expect(person.name).to eql(name)
+        end
+
+        it "does not save the target" do
+          expect(person).to_not be_persisted
+        end
+      end
+
+      context "when the parent is not a new record" do
+
+        let(:person) do
+          Person.create
+        end
+
+        let(:name) do
+          Name.new
+        end
+
+        before do
+          name.namable = person
+        end
+
+        it "sets the target of the relation" do
+          expect(name.namable).to eq(person)
+        end
+
+        it "sets the base on the inverse relation" do
+          expect(person.name).to eq(name)
+        end
+
+        it "sets the same instance on the inverse relation" do
+          expect(person.name).to eql(name)
+        end
+
+        it "does not save the base" do
+          expect(name).to_not be_persisted
+        end
+      end
+    end
+
+    context "when the inverse of an embeds many" do
+
+      context "when the child is a new record" do
+
+        let(:person) do
+          Person.new
+        end
+
+        let(:address) do
+          Address.new
+        end
+
+        before do
+          address.addressable = person
+        end
+
+        it "sets the target of the relation" do
+          expect(address.addressable).to eq(person)
+        end
+
+        it "appends the base on the inverse relation" do
+          expect(person.addresses).to eq([ address ])
+        end
+
+        it "sets the same instance in the inverse relation" do
+          expect(person.addresses.first).to eql(address)
+        end
+
+        it "does not save the target" do
+          expect(person).to_not be_persisted
+        end
+      end
+
+      context "when the parent is not a new record" do
+
+        let!(:person) do
+          Person.create!
+        end
+
+        let(:address) do
+          Address.new
+        end
+
+        before do
+          address.addressable = person
+        end
+
+        it "sets the target of the relation" do
+          expect(address.addressable).to eq(person)
+        end
+
+        it "sets the same instance in the inverse relation" do
+          expect(person.addresses.first).to eql(address)
+        end
+
+        it "appends the base on the inverse relation" do
+          expect(person.addresses).to eq([ address ])
+        end
+      end
+    end
+  end
+
+  describe "#= nil" do
+
+    context "when the inverse of an embeds one" do
+
+      context "when the parent is a new record" do
+
+        let(:person) do
+          Person.new
+        end
+
+        let(:name) do
+          Name.new
+        end
+
+        before do
+          name.namable = person
+          name.namable = nil
+        end
+
+        it "sets the relation to nil" do
+          expect(name.namable).to be_nil
+        end
+
+        it "removes the inverse relation" do
+          expect(person.name).to be_nil
+        end
+      end
+
+      context "when the inverse is already nil" do
+
+        let(:person) do
+          Person.new
+        end
+
+        let(:name) do
+          Name.new
+        end
+
+        before do
+          name.namable = nil
+        end
+
+        it "sets the relation to nil" do
+          expect(name.namable).to be_nil
+        end
+
+        it "removes the inverse relation" do
+          expect(person.name).to be_nil
+        end
+      end
+
+      context "when the documents are not new records" do
+
+        let(:person) do
+          Person.create
+        end
+
+        let(:name) do
+          Name.new
+        end
+
+        before do
+          name.namable = person
+          name.namable = nil
+        end
+
+        it "sets the relation to nil" do
+          expect(name.namable).to be_nil
+        end
+
+        it "removed the inverse relation" do
+          expect(person.name).to be_nil
+        end
+
+        it "deletes the child document" do
+          expect(name).to be_destroyed
+        end
+      end
+    end
+
+    context "when the inverse of an embeds many" do
+
+      context "when the parent is a new record" do
+
+        let(:person) do
+          Person.new
+        end
+
+        let(:address) do
+          Address.new
+        end
+
+        before do
+          address.addressable = person
+          address.addressable = nil
+        end
+
+        it "sets the relation to nil" do
+          expect(address.addressable).to be_nil
+        end
+
+        it "removes the inverse relation" do
+          expect(person.addresses).to be_empty
+        end
+      end
+
+      context "when the inverse is already nil" do
+
+        let(:address) do
+          Address.new
+        end
+
+        before do
+          address.addressable = nil
+        end
+
+        it "sets the relation to nil" do
+          expect(address.addressable).to be_nil
+        end
+      end
+
+      context "when the documents are not new records" do
+
+        let(:person) do
+          Person.create
+        end
+
+        let(:address) do
+          Address.new
+        end
+
+        before do
+          address.addressable = person
+          address.addressable = nil
+        end
+
+        it "sets the relation to nil" do
+          expect(address.addressable).to be_nil
+        end
+
+        it "removed the inverse relation" do
+          expect(person.addresses).to be_empty
+        end
+
+        it "deletes the child document" do
+          expect(address).to be_destroyed
+        end
+      end
+
+      context "when a child already exists on the parent" do
+
+        let(:person) do
+          Person.create
+        end
+
+        let(:address_one) do
+          Address.new(street: "first")
+        end
+
+        let(:address_two) do
+          Address.new(street: "second")
+        end
+
+        before do
+          person.addresses = [ address_one, address_two ]
+          address_one.addressable = nil
+        end
+
+        it "sets the relation to nil" do
+          expect(address_one.addressable).to be_nil
+        end
+
+        it "removed the inverse relation" do
+          expect(person.addresses).to eq([ address_two ])
+        end
+
+        it "deletes the child document" do
+          expect(address_one).to be_destroyed
+        end
+
+        it "reindexes the children" do
+          expect(address_two._index).to eq(0)
+        end
+      end
+    end
+  end
+
+  describe ".embedded?" do
+
+    it "returns true" do
+      expect(described_class).to be_embedded
+    end
+  end
+
+  describe "#respond_to?" do
+
+    let(:person) do
+      Person.new
+    end
+
+    let!(:name) do
+      person.build_name(first_name: "Tony")
+    end
+
+    let(:document) do
+      name.namable
+    end
+
+    Mongoid::Document.public_instance_methods(true).each do |method|
+
+      context "when checking #{method}" do
+
+        it "returns true" do
+          expect(document.respond_to?(method)).to be true
+        end
+      end
+    end
+  end
+
+  context "when creating the tree through initialization" do
+
+    let!(:person) do
+      Person.create
+    end
+
+    let!(:address) do
+      Address.create(addressable: person)
+    end
+
+    let!(:first_location) do
+      Location.create(address: address)
+    end
+
+    let!(:second_location) do
+      Location.create(address: address)
+    end
+
+    it "saves the child" do
+      expect(Person.last.addresses.last).to eq(address)
+    end
+
+    it "indexes the child" do
+      expect(address._index).to eq(0)
+    end
+
+    it "saves the first location with the correct index" do
+      expect(first_location._index).to eq(0)
+    end
+
+    it "saves the second location with the correct index" do
+      expect(second_location._index).to eq(1)
+    end
+
+    it "has the locations in the association array" do
+      expect(Person.last.addresses.last.locations).to eq(
+                                                          [first_location, second_location]
+                                                      )
+    end
+  end
+
+  context "when instantiating a new child with a persisted parent" do
+
+    let!(:person) do
+      Person.create
+    end
+
+    let!(:address) do
+      Address.new(addressable: person)
+    end
+
+    let!(:location) do
+      Location.new(address: address)
+    end
+
+    it "does not save the child" do
+      expect(address).to_not be_persisted
+    end
+
+    it "does not save the deeply embedded children" do
+      expect(address.locations.first).to_not be_persisted
+    end
+  end
+
+  context "when replacing the relation with another" do
+
+    let!(:person) do
+      Person.create
+    end
+
+    let!(:person_two) do
+      Person.create
+    end
+
+    let!(:address) do
+      person.addresses.create(street: "Kotbusser Damm")
+    end
+
+    let!(:name) do
+      person_two.create_name(first_name: "Syd")
+    end
+
+    before do
+      name.namable = address.addressable
+      name.namable.save
+    end
+
+    it "sets the new parent" do
+      expect(name.namable).to eq(person)
+    end
+
+    it "removes the previous parent relation" do
+      expect(person_two.name).to be_nil
+    end
+
+    it "sets the new child relation" do
+      expect(person.name).to eq(name)
+    end
+
+    context "when reloading" do
+
+      before do
+        person.reload
+      end
+
+      it "sets the new parent" do
+        expect(name.namable).to eq(person)
+      end
+
+      it "removes the previous parent relation" do
+        expect(person_two.name).to be_nil
+      end
+
+      it "sets the new child relation" do
+        expect(person.name).to eq(name)
+      end
+    end
+  end
+
+  context "when the same class is embedded multiple times" do
+
+    let(:customer) do
+      Customer.new
+    end
+
+    context "assignment after saving" do
+
+      it "correctly sets the association for the embedded class" do
+        pending 'MONGOID-5039'
+
+        customer.home_address = CustomerAddress.new
+        customer.work_address = CustomerAddress.new
+
+        expect(customer.home_address._association.store_as).to eq("home_address")
+        expect(customer.work_address._association.store_as).to eq("work_address")
+
+        expect(customer.home_address.instance_eval { _association.store_as }).to eq("home_address")
+        expect(customer.work_address.instance_eval { _association.store_as }).to eq("work_address")
+
+        customer.save!
+
+        customer.home_address = CustomerAddress.new
+        customer.work_address = CustomerAddress.new
+
+        expect(customer.home_address._association.store_as).to eq("home_address")
+        expect(customer.work_address._association.store_as).to eq("work_address")
+
+        expect(customer.home_address.instance_eval { _association.store_as }).to eq("home_address")
+        expect(customer.work_address.instance_eval { _association.store_as }).to eq("work_address")
+      end
+    end
+
+    context "inverse assignment" do
+
+      it "correctly sets the association for the embedded class" do
+        pending 'MONGOID-5039'
+
+        customer.work_address = CustomerAddress.new
+        customer.work_address.addressable = customer
+
+        expect(customer.home_address._association.store_as).to eq("home_address")
+        expect(customer.work_address._association.store_as).to eq("work_address")
+
+        expect(customer.home_address.instance_eval { _association.store_as }).to eq("home_address")
+        expect(customer.work_address.instance_eval { _association.store_as }).to eq("work_address")
+      end
+    end
+  end
+end