mongoid 7.6.2 → 8.0.1

data/spec/mongoid/contextual/memory_spec.rb

@@ -438,32 +438,6 @@ describe Mongoid::Contextual::Memory do
           }.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
         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
-
-        let(:context) do
-          described_class.new(criteria)
-        end
-
-        it "does not call the method" do
-          expect(address).not_to receive(:destroy)
-          expect(context.distinct(:destroy)).to eq([ nil ])
-        end
-      end
     end
 
     context "when legacy_pluck_distinct is false" do
@@ -658,28 +632,6 @@ describe Mongoid::Contextual::Memory do
           expect(context.distinct("label.sales")).to eq([ BigDecimal("1E2") ])
         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.distinct(:destroy)).to eq([ nil ])
-        end
-      end
     end
   end
 
@@ -878,10 +830,6 @@ describe Mongoid::Contextual::Memory do
         expect(context.send(method, 1)).to eq([ hobrecht ])
       end
 
-      it "returns the matching document when passing deprecated options" do
-        expect(context.send(method, id_sort: :none)).to eq(hobrecht)
-      end
-
       context 'when there is a collation on the criteria' do
 
         let(:criteria) do
@@ -1134,10 +1082,6 @@ describe Mongoid::Contextual::Memory do
       expect(context.last(1)).to eq([ friedel ])
     end
 
-    it "returns the matching document when passing deprecated options" do
-      expect(context.last(id_sort: :none)).to eq(friedel)
-    end
-
     context 'when there is a collation on the criteria' do
 
       let(:criteria) do
@@ -1400,7 +1344,7 @@ describe Mongoid::Contextual::Memory do
         Band.create!(name: "Photek", likes: 1)
       end
 
-      let(:maniacs) do
+      let!(:maniacs) do
         Band.create!(name: "10,000 Maniacs", likes: 1, sales: "1E2")
       end
 
@@ -1726,9 +1670,12 @@ describe Mongoid::Contextual::Memory do
           Band.where(name: maniacs.name).pluck(:sales)
         end
 
-        it "demongoizes the field" do
-          expect(plucked.first).to be_a(BigDecimal)
-          expect(plucked.first).to eq(BigDecimal("1E2"))
+        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
         end
       end
 
@@ -1738,7 +1685,7 @@ describe Mongoid::Contextual::Memory do
 
         let(:plucked) do
           Band.where(_id: band.id).tap do |crit|
-            crit.documents = [band]
+            crit.documents = [ band ]
           end.pluck("label.sales")
         end
 
@@ -1764,7 +1711,7 @@ describe Mongoid::Contextual::Memory do
 
         let(:plucked) do
           Band.where(_id: band.id).tap do |crit|
-            crit.documents = band
+            crit.documents = [ band ]
           end.pluck("label.qwerty")
         end
 
@@ -1795,174 +1742,538 @@ describe Mongoid::Contextual::Memory do
           ])
         end
       end
+    end
+  end
 
-      context "when plucking a dynamic attribute" do
+  describe "#pick" do
 
-        let(:criteria) do
-          Band.all.tap do |crit|
-            crit.documents = [ Band.create!(name: "Depeche Mode", mood: "dark") ]
-          end
-        end
+    let(:depeche) do
+      Band.create!(name: "Depeche Mode", likes: 3)
+    end
+
+    let(:tool) do
+      Band.create!(name: "Tool", likes: 3)
+    end
+
+    let(:criteria) do
+      Band.all.tap do |crit|
+        crit.documents = [ depeche, tool ]
+      end
+    end
+
+    let(:context) do
+      described_class.new(criteria)
+    end
+
+    context "when picking a field" do
+
+      let(:picked) do
+        context.pick(:name)
+      end
+
+      it "returns one element" do
+        expect(picked).to eq("Depeche Mode")
+      end
+    end
+
+    context "when picking multiple fields" do
+
+      let(:picked) do
+        context.pick(:name, :likes)
+      end
 
-        it "returns the value from the attributes" do
-          expect(context.pluck(:mood)).to eq([ "dark" ])
+      it "returns an array" do
+        expect(picked).to eq([ "Depeche Mode", 3 ])
+      end
+    end
+
+    context "when no documents to pick" do
+
+      let(:criteria) do
+        Band.all.tap do |crit|
+          crit.documents = []
         end
       end
 
