mongoid 8.1.13 → 9.0.0

data/spec/mongoid/contextual/memory_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# rubocop:todo all
 
 require "spec_helper"
 
@@ -408,270 +409,183 @@ describe Mongoid::Contextual::Memory do
   end
 
   describe "#distinct" do
+    let(:depeche) { Band.create!(name: "Depeche Mode", years: 30, sales: "1E2") }
+    let(:new_order) { Band.create!(name: "New Order", years: 25, sales: "2E3") }
+    let(:maniacs) { Band.create!(name: "10,000 Maniacs", years: 20, sales: "1E2") }
 
-    context "when legacy_pluck_distinct is true" do
-      config_override :legacy_pluck_distinct, true
-
-      let(:hobrecht) do
-        Address.new(street: "hobrecht")
+    let(:criteria) do
+      Band.all.tap do |crit|
+        crit.documents = [ depeche, new_order, maniacs ]
       end
+    end
 
-      let(:friedel) do
-        Address.new(street: "friedel")
-      end
+    let(:context) do
+      described_class.new(criteria)
+    end
 
-      context "when limiting the result set" do
+    context "when limiting the result set" do
 
-        let(:criteria) do
-          Address.where(street: "hobrecht").tap do |crit|
-            crit.documents = [ hobrecht, hobrecht, friedel ]
-          end
-        end
-
-        let(:context) do
-          described_class.new(criteria)
+      let(:criteria) do
+        Band.where(name: "Depeche Mode").tap do |crit|
+          crit.documents = [ depeche ]
         end
+      end
 
-        it "returns the distinct field values" do
-          expect(context.distinct(:street)).to eq([ "hobrecht" ])
-        end
+      it "returns the distinct matching fields" do
+        expect(context.distinct(:name)).to eq([ "Depeche Mode" ])
       end
+    end
 
-      context "when not limiting the result set" do
+    context "when not limiting the result set" do
 
-        let(:criteria) do
-          Address.all.tap do |crit|
-            crit.documents = [ hobrecht, friedel, friedel ]
-          end
-        end
+      it "returns the distinct field values" do
+        expect(context.distinct(:name).sort).to eq([ "10,000 Maniacs", "Depeche Mode", "New Order" ].sort)
+      end
+    end
 
-        let(:context) do
-          described_class.new(criteria)
-        end
+    context "when providing an aliased field" do
 
-        it "returns the distinct field values" do
-          expect(context.distinct(:street)).to eq([ "hobrecht", "friedel" ])
-        end
+      it "returns the distinct field values" do
+        expect(context.distinct(:years).sort).to eq([ 20, 25, 30 ])
       end
+    end
 
-      context 'when there is a collation on the criteria' do
-
-        let(:criteria) do
-          Address.where(street: "hobrecht").tap do |crit|
-            crit.documents = [ hobrecht, hobrecht, friedel ]
-          end.collation(locale: 'en_US', strength: 2)
-        end
+    context "when providing a demongoizable field" do
 
-        it "raises an exception" do
-          expect {
-            context.distinct(:street)
-          }.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
-        end
+      it "returns the non-demongoized distinct field values" do
+        expect(context.distinct(:sales).sort).to eq([ BigDecimal("1E2"), BigDecimal("2E3") ])
       end
     end
 
-    context "when legacy_pluck_distinct is false" do
-      config_override :legacy_pluck_distinct, false
+    context "when getting a localized field" do
+      with_default_i18n_configs
 
-      let(:depeche) { Band.create!(name: "Depeche Mode", years: 30, sales: "1E2") }
-      let(:new_order) { Band.create!(name: "New Order", years: 25, sales: "2E3") }
-      let(:maniacs) { Band.create!(name: "10,000 Maniacs", years: 20, sales: "1E2") }
+      before do
+        I18n.locale = :en
+        d = Dictionary.create!(description: 'english-text')
+        I18n.locale = :de
+        d.description = 'deutsch-text'
+        d.save!
+      end
 
       let(:criteria) do
-        Band.all.tap do |crit|
-          crit.documents = [ depeche, new_order, maniacs ]
+        Dictionary.all.tap do |crit|
+          crit.documents = [ Dictionary.first ]
         end
       end
 
-      let(:context) do
-        described_class.new(criteria)
+      context "when getting the field without _translations" do
+        it "gets the demongoized localized field" do
+          expect(context.distinct(:description)).to eq([ 'deutsch-text' ])
+        end
       end
 
-      context "when limiting the result set" do
-
-        let(:criteria) do
-          Band.where(name: "Depeche Mode").tap do |crit|
-            crit.documents = [ depeche ]
-          end
-        end
+      context "when getting the field with _translations" do
 
-        it "returns the distinct matching fields" do
-          expect(context.distinct(:name)).to eq([ "Depeche Mode" ])
+        it "gets the full hash" do
+          expect(context.distinct(:description_translations)).to eq([ { "de" => "deutsch-text", "en" => "english-text" } ])
         end
       end
 
