mongoid 6.4.8 → 7.5.4

data/spec/mongoid/contextual/none_spec.rb

@@ -1,19 +1,20 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Mongoid::Contextual::None do
 
-  describe "#==" do
+  before do
+    Band.create!(name: "Depeche Mode")
+  end
 
-    let!(:band) do
-      Band.create(name: "Depeche Mode")
-    end
+  let(:context) do
+    described_class.new(Band.where(name: "Depeche Mode"))
+  end
 
-    let(:context) do
-      described_class.new(Band.where(name: "Depeche Mode"))
-    end
+  describe "#==" do
 
     context "when the other is a none" do
-
       let(:other) do
         described_class.new(Band.where(name: "Depeche Mode"))
       end
@@ -24,7 +25,6 @@ describe Mongoid::Contextual::None do
     end
 
     context "when the other is not a none" do
-
       let(:other) do
         Mongoid::Contextual::Memory.new(Band.where(name: "Depeche Mode"))
       end
@@ -36,120 +36,94 @@ describe Mongoid::Contextual::None do
   end
 
   describe "#each" do
-
-    let!(:band) do
-      Band.create(name: "Depeche Mode")
-    end
-
-    let(:context) do
-      described_class.new(Band.where(name: "Depeche Mode"))
-    end
-
     it "iterates over no documents" do
       expect(context.each.entries).to be_empty
     end
   end
 
   describe "#exists?" do
-
-    let!(:band) do
-      Band.create(name: "Depeche Mode")
-    end
-
-    let(:context) do
-      described_class.new(Band.where(name: "Depeche Mode"))
-    end
-
     it "returns false" do
       expect(context).to_not be_exists
     end
   end
 
   describe "#distinct" do
-
-    let!(:band) do
-      Band.create(name: "Depeche Mode")
-    end
-
-    let(:context) do
-      described_class.new(Band.where(name: "Depeche Mode"))
-    end
-
     it "returns an empty array" do
       expect(context.distinct(:id)).to eq([])
     end
   end
 
   describe "#pluck" do
-
-    let!(:band) do
-      Band.create(name: "Depeche Mode")
-    end
-
-    let(:context) do
-      described_class.new(Band.where(name: "Depeche Mode"))
-    end
-
     it "returns an empty array" do
       expect(context.pluck(:id)).to eq([])
     end
   end
 
   describe "#first" do
+    it "returns nil" do
+      expect(context.first).to be_nil
+    end
 
-    let!(:band) do
-      Band.create(name: "Depeche Mode")
+    it "doen't raise when passing options" do
+      expect do
+        context.first(id_sort: :none)
+      end.to_not raise_error
     end
 
-    let(:context) do
-      described_class.new(Band.where(name: "Depeche Mode"))
+    it "returns nil when passing a hash" do
+      expect(context.first(id_sort: :none)).to be_nil
     end
 
-    it "returns nil" do
-      expect(context.first).to be_nil
+    it "returns [] when passing a limit" do
+      expect(context.first(1)).to eq([])
     end
   end
 
   describe "#last" do
+    it "returns nil" do
+      expect(context.last).to be_nil
+    end
 
-    let!(:band) do
-      Band.create(name: "Depeche Mode")
+    it "doen't raise when passing options" do
+      expect do
+        context.last(id_sort: :none)
+      end.to_not raise_error
     end
 
-    let(:context) do
-      described_class.new(Band.where(name: "Depeche Mode"))
+    it "returns nil when passing a hash" do
+      expect(context.last(id_sort: :none)).to be_nil
     end
 
-    it "returns nil" do
-      expect(context.last).to be_nil
+    it "returns [] when passing a limit" do
+      expect(context.last(1)).to eq([])
     end
   end
 
-  describe "#length" do
+  describe "#take" do
+    it "returns nil" do
+      expect(context.take).to be_nil
+    end
 
-    let!(:band) do
-      Band.create(name: "Depeche Mode")
+    it "returns nil with params" do
+      expect(context.take(1)).to eq([])
     end
+  end
 