-      context "when the field name is a method name" do
+      let(:picked) do
+        context.pick(:name)
+      end
+
+      it "returns nil" do
+        expect(picked).to be_nil
+      end
+    end
+  end
+
+  describe "#tally" do
+    let(:fans1) { [ Fanatic.new(age:1), Fanatic.new(age:2) ] }
+    let(:fans2) { [ Fanatic.new(age:1), Fanatic.new(age:2) ] }
+    let(:fans3) { [ Fanatic.new(age:1), Fanatic.new(age:3) ] }
+
+    let(:genres1) { [ { x: 1, y: { z: 1 } }, { x: 2, y: { z: 2 } }, { y: 3 } ]}
+    let(:genres2) { [ { x: 1, y: { z: 1 } }, { x: 2, y: { z: 2 } }, { y: 4 } ]}
+    let(:genres3) { [ { x: 1, y: { z: 1 } }, { x: 3, y: { z: 3 } }, { y: 5 } ]}
+
+    let(:label1) {  Label.new(name: "Atlantic") }
+    let(:label2) {  Label.new(name: "Atlantic") }
+    let(:label3) {  Label.new(name: "Columbia") }
+
+
+    let(:band1) { Band.new(origin: "tally", name: "Depeche Mode", years: 30, sales: "1E2", label: label1, genres: genres1) }
+    let(:band2) { Band.new(origin: "tally", name: "New Order", years: 30, sales: "2E3", label: label2, genres: genres2) }
+    let(:band3) { Band.new(origin: "tally", name: "10,000 Maniacs", years: 30, sales: "1E2", label: label3, genres: genres3) }
+    let(:band4) { Band.new(origin: "tally2", fanatics: fans1, genres: [1, 2]) }
+    let(:band5) { Band.new(origin: "tally2", fanatics: fans2, genres: [1, 2]) }
+    let(:band6) { Band.new(origin: "tally2", fanatics: fans3, genres: [1, 3]) }
+
+    let(:criteria) do
+      Band.where(origin: "tally").all.tap do |crit|
+        crit.documents = [ band1, band2, band3 ]
+      end
+    end
+
+    let(:criteria2) do
+      Band.where(origin: "tally2").tap do |crit|
+        crit.documents = [ band4, band5, band6 ]
+      end
+    end
+
+    let(:context) do
+      described_class.new(criteria)
+    end
+
+    let(:context2) do
+      described_class.new(criteria2)
+    end
+
+    context "when tallying a string" do
+      let(:tally) do
+        context.tally(:name)
+      end
+
+      it "returns the correct hash" do
+        expect(tally).to eq("Depeche Mode" => 1, "New Order" => 1, "10,000 Maniacs" => 1)
+      end
+    end
+
+    context "using an aliased field" do
+      let(:tally) do
+        context.tally(:years)
+      end
+
+      it "returns the correct hash" do
+        expect(tally).to eq(30 => 3)
+      end
+    end
+
+    context "when tallying a demongoizable field" do
+      let(:tally) do
+        context.tally(:sales)
+      end
+
+      it "returns the correct hash" do
+        expect(tally).to eq(BigDecimal("1E2") => 2, BigDecimal("2E3") => 1)
+      end
+    end
+
+    context "when tallying a localized field" do
+      let(:d1) { Dictionary.new(description: 'en1') }
+      let(:d2) { Dictionary.new(description: 'en1') }
+      let(:d3) { Dictionary.new(description: 'en1') }
+      let(:d4) { Dictionary.new(description: 'en2') }
+
+      before do
+        I18n.locale = :en
+        d1
+        d2
+        d3
+        d4
+        I18n.locale = :de
+        d1.description = 'de1'
+        d2.description = 'de1'
+        d3.description = 'de2'
+        d4.description = 'de3'
+        I18n.locale = :en
+      end
 
-        let!(:person) do
-          Person.create!(ssn: "secret-ssn")
+      let(:criteria) do
+        Dictionary.all.tap do |crit|
+          crit.documents = [ d1, d2, d3, d4 ]
         end
+      end
 
-        let!(:address) do
-          person.addresses.create!(street: "hobrecht")
+      context "when getting the demongoized field" do
+        let(:tallied) do
+          context.tally(:description)
         end
 
-        let(:criteria) do
-          Address.all.tap do |crit|
-            crit.documents = [ address ]
-          end
+        it "returns the translation for the current locale" do
+          expect(tallied).to eq("en1" => 3, "en2" => 1)
         end
+      end
 
-        it "does not call the method" do
-          expect(address).not_to receive(:destroy)
-          expect(context.pluck(:destroy)).to eq([ nil ])
+      context "when getting a specific locale" do
+        let(:tallied) do
+          context.tally("description.de")
         end
 