-      context "when not limiting the result set" do
+      context 'when plucking a specific locale' do
 
-        it "returns the distinct field values" do
-          expect(context.distinct(:name).sort).to eq([ "10,000 Maniacs", "Depeche Mode", "New Order" ].sort)
+        let(:distinct) do
+          context.distinct(:'description.de')
         end
-      end
 
-      context "when providing an aliased field" do
-
-        it "returns the distinct field values" do
-          expect(context.distinct(:years).sort).to eq([ 20, 25, 30 ])
+        it 'returns the specific translation' do
+          expect(distinct).to eq([ "deutsch-text" ])
         end
       end
 
-      context "when providing a demongoizable field" do
+      context 'when plucking a specific locale from _translations field' do
+
+        let(:distinct) do
+          context.distinct(:'description_translations.de')
+        end
 
-        it "returns the non-demongoized distinct field values" do
-          expect(context.distinct(:sales).sort).to eq([ BigDecimal("1E2"), BigDecimal("2E3") ])
+        it 'returns the specific translations' do
+          expect(distinct).to eq(['deutsch-text'])
         end
       end
 
-      context "when getting a localized field" do
+      context 'when fallbacks are enabled with a locale list' do
+        require_fallbacks
         with_default_i18n_configs
 
         before do
-          I18n.locale = :en
-          d = Dictionary.create!(description: 'english-text')
-          I18n.locale = :de
-          d.description = 'deutsch-text'
-          d.save!
-        end
-
-        let(:criteria) do
-          Dictionary.all.tap do |crit|
-            crit.documents = [ Dictionary.first ]
-          end
+          I18n.fallbacks[:he] = [ :en ]
         end
 
-        context "when getting the field without _translations" do
-          it "gets the demongoized localized field" do
-            expect(context.distinct(:description)).to eq([ 'deutsch-text' ])
-          end
+        let(:distinct) do
+          context.distinct(:description).first
         end
 
-        context "when getting the field with _translations" do
-
-          it "gets the full hash" do
-            expect(context.distinct(:description_translations)).to eq([ { "de" => "deutsch-text", "en" => "english-text" } ])
-          end
+        it "correctly uses the fallback" do
+          I18n.locale = :en
+          Dictionary.create!(description: 'english-text')
+          I18n.locale = :he
+          distinct.should == "english-text"
         end
+      end
 
-        context 'when plucking a specific locale' do
+      context "when the localized field is embedded" do
+        with_default_i18n_configs
 
-          let(:distinct) do
-            context.distinct(:'description.de')
-          end
+        let(:person) do
+          p = Passport.new
+          I18n.locale = :en
+          p.name = "Neil"
+          I18n.locale = :he
+          p.name = "Nissim"
 
-          it 'returns the specific translation' do
-            expect(distinct).to eq([ "deutsch-text" ])
-          end
+          Person.create!(passport: p, employer_id: 12345)
         end
 
-        context 'when plucking a specific locale from _translations field' do
-
-          let(:distinct) do
-            context.distinct(:'description_translations.de')
-          end
-
-          it 'returns the specific translations' do
-            expect(distinct).to eq(['deutsch-text'])
+        let(:criteria) do
+          Person.where(employer_id: 12345).tap do |crit|
+            crit.documents = [ person ]
           end
         end
 
-        context 'when fallbacks are enabled with a locale list' do
-          require_fallbacks
-          with_default_i18n_configs
-
-          before do
-            I18n.fallbacks[:he] = [ :en ]
-          end
-
-          let(:distinct) do
-            context.distinct(:description).first
-          end
-
-          it "correctly uses the fallback" do
-            I18n.locale = :en
-            Dictionary.create!(description: 'english-text')
-            I18n.locale = :he
-            distinct.should == "english-text"
-          end
+        let(:distinct) do
+          context.distinct("pass.name").first
         end
 
-        context "when the localized field is embedded" do
-          with_default_i18n_configs
-
-          let(:person) do
-            p = Passport.new
-            I18n.locale = :en
-            p.name = "Neil"
-            I18n.locale = :he
-            p.name = "Nissim"
-
-            Person.create!(passport: p, employer_id: 12345)
-          end
-
-          let(:criteria) do
-            Person.where(employer_id: 12345).tap do |crit|
-              crit.documents = [ person ]
-            end
-          end
-
-          let(:distinct) do
-            context.distinct("pass.name").first
-          end
-
-          let(:distinct_translations) do
-            context.distinct("pass.name_translations").first
-          end
-
-          let(:distinct_translations_field) do
-            context.distinct("pass.name_translations.en").first
-          end
-
-          it "returns the translation for the current locale" do
-            expect(distinct).to eq("Nissim")
-          end
-
-          it "returns the full _translation hash" do
-            expect(distinct_translations).to eq({ "en" => "Neil", "he" => "Nissim" })
-          end
+        let(:distinct_translations) do
+          context.distinct("pass.name_translations").first
+        end
 
