mongoid 7.5.1 → 8.1.4

data/spec/mongoid/contextual/none_spec.rb

@@ -54,24 +54,35 @@ describe Mongoid::Contextual::None do
   end
 
   describe "#pluck" do
-    it "returns an empty array" do
-      expect(context.pluck(:id)).to eq([])
+
+    context "when plucking one field" do
+      it "returns an empty array" do
+        expect(context.pluck(:id)).to eq([])
+      end
+    end
+
+    context "when plucking multiple fields" do
+      it "returns an empty array" do
+        expect(context.pluck(:id, :foo)).to eq([])
+      end
     end
   end
 
-  describe "#first" do
-    it "returns nil" do
-      expect(context.first).to be_nil
+  describe "#pick" do
+    it "returns an empty array" do
+      expect(context.pick(:id)).to eq(nil)
     end
+  end
 
-    it "doen't raise when passing options" do
-      expect do
-        context.first(id_sort: :none)
-      end.to_not raise_error
+  describe "#tally" do
+    it "returns an empty hash" do
+      expect(context.tally(:id)).to eq({})
     end
+  end
 
-    it "returns nil when passing a hash" do
-      expect(context.first(id_sort: :none)).to be_nil
+  describe "#first" do
+    it "returns nil" do
+      expect(context.first).to be_nil
     end
 
     it "returns [] when passing a limit" do
@@ -79,19 +90,17 @@ describe Mongoid::Contextual::None do
     end
   end
 
-  describe "#last" do
-    it "returns nil" do
-      expect(context.last).to be_nil
-    end
-
-    it "doen't raise when passing options" do
+  describe "#first!" do
+    it "raises an error" do
       expect do
-        context.last(id_sort: :none)
-      end.to_not raise_error
+        context.first!
+      end.to raise_error(Mongoid::Errors::DocumentNotFound, /Could not find a document of class Band./)
     end
+  end
 
-    it "returns nil when passing a hash" do
-      expect(context.last(id_sort: :none)).to be_nil
+  describe "#last" do
+    it "returns nil" do
+      expect(context.last).to be_nil
     end
 
     it "returns [] when passing a limit" do
@@ -99,6 +108,14 @@ describe Mongoid::Contextual::None do
     end
   end
 
+  describe "#last!" do
+    it "raises an error" do
+      expect do
+        context.last!
+      end.to raise_error(Mongoid::Errors::DocumentNotFound, /Could not find a document of class Band./)
+    end
+  end
+
   describe "#take" do
     it "returns nil" do
       expect(context.take).to be_nil
@@ -117,6 +134,28 @@ describe Mongoid::Contextual::None do
     end
   end
 
+  [ :second,
+    :third,
+    :fourth,
+    :fifth,
+    :second_to_last,
+    :third_to_last
+  ].each do |meth|
+    describe "##{meth}" do
+      it "returns nil" do
+        expect(context.send(meth)).to be_nil
+      end
+    end
+
+    describe "##{meth}!" do
+      it "raises an error" do
+        expect do
+          context.send("#{meth}!")
+        end.to raise_error(Mongoid::Errors::DocumentNotFound, /Could not find a document of class Band./)
+      end
+    end
+  end
+
   describe "#length" do
     it "returns zero" do
       expect(context.length).to eq(0)

data/spec/mongoid/copyable_spec.rb

@@ -90,7 +90,7 @@ describe Mongoid::Copyable do
           end
 
           it 'calls constructor with explicitly declared attributes only' do
-            expect(cls).to receive(:new).with('name' => 'test').and_call_original
+            expect(Mongoid::Factory).to receive(:build).with(cls, { 'name' => 'test' }).and_call_original
             cloned
           end
         end
@@ -164,19 +164,15 @@ describe Mongoid::Copyable do
       end
 
       context "when cloning a document with multiple languages field" do
+        with_default_i18n_configs
 
         before do
-          I18n.enforce_available_locales = false
           I18n.locale = 'pt_BR'
           person.desc = "descrição"
           person.addresses.first.name = "descrição"
           person.save!
         end
 
-        after do
-          I18n.locale = :en
-        end
-
         let!(:from_db) do
           Person.find(person.id)
         end
@@ -212,22 +208,18 @@ describe Mongoid::Copyable do
       end
 
       context "when cloning a document with polymorphic embedded documents with multiple language field" do