-        it "does not return the attributes hash" do
-          expect(context.pluck(:attributes)).to eq([ nil ])
+        it "returns the translation for the the specific locale" do
+          expect(tallied).to eq("de1" => 2, "de2" => 1, "de3" => 1)
         end
+      end
 
-        it "does not traverse to the parent document" do
-          expect(context.pluck("_root.ssn")).to eq([ nil ])
+      context "when getting the full hash" do
+        let(:tallied) do
+          context.tally("description_translations")
         end
 
-        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 "returns the correct hash" do
+          expect(tallied).to eq(
+            {"de" => "de1", "en" => "en1" } => 2,
+            {"de" => "de2", "en" => "en1" } => 1,
+            {"de" => "de3", "en" => "en2" } => 1
+          )
         end
       end
+    end
 
-      context "when plucking a belongs_to association" do
+    context "when tallying an embedded localized field" do
 
-        let!(:band) do
-          Band.create!(name: "Depeche Mode")
-        end
+      let(:person1) { Person.create!(addresses: [ address1a, address1b ]) }
+      let(:person2) { Person.create!(addresses: [ address2a, address2b ]) }
 
-        let!(:artist) do
-          Artist.create!(band: band)
-        end
+      let(:address1a) { Address.new(name: "en1") }
+      let(:address1b) { Address.new(name: "en2") }
+      let(:address2a) { Address.new(name: "en1") }
+      let(:address2b) { Address.new(name: "en3") }
 
-        let(:criteria) do
-          Artist.all.tap do |crit|
-            crit.documents = [ artist ]
-          end
-        end
+      before do
+        I18n.locale = :en
+        address1a
+        address1b
+        address2a
+        address2b
+        I18n.locale = :de
+        address1a.name = "de1"
+        address1b.name = "de2"
+        address2a.name = "de1"
+        address2b.name = "de3"
+        person1
+        person2
+
+        I18n.locale = :en
+      end
 
-        it "traverses to the associated document" do
-          expect(context.pluck("band.name")).to eq([ "Depeche Mode" ])
+      let(:criteria) do
+        Person.all.tap do |crit|
+          crit.documents = [ person1, person2 ]
         end
+      end
 
-        it "returns the document for the association name" do
-          expect(context.pluck(:band)).to eq([ band ])
+      context "when getting the demongoized field" do
+        let(:tallied) do
+          context.tally("addresses.name")
         end
 
-        it "returns the id for the foreign key" do
-          expect(context.pluck(:band_id)).to eq([ band.id ])
+        it "returns the translation for the current locale" do
+          expect(tallied).to eq(
+            [ "en1", "en2" ] => 1,
+            [ "en1", "en3" ] => 1,
+          )
         end
       end
 
-      context "when plucking the foreign key of a many to many association" do
-
-        let!(:preference) do
-          Preference.create!(name: "nature")
+      context "when getting a specific locale" do
+        let(:tallied) do
+          context.tally("addresses.name.de")
         end
 
-        let!(:person) do
-          Person.create!(preferences: [ preference ])
+        it "returns the translation for the the specific locale" do
+          expect(tallied).to eq(
+            [ "de1", "de2" ] => 1,
+            [ "de1", "de3" ] => 1,
+          )
         end
+      end
 
-        let(:criteria) do
-          Person.all.tap do |crit|
-            crit.documents = [ person ]
-          end
+      context "when getting the full hash" do
+        let(:tallied) do
+          context.tally("addresses.name_translations")
         end
 
-        it "returns the stored ids" do
-          expect(context.pluck(:preference_ids)).to eq([ [ preference.id ] ])
+        it "returns the correct hash" do
+          expect(tallied).to eq(
+            [{ "de" => "de1", "en" => "en1" }, { "de" => "de2", "en" => "en2" }] => 1,
+            [{ "de" => "de1", "en" => "en1" }, { "de" => "de3", "en" => "en3" }] => 1,
+          )
         end
       end
+    end
 
-      context "when the field path has an empty segment" do
+    context "when tallying an embedded field" do
+      let(:tally) do
+        context.tally("label.name")
+      end
 
-        let!(:band) do
-          Band.create!(name: "Depeche Mode", label: Label.new(name: "Mute"))
-        end
+      it "returns the correct hash" do
+        expect(tally).to eq("Atlantic" => 2, "Columbia" => 1)
+      end
+    end
 