-          it "returns the translation for the requested locale" do
-            expect(distinct_translations_field).to eq("Neil")
-          end
+        let(:distinct_translations_field) do
+          context.distinct("pass.name_translations.en").first
         end
-      end
 
-      context "when getting an embedded field" do
+        it "returns the translation for the current locale" do
+          expect(distinct).to eq("Nissim")
+        end
 
-        let(:label) { Label.new(sales: "1E2") }
-        let!(:band) { Band.create!(label: label) }
-        let(:criteria) do
-          Band.where(_id: band.id).tap do |crit|
-            crit.documents = [ band ]
-          end
+        it "returns the full _translation hash" do
+          expect(distinct_translations).to eq({ "en" => "Neil", "he" => "Nissim" })
         end
 
-        it "returns the distinct matching fields" do
-          expect(context.distinct("label.sales")).to eq([ BigDecimal("1E2") ])
+        it "returns the translation for the requested locale" do
+          expect(distinct_translations_field).to eq("Neil")
         end
       end
     end
 
-    context 'when the field name is a method name' do
-      let!(:person) do
-        Person.create!(ssn: 'secret-ssn')
-      end
-
-      let!(:address) do
-        person.addresses.create!(street: 'hobrecht')
-      end
+    context "when getting an embedded field" do
 
+      let(:label) { Label.new(sales: "1E2") }
+      let!(:band) { Band.create!(label: label) }
       let(:criteria) do
-        Address.all.tap do |crit|
-          crit.documents = [ address ]
+        Band.where(_id: band.id).tap do |crit|
+          crit.documents = [ band ]
         end
       end
 
-      it 'does not call the method' do
-        expect(address).not_to receive(:destroy)
-        expect(context.distinct(:destroy)).to eq([ nil ])
+      it "returns the distinct matching fields" do
+        expect(context.distinct("label.sales")).to eq([ BigDecimal("1E2") ])
       end
     end
   end
@@ -1513,618 +1427,403 @@ describe Mongoid::Contextual::Memory do
       described_class.new(criteria)
     end
 
-    context "when legacy_pluck_distinct is true" do
-      config_override :legacy_pluck_distinct, true
-
-      let(:hobrecht) do
-        Address.new(street: "hobrecht", number: 213)
-      end
-
-      let(:friedel) do
-        Address.new(street: "friedel", number: 11)
-      end
+    let!(:depeche) do
+      Band.create!(name: "Depeche Mode", likes: 3)
+    end
 
-      let(:criteria) do
-        Address.all.tap do |crit|
-          crit.documents = [ hobrecht, friedel ]
-        end
-      end
+    let!(:tool) do
+      Band.create!(name: "Tool", likes: 3)
+    end
 
-      context "when plucking" do
+    let!(:photek) do
+      Band.create!(name: "Photek", likes: 1)
+    end
 
-        let!(:plucked) do
-          context.pluck(:street)
-        end
+    let!(:maniacs) do
+      Band.create!(name: "10,000 Maniacs", likes: 1, sales: "1E2")
+    end
 
-        it "returns the values" do
-          expect(plucked).to eq([ "hobrecht", "friedel" ])
-        end
+    let(:criteria) do
+      Band.all.tap do |crit|
+        crit.documents = [ depeche, tool, photek, maniacs ]
       end
+    end
 
-      context "when plucking multiple fields" do
-
-        let!(:plucked) do
-          context.pluck(:street, :number)
-        end
+    context "when the field is aliased" do
 
-        it "returns the values as an array" do
-          expect(plucked).to eq([ ["hobrecht", 213], ["friedel", 11] ])
-        end
+      let!(:expensive) do
+        Product.create!(price: 100000)
       end
 
-      context "when plucking a mix of empty and non-empty values" do
-
-        let(:empty_doc) do
-          Address.new(street: nil)
-        end
-
-        let(:criteria) do
-          Address.all.tap do |crit|
-            crit.documents = [ hobrecht, friedel, empty_doc ]
-          end
-        end
-
-        let!(:plucked) do
-          context.pluck(:street)
-        end
-
-        it "returns the values" do
-          expect(plucked).to eq([ "hobrecht", "friedel", nil ])
-        end
+      let!(:cheap) do
+        Product.create!(price: 1)
       end
 
-      context "when plucking a field that doesnt exist" do
-
-        context "when pluck one field" do
-
-          let(:plucked) do
-            context.pluck(:foo)
-          end
-
-          it "returns an empty array" do
-            expect(plucked).to eq([nil, nil])
-          end
-        end
-
-        context "when pluck multiple fields" do
-
-          let(:plucked) do
-            context.pluck(:foo, :bar)
-          end
-
-          it "returns an empty array" do
-            expect(plucked).to eq([[nil, nil], [nil, nil]])
-          end
+      let(:criteria) do
+        Product.all.tap do |crit|
+          crit.documents = [ expensive, cheap ]
         end
       end
 
-      context 'when there is a collation on the criteria' do
+      context "when using alias_attribute" do
 