-    let(:context) do
-      described_class.new(Band.where(name: "Depeche Mode"))
+  describe "#take!" do
+    it "raises an error" do
+      expect do
+        context.take!
+      end.to raise_error(Mongoid::Errors::DocumentNotFound, /Could not find a document of class Band./)
     end
+  end
 
+  describe "#length" do
     it "returns zero" do
       expect(context.length).to eq(0)
     end
   end
 
   describe "#size" do
-
-    let!(:band) do
-      Band.create(name: "Depeche Mode")
-    end
-
-    let(:context) do
-      described_class.new(Band.where(name: "Depeche Mode"))
-    end
-
     it "returns zero" do
       expect(context.size).to eq(0)
     end

data/spec/mongoid/copyable_spec.rb

@@ -1,6 +1,9 @@
-# -*- coding: utf-8 -*-
+# frozen_string_literal: true
+
 require "spec_helper"
 
+require_relative './copyable_spec_models'
+
 describe Mongoid::Copyable do
 
   [ :clone, :dup ].each do |method|
@@ -35,10 +38,14 @@ describe Mongoid::Copyable do
         person.build_game(name: "Tron")
       end
 
+      let!(:name_translations) do
+        person.name.translations.build(language: 'en')
+      end
+
       context "when the document has an id field in the database" do
 
         let!(:band) do
-          Band.create(name: "Tool")
+          Band.create!(name: "Tool")
         end
 
         before do
@@ -56,46 +63,106 @@ describe Mongoid::Copyable do
 
       context "when a document has fields from a legacy schema" do
 
-        let!(:actor) do
-          Actor.create(name: "test")
-        end
+        shared_examples 'behaves as expected' do
+          let!(:instance) do
+            cls.create!(name: "test")
+          end
 
-        before do
-          legacy_fields = { "this_is_not_a_field" => 1, "this_legacy_field_is_nil" => nil }
-          Actor.collection.find(_id: actor.id).update_one("$set" => legacy_fields)
-        end
+          before do
+            legacy_fields = { "this_is_not_a_field" => 1, "this_legacy_field_is_nil" => nil }
+            cls.collection.find(_id: instance.id).update_one("$set" => legacy_fields)
+          end
 
-        let(:cloned) do
-          actor.reload.send(method)
-        end
+          let(:cloned) do
+            instance.reload.send(method)
+          end
 
-        it "sets the legacy attribute" do
-          expect(cloned.attributes['this_is_not_a_field']).to eq(1)
+          it "sets the legacy attribute" do
+            expect(cloned.attributes['this_is_not_a_field']).to eq(1)
+          end
+
+          it "contains legacy attributes that are nil" do
+            expect(cloned.attributes.key?('this_legacy_field_is_nil')).to eq(true)
+          end
+
+          it "copies the known attributes" do
+            expect(cloned.name).to eq('test')
+          end
+
+          it 'calls constructor with explicitly declared attributes only' do
+            expect(cls).to receive(:new).with('name' => 'test').and_call_original
+            cloned
+          end
         end
 
-        it "contains legacy attributes that are nil" do
-          expect(cloned.attributes.key?('this_legacy_field_is_nil')).to eq(true)
+        context 'without Attributes::Dynamic' do
+          let(:cls) { CopyableSpec::Reg }
+
+          before do
+            cls.should_not include(Mongoid::Attributes::Dynamic)
+          end
+
+          include_examples 'behaves as expected'
         end
 
-        it "copies the known attributes" do
-          expect(cloned.name).to eq('test')
+        context 'with Attributes::Dynamic' do
+          let(:cls) { CopyableSpec::Dyn }
+
+          before do
+            cls.should include(Mongoid::Attributes::Dynamic)
+          end
+
+          include_examples 'behaves as expected'
         end
+
       end
 
       context "when using store_as" do
 
         context "and dynamic attributes are not set" do
 