-        let(:criteria) do
-          Band.all.tap do |crit|
-            crit.documents = [ band ]
-          end
+    context "when tallying an element in an embeds_many field" do
+
+      let(:tally) do
+        context2.tally("fanatics.age")
+      end
+
+      it "returns the correct hash" do
+        expect(tally).to eq(
+          [1, 2] => 2,
+          [1, 3] => 1
+        )
+      end
+    end
+
+    context "when tallying an embeds_many field" do
+
+      let(:tally) do
+        context2.tally("fanatics")
+      end
+
+      it "returns the correct hash" do
+        expect(tally).to eq(
+          fans1 => 1,
+          fans2 => 1,
+          fans3 => 1,
+        )
+      end
+    end
+
+    context "when tallying a field of type array" do
+
+      let(:tally) do
+        context2.tally("genres")
+      end
+
+      it "returns the correct hash" do
+        expect(tally).to eq(
+          [1, 2] => 2,
+          [1, 3] => 1
+        )
+      end
+    end
+
+    context "when tallying an element from an array of hashes" do
+
+      let(:tally) do
+        context.tally("genres.x")
+      end
+
+      it "returns the correct hash without the nil keys" do
+        expect(tally).to eq(
+          [1, 2] => 2,
+          [1, 3] => 1
+        )
+      end
+    end
+
+    context "when tallying an element from an array of hashes; with duplicate" do
+
+      let(:band4) { Band.new(origin: "tally", genres: [ { x: 1 }, {x: 1} ] ) }
+
+      let(:criteria) do
+        Band.where(origin: "tally").all.tap do |crit|
+          crit.documents = [ band1, band2, band3, band4 ]
         end
+      end
 
-        it "returns nil" do
-          expect(context.pluck("label..name")).to eq([ nil ])
+      let(:tally) do
+        context.tally("genres.x")
+      end
+
+      it "returns the correct hash without the nil keys" do
+        expect(tally).to eq(
+          [1, 2] => 2,
+          [1, 3] => 1,
+          [1, 1] => 1,
+        )
+      end
+    end
+
+    context "when tallying an aliased field of type array" do
+
+      let(:person1) { Person.new(array: [ 1, 2 ]) }
+      let(:person2) { Person.new(array: [ 1, 3 ]) }
+
+      let(:criteria) do
+        Person.all.tap do |crit|
+          crit.documents = [ person1, person2 ]
         end
       end
+
+      let(:tally) do
+        context.tally("array")
+      end
+
+      it "returns the correct hash" do
+        expect(tally).to eq(
+          [1, 2] => 1,
+          [1, 3] => 1
+        )
+      end
     end
-  end
 
-  describe '#inc' do
+    context "when going multiple levels deep in arrays" do
 
-    let(:criteria) do
-      Address.all.tap do |crit|
-        crit.documents = [ Address.new(number: 1),
-                           Address.new(number: 2),
-                           Address.new(number: 3) ]
+      let(:tally) do
+        context.tally("genres.y.z")
+      end
+
+      it "returns the correct hash" do
+        expect(tally).to eq(
+          [1, 2] => 2,
+          [1, 3] => 1
+        )
       end
     end
 
-    let(:context) do
-      described_class.new(criteria)
+    context "when going multiple levels deep in an array" do
+
+      let(:tally) do
+        context.tally("genres.y.z")
+      end
+
+      it "returns the correct hash" do
+        expect(tally).to eq(
+          [1, 2] => 2,
+          [1, 3] => 1
+        )
+      end
     end
 
-    it 'increases each member' do
-      expect(context.inc(number: 10).collect(&:number)).to eql([11, 12, 13])
+    context "when tallying deeply nested arrays/embedded associations" do
+
+      let(:person1) { Person.new(addresses: [ Address.new(code: Code.new(deepest: Deepest.new(array: [ { y: { z: 1 } }, { y: { z: 2 } } ]))) ]) }
+      let(:person2) { Person.new(addresses: [ Address.new(code: Code.new(deepest: Deepest.new(array: [ { y: { z: 1 } }, { y: { z: 2 } } ]))) ]) }
+      let(:person3) { Person.new(addresses: [ Address.new(code: Code.new(deepest: Deepest.new(array: [ { y: { z: 1 } }, { y: { z: 3 } } ]))) ]) }
+
+      let(:criteria) do
+        Person.all.tap do |crit|
+          crit.documents = [ person1, person2, person3 ]
+        end
+      end
+
+      let(:tally) do
+        context.tally("addresses.code.deepest.array.y.z")
+      end
+
+      it "returns the correct hash" do
+        expect(tally).to eq(
+          [ [ 1, 2 ] ] => 2,
+          [ [ 1, 3 ] ] => 1
+        )
+      end
     end
