mongoid 7.5.4 → 8.1.6

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "spec_helper"
+require_relative '../embeds_many_models'
 
 describe Mongoid::Association::Embedded::EmbeddedIn::Proxy do
 
@@ -507,7 +508,7 @@ describe Mongoid::Association::Embedded::EmbeddedIn::Proxy do
     end
   end
 
-  context "when the same class is embedded multiple times" do
+  context "when the same class is embedded multiple times; embeds_one" do
 
     let(:customer) do
       Customer.new
@@ -516,7 +517,6 @@ describe Mongoid::Association::Embedded::EmbeddedIn::Proxy do
     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
@@ -537,23 +537,110 @@ describe Mongoid::Association::Embedded::EmbeddedIn::Proxy do
 
         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")
+
+        expect(customer.home_address.addressable).to eq(customer)
+        expect(customer.work_address.addressable).to eq(customer)
       end
     end
 
     context "inverse assignment" do
 
+      it "raises an error when trying to set the association" do
+        customer.work_address = CustomerAddress.new
+
+        expect do
+          customer.work_address.addressable = customer
+        end.to raise_error(Mongoid::Errors::InvalidSetPolymorphicRelation)
+      end
+    end
+
+    context "when there is an explicit inverse_of" do
+
+      let(:customer) { EmmCustomer.new }
+
       it "correctly sets the association for the embedded class" do
-        pending 'MONGOID-5039'
+        customer.work_address = EmmCustomerAddress.new
 
-        customer.work_address = CustomerAddress.new
-        customer.work_address.addressable = customer
+        expect do
+          customer.work_address.addressable = customer
+        end.to_not raise_error
 
-        expect(customer.home_address._association.store_as).to eq("home_address")
-        expect(customer.work_address._association.store_as).to eq("work_address")
+        expect(customer.work_address.addressable).to eq(customer)
+      end
+    end
+  end
 
-        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")
+  context "when the same class is embedded multiple times; embeds_many" do
+
+    let(:customer) do
+      EmmCustomer.new
+    end
+
+    context "assignment after saving" do
+
+      it "correctly sets the association for the embedded class" do
+
+        customer.close_friends = [EmmFriend.new]
+        customer.acquaintances = [EmmFriend.new]
+
+        expect(customer.close_friends._association.store_as).to eq("close_friends")
+        expect(customer.acquaintances._association.store_as).to eq("acquaintances")
+
+        expect(customer.close_friends[0].instance_eval { _association.store_as }).to eq("close_friends")
+        expect(customer.acquaintances[0].instance_eval { _association.store_as }).to eq("acquaintances")
+
+        customer.save!
+
+        customer.close_friends = [EmmFriend.new]
+        customer.acquaintances = [EmmFriend.new]
+
+        expect(customer.close_friends._association.store_as).to eq("close_friends")
+        expect(customer.acquaintances._association.store_as).to eq("acquaintances")
+
+        expect(customer.close_friends[0].instance_eval { _association.store_as }).to eq("close_friends")
+        expect(customer.acquaintances[0].instance_eval { _association.store_as }).to eq("acquaintances")
+
+        expect(customer.close_friends[0].befriendable).to eq(customer)
+        expect(customer.acquaintances[0].befriendable).to eq(customer)
       end
     end
+
+    context "inverse assignment" do
+
+      it "raises an error when trying to set the association" do
+        customer.acquaintances = [EmmFriend.new]
+
+        expect do
+          customer.acquaintances[0].befriendable = customer
+        end.to raise_error(Mongoid::Errors::InvalidSetPolymorphicRelation)
+      end
+    end
+  end
+
+  context "when assigning a hash" do
+    let(:building_address) { BuildingAddress.new }
+
+    before do
+      building_address.building = { name: "Chrysler" }
+    end
+
+    it "creates the objects correctly" do
+      expect(building_address.building).to be_a(Building)
+      expect(building_address.building.name).to eq("Chrysler")
+    end
+  end
+
+  context "when replacing an association with a hash" do
+    let(:building_address) { BuildingAddress.new }
+
+    before do
+      building_address.building = { name: "Chrysler" }
+      building_address.building = { name: "Empire State" }
+    end
+
+    it "creates the objects correctly" do
+      expect(building_address.building).to be_a(Building)
+      expect(building_address.building.name).to eq("Empire State")
+    end
   end
 end

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

@@ -103,4 +103,116 @@ describe Mongoid::Association::Embedded::EmbedsMany::Buildable do
       end
     end
   end
+
+  context 'when the object is already associated with another object' do
+
+    context "when using <<" do
+
+      let(:person1) do
+        Person.new
+      end
+
+      let(:person2) do
+        Person.new
+      end
+
+      let(:appointment) do
+        Appointment.new
+      end
+
+      before do
+        person1.appointments << appointment
+        person2.appointments << appointment
+      end
+
+      it 'clears the object of its previous association' do
+        expect(person1.appointments).to eq([])
+        expect(person2.appointments).to eq([appointment])
+      end
+    end
+
+    context "when using concat" do
+
+      let(:person1) do
+        Person.new
+      end
+
+      let(:person2) do
+        Person.new
+      end
+
+      let(:appointment) do
+        Appointment.new
+      end
+
+      before do
+        person1.appointments.concat([appointment])
+        person2.appointments.concat([appointment])
+      end
+
+      it 'clears the object of its previous association' do
+        expect(person1.appointments).to eq([])
+        expect(person2.appointments).to eq([appointment])
+      end
+    end
+
+    context "when using =" do
+
+      let(:person1) do
+        Person.new
+      end
+
+      let(:person2) do
+        Person.new
+      end
+
+      let(:appointment) do
+        Appointment.new
+      end
+
+      let(:apts) { [ appointment ] }
+
+      before do
+        person1.appointments = apts
+        person2.appointments = apts
+        expect(apts).to eq([ appointment ])
+      end
+
+      it 'clears the object of its previous association' do
+        expect(person1.appointments).to eq([])
+        expect(person2.appointments).to eq([appointment])
+      end
+    end
+
+    context "when using = on the same document twice" do
+
+      let(:person1) do
+        Person.new
+      end
+
+      let(:person2) do
+        Person.new
+      end
+
+      let(:appointment1) do
+        Appointment.new
+      end
+
+      let(:appointment2) do
+        Appointment.new
+      end
+
+      let(:apts) { [ appointment1, appointment2 ] }
+
+      before do
+        person1.appointments = apts
+        person1.appointments = person1.appointments.reverse
+        expect(apts).to eq([ appointment1, appointment2  ])
+      end
+
+      it 'clears the object of its previous association' do
+        expect(person1.appointments).to eq([ appointment2, appointment1 ])
+      end
+    end
+  end
 end