-          it "clones" do
-            t = StoreAsDupTest1.new(:name => "hi")
-            t.build_store_as_dup_test2(:name => "there")
-            t.save
-            copy = t.send(method)
-            expect(copy.store_as_dup_test2.name).to eq(t.store_as_dup_test2.name)
+          context 'embeds_one' do
+
+            it "clones" do
+              t = StoreAsDupTest1.new(:name => "hi")
+              t.build_store_as_dup_test2(:name => "there")
+              t.save!
+              copy = t.send(method)
+              expect(copy.object_id).not_to eq(t.object_id)
+              expect(copy.store_as_dup_test2.name).to eq(t.store_as_dup_test2.name)
+            end
+          end
+
+          context 'embeds_many' do
+
+
+            it "clones" do
+              t = StoreAsDupTest3.new(:name => "hi")
+              t.store_as_dup_test4s << StoreAsDupTest4.new
+              t.save!
+              copy = t.send(method)
+              expect(copy.object_id).not_to eq(t.object_id)
+              expect(copy.store_as_dup_test4s).not_to be_empty
+              expect(copy.store_as_dup_test4s.first.object_id).not_to eq(t.store_as_dup_test4s.first.object_id)
+            end
           end
         end
       end
 
+      context 'nested embeds_many' do
+        it 'works' do
+          a = CopyableSpec::A.new
+          a.locations << CopyableSpec::Location.new
+          a.locations.first.buildings << CopyableSpec::Building.new
+          a.save!
+
+          new_a = a.send(method)
+
+          expect(new_a.locations.length).to be 1
+          expect(new_a.locations.first.buildings.length).to be 1
+        end
+      end
+
       context "when cloning a document with multiple languages field" do
 
         before do
@@ -103,7 +170,7 @@ describe Mongoid::Copyable do
           I18n.locale = 'pt_BR'
           person.desc = "descrição"
           person.addresses.first.name = "descrição"
-          person.save
+          person.save!
         end
 
         after do
@@ -144,10 +211,44 @@ describe Mongoid::Copyable do
         end
       end
 
+      context "when cloning a document with polymorphic embedded documents with multiple language field" do
+
+        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
+
+        let(:copy) do
+          from_db.send(method)
+        end
+
+        it 'sets embedded translations' do
+          I18n.locale = 'pt_BR'
+          copy.addresses.type(ShipmentAddress).each do |address|
+            expect(address.shipping_name).to eq("Título")
+          end
+        end
+
+      end
+
       context "when cloning a loaded document" do
 
         before do
-          person.save
+          person.save!
         end
 
         let!(:from_db) do
@@ -211,14 +312,26 @@ describe Mongoid::Copyable do
             expect(copy.addresses).to eq(person.addresses)
           end
 
+          it "copys deep embeds many documents" do
+            expect(copy.name.translations).to eq(person.name.translations)
+          end
+
           it "sets the embedded many documents as new" do
             expect(copy.addresses.first).to be_new_record
           end
 
+          it "sets the deep embedded many documents as new" do
+            expect(copy.name.translations.first).to be_new_record
+          end
+
           it "creates new embeds many instances" do
             expect(copy.addresses).to_not equal(person.addresses)
           end
 
+          it "creates new deep embeds many instances" do
+            expect(copy.name.translations).to_not equal(person.name.translations)
+          end
+
           it "copys embeds one documents" do
             expect(copy.name).to eq(person.name)
           end
@@ -250,7 +363,84 @@ describe Mongoid::Copyable do
             end
 
             before do
-              copy.save(validate: false)
+              copy.save!(validate: false)
+            end
+
+            it "persists the attributes" do
+              expect(reloaded.title).to eq("Sir")
+            end
+
+            it "persists the embeds many relation" do
+              expect(reloaded.addresses).to eq(person.addresses)
+            end
+
+            it "persists the embeds one relation" do
+              expect(reloaded.name).to eq(person.name)
+            end
+          end
+        end
+
+        context "when using a custom discriminator_key" do
+          before do
+            Person.discriminator_key = "dkey"
+          end
+
+          after do
+            Person.discriminator_key = nil
+          end
+
+          let(:copy) do
+            person.send(method)
+          end
+
+          before do
+            person[:versions] = [ { number: 1 } ]
+          end
+
+          it "copys embeds many documents" do
+            expect(copy.addresses).to eq(person.addresses)
+          end
+
+          it "copys deep embeds many documents" do
+            expect(copy.name.translations).to eq(person.name.translations)
+          end
+
+          it "sets the embedded many documents as new" do
+            expect(copy.addresses.first).to be_new_record
+          end
+
+          it "sets the deep embedded many documents as new" do
+            expect(copy.name.translations.first).to be_new_record
+          end
+
+          it "creates new embeds many instances" do
+            expect(copy.addresses).to_not equal(person.addresses)
+          end
+
+          it "creates new deep embeds many instances" do
+            expect(copy.name.translations).to_not equal(person.name.translations)
+          end
+
+          it "copys embeds one documents" do
+            expect(copy.name).to eq(person.name)
+          end
+
+          it "flags the embeds one documents as new" do
+            expect(copy.name).to be_new_record
+          end
+
+          it "creates a new embeds one instance" do
+            expect(copy.name).to_not equal(person.name)
+          end
+
+          context "when saving the copy" do
+
+            let(:reloaded) do
+              copy.reload
+            end
+
+            before do
+              copy.save!(validate: false)
             end
 
             it "persists the attributes" do