-  end
 
-  describe "#tally" do
+    context "when tallying deeply nested arrays/embedded associations" do
 
-    let(:context) do
-      described_class.new(criteria)
+      let(:person1) do
+        Person.new(addresses: [ Address.new(code: Code.new(deepest: Deepest.new(array: [ { y: { z: 1 } }, { y: { z: 2 } } ]))),
+                                    Address.new(code: Code.new(deepest: Deepest.new(array: [ { y: { z: 1 } }, { y: { z: 2 } } ]))) ])
+      end
+
+      let(:person2) do
+        Person.new(addresses: [ Address.new(code: Code.new(deepest: Deepest.new(array: [ { y: { z: 1 } }, { y: { z: 2 } } ]))),
+                                    Address.new(code: Code.new(deepest: Deepest.new(array: [ { y: { z: 1 } }, { y: { z: 2 } } ]))) ])
+      end
+
+      let(:person3) do
+        Person.new(addresses: [ Address.new(code: Code.new(deepest: Deepest.new(array: [ { y: { z: 1 } }, { y: { z: 3 } } ]))),
+                                    Address.new(code: Code.new(deepest: Deepest.new(array: [ { y: { z: 1 } }, { y: { z: 3 } } ]))) ])
+      end
+
+      let(:criteria) do
+        Person.all.tap do |crit|
+          crit.documents = [ person1, person2, person3 ]
+        end
+      end
+
+      let(:tally) do
+        context.tally("addresses.code.deepest.array.y.z")
+      end
+
+      it "returns the correct hash" do
+        expect(tally).to eq(
+          [ [ 1, 2 ], [ 1, 2 ] ] => 2,
+          [ [ 1, 3 ], [ 1, 3 ] ] => 1
+        )
+      end
     end
 
-    context "when the field name is a method name" do
+    context "when some keys are missing" do
+
+      let(:criteria) do
+        Band.where(origin: "tally").all.tap do |crit|
+          crit.documents = [ band1, band2, band3 ]
+          3.times{ crit.documents << Band.new(origin: "tally") }
+        end
+      end
 
-      let!(:person) do
-        Person.create!(ssn: "secret-ssn")
+      let(:tally) do
+        context.tally(:name)
       end
 
-      let!(:address) do
-        person.addresses.create!(street: "hobrecht")
+      it "returns the correct hash" do
+        expect(tally).to eq(
+          "Depeche Mode" => 1,
+          "New Order" => 1,
+          "10,000 Maniacs" => 1,
+          nil => 3
+        )
       end
+    end
+
+    context "when the first element is an embeds_one" do
+      let(:person1) { Person.create!(name: Name.new(translations: [ Translation.new(language: 1), Translation.new(language: 2) ])) }
+      let(:person2) { Person.create!(name: Name.new(translations: [ Translation.new(language: 1), Translation.new(language: 2) ])) }
+      let(:person3) { Person.create!(name: Name.new(translations: [ Translation.new(language: 1), Translation.new(language: 3) ])) }
 
       let(:criteria) do
-        Address.all.tap do |crit|
-          crit.documents = [ address ]
+        Person.all.tap do |crit|
+          crit.documents = [ person1, person2, person3 ]
         end
       end
 
-      it "does not call the method" do
-        expect(address).not_to receive(:destroy)
-        expect(context.tally(:destroy)).to eq(nil => 1)
+      let(:tally) do
+        context.tally("name.translations.language")
+      end
+
+      it "returns the correct hash" do
+        expect(tally).to eq(
+          [1, 2] => 2,
+          [1, 3] => 1
+        )
       end
+    end
+  end
+
+  describe '#inc' do
 
-      it "does not disclose the parent document fields" do
-        expect(context.tally("_root.ssn")).to eq(nil => 1)
+    let(:criteria) do
+      Address.all.tap do |crit|
+        crit.documents = [ Address.new(number: 1),
+                           Address.new(number: 2),
+                           Address.new(number: 3) ]
       end
     end
+
+    let(:context) do
+      described_class.new(criteria)
+    end
+
+    it 'increases each member' do
+      expect(context.inc(number: 10).collect(&:number)).to eql([11, 12, 13])
+    end
   end
 
   describe "#skip" do