-        let(:criteria) do
-          Address.all.tap do |crit|
-            crit.documents = [ hobrecht, friedel ]
-          end.collation(locale: 'en_US', strength: 2)
+        let(:plucked) do
+          context.pluck(:price)
         end
 
-        it "raises an exception" do
-          expect {
-            context.pluck(:foo, :bar)
-          }.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
+        it "uses the aliases" do
+          expect(plucked).to eq([ 100000, 1 ])
         end
       end
     end
 
-    context "when legacy_pluck_distinct is false" do
-      config_override :legacy_pluck_distinct, false
-
-      let!(:depeche) do
-        Band.create!(name: "Depeche Mode", likes: 3)
-      end
-
-      let!(:tool) do
-        Band.create!(name: "Tool", likes: 3)
-      end
-
-      let!(:photek) do
-        Band.create!(name: "Photek", likes: 1)
-      end
+    context "when the criteria matches" do
 
-      let!(:maniacs) do
-        Band.create!(name: "10,000 Maniacs", likes: 1, sales: "1E2")
-      end
+      context "when there are no duplicate values" do
 
-      let(:criteria) do
-        Band.all.tap do |crit|
-          crit.documents = [ depeche, tool, photek, maniacs ]
+        let!(:plucked) do
+          context.pluck(:name)
         end
-      end
 
-      context "when the field is aliased" do
-
-        let!(:expensive) do
-          Product.create!(price: 100000)
+        it "returns the values" do
+          expect(plucked).to contain_exactly("10,000 Maniacs", "Depeche Mode", "Tool", "Photek")
         end
 
-        let!(:cheap) do
-          Product.create!(price: 1)
-        end
+        context "when subsequently executing the criteria without a pluck" do
 
-        let(:criteria) do
-          Product.all.tap do |crit|
-            crit.documents = [ expensive, cheap ]
+          it "does not limit the fields" do
+            expect(context.first.likes).to eq(3)
           end
         end
 
-        context "when using alias_attribute" do
-
-          let(:plucked) do
-            context.pluck(:price)
-          end
+        context 'when the field is a subdocument' do
 
-          it "uses the aliases" do
-            expect(plucked).to eq([ 100000, 1 ])
-          end
-        end
-      end
-
-      context "when the criteria matches" do
-
-        context "when there are no duplicate values" do
-
-          let!(:plucked) do
-            context.pluck(:name)
-          end
+          context 'when a top-level field and a subdocument field are plucked' do
+            let(:criteria) do
+              Band.where(name: 'FKA Twigs').tap do |crit|
+                crit.documents = [
+                  Band.create!(name: 'FKA Twigs'),
+                  Band.create!(name: 'FKA Twigs', records: [ Record.new(name: 'LP1') ])
+                ]
+              end
+            end
 
-          it "returns the values" do
-            expect(plucked).to contain_exactly("10,000 Maniacs", "Depeche Mode", "Tool", "Photek")
-          end
+            let(:embedded_pluck) do
+              context.pluck(:name, 'records.name')
+            end
 
-          context "when subsequently executing the criteria without a pluck" do
+            let(:expected) do
+              [
+                ["FKA Twigs", []],
+                ['FKA Twigs', ["LP1"]]
+              ]
+            end
 
-            it "does not limit the fields" do
-              expect(context.first.likes).to eq(3)
+            it 'returns the list of top-level field and subdocument values' do
+              expect(embedded_pluck).to eq(expected)
             end
           end
 
-          context 'when the field is a subdocument' do
+          context 'when only a subdocument field is plucked' do
 