+        with_default_i18n_configs
 
         let!(:shipment_address) do
           person.addresses.build({ shipping_name: "Title" }, ShipmentAddress)
         end
 
         before do
-          I18n.enforce_available_locales = false
           I18n.locale = 'pt_BR'
           person.addresses.type(ShipmentAddress).each { |address| address.shipping_name = "Título" }
           person.save!
         end
 
-        after do
-          I18n.locale = :en
-        end
-
         let!(:from_db) do
           Person.find(person.id)
         end
@@ -696,5 +688,455 @@ describe Mongoid::Copyable do
         end
       end
     end
+
+    context "when fields are removed before cloning" do
+
+      context "when using embeds_one associations" do
+
+        before do
+          class CloneParent
+            include Mongoid::Document
+
+            embeds_one :clone_child
+
+            field :a, type: :string
+            field :b, type: :string
+          end
+
+          class CloneChild
+            include Mongoid::Document
+
+            embedded_in :clone_parent
+            embeds_one :clone_grandchild
+
+            field :c, type: :string
+            field :d, type: :string
+          end
+
+          class CloneGrandchild
+            include Mongoid::Document
+
+            embedded_in :clone_child
+
+            field :e, type: :string
+            field :f, type: :string
+          end
+
+        end
+
+        after do
+          Object.send(:remove_const, :CloneParent)
+          Object.send(:remove_const, :CloneChild)
+          Object.send(:remove_const, :CloneGrandchild)
+        end
+
+        context "when removing from the parent" do
+
+          before do
+            CloneParent.create(a: "1", b: "2")
+
+            Object.send(:remove_const, :CloneParent)
+
+            class CloneParent
+              include Mongoid::Document
+              field :a, type: :string
+            end
+          end
+
+          let(:parent) { CloneParent.last }
+          let(:clone) { parent.send(method) }
+
+          it "doesn't have the removed field" do
+            expect do
+              parent.b
+            end.to raise_error(NoMethodError)
+          end
+
+          it "contains the missing field in the attributes" do
+            expect(parent.attributes).to include({ "b" => "2" })
+          end
+
+          it "clones correctly" do
+            expect(clone).to be_a(CloneParent)
+            expect(clone.a).to eq("1")
+            expect(clone.attributes).to include({ "b" => "2" })
+          end
+        end
+
+        context "when removing from the child" do
+
+          before do
+            parent = CloneParent.new(a: "1", b: "2")
+            parent.clone_child = CloneChild.new(c: "3", d: "4")
+            parent.save
+
+            Object.send(:remove_const, :CloneParent)
+            Object.send(:remove_const, :CloneChild)
+
+            class CloneParent
+              include Mongoid::Document
+              embeds_one :clone_child
+              field :a, type: :string
+              field :b, type: :string
+            end
+
+            class CloneChild
+              include Mongoid::Document
+              embedded_in :clone_parent
+              field :c, type: :string
+            end
+          end
+
+          let(:parent) { CloneParent.last }
+          let(:clone) { parent.send(method) }
+
+          it "doesn't have the removed field" do
+            expect do
+              parent.clone_child.d
+            end.to raise_error(NoMethodError)
+          end
+
+          it "contains the missing field in the attributes" do
+            expect(parent.clone_child.attributes).to include({ "d" => "4" })
+          end
+
+          it "clones the parent correctly" do
+            expect(clone).to be_a(CloneParent)
+            expect(clone.a).to eq("1")
+            expect(clone.b).to eq("2")
+          end
+
+          it "clones the child correctly" do
+            expect(clone.clone_child).to be_a(CloneChild)
+            expect(clone.clone_child.c).to eq("3")
+            expect(clone.clone_child.attributes).to include({ "d" => "4" })
+          end
+        end
+
+        context "when removing from the grandchild" do
+
+          before do
+            parent = CloneParent.new(a: "1", b: "2")
+            parent.clone_child = CloneChild.new(c: "3", d: "4")
+            parent.clone_child.clone_grandchild = CloneGrandchild.new(e: "5", f: "6")
+            parent.save
+
+            Object.send(:remove_const, :CloneParent)
+            Object.send(:remove_const, :CloneChild)
+            Object.send(:remove_const, :CloneGrandchild)
+
+            class CloneParent
+              include Mongoid::Document
+              embeds_one :clone_child
+              field :a, type: :string
+              field :b, type: :string
+            end
+
+            class CloneChild
+              include Mongoid::Document
+              embedded_in :clone_parent
+              embeds_one :clone_grandchild
+              field :c, type: :string
+              field :d, type: :string
+            end
+
+            class CloneGrandchild
+              include Mongoid::Document
+              embedded_in :clone_child
+              field :e, type: :string
+            end
+          end
+
+          let(:parent) { CloneParent.last }
+          let(:clone) { parent.send(method) }
+
+          it "doesn't have the removed field" do
+            expect do
+              parent.clone_child.clone_grandchild.f
+            end.to raise_error(NoMethodError)
+          end
+
+          it "contains the missing field in the attributes" do
+            expect(parent.clone_child.clone_grandchild.attributes).to include({ "f" => "6" })
+          end
+
+          it "clones the parent correctly" do
+            expect(clone).to be_a(CloneParent)
+            expect(clone.a).to eq("1")
+            expect(clone.b).to eq("2")
+          end
+
+          it "clones the child correctly" do
+            expect(clone.clone_child).to be_a(CloneChild)
+            expect(clone.clone_child.c).to eq("3")
+            expect(clone.clone_child.d).to eq("4")
+          end
+
+          it "clones the child correctly" do
+            expect(clone.clone_child.clone_grandchild).to be_a(CloneGrandchild)
+            expect(clone.clone_child.clone_grandchild.e).to eq("5")
+            expect(clone.clone_child.clone_grandchild.attributes).to include({ "f" => "6" })
+          end
+        end
+      end
+
+      context "when using embeds_many associations" do
+
+        before do
+          class CloneParent
+            include Mongoid::Document
+
+            embeds_many :clone_children
+
+            field :a, type: :string
+            field :b, type: :string
+          end
+
+          class CloneChild
+            include Mongoid::Document
+
+            embedded_in :clone_parent
+            embeds_many :clone_grandchildren
+
+            field :c, type: :string
+            field :d, type: :string
+          end
+
+          class CloneGrandchild
+            include Mongoid::Document
+
+            embedded_in :clone_child
+
+            field :e, type: :string
+            field :f, type: :string
+          end
+
+        end
+
+        after do
+          Object.send(:remove_const, :CloneParent)
+          Object.send(:remove_const, :CloneChild)
+          Object.send(:remove_const, :CloneGrandchild)
+        end
+
+        context "when removing from the parent" do
+
+          before do
+            CloneParent.create(a: "1", b: "2")
+
+            Object.send(:remove_const, :CloneParent)
+
+            class CloneParent
+              include Mongoid::Document
+              field :a, type: :string
+            end
+          end
+
+          let(:parent) { CloneParent.last }
+          let(:clone) { parent.send(method) }
+
+          it "doesn't have the removed field" do
+            expect do
+              parent.b
+            end.to raise_error(NoMethodError)
+          end
+
+          it "contains the missing field in the attributes" do
+            expect(parent.attributes).to include({ "b" => "2" })
+          end
+
+          it "clones correctly" do
+            expect(clone).to be_a(CloneParent)
+            expect(clone.a).to eq("1")
+            expect(clone.attributes).to include({ "b" => "2" })
+          end
+        end
+
+        context "when removing from the child" do
+
+          before do
+            parent = CloneParent.new(a: "1", b: "2")
+            parent.clone_children = [ CloneChild.new(c: "3", d: "4"), CloneChild.new(c: "3", d: "4") ]
+            parent.save
+
+            Object.send(:remove_const, :CloneParent)
+            Object.send(:remove_const, :CloneChild)
+
+            class CloneParent
+              include Mongoid::Document
+              embeds_many :clone_children
+              field :a, type: :string
+              field :b, type: :string
+            end
+
+            class CloneChild
+              include Mongoid::Document
+              embedded_in :clone_parent
+              field :c, type: :string
+            end
+          end
+
+          let(:parent) { CloneParent.last }
+          let(:clone) { parent.send(method) }
+
+          it "doesn't have the removed field" do
+            parent.clone_children.each do |clone_child|
+              expect do
+                clone_child.d
+              end.to raise_error(NoMethodError)
+            end
+          end
+
+          it "contains the missing field in the attributes" do
+            expect(parent.clone_children[0].attributes).to include({ "d" => "4" })
+            expect(parent.clone_children[1].attributes).to include({ "d" => "4" })
+          end
+
+          it "clones the parent correctly" do
+            expect(clone).to be_a(CloneParent)
+            expect(clone.a).to eq("1")
+            expect(clone.b).to eq("2")
+          end
+
+          it "clones the child correctly" do
+            expect(clone.clone_children.length).to eq(2)
+            clone.clone_children.each do |clone_child|
+              expect(clone_child).to be_a(CloneChild)
+              expect(clone_child.c).to eq("3")
+              expect(clone_child.attributes).to include({ "d" => "4" })
+            end
+          end
+        end
+
+        context "when removing from the grandchild" do
+
+          before do
+            parent = CloneParent.new(a: "1", b: "2")
+            parent.clone_children = [ CloneChild.new(c: "3", d: "4"), CloneChild.new(c: "3", d: "4") ]
+            parent.clone_children.each do |cc|
+              cc.clone_grandchildren = [ CloneGrandchild.new(e: "5", f: "6"), CloneGrandchild.new(e: "5", f: "6") ]
+            end
+            parent.save
+
+            Object.send(:remove_const, :CloneParent)
+            Object.send(:remove_const, :CloneChild)
+            Object.send(:remove_const, :CloneGrandchild)
+
+            class CloneParent
+              include Mongoid::Document
+              embeds_many :clone_children
+              field :a, type: :string
+              field :b, type: :string
+            end
+
+            class CloneChild
+              include Mongoid::Document
+              embedded_in :clone_parent
+              embeds_many :clone_grandchildren
+              field :c, type: :string
+              field :d, type: :string
+            end
+
+            class CloneGrandchild
+              include Mongoid::Document
+              embedded_in :clone_child
+              field :e, type: :string
+            end
+          end
+
+          let(:parent) { CloneParent.last }
+          let(:clone) { parent.send(method) }
+
+          it "doesn't have the removed field" do
+            parent.clone_children.each do |cc|
+              cc.clone_grandchildren.each do |cg|
+                expect do
+                  cg.f
+                end.to raise_error(NoMethodError)
+              end
+            end
+          end
+
+          it "contains the missing field in the attributes" do
+            parent.clone_children.each do |cc|
+              cc.clone_grandchildren.each do |cg|
+                expect(cg.attributes).to include({ "f" => "6" })
+              end
+            end
+          end
+
+          it "clones the parent correctly" do
+            expect(clone).to be_a(CloneParent)
+            expect(clone.a).to eq("1")
+            expect(clone.b).to eq("2")
+          end
+
+          it "clones the child correctly" do
+            expect(clone.clone_children.length).to eq(2)
+            clone.clone_children.each do |clone_child|
+              expect(clone_child).to be_a(CloneChild)
+              expect(clone_child.c).to eq("3")
+              expect(clone_child.attributes).to include({ "d" => "4" })
+            end
+          end
+
+          it "clones the grandchild correctly" do
+            parent.clone_children.each do |cc|
+              expect(cc.clone_grandchildren.length).to eq(2)
+              cc.clone_grandchildren.each do |cg|
+                expect(cg).to be_a(CloneGrandchild)
+                expect(cg.e).to eq("5")
+                expect(cg.attributes).to include({ "f" => "6" })
+              end
+            end
+          end
+        end
+      end
+
+      context "when using embedded_in associations" do
+
+        before do
+          class CloneParent
+            include Mongoid::Document
+
+            embeds_one :clone_child
+
+            field :a, type: :string
+            field :b, type: :string
+          end
+
+          class CloneChild
+            include Mongoid::Document
+
+            embedded_in :clone_parent
+
+            field :c, type: :string
+            field :d, type: :string
+          end
+        end
+
+        after do
+          Object.send(:remove_const, :CloneParent)
+          Object.send(:remove_const, :CloneChild)
+        end
+
+
+        context "when accessing the parent" do
+
+          before do
+            parent = CloneParent.new(a: "1", b: "2")
+            parent.clone_child = CloneChild.new(c: "3", d: "4")
+            parent.save
+          end
+
+          let(:parent) { CloneParent.last }
+          let(:clone) { parent.clone_child.send(method) }
+
+          it "doesn't clone the parent" do
+            expect(clone.clone_parent).to be_nil
+          end
+        end
+      end
+    end
   end
 end