@@ -339,7 +529,7 @@ describe Mongoid::Copyable do
             end
 
             before do
-              copy.save(validate: false)
+              copy.save!(validate: false)
             end
 
             it "persists the attributes" do
@@ -414,7 +604,7 @@ describe Mongoid::Copyable do
           end
 
           before do
-            copy.save(validate: false)
+            copy.save!(validate: false)
           end
 
           it "persists the attributes" do
@@ -430,6 +620,81 @@ describe Mongoid::Copyable do
           end
         end
       end
+
+      context "when cloning a document with an embedded child class and a custom discriminator value" do
+
+        before do
+          ShipmentAddress.discriminator_value = "dvalue"
+        end
+
+        after do
+          ShipmentAddress.discriminator_value = nil
+        end
+
+        let!(:shipment_address) do
+          person.addresses.build({}, ShipmentAddress)
+        end
+
+        before do
+          person.save!
+        end
+
+        let!(:from_db) do
+          Person.find(person.id)
+        end
+
+        let(:copy) do
+          from_db.send(method)
+        end
+
+        it "copys embeds many documents" do
+          expect(copy.addresses).to eq(person.addresses)
+        end
+      end
+
+      context 'when cloning a document with embedded child that uses inheritance' do
+        let(:original) do
+          CopyableSpec::A.new(influencers: [child_cls.new])
+        end
+
+        let(:copy) do
+          original.send(method)
+        end
+
+        context 'embedded child is root of hierarchy' do
+          let(:child_cls) do
+            CopyableSpec::Influencer
+          end
+
+          before do
+            # When embedded class is the root in hierarchy, their
+            # discriminator value is not explicitly stored.
+            child_cls.discriminator_mapping[child_cls.name].should be nil
+          end
+
+          it 'works' do
+            copy.class.should be original.class
+            copy.object_id.should_not == original.object_id
+          end
+        end
+
+        context 'embedded child is leaf of hierarchy' do
+          let(:child_cls) do
+            CopyableSpec::Youtuber
+          end
+
+          before do
+            # When embedded class is a leaf in hierarchy, their
+            # discriminator value is explicitly stored.
+            child_cls.discriminator_mapping[child_cls.name].should_not be nil
+          end
+
+          it 'works' do
+            copy.class.should be original.class
+            copy.object_id.should_not == original.object_id
+          end
+        end
+      end
     end
   end
 end

data/spec/mongoid/copyable_spec_models.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module CopyableSpec
+  class A
+    include Mongoid::Document
+
+    embeds_many :locations
+    embeds_many :influencers
+  end
+
+  class Location
+    include Mongoid::Document
+
+    embeds_many :buildings
+  end
+
+  class Building
+    include Mongoid::Document
+  end
+
+  class Influencer
+    include Mongoid::Document
+
+    embeds_many :blurbs
+  end
+
+  class Youtuber < Influencer
+  end
+
+  class Blurb
+    include Mongoid::Document
+  end
+
+  # Do not include Attributes::Dynamic
+  class Reg
+    include Mongoid::Document
+
+    field :name, type: String
+  end
+
+  class Dyn
+    include Mongoid::Document
+    include Mongoid::Attributes::Dynamic
+
+    field :name, type: String
+  end
+end