-            context 'when a top-level field and a subdocument field are plucked' do
-              let(:criteria) do
-                Band.where(name: 'FKA Twigs').tap do |crit|
-                  crit.documents = [
-                    Band.create!(name: 'FKA Twigs'),
-                    Band.create!(name: 'FKA Twigs', records: [ Record.new(name: 'LP1') ])
-                  ]
-                end
-              end
-
-              let(:embedded_pluck) do
-                context.pluck(:name, 'records.name')
-              end
-
-              let(:expected) do
-                [
-                  ["FKA Twigs", []],
-                  ['FKA Twigs', ["LP1"]]
+            let(:criteria) do
+              Band.where(name: 'FKA Twigs').tap do |crit|
+                crit.documents = [
+                  Band.create!(name: 'FKA Twigs'),
+                  Band.create!(name: 'FKA Twigs', records: [ Record.new(name: 'LP1') ])
                 ]
               end
-
-              it 'returns the list of top-level field and subdocument values' do
-                expect(embedded_pluck).to eq(expected)
-              end
             end
 
-            context 'when only a subdocument field is plucked' do
-
-              let(:criteria) do
-                Band.where(name: 'FKA Twigs').tap do |crit|
-                  crit.documents = [
-                    Band.create!(name: 'FKA Twigs'),
-                    Band.create!(name: 'FKA Twigs', records: [ Record.new(name: 'LP1') ])
-                  ]
-                end
-              end
-
-              let(:embedded_pluck) do
-                context.pluck('records.name')
-              end
+            let(:embedded_pluck) do
+              context.pluck('records.name')
+            end
 
-              let(:expected) do
-                [
-                  [],
-                  ["LP1"]
-                ]
-              end
+            let(:expected) do
+              [
+                [],
+                ["LP1"]
+              ]
+            end
 
-              it 'returns the list of subdocument values' do
-                expect(embedded_pluck).to eq(expected)
-              end
+            it 'returns the list of subdocument values' do
+              expect(embedded_pluck).to eq(expected)
             end
           end
         end
+      end
 
-        context "when plucking multi-fields" do
-
-          let(:plucked) do
-            context.pluck(:name, :likes)
-          end
+      context "when plucking multi-fields" do
 
-          it "returns the values" do
-            expect(plucked).to contain_exactly(["10,000 Maniacs", 1], ["Depeche Mode", 3], ["Tool", 3], ["Photek", 1])
-          end
+        let(:plucked) do
+          context.pluck(:name, :likes)
         end
 
-        context "when there are duplicate values" do
-
-          let(:plucked) do
-            context.pluck(:likes)
-          end
-
-          it "returns the duplicates" do
-            expect(plucked).to contain_exactly(1, 3, 3, 1)
-          end
+        it "returns the values" do
+          expect(plucked).to contain_exactly(["10,000 Maniacs", 1], ["Depeche Mode", 3], ["Tool", 3], ["Photek", 1])
         end
       end
 
-      context "when plucking an aliased field" do
+      context "when there are duplicate values" do
 
         let(:plucked) do
-          context.pluck(:id)
+          context.pluck(:likes)
         end
 
-        it "returns the field values" do
-          expect(plucked).to eq([ depeche.id, tool.id, photek.id, maniacs.id ])
+        it "returns the duplicates" do
+          expect(plucked).to contain_exactly(1, 3, 3, 1)
         end
       end
+    end
 
-      context "when plucking existent and non-existent fields" do
+    context "when plucking an aliased field" do
 
-        let(:plucked) do
-          context.pluck(:id, :fooz)
-        end
+      let(:plucked) do
+        context.pluck(:id)
+      end
 
-        it "returns nil for the field that doesnt exist" do
-          expect(plucked).to eq([[depeche.id, nil], [tool.id, nil], [photek.id, nil], [maniacs.id, nil] ])
-        end
+      it "returns the field values" do
+        expect(plucked).to eq([ depeche.id, tool.id, photek.id, maniacs.id ])
       end
+    end
 
-      context "when plucking a field that doesnt exist" do
+    context "when plucking existent and non-existent fields" do
 
-        context "when pluck one field" do
+      let(:plucked) do
+        context.pluck(:id, :fooz)
+      end
 
-          let(:plucked) do
-            context.pluck(:foo)
-          end
+      it "returns nil for the field that doesnt exist" do
+        expect(plucked).to eq([[depeche.id, nil], [tool.id, nil], [photek.id, nil], [maniacs.id, nil] ])
+      end
+    end
 
-          it "returns an array with nil values" do
-            expect(plucked).to eq([nil, nil, nil, nil])
-          end
-        end
+    context "when plucking a field that doesnt exist" do
 
-        context "when pluck multiple fields" do
+      context "when pluck one field" do
 
-          let(:plucked) do
-            context.pluck(:foo, :bar)
-          end
+        let(:plucked) do
+          context.pluck(:foo)
+        end
 
-          it "returns an array of arrays with nil values" do
-            expect(plucked).to eq([[nil, nil], [nil, nil], [nil, nil], [nil, nil]])
-          end
+        it "returns an array with nil values" do
+          expect(plucked).to eq([nil, nil, nil, nil])
         end
       end
 
-      context 'when plucking a localized field' do
-        with_default_i18n_configs
+      context "when pluck multiple fields" do
 
-        before do
-          I18n.locale = :en
-          d = Dictionary.create!(description: 'english-text')
-          I18n.locale = :de
-          d.description = 'deutsch-text'
-          d.save!
+        let(:plucked) do
+          context.pluck(:foo, :bar)
         end
 
-        let(:criteria) do
-          Dictionary.all.tap do |crit|
-            crit.documents = [ Dictionary.first ]
-          end
+        it "returns an array of arrays with nil values" do
+          expect(plucked).to eq([[nil, nil], [nil, nil], [nil, nil], [nil, nil]])
         end
+      end
+    end
 
-        context 'when plucking the entire field' do
-
-          let(:plucked) do
-            context.pluck(:description)
-          end
-
-          let(:plucked_translations) do
-            context.pluck(:description_translations)
-          end
-
-          let(:plucked_translations_both) do
-            context.pluck(:description_translations, :description)
-          end
-
-          it 'returns the demongoized translations' do
-            expect(plucked.first).to eq('deutsch-text')
-          end
+    context 'when plucking a localized field' do
+      with_default_i18n_configs
 
-          it 'returns the full translations hash to _translations' do
-            expect(plucked_translations.first).to eq({"de"=>"deutsch-text", "en"=>"english-text"})
-          end
+      before do
+        I18n.locale = :en
+        d = Dictionary.create!(description: 'english-text')
+        I18n.locale = :de
+        d.description = 'deutsch-text'
+        d.save!
+      end
 
-          it 'returns both' do
-            expect(plucked_translations_both.first).to eq([{"de"=>"deutsch-text", "en"=>"english-text"}, "deutsch-text"])
-          end
+      let(:criteria) do
+        Dictionary.all.tap do |crit|
+          crit.documents = [ Dictionary.first ]
         end
+      end
 
-        context 'when plucking a specific locale' do
-
-          let(:plucked) do
-            context.pluck(:'description.de')
-          end
+      context 'when plucking the entire field' do
 
-          it 'returns the specific translations' do
-            expect(plucked.first).to eq('deutsch-text')
-          end
+        let(:plucked) do
+          context.pluck(:description)
         end
 
-        context 'when plucking a specific locale from _translations field' do
-
-          let(:plucked) do
-            context.pluck(:'description_translations.de')
-          end
-
-          it 'returns the specific translations' do
-            expect(plucked.first).to eq('deutsch-text')
-          end
+        let(:plucked_translations) do
+          context.pluck(:description_translations)
         end
 
-        context 'when fallbacks are enabled with a locale list' do
-          require_fallbacks
-          with_default_i18n_configs
-
-          before do
-            I18n.fallbacks[:he] = [ :en ]
-          end
-
-          let(:plucked) do
-            context.pluck(:description).first
-          end
-
-          it "correctly uses the fallback" do
-            I18n.locale = :en
-            Dictionary.create!(description: 'english-text')
-            I18n.locale = :he
-            plucked.should == "english-text"
-          end
+        let(:plucked_translations_both) do
+          context.pluck(:description_translations, :description)
         end
 
-        context "when the localized field is embedded" do
-          with_default_i18n_configs
-
-          before do
-            p = Passport.new
-            I18n.locale = :en
-            p.name = "Neil"
-            I18n.locale = :he
-            p.name = "Nissim"
-
-            Person.create!(passport: p, employer_id: 12345)
-          end
-
-          let(:plucked) do
-            Person.where(employer_id: 12345).pluck("pass.name").first
-          end
-
-          let(:plucked_translations) do
-            Person.where(employer_id: 12345).pluck("pass.name_translations").first
-          end
-
-          let(:plucked_translations_field) do
-            Person.where(employer_id: 12345).pluck("pass.name_translations.en").first
-          end
-
-          it "returns the translation for the current locale" do
-            expect(plucked).to eq("Nissim")
-          end
+        it 'returns the demongoized translations' do
+          expect(plucked.first).to eq('deutsch-text')
+        end
 
-          it "returns the full _translation hash" do
-            expect(plucked_translations).to eq({ "en" => "Neil", "he" => "Nissim" })
-          end
+        it 'returns the full translations hash to _translations' do
+          expect(plucked_translations.first).to eq({"de"=>"deutsch-text", "en"=>"english-text"})
+        end
 
-          it "returns the translation for the requested locale" do
-            expect(plucked_translations_field).to eq("Neil")
-          end
+        it 'returns both' do
+          expect(plucked_translations_both.first).to eq([{"de"=>"deutsch-text", "en"=>"english-text"}, "deutsch-text"])
         end
       end
 
-      context 'when plucking a field to be demongoized' do
+      context 'when plucking a specific locale' do
 
         let(:plucked) do
-          Band.where(name: maniacs.name).pluck(:sales)
+          context.pluck(:'description.de')
         end
 
-        with_config_values :map_big_decimal_to_decimal128, true, false do
-
-          it "demongoizes the field" do
-            expect(plucked.first).to be_a(BigDecimal)
-            expect(plucked.first).to eq(BigDecimal("1E2"))
-          end
+        it 'returns the specific translations' do
+          expect(plucked.first).to eq('deutsch-text')
         end
       end
 
-      context "when plucking an embedded field" do
-        let(:label) { Label.new(sales: "1E2") }
-        let!(:band) { Band.create!(label: label) }
+      context 'when plucking a specific locale from _translations field' do
 
         let(:plucked) do
-          Band.where(_id: band.id).tap do |crit|
-            crit.documents = [ band ]
-          end.pluck("label.sales")
+          context.pluck(:'description_translations.de')
         end
 
-        it "demongoizes the field" do
-          expect(plucked).to eq([ BigDecimal("1E2") ])
+        it 'returns the specific translations' do
+          expect(plucked.first).to eq('deutsch-text')
         end
       end
 
-      context "when plucking an embeds_many field" do
-        let(:label) { Label.new(sales: "1E2") }
-        let!(:band) { Band.create!(labels: [label]) }
-
-        let(:plucked) { Band.where(_id: band.id).pluck("labels.sales") }
+      context 'when fallbacks are enabled with a locale list' do
+        require_fallbacks
+        with_default_i18n_configs
 
-        it "demongoizes the field" do
-          expect(plucked.first).to eq([ BigDecimal("1E2") ])
+        before do
+          I18n.fallbacks[:he] = [ :en ]
         end
-      end
-
-      context "when plucking a nonexistent embedded field" do
-        let(:label) { Label.new(sales: "1E2") }
-        let!(:band) { Band.create!(label: label) }
 
         let(:plucked) do
-          Band.where(_id: band.id).tap do |crit|
-            crit.documents = [ band ]
-          end.pluck("label.qwerty")
+          context.pluck(:description).first
         end
 
-        it "returns nil" do
-          expect(plucked.first).to eq(nil)
+        it "correctly uses the fallback" do
+          I18n.locale = :en
+          Dictionary.create!(description: 'english-text')
+          I18n.locale = :he
+          plucked.should == "english-text"
         end
       end
 
-      context "when plucking deeply nested arrays/embedded associations" do
+      context "when the localized field is embedded" do
+        with_default_i18n_configs
 
-        let(:criteria) do
-          Person.all.tap do |crit|
-            crit.documents = [
-              Person.create!(addresses: [ Address.new(code: Code.new(deepest: Deepest.new(array: [ { y: { z: 1 } }, { y: { z: 2 } } ]))) ]),
-              Person.create!(addresses: [ Address.new(code: Code.new(deepest: Deepest.new(array: [ { y: { z: 1 } }, { y: { z: 2 } } ]))) ]),
-              Person.create!(addresses: [ Address.new(code: Code.new(deepest: Deepest.new(array: [ { y: { z: 1 } }, { y: { z: 3 } } ]))) ]),
-            ]
-          end
+        before do
+          p = Passport.new
+          I18n.locale = :en
+          p.name = "Neil"
+          I18n.locale = :he
+          p.name = "Nissim"
+
+          Person.create!(passport: p, employer_id: 12345)
         end
 
         let(:plucked) do
-          context.pluck("addresses.code.deepest.array.y.z")
+          Person.where(employer_id: 12345).pluck("pass.name").first
         end
 
-        it "returns the correct hash" do
-          expect(plucked).to eq([
-            [ [ 1, 2 ] ], [ [ 1, 2 ] ], [ [ 1, 3 ] ]
-          ])
+        let(:plucked_translations) do
+          Person.where(employer_id: 12345).pluck("pass.name_translations").first
         end
-      end
-    end
 
-    context 'when plucking a dynamic attribute' do
-      let(:criteria) do
-        Band.all.tap do |crit|
-          crit.documents = [ Band.create!(name: 'Depeche Mode', mood: 'dark') ]
+        let(:plucked_translations_field) do
+          Person.where(employer_id: 12345).pluck("pass.name_translations.en").first
         end
-      end
-
-      it 'returns the value from the attributes' do
-        expect(context.pluck(:mood)).to eq([ 'dark' ])
-      end
-    end
 
-    context 'when the field name is a method name' do
-      let!(:person) do
-        Person.create!(ssn: 'secret-ssn')
-      end
+        it "returns the translation for the current locale" do
+          expect(plucked).to eq("Nissim")
+        end
 
-      let!(:address) do
-        person.addresses.create!(street: 'hobrecht')
-      end
+        it "returns the full _translation hash" do
+          expect(plucked_translations).to eq({ "en" => "Neil", "he" => "Nissim" })
+        end
 
-      let(:criteria) do
-        Address.all.tap do |crit|
-          crit.documents = [ address ]
+        it "returns the translation for the requested locale" do
+          expect(plucked_translations_field).to eq("Neil")
         end
       end
+    end
 
-      it 'does not call the method' do
-        expect(address).not_to receive(:destroy)
-        expect(context.pluck(:destroy)).to eq([ nil ])
-      end
+    context 'when plucking a field to be demongoized' do
 
-      it 'does not return the attributes hash' do
-        expect(context.pluck(:attributes)).to eq([ nil ])
+      let(:plucked) do
+        Band.where(name: maniacs.name).pluck(:sales)
       end
 
-      it 'does not traverse to the parent document' do
-        expect(context.pluck('_root.ssn')).to eq([ nil ])
-      end
+      with_config_values :map_big_decimal_to_decimal128, true, false do
 
-      it 'does not destroy the parent document' do
-        expect(context.pluck('_root.destroy')).to eq([ nil ])
-        expect(Person.where(_id: person.id).count).to eq(1)
+        it "demongoizes the field" do
+          expect(plucked.first).to be_a(BigDecimal)
+          expect(plucked.first).to eq(BigDecimal("1E2"))
+        end
       end
     end
 
-    context 'when plucking a belongs_to association' do
-      let!(:band) do
-        Band.create!(name: 'Depeche Mode')
-      end
+    context "when plucking an embedded field" do
+      let(:label) { Label.new(sales: "1E2") }
+      let!(:band) { Band.create!(label: label) }
 
-      let!(:artist) do
-        Artist.create!(band: band)
+      let(:plucked) do
+        Band.where(_id: band.id).tap do |crit|
+          crit.documents = [ band ]
+        end.pluck("label.sales")
       end
 
-      let(:criteria) do
-        Artist.all.tap do |crit|
-          crit.documents = [ artist ]
-        end
+      it "demongoizes the field" do
+        expect(plucked).to eq([ BigDecimal("1E2") ])
       end
+    end
 
-      it 'traverses to the associated document' do
-        expect(context.pluck('band.name')).to eq([ 'Depeche Mode' ])
-      end
+    context "when plucking an embeds_many field" do
+      let(:label) { Label.new(sales: "1E2") }
+      let!(:band) { Band.create!(labels: [label]) }
 
-      it 'returns the document for the association name' do
-        expect(context.pluck(:band)).to eq([ band ])
-      end
+      let(:plucked) { Band.where(_id: band.id).pluck("labels.sales") }
 
-      it 'returns the id for the foreign key' do
-        expect(context.pluck(:band_id)).to eq([ band.id ])
+      it "demongoizes the field" do
+        expect(plucked.first).to eq([ BigDecimal("1E2") ])
       end
     end
 
-    context 'when plucking the foreign key of a many to many association' do
-      let!(:preference) do
-        Preference.create!(name: 'nature')
-      end
-
-      let!(:person) do
-        Person.create!(preferences: [ preference ])
-      end
+    context "when plucking a nonexistent embedded field" do
+      let(:label) { Label.new(sales: "1E2") }
+      let!(:band) { Band.create!(label: label) }
 
-      let(:criteria) do
-        Person.all.tap do |crit|
-          crit.documents = [ person ]
-        end
+      let(:plucked) do
+        Band.where(_id: band.id).tap do |crit|
+          crit.documents = [ band ]
+        end.pluck("label.qwerty")
       end
 
-      it 'returns the stored ids' do
-        expect(context.pluck(:preference_ids)).to eq([ [ preference.id ] ])
+      it "returns nil" do
+        expect(plucked.first).to eq(nil)
       end
     end
 
-    context 'when the field path has an empty segment' do
-      let!(:band) do
-        Band.create!(name: 'Depeche Mode', label: Label.new(name: 'Mute'))
-      end
+    context "when plucking deeply nested arrays/embedded associations" do
 
       let(:criteria) do
-        Band.all.tap do |crit|
-          crit.documents = [ band ]
+        Person.all.tap do |crit|
+          crit.documents = [
+            Person.create!(addresses: [ Address.new(code: Code.new(deepest: Deepest.new(array: [ { y: { z: 1 } }, { y: { z: 2 } } ]))) ]),
+            Person.create!(addresses: [ Address.new(code: Code.new(deepest: Deepest.new(array: [ { y: { z: 1 } }, { y: { z: 2 } } ]))) ]),
+            Person.create!(addresses: [ Address.new(code: Code.new(deepest: Deepest.new(array: [ { y: { z: 1 } }, { y: { z: 3 } } ]))) ]),
+          ]
         end
       end
 
-      it 'returns nil' do
-        expect(context.pluck('label..name')).to eq([ nil ])
+      let(:plucked) do
+        context.pluck("addresses.code.deepest.array.y.z")
+      end
+
+      it "returns the correct hash" do
+        expect(plucked).to eq([
+          [ [ 1, 2 ] ], [ [ 1, 2 ] ], [ [ 1, 3 ] ]
+        ])
       end
     end
   end
@@ -2187,27 +1886,6 @@ describe Mongoid::Contextual::Memory do
         expect(picked).to be_nil
       end
     end
-
-    context 'when the field name is a method name' do
-      let!(:person) do
-        Person.create!(ssn: 'secret-ssn')
-      end
-
-      let!(:address) do
-        person.addresses.create!(street: 'hobrecht')
-      end
-
-      let(:criteria) do
-        Address.all.tap do |crit|
-          crit.documents = [ address ]
-        end
-      end
-
-      it 'does not call the method' do
-        expect(address).not_to receive(:destroy)
-        expect(context.pick(:destroy)).to be_nil
-      end
-    end
   end
 
   describe "#tally" do
@@ -2662,31 +2340,6 @@ describe Mongoid::Contextual::Memory do
         )
       end
     end
-
-    context 'when the field name is a method name' do
-      let!(:person) do
-        Person.create!(ssn: 'secret-ssn')
-      end
-
-      let!(:address) do
-        person.addresses.create!(street: 'hobrecht')
-      end
-
-      let(:criteria) do
-        Address.all.tap do |crit|
-          crit.documents = [ address ]
-        end
-      end
-
-      it 'does not call the method' do
-        expect(address).not_to receive(:destroy)
-        expect(context.tally(:destroy)).to eq(nil => 1)
-      end
-
-      it 'does not disclose the parent document fields' do
-        expect(context.tally('_root.ssn')).to eq(nil => 1)
-      end
-    end
   end
 
   describe '#inc' do