mongoid 3.1.5 → 8.0.2

data/spec/mongoid/contextual/memory_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Mongoid::Contextual::Memory do
@@ -27,7 +29,7 @@ describe Mongoid::Contextual::Memory do
         end
 
         it "returns false" do
-          context.send(method).should be_false
+          expect(context.send(method)).to be false
         end
       end
 
@@ -44,7 +46,22 @@ describe Mongoid::Contextual::Memory do
         end
 
         it "returns true" do
-          context.send(method).should be_true
+          expect(context.send(method)).to be true
+        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, friedel ]
+          end.collation(locale: 'en_US', strength: 2)
+        end
+
+        it "raises an exception" do
+          expect {
+            context.send(method)
+          }.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
         end
       end
     end
@@ -73,7 +90,22 @@ describe Mongoid::Contextual::Memory do
     context "context when no arguments are provided" do
 
       it "returns the number of matches" do
-        context.count.should eq(1)
+        expect(context.count).to eq(1)
+      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, friedel ]
+        end.collation(locale: 'en_US', strength: 2)
+      end
+
+      it "raises an exception" do
+        expect {
+          context.count
+        }.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
       end
     end
 
@@ -86,7 +118,7 @@ describe Mongoid::Contextual::Memory do
         end
 
         it "returns 1" do
-          count.should eq(1)
+          expect(count).to eq(1)
         end
       end
 
@@ -97,7 +129,7 @@ describe Mongoid::Contextual::Memory do
         end
 
         it "returns 0" do
-          count.should eq(0)
+          expect(count).to eq(0)
         end
       end
     end
@@ -113,7 +145,7 @@ describe Mongoid::Contextual::Memory do
         end
 
         it "returns 1" do
-          count.should eq(1)
+          expect(count).to eq(1)
         end
       end
 
@@ -126,7 +158,7 @@ describe Mongoid::Contextual::Memory do
         end
 
         it "returns 0" do
-          count.should eq(0)
+          expect(count).to eq(0)
         end
       end
     end
@@ -135,19 +167,19 @@ describe Mongoid::Contextual::Memory do
   [ :delete, :delete_all ].each do |method|
 
     let(:person) do
-      Person.create
+      Person.create!
     end
 
     let(:hobrecht) do
-      person.addresses.create(street: "hobrecht")
+      person.addresses.create!(street: "hobrecht")
     end
 
     let(:friedel) do
-      person.addresses.create(street: "friedel")
+      person.addresses.create!(street: "friedel")
     end
 
     let(:pfluger) do
-      person.addresses.create(street: "pfluger")
+      person.addresses.create!(street: "pfluger")
     end
 
     describe "##{method}" do
@@ -169,42 +201,42 @@ describe Mongoid::Contextual::Memory do
         end
 
         it "deletes the first matching document" do
-          hobrecht.should be_destroyed
+          expect(hobrecht).to be_destroyed
         end
 
         it "deletes the last matching document" do
-          friedel.should be_destroyed
+          expect(friedel).to be_destroyed
         end
 
         it "does not delete non matching docs" do
-          pfluger.should_not be_destroyed
+          expect(pfluger).to_not be_destroyed
         end
 
         it "removes the docs from the relation" do
-          person.addresses.should eq([ pfluger ])
+          expect(person.addresses).to eq([ pfluger ])
         end
 
         it "removes the docs from the context" do
-          context.entries.should be_empty
+          expect(context.entries).to be_empty
         end
 
         it "persists the changes to the database" do
-          person.reload.addresses.should eq([ pfluger ])
+          expect(person.reload.addresses).to eq([ pfluger ])
         end
 
         it "returns the number of deleted documents" do
-          deleted.should eq(2)
+          expect(deleted).to eq(2)
         end
       end
 
       context "when embedded multiple levels" do
 
         let!(:home) do
-          hobrecht.locations.create(name: "home")
+          hobrecht.locations.create!(name: "home")
         end
 
         let!(:work) do
-          hobrecht.locations.create(name: "work")
+          hobrecht.locations.create!(name: "work")
         end
 
         let(:criteria) do
@@ -222,27 +254,42 @@ describe Mongoid::Contextual::Memory do
         end
 
         it "deletes the first matching document" do
-          work.should be_destroyed
+          expect(work).to be_destroyed
         end
 
         it "does not delete non matching docs" do
-          home.should_not be_destroyed
+          expect(home).to_not be_destroyed
         end
 
         it "removes the docs from the relation" do
-          person.addresses.first.locations.should eq([ home ])
+          expect(person.addresses.first.locations).to eq([ home ])
         end
 
         it "removes the docs from the context" do
-          context.entries.should be_empty
+          expect(context.entries).to be_empty
         end
 
         it "persists the changes to the database" do
-          person.reload.addresses.first.locations.should eq([ home ])
+          expect(person.reload.addresses.first.locations).to eq([ home ])
         end
 
         it "returns the number of deleted documents" do
-          deleted.should eq(1)
+          expect(deleted).to eq(1)
+        end
+      end
+
+      context 'when there is a collation on the criteria' do
+
+        let(:criteria) do
+          Address.any_in(street: [ "hobrecht", "friedel" ]).tap do |crit|
+            crit.documents = [ hobrecht, friedel, pfluger ]
+          end.collation(locale: 'en_US', strength: 2)
+        end
+
+        it "raises an exception" do
+          expect {
+            context.send(method)
+          }.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
         end
       end
     end
@@ -251,19 +298,19 @@ describe Mongoid::Contextual::Memory do
   [ :destroy, :destroy_all ].each do |method|
 
     let(:person) do
-      Person.create
+      Person.create!
     end
 
     let(:hobrecht) do
-      person.addresses.create(street: "hobrecht")
+      person.addresses.create!(street: "hobrecht")
     end
 
     let(:friedel) do
-      person.addresses.create(street: "friedel")
+      person.addresses.create!(street: "friedel")
     end
 
     let(:pfluger) do
-      person.addresses.create(street: "pfluger")
+      person.addresses.create!(street: "pfluger")
     end
 
     let(:criteria) do
@@ -278,55 +325,131 @@ describe Mongoid::Contextual::Memory do
 
     describe "##{method}" do
 
-      let!(:destroyed) do
-        context.send(method)
-      end
+      context 'when there is no collation on the criteria' do
 
-      it "deletes the first matching document" do
-        hobrecht.should be_destroyed
-      end
+        let!(:destroyed) do
+          context.send(method)
+        end
+
+        it "deletes the first matching document" do
+          expect(hobrecht).to be_destroyed
+        end
+
+        it "deletes the last matching document" do
+          expect(friedel).to be_destroyed
+        end
+
+        it "does not delete non matching docs" do
+          expect(pfluger).to_not be_destroyed
+        end
+
+        it "removes the docs from the relation" do
+          expect(person.addresses).to eq([ pfluger ])
+        end
+
+        it "removes the docs from the context" do
+          expect(context.entries).to be_empty
+        end
+
+        it "persists the changes to the database" do
+          expect(person.reload.addresses).to eq([ pfluger ])
+        end
 
-      it "deletes the last matching document" do
-        friedel.should be_destroyed
+        it "returns the number of destroyed documents" do
+          expect(destroyed).to eq(2)
+        end
       end
 
-      it "does not delete non matching docs" do
-        pfluger.should_not be_destroyed
+      context 'when there is a collation on the criteria' do
+
+        let(:criteria) do
+          Address.any_in(street: [ "hobrecht", "friedel" ]).tap do |crit|
+            crit.documents = [ hobrecht, friedel, pfluger ]
+          end.collation(locale: 'en_US', strength: 2)
+        end
+
+        it "raises an exception" do
+          expect {
+            context.send(method)
+          }.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
+        end
       end
+    end
+  end
+
+  describe "#distinct" do
+
+    context "when legacy_pluck_distinct is true" do
+      config_override :legacy_pluck_distinct, true
 
-      it "removes the docs from the relation" do
-        person.addresses.should eq([ pfluger ])
+      let(:hobrecht) do
+        Address.new(street: "hobrecht")
       end
 
-      it "removes the docs from the context" do
-        context.entries.should be_empty
+      let(:friedel) do
+        Address.new(street: "friedel")
       end
 
-      it "persists the changes to the database" do
-        person.reload.addresses.should eq([ pfluger ])
+      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)
+        end
+
+        it "returns the distinct field values" do
+          expect(context.distinct(:street)).to eq([ "hobrecht" ])
+        end
       end
 
-      it "returns the number of destroyed documents" do
-        destroyed.should eq(2)
+      context "when not limiting the result set" do
+
+        let(:criteria) do
+          Address.all.tap do |crit|
+            crit.documents = [ hobrecht, friedel, friedel ]
+          end
+        end
+
+        let(:context) do
+          described_class.new(criteria)
+        end
+
+        it "returns the distinct field values" do
+          expect(context.distinct(:street)).to eq([ "hobrecht", "friedel" ])
+        end
       end
-    end
-  end
 
-  describe "#distinct" do
+      context 'when there is a collation on the criteria' do
 
-    let(:hobrecht) do
-      Address.new(street: "hobrecht")
-    end
+        let(:criteria) do
+          Address.where(street: "hobrecht").tap do |crit|
+            crit.documents = [ hobrecht, hobrecht, friedel ]
+          end.collation(locale: 'en_US', strength: 2)
+        end
 
-    let(:friedel) do
-      Address.new(street: "friedel")
+        it "raises an exception" do
+          expect {
+            context.distinct(:street)
+          }.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
+        end
+      end
     end
 
-    context "when limiting the result set" do
+    context "when legacy_pluck_distinct is false" do
+      config_override :legacy_pluck_distinct, false
+
+      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") }
 
       let(:criteria) do
-        Address.where(street: "hobrecht").tap do |crit|
-          crit.documents = [ hobrecht, hobrecht, friedel ]
+        Band.all.tap do |crit|
+          crit.documents = [ depeche, new_order, maniacs ]
         end
       end
 
@@ -334,25 +457,180 @@ describe Mongoid::Contextual::Memory do
         described_class.new(criteria)
       end
 
-      it "returns the distinct field values" do
-        context.distinct(:street).should eq([ "hobrecht" ])
+      context "when limiting the result set" do
+
+        let(:criteria) do
+          Band.where(name: "Depeche Mode").tap do |crit|
+            crit.documents = [ depeche ]
+          end
+        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
+
+        it "returns the distinct field values" do
+          expect(context.distinct(:name).sort).to eq([ "10,000 Maniacs", "Depeche Mode", "New Order" ].sort)
+        end
       end
-    end
 
-    context "when not limiting the result set" do
+      context "when providing an aliased field" do
 
-      let(:criteria) do
-        Address.all.tap do |crit|
-          crit.documents = [ hobrecht, friedel, friedel ]
+        it "returns the distinct field values" do
+          expect(context.distinct(:years).sort).to eq([ 20, 25, 30 ])
         end
       end
 
-      let(:context) do
-        described_class.new(criteria)
+      context "when providing a demongoizable field" do
+
+        it "returns the non-demongoized distinct field values" do
+          expect(context.distinct(:sales).sort).to eq([ BigDecimal("1E2"), BigDecimal("2E3") ])
+        end
+      end
+
+      context "when getting a localized field" do
+        before do
+          I18n.locale = :en
+          d = Dictionary.create!(description: 'english-text')
+          I18n.locale = :de
+          d.description = 'deutsch-text'
+          d.save!
+        end
+
+        after do
+          I18n.locale = :en
+        end
+
+        let(:criteria) do
+          Dictionary.all.tap do |crit|
+            crit.documents = [ Dictionary.first ]
+          end
+        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
+        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
+        end
+
+        context 'when plucking a specific locale' do
+
+          let(:distinct) do
+            context.distinct(:'description.de')
+          end
+
+          it 'returns the specific translation' do
+            expect(distinct).to eq([ "deutsch-text" ])
+          end
+        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'])
+          end
+        end
+
+        context 'when fallbacks are enabled with a locale list' do
+          require_fallbacks
+
+          around(:all) do |example|
+            prev_fallbacks = I18n.fallbacks.dup
+            I18n.fallbacks[:he] = [ :en ]
+            example.run
+            I18n.fallbacks = prev_fallbacks
+          end
+
+          after do
+            I18n.locale = :en
+          end
+
+          let(:distinct) do
+            context.distinct(:description).first
+          end
+
+          it "correctly uses the fallback" do
+            I18n.locale = :en
+            d = Dictionary.create!(description: 'english-text')
+            I18n.locale = :he
+            distinct.should == "english-text"
+          end
+        end
+
+        context "when the localized field is embedded" do
+          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
+
+          after do
+            I18n.locale = :en
+          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
+
+          it "returns the translation for the requested locale" do
+            expect(distinct_translations_field).to eq("Neil")
+          end
+        end
       end
 
-      it "returns the distinct field values" do
-        context.distinct(:street).should eq([ "hobrecht", "friedel" ])
+      context "when getting an embedded field" do
+
+        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
+        end
+
+        it "returns the distinct matching fields" do
+          expect(context.distinct("label.sales")).to eq([ BigDecimal("1E2") ])
+        end
       end
     end
   end
@@ -384,7 +662,7 @@ describe Mongoid::Contextual::Memory do
       end
 
       it "contains no documents" do
-        context.map(&:street).should be_empty
+        expect(context.map(&:street)).to be_empty
       end
 
       context "when calling next on the enumerator" do
@@ -401,13 +679,13 @@ describe Mongoid::Contextual::Memory do
 
       it "yields mongoid documents to the block" do
         context.each do |doc|
-          doc.should be_a(Mongoid::Document)
+          expect(doc).to be_a(Mongoid::Document)
         end
       end
 
       it "iterates over the matching documents" do
         context.each do |doc|
-          doc.should eq(hobrecht)
+          expect(doc).to eq(hobrecht)
         end
       end
     end
@@ -419,7 +697,7 @@ describe Mongoid::Contextual::Memory do
       end
 
       it "returns an enumerator" do
-        enum.should be_a(Enumerator)
+        expect(enum).to be_a(Enumerator)
       end
 
       context "when iterating over the enumerator" do
@@ -428,7 +706,7 @@ describe Mongoid::Contextual::Memory do
 
           it "yields mongoid documents to the block" do
             enum.each do |doc|
-              doc.should be_a(Mongoid::Document)
+              expect(doc).to be_a(Mongoid::Document)
             end
           end
         end
@@ -436,11 +714,26 @@ describe Mongoid::Contextual::Memory do
         context "when iterating with next" do
 
           it "yields mongoid documents" do
-            enum.next.should be_a(Mongoid::Document)
+            expect(enum.next).to be_a(Mongoid::Document)
           end
         end
       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, friedel ]
+        end.collation(locale: 'en_US', strength: 2)
+      end
+
+      it "raises an exception" do
+        expect {
+          context.each
+        }.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
+      end
+    end
   end
 
   describe "#exists?" do
@@ -466,7 +759,7 @@ describe Mongoid::Contextual::Memory do
       end
 
       it "returns true" do
-        context.should be_exists
+        expect(context).to be_exists
       end
     end
 
@@ -483,42 +776,29 @@ describe Mongoid::Contextual::Memory do
       end
 
       it "returns false" do
-        context.should_not be_exists
+        expect(context).to_not be_exists
       end
     end
-  end
-
-  [ :first, :one ].each do |method|
-
-    describe "##{method}" do
-
-      let(:hobrecht) do
-        Address.new(street: "hobrecht")
-      end
 
-      let(:friedel) do
-        Address.new(street: "friedel")
-      end
+    context 'when there is a collation on the criteria' do
 
       let(:criteria) do
-        Address.where(:street.in => [ "hobrecht", "friedel" ]).tap do |crit|
+        Address.where(street: "pfluger").tap do |crit|
           crit.documents = [ hobrecht, friedel ]
-        end
-      end
-
-      let(:context) do
-        described_class.new(criteria)
+        end.collation(locale: 'en_US', strength: 2)
       end
 
-      it "returns the first matching document" do
-        context.send(method).should eq(hobrecht)
+      it "raises an exception" do
+        expect {
+          context
+        }.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
       end
     end
   end
 
-  describe "#initialize" do
+  [ :first, :one ].each do |method|
 
-    context "when the criteria has no options" do
+    describe "##{method}" do
 
       let(:hobrecht) do
         Address.new(street: "hobrecht")
@@ -529,7 +809,7 @@ describe Mongoid::Contextual::Memory do
       end
 
       let(:criteria) do
-        Address.where(street: "hobrecht").tap do |crit|
+        Address.where(:street.in => [ "hobrecht", "friedel" ]).tap do |crit|
           crit.documents = [ hobrecht, friedel ]
         end
       end
@@ -538,83 +818,1023 @@ describe Mongoid::Contextual::Memory do
         described_class.new(criteria)
       end
 
-      it "sets the criteria" do
-        context.criteria.should eq(criteria)
+      it "returns the first matching document" do
+        expect(context.send(method)).to eq(hobrecht)
       end
 
-      it "sets the klass" do
-        context.klass.should eq(Address)
+      it "returns a list when passing a limit" do
+        expect(context.send(method, 2)).to eq([ hobrecht, friedel ])
       end
 
-      it "sets the matching documents" do
-        context.documents.should eq([ hobrecht ])
+      it "returns a list when passing 1" do
+        expect(context.send(method, 1)).to eq([ hobrecht ])
       end
-    end
-
-    context "when the criteria skips" do
 
-      let(:hobrecht) do
-        Address.new(street: "hobrecht")
-      end
+      context 'when there is a collation on the criteria' do
 
-      let(:friedel) do
-        Address.new(street: "friedel")
-      end
+        let(:criteria) do
+          Address.where(:street.in => [ "hobrecht", "friedel" ]).tap do |crit|
+            crit.documents = [ hobrecht, friedel ]
+          end.collation(locale: 'en_US', strength: 2)
+        end
 
-      let(:criteria) do
-        Address.all.skip(1).tap do |crit|
-          crit.documents = [ hobrecht, friedel ]
+        it "raises an exception" do
+          expect {
+            context.send(method)
+          }.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
         end
       end
+    end
+  end
 
-      let(:context) do
-        described_class.new(criteria)
-      end
+  describe "#take" do
 
-      it "limits the matching documents" do
-        context.should eq([ friedel ])
-      end
+    let(:hobrecht) do
+      Address.new(street: "hobrecht")
     end
 
-    context "when the criteria limits" do
-
+    let(:friedel) do
+      Address.new(street: "friedel")
+    end
+
+    let(:criteria) do
+      Address.where(:street.in => [ "hobrecht", "friedel" ]).tap do |crit|
+        crit.documents = [ hobrecht, friedel ]
+      end
+    end
+
+    let(:context) do
+      described_class.new(criteria)
+    end
+
+    it "returns the first matching document" do
+      expect(context.take).to eq(hobrecht)
+    end
+
+    it "returns an array when passing a limit" do
+      expect(context.take(2)).to eq([ hobrecht, friedel ])
+    end
+
+    it "returns an array when passing a limit as 1" do
+      expect(context.take(1)).to eq([ hobrecht ])
+    end
+
+    context 'when there is a collation on the criteria' do
+
+      let(:criteria) do
+        Address.where(:street.in => [ "hobrecht", "friedel" ]).tap do |crit|
+          crit.documents = [ hobrecht, friedel ]
+        end.collation(locale: 'en_US', strength: 2)
+      end
+
+      it "raises an exception" do
+        expect {
+          context.take
+        }.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
+      end
+    end
+  end
+
+  describe "#take!" do
+
+    let(:hobrecht) do
+      Address.new(street: "hobrecht")
+    end
+
+    let(:friedel) do
+      Address.new(street: "friedel")
+    end
+
+    let(:criteria) do
+      Address.where(:street.in => [ "hobrecht", "friedel" ]).tap do |crit|
+        crit.documents = [ hobrecht, friedel ]
+      end
+    end
+
+    let(:context) do
+      described_class.new(criteria)
+    end
+
+    it "returns the first matching document" do
+      expect(context.take!).to eq(hobrecht)
+    end
+
+    context "when the criteria is empty" do
+      let(:criteria) do
+        Address.where(street: "bogus").tap do |crit|
+          crit.documents = []
+        end
+      end
+
+      it "raise an error" do
+        expect do
+          context.take!
+        end.to raise_error(Mongoid::Errors::DocumentNotFound, /Could not find a document of class Address./)
+      end
+    end
+
+    context 'when there is a collation on the criteria' do
+
+      let(:criteria) do
+        Address.where(:street.in => [ "hobrecht", "friedel" ]).tap do |crit|
+          crit.documents = [ hobrecht, friedel ]
+        end.collation(locale: 'en_US', strength: 2)
+      end
+
+      it "raises an exception" do
+        expect {
+          context.take
+        }.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
+      end
+    end
+  end
+
+  describe "#initialize" do
+
+    context "when the criteria has no options" do
+
+      let(:hobrecht) do
+        Address.new(street: "hobrecht")
+      end
+
+      let(:friedel) do
+        Address.new(street: "friedel")
+      end
+
+      let(:criteria) do
+        Address.where(street: "hobrecht").tap do |crit|
+          crit.documents = [ hobrecht, friedel ]
+        end
+      end
+
+      let(:context) do
+        described_class.new(criteria)
+      end
+
+      it "sets the criteria" do
+        expect(context.criteria).to eq(criteria)
+      end
+
+      it "sets the klass" do
+        expect(context.klass).to eq(Address)
+      end
+
+      it "sets the matching documents" do
+        expect(context.documents).to eq([ hobrecht ])
+      end
+    end
+
+    context "when the criteria skips" do
+
+      let(:hobrecht) do
+        Address.new(street: "hobrecht")
+      end
+
+      let(:friedel) do
+        Address.new(street: "friedel")
+      end
+
+      let(:criteria) do
+        Address.all.skip(1).tap do |crit|
+          crit.documents = [ hobrecht, friedel ]
+        end
+      end
+
+      let(:context) do
+        described_class.new(criteria)
+      end
+
+      it "limits the matching documents" do
+        expect(context).to eq([ friedel ])
+      end
+    end
+
+    context "when the criteria limits" do
+
+      let(:hobrecht) do
+        Address.new(street: "hobrecht")
+      end
+
+      let(:friedel) do
+        Address.new(street: "friedel")
+      end
+
+      let(:criteria) do
+        Address.all.limit(1).tap do |crit|
+          crit.documents = [ hobrecht, friedel ]
+        end
+      end
+
+      let(:context) do
+        described_class.new(criteria)
+      end
+
+      it "limits the matching documents" do
+        expect(context).to eq([ hobrecht ])
+      end
+    end
+
+    context 'when there is a collation on the criteria' do
+
+      let(:criteria) do
+        Address.all.limit(1).tap do |crit|
+          crit.documents = [ hobrecht, friedel ]
+        end.collation(locale: 'en_US', strength: 2)
+      end
+
+      it "raises an exception" do
+        expect {
+          context
+        }.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
+      end
+    end
+  end
+
+  describe "#last" do
+
+    let(:hobrecht) do
+      Address.new(street: "hobrecht")
+    end
+
+    let(:friedel) do
+      Address.new(street: "friedel")
+    end
+
+    let(:criteria) do
+      Address.where(:street.in => [ "hobrecht", "friedel" ]).tap do |crit|
+        crit.documents = [ hobrecht, friedel ]
+      end
+    end
+
+    let(:context) do
+      described_class.new(criteria)
+    end
+
+    it "returns the last matching document" do
+      expect(context.last).to eq(friedel)
+    end
+
+    it "returns a list when a limit is passed" do
+      expect(context.last(2)).to eq([ hobrecht, friedel ])
+    end
+
+    it "returns a list when the limit is 1" do
+      expect(context.last(1)).to eq([ friedel ])
+    end
+
+    context 'when there is a collation on the criteria' do
+
+      let(:criteria) do
+        Address.where(:street.in => [ "hobrecht", "friedel" ]).tap do |crit|
+          crit.documents = [ hobrecht, friedel ]
+        end.collation(locale: 'en_US', strength: 2)
+      end
+
+      it "raises an exception" do
+        expect {
+          context.last
+        }.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
+      end
+    end
+  end
+
+  [ :length, :size ].each do |method|
+
+    describe "##{method}" do
+
+      let(:hobrecht) do
+        Address.new(street: "hobrecht")
+      end
+
+      let(:friedel) do
+        Address.new(street: "friedel")
+      end
+
+      context "when there are matching documents" do
+
+        let(:criteria) do
+          Address.where(street: "hobrecht").tap do |crit|
+            crit.documents = [ hobrecht, friedel ]
+          end
+        end
+
+        let(:context) do
+          described_class.new(criteria)
+        end
+
+        it "returns the number of matches" do
+          expect(context.send(method)).to eq(1)
+        end
+      end
+
+      context "when there are no matching documents" do
+
+        let(:criteria) do
+          Address.where(street: "pfluger").tap do |crit|
+            crit.documents = [ hobrecht, friedel ]
+          end
+        end
+
+        let(:context) do
+          described_class.new(criteria)
+        end
+
+        it "returns zero" do
+          expect(context.send(method)).to eq(0)
+        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, friedel ]
+          end.collation(locale: 'en_US', strength: 2)
+        end
+
+        it "raises an exception" do
+          expect {
+            context.send(method)
+          }.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
+        end
+      end
+    end
+  end
+
+  describe "#limit" do
+
+    let(:hobrecht) do
+      Address.new(street: "hobrecht")
+    end
+
+    let(:friedel) do
+      Address.new(street: "friedel")
+    end
+
+    let(:pfluger) do
+      Address.new(street: "pfluger")
+    end
+
+    let(:criteria) do
+      Address.all.tap do |crit|
+        crit.documents = [ hobrecht, friedel, pfluger ]
+      end
+    end
+
+    let(:context) do
+      described_class.new(criteria)
+    end
+
+    context 'when there is no collation on the criteria' do
+
+      let!(:limit) do
+        context.limit(2)
+      end
+
+      it "returns the context" do
+        expect(limit).to eq(context)
+      end
+
+      context "when asking for all documents" do
+
+        context "when only a limit exists" do
+
+          it "only returns the limited documents" do
+            expect(context.entries).to eq([ hobrecht, friedel ])
+          end
+        end
+
+        context "when a skip and limit exist" do
+
+          before do
+            limit.skip(1)
+          end
+
+          it "applies the skip before the limit" do
+            expect(context.entries).to eq([ friedel, pfluger ])
+          end
+        end
+      end
+    end
+
+    context 'when there is a collation on the criteria' do
+
+      let(:criteria) do
+        Address.all.tap do |crit|
+          crit.documents = [ hobrecht, friedel, pfluger ]
+        end.collation(locale: 'en_US', strength: 2)
+      end
+
+      it "raises an exception" do
+        expect {
+          context.limit(2)
+        }.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
+      end
+    end
+  end
+
+  describe "#pluck" do
+
+    let(:context) 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")
       end
 
-      let(:friedel) do
-        Address.new(street: "friedel")
+      let(:friedel) do
+        Address.new(street: "friedel")
+      end
+
+      let(:criteria) do
+        Address.all.tap do |crit|
+          crit.documents = [ hobrecht, friedel ]
+        end
+      end
+
+      context "when plucking" do
+
+        let!(:plucked) do
+          context.pluck(:street)
+        end
+
+        it "returns the values" do
+          expect(plucked).to eq([ "hobrecht", "friedel" ])
+        end
+      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
+      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 a 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 a empty array" do
+            expect(plucked).to eq([[nil, nil], [nil, nil]])
+          end
+        end
+      end
+
+      context 'when there is a collation on the criteria' do
+
+        let(:criteria) do
+          Address.all.tap do |crit|
+            crit.documents = [ hobrecht, friedel ]
+          end.collation(locale: 'en_US', strength: 2)
+        end
+
+        it "raises an exception" do
+          expect {
+            context.pluck(:foo, :bar)
+          }.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
+        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
+
+      let!(:maniacs) do
+        Band.create!(name: "10,000 Maniacs", likes: 1, sales: "1E2")
+      end
+
+      let(:criteria) do
+        Band.all.tap do |crit|
+          crit.documents = [ depeche, tool, photek, maniacs ]
+        end
+      end
+
+      context "when the field is aliased" do
+
+        let!(:expensive) do
+          Product.create!(price: 100000)
+        end
+
+        let!(:cheap) do
+          Product.create!(price: 1)
+        end
+
+        let(:criteria) do
+          Product.all.tap do |crit|
+            crit.documents = [ expensive, cheap ]
+          end
+        end
+
+        context "when using alias_attribute" do
+
+          let(:plucked) do
+            context.pluck(:price)
+          end
+
+          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
+
+          it "returns the values" do
+            expect(plucked).to contain_exactly("10,000 Maniacs", "Depeche Mode", "Tool", "Photek")
+          end
+
+          context "when subsequently executing the criteria without a pluck" do
+
+            it "does not limit the fields" do
+              expect(context.first.likes).to eq(3)
+            end
+          end
+
+          context 'when the field is a subdocument' 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"]]
+                ]
+              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(:expected) do
+                [
+                  [],
+                  ["LP1"]
+                ]
+              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
+
+          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 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
+        end
+      end
+
+      context "when plucking an aliased field" do
+
+        let(:plucked) do
+          context.pluck(:id)
+        end
+
+        it "returns the field values" do
+          expect(plucked).to eq([ depeche.id, tool.id, photek.id, maniacs.id ])
+        end
+      end
+
+      context "when plucking existent and non-existent fields" do
+
+        let(:plucked) do
+          context.pluck(:id, :fooz)
+        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
+
+      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 array with nil values" do
+            expect(plucked).to eq([nil, nil, nil, nil])
+          end
+        end
+
+        context "when pluck multiple fields" do
+
+          let(:plucked) do
+            context.pluck(:foo, :bar)
+          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 a localized field' do
+
+        before do
+          I18n.locale = :en
+          d = Dictionary.create!(description: 'english-text')
+          I18n.locale = :de
+          d.description = 'deutsch-text'
+          d.save!
+        end
+
+        after do
+          I18n.locale = :en
+        end
+
+        let(:criteria) do
+          Dictionary.all.tap do |crit|
+            crit.documents = [ Dictionary.first ]
+          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
+
+          it 'returns the full translations hash to _translations' do
+            expect(plucked_translations.first).to eq({"de"=>"deutsch-text", "en"=>"english-text"})
+          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 specific locale' do
+
+          let(:plucked) do
+            context.pluck(:'description.de')
+          end
+
+          it 'returns the specific translations' do
+            expect(plucked.first).to eq('deutsch-text')
+          end
+        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
+        end
+
+        context 'when fallbacks are enabled with a locale list' do
+          require_fallbacks
+
+          around(:all) do |example|
+            prev_fallbacks = I18n.fallbacks.dup
+            I18n.fallbacks[:he] = [ :en ]
+            example.run
+            I18n.fallbacks = prev_fallbacks
+          end
+
+          after do
+            I18n.locale = :en
+          end
+
+          let(:plucked) do
+            context.pluck(:description).first
+          end
+
+          it "correctly uses the fallback" do
+            I18n.locale = :en
+            d = Dictionary.create!(description: 'english-text')
+            I18n.locale = :he
+            plucked.should == "english-text"
+          end
+        end
+
+        context "when the localized field is embedded" do
+          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
+
+          after do
+            I18n.locale = :en
+          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 full _translation hash" do
+            expect(plucked_translations).to eq({ "en" => "Neil", "he" => "Nissim" })
+          end
+
+          it "returns the translation for the requested locale" do
+            expect(plucked_translations_field).to eq("Neil")
+          end
+        end
+      end
+
+      context 'when plucking a field to be demongoized' do
+
+        let(:plucked) do
+          Band.where(name: maniacs.name).pluck(:sales)
+        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
+        end
+      end
+
+      context "when plucking an 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.sales")
+        end
+
+        it "demongoizes the field" do
+          expect(plucked).to eq([ BigDecimal("1E2") ])
+        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") }
+
+        it "demongoizes the field" do
+          expect(plucked.first).to eq([ BigDecimal("1E2") ])
+        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")
+        end
+
+        it "returns nil" do
+          expect(plucked.first).to eq(nil)
+        end
+      end
+
+      context "when tallying deeply nested arrays/embedded associations" do
+
+        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
+        end
+
+        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
+  end
+
+  describe "#pick" do
+
+    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 an array" do
+        expect(picked).to eq([ "Depeche Mode", 3 ])
       end
+    end
+
+    context "when no documents to pick" do
 
       let(:criteria) do
-        Address.all.limit(1).tap do |crit|
-          crit.documents = [ hobrecht, friedel ]
+        Band.all.tap do |crit|
+          crit.documents = []
         end
       end
 
-      let(:context) do
-        described_class.new(criteria)
+      let(:picked) do
+        context.pick(:name)
       end
 
-      it "limits the matching documents" do
-        context.should eq([ hobrecht ])
+      it "returns nil" do
+        expect(picked).to be_nil
       end
     end
   end
 
-  describe "#last" do
+  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(:hobrecht) do
-      Address.new(street: "hobrecht")
-    end
+    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(:friedel) do
-      Address.new(street: "friedel")
-    end
+
+    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
-      Address.where(:street.in => [ "hobrecht", "friedel" ]).tap do |crit|
-        crit.documents = [ hobrecht, friedel ]
+      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
 
@@ -622,110 +1842,437 @@ describe Mongoid::Contextual::Memory do
       described_class.new(criteria)
     end
 
-    it "returns the last matching document" do
-      context.last.should eq(friedel)
+    let(:context2) do
+      described_class.new(criteria2)
     end
-  end
 
-  [ :length, :size ].each do |method|
+    context "when tallying a string" do
+      let(:tally) do
+        context.tally(:name)
+      end
 
-    describe "##{method}" do
+      it "returns the correct hash" do
+        expect(tally).to eq("Depeche Mode" => 1, "New Order" => 1, "10,000 Maniacs" => 1)
+      end
+    end
 
-      let(:hobrecht) do
-        Address.new(street: "hobrecht")
+    context "using an aliased field" do
+      let(:tally) do
+        context.tally(:years)
       end
 
-      let(:friedel) do
-        Address.new(street: "friedel")
+      it "returns the correct hash" do
+        expect(tally).to eq(30 => 3)
       end
+    end
 
-      context "when there are matching documents" do
+    context "when tallying a demongoizable field" do
+      let(:tally) do
+        context.tally(:sales)
+      end
 
-        let(:criteria) do
-          Address.where(street: "hobrecht").tap do |crit|
-            crit.documents = [ hobrecht, friedel ]
-          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(:criteria) do
+        Dictionary.all.tap do |crit|
+          crit.documents = [ d1, d2, d3, d4 ]
         end
+      end
 
-        let(:context) do
-          described_class.new(criteria)
+      context "when getting the demongoized field" do
+        let(:tallied) do
+          context.tally(:description)
         end
 
-        it "returns the number of matches" do
-          context.send(method).should eq(1)
+        it "returns the translation for the current locale" do
+          expect(tallied).to eq("en1" => 3, "en2" => 1)
         end
       end
 
-      context "when there are no matching documents" do
+      context "when getting a specific locale" do
+        let(:tallied) do
+          context.tally("description.de")
+        end
 
-        let(:criteria) do
-          Address.where(street: "pfluger").tap do |crit|
-            crit.documents = [ hobrecht, friedel ]
-          end
+        it "returns the translation for the the specific locale" do
+          expect(tallied).to eq("de1" => 2, "de2" => 1, "de3" => 1)
         end
+      end
 
-        let(:context) do
-          described_class.new(criteria)
+      context "when getting the full hash" do
+        let(:tallied) do
+          context.tally("description_translations")
         end
 
-        it "returns zero" do
-          context.send(method).should eq(0)
+        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
-  end
 
-  describe "#limit" do
+    context "when tallying an embedded localized field" do
 
-    let(:hobrecht) do
-      Address.new(street: "hobrecht")
+      let(:person1) { Person.create!(addresses: [ address1a, address1b ]) }
+      let(:person2) { Person.create!(addresses: [ address2a, address2b ]) }
+
+      let(:address1a) { Address.new(name: "en1") }
+      let(:address1b) { Address.new(name: "en2") }
+      let(:address2a) { Address.new(name: "en1") }
+      let(:address2b) { Address.new(name: "en3") }
+
+      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
+
+      let(:criteria) do
+        Person.all.tap do |crit|
+          crit.documents = [ person1, person2 ]
+        end
+      end
+
+      context "when getting the demongoized field" do
+        let(:tallied) do
+          context.tally("addresses.name")
+        end
+
+        it "returns the translation for the current locale" do
+          expect(tallied).to eq(
+            [ "en1", "en2" ] => 1,
+            [ "en1", "en3" ] => 1,
+          )
+        end
+      end
+
+      context "when getting a specific locale" do
+        let(:tallied) do
+          context.tally("addresses.name.de")
+        end
+
+        it "returns the translation for the the specific locale" do
+          expect(tallied).to eq(
+            [ "de1", "de2" ] => 1,
+            [ "de1", "de3" ] => 1,
+          )
+        end
+      end
+
+      context "when getting the full hash" do
+        let(:tallied) do
+          context.tally("addresses.name_translations")
+        end
+
+        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
 
-    let(:friedel) do
-      Address.new(street: "friedel")
+    context "when tallying an embedded field" do
+      let(:tally) do
+        context.tally("label.name")
+      end
+
+      it "returns the correct hash" do
+        expect(tally).to eq("Atlantic" => 2, "Columbia" => 1)
+      end
     end
 
-    let(:pfluger) do
-      Address.new(street: "pfluger")
+    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
 
-    let(:criteria) do
-      Address.all.tap do |crit|
-        crit.documents = [ hobrecht, friedel, pfluger ]
+    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
 
-    let(:context) do
-      described_class.new(criteria)
+    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
+
+      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
 
-    let!(:limit) do
-      context.limit(2)
+    context "when going multiple levels deep in arrays" 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
+
+    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 "returns the context" do
-      limit.should eq(context)
+    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
 
-    context "when asking for all documents" do
+    context "when tallying deeply nested arrays/embedded associations" do
+
+      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
 
-      context "when only a limit exists" do
+      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
 
-        it "only returns the limited documents" do
-          context.entries.should eq([ hobrecht, friedel ])
+      let(:criteria) do
+        Person.all.tap do |crit|
+          crit.documents = [ person1, person2, person3 ]
         end
       end
 
-      context "when a skip and limit exist" do
+      let(:tally) do
+        context.tally("addresses.code.deepest.array.y.z")
+      end
 
-        before do
-          limit.skip(1)
+      it "returns the correct hash" do
+        expect(tally).to eq(
+          [ [ 1, 2 ], [ 1, 2 ] ] => 2,
+          [ [ 1, 3 ], [ 1, 3 ] ] => 1
+        )
+      end
+    end
+
+    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(: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,
+          nil => 3
+        )
+      end
+    end
 
-        it "applies the skip before the limit" do
-          context.entries.should eq([ friedel, pfluger ])
+    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
+        Person.all.tap do |crit|
+          crit.documents = [ person1, person2, person3 ]
         end
       end
+
+      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
+
+    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
 
@@ -753,34 +2300,52 @@ describe Mongoid::Contextual::Memory do
       described_class.new(criteria)
     end
 
-    let!(:skip) do
-      context.skip(1)
-    end
+    context 'when there is no collation on the criteria' do
 
-    it "returns the context" do
-      skip.should eq(context)
-    end
+      let!(:skip) do
+        context.skip(1)
+      end
 
-    context "when asking for all documents" do
+      it "returns the context" do
+        expect(skip).to eq(context)
+      end
 
-      context "when only a skip exists" do
+      context "when asking for all documents" do
 
-        it "skips the correct number" do
-          context.entries.should eq([ friedel, pfluger ])
+        context "when only a skip exists" do
+
+          it "skips the correct number" do
+            expect(context.entries).to eq([ friedel, pfluger ])
+          end
         end
-      end
 
-      context "when a skip and limit exist" do
+        context "when a skip and limit exist" do
 
-        before do
-          skip.limit(1)
-        end
+          before do
+            skip.limit(1)
+          end
 
-        it "applies the skip before the limit" do
-          context.entries.should eq([ friedel ])
+          it "applies the skip before the limit" do
+            expect(context.entries).to eq([ friedel ])
+          end
         end
       end
     end
+
+    context 'when there is a collation on the criteria' do
+
+      let(:criteria) do
+        Address.all.tap do |crit|
+          crit.documents = [ hobrecht, friedel, pfluger ]
+        end.collation(locale: 'en_US', strength: 2)
+      end
+
+      it "raises an exception" do
+        expect {
+          context.skip(1)
+        }.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
+      end
+    end
   end
 
   describe "#sort" do
@@ -816,11 +2381,11 @@ describe Mongoid::Contextual::Memory do
         end
 
         it "sorts the documents" do
-          context.entries.should eq([ friedel, hobrecht, pfluger ])
+          expect(context.entries).to eq([ friedel, hobrecht, pfluger ])
         end
 
         it "returns the context" do
-          sorted.should eq(context)
+          expect(sorted).to eq(context)
         end
       end
 
@@ -833,11 +2398,11 @@ describe Mongoid::Contextual::Memory do
           end
 
           it "sorts the documents" do
-            context.entries.should eq([ pfluger, hobrecht, friedel ])
+            expect(context.entries).to eq([ pfluger, hobrecht, friedel ])
           end
 
           it "returns the context" do
-            sorted.should eq(context)
+            expect(sorted).to eq(context)
           end
         end
 
@@ -853,11 +2418,11 @@ describe Mongoid::Contextual::Memory do
           end
 
           it "sorts the documents" do
-            context.entries.should eq([ friedel, hobrecht, pfluger ])
+            expect(context.entries).to eq([ friedel, hobrecht, pfluger ])
           end
 
           it "returns the context" do
-            sorted.should eq(context)
+            expect(sorted).to eq(context)
           end
         end
       end
@@ -869,8 +2434,13 @@ describe Mongoid::Contextual::Memory do
         Address.new(street: "lenau", number: 5, name: "lenau")
       end
 
+      let(:kampuchea_krom) do
+        Address.new(street: "kampuchea krom", number: 5, name: "kampuchea krom")
+      end
+
       before do
         criteria.documents.unshift(lenau)
+        criteria.documents.unshift(kampuchea_krom)
       end
 
       context "when the sort is ascending" do
@@ -880,11 +2450,11 @@ describe Mongoid::Contextual::Memory do
         end
 
         it "sorts the documents" do
-          context.entries.should eq([ friedel, lenau, pfluger, hobrecht ])
+          expect(context.entries).to eq([ friedel, kampuchea_krom, lenau, pfluger, hobrecht ])
         end
 
         it "returns the context" do
-          sorted.should eq(context)
+          expect(sorted).to eq(context)
         end
       end
 
@@ -895,11 +2465,11 @@ describe Mongoid::Contextual::Memory do
         end
 
         it "sorts the documents" do
-          context.entries.should eq([ hobrecht, pfluger, lenau, friedel ])
+          expect(context.entries).to eq([ hobrecht, pfluger, lenau, kampuchea_krom, friedel ])
         end
 
         it "returns the context" do
-          sorted.should eq(context)
+          expect(sorted).to eq(context)
         end
       end
     end
@@ -911,11 +2481,11 @@ describe Mongoid::Contextual::Memory do
       end
 
       it "does not sort the documents" do
-        context.entries.should eq([ hobrecht, friedel, pfluger ])
+        expect(context.entries).to eq([ hobrecht, friedel, pfluger ])
       end
 
       it "returns the context" do
-        sorted.should eq(context)
+        expect(sorted).to eq(context)
       end
     end
 
@@ -926,7 +2496,22 @@ describe Mongoid::Contextual::Memory do
       end
 
       it "sorts the documents" do
-        context.entries.should eq([ friedel, hobrecht, pfluger ])
+        expect(context.entries).to eq([ friedel, hobrecht, pfluger ])
+      end
+    end
+
+    context 'when there is a collation on the criteria' do
+
+      let(:criteria) do
+        Address.all.tap do |crit|
+          crit.documents = [ hobrecht, friedel, pfluger ]
+        end.collation(locale: 'en_US', strength: 2)
+      end
+
+      it "raises an exception" do
+        expect {
+          context.sort(state: 1)
+        }.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
       end
     end
   end
@@ -934,19 +2519,19 @@ describe Mongoid::Contextual::Memory do
   describe "#update" do
 
     let(:person) do
-      Person.create
+      Person.create!
     end
 
     let(:hobrecht) do
-      person.addresses.create(street: "hobrecht")
+      person.addresses.create!(street: "hobrecht")
     end
 
     let(:friedel) do
-      person.addresses.create(street: "friedel")
+      person.addresses.create!(street: "friedel")
     end
 
     let(:pfluger) do
-      person.addresses.create(street: "pfluger")
+      person.addresses.create!(street: "pfluger")
     end
 
     context "when the documents are embedded one level" do
@@ -968,29 +2553,29 @@ describe Mongoid::Contextual::Memory do
         end
 
         it "updates the first matching document" do
-          hobrecht.number.should eq(5)
+          expect(hobrecht.number).to eq(5)
         end
 
         it "does not update the last matching document" do
-          friedel.number.should be_nil
+          expect(friedel.number).to be_nil
         end
 
         it "does not update non matching docs" do
-          pfluger.number.should be_nil
+          expect(pfluger.number).to be_nil
         end
 
         context "when reloading the embedded documents" do
 
           it "updates the first matching document" do
-            hobrecht.reload.number.should eq(5)
+            expect(hobrecht.reload.number).to eq(5)
           end
 
           it "updates the last matching document" do
-            friedel.reload.number.should be_nil
+            expect(friedel.reload.number).to be_nil
           end
 
           it "does not update non matching docs" do
-            pfluger.reload.number.should be_nil
+            expect(pfluger.reload.number).to be_nil
           end
         end
       end
@@ -998,7 +2583,7 @@ describe Mongoid::Contextual::Memory do
       context "when no attributes are provided" do
 
         it "returns false" do
-          context.update.should be_false
+          expect(context.update).to be false
         end
       end
     end
@@ -1006,11 +2591,11 @@ describe Mongoid::Contextual::Memory do
     context "when the documents are embedded multiple levels" do
 
       let!(:home) do
-        hobrecht.locations.create(name: "home")
+        hobrecht.locations.create!(name: "home")
       end
 
       let!(:work) do
-        hobrecht.locations.create(name: "work")
+        hobrecht.locations.create!(name: "work")
       end
 
       let(:criteria) do
@@ -1030,21 +2615,21 @@ describe Mongoid::Contextual::Memory do
         end
 
         it "updates the first matching document" do
-          work.number.should eq(5)
+          expect(work.number).to eq(5)
         end
 
         it "does not update non matching docs" do
-          home.number.should be_nil
+          expect(home.number).to be_nil
         end
 
         context "when reloading the embedded documents" do
 
           it "updates the first matching document" do
-            work.reload.number.should eq(5)
+            expect(work.reload.number).to eq(5)
           end
 
           it "does not update non matching docs" do
-            home.reload.number.should be_nil
+            expect(home.reload.number).to be_nil
           end
         end
       end
@@ -1052,34 +2637,60 @@ describe Mongoid::Contextual::Memory do
       context "when no attributes are provided" do
 
         it "returns false" do
-          context.update.should be_false
+          expect(context.update).to be false
         end
       end
     end
+
+    context 'when there is a collation on the criteria' do
+
+      let(:criteria) do
+        Address.all.collation(locale: 'en_US', strength: 2)
+      end
+
+      it "raises an exception" do
+        expect {
+          context.update
+        }.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
+      end
+    end
   end
 
   describe "#update_all" do
 
     let(:person) do
-      Person.create
+      Person.create!
     end
 
     let(:hobrecht) do
-      person.addresses.create(street: "hobrecht")
+      person.addresses.create!(street: "hobrecht")
     end
 
     let(:friedel) do
-      person.addresses.create(street: "friedel")
+      person.addresses.create!(street: "friedel")
     end
 
     let(:pfluger) do
-      person.addresses.create(street: "pfluger")
+      person.addresses.create!(street: "pfluger")
+    end
+
+    context 'when there is a collation on the criteria' do
+
+      let(:criteria) do
+        Address.all.collation(locale: 'en_US', strength: 2)
+      end
+
+      it "raises an exception" do
+        expect {
+          context.update_all({})
+        }.to raise_exception(Mongoid::Errors::InMemoryCollationNotSupported)
+      end
     end
 
     context "when the documents are empty" do
 
       let(:person_two) do
-        Person.create
+        Person.create!
       end
 
       let(:criteria) do
@@ -1091,7 +2702,7 @@ describe Mongoid::Contextual::Memory do
       end
 
       it "returns false" do
-        context.update_all({}).should be_false
+        expect(context.update_all({})).to be false
       end
     end
 
@@ -1114,15 +2725,15 @@ describe Mongoid::Contextual::Memory do
         end
 
         it "updates the first matching document" do
-          hobrecht.suite.should eq("10B")
+          expect(hobrecht.suite).to eq("10B")
         end
 
         it "updates the last matching document" do
-          friedel.suite.should eq("10B")
+          expect(friedel.suite).to eq("10B")
         end
 
         it "does not update non matching docs" do
-          pfluger.suite.should be_nil
+          expect(pfluger.suite).to be_nil
         end
       end
 
@@ -1133,29 +2744,29 @@ describe Mongoid::Contextual::Memory do
         end
 
         it "updates the first matching document" do
-          hobrecht.number.should eq(5)
+          expect(hobrecht.number).to eq(5)
         end
 
         it "updates the last matching document" do
-          friedel.number.should eq(5)
+          expect(friedel.number).to eq(5)
         end
 
         it "does not update non matching docs" do
-          pfluger.number.should be_nil
+          expect(pfluger.number).to be_nil
         end
 
         context "when reloading the embedded documents" do
 
           it "updates the first matching document" do
-            hobrecht.reload.number.should eq(5)
+            expect(hobrecht.reload.number).to eq(5)
           end
 
           it "updates the last matching document" do
-            friedel.reload.number.should eq(5)
+            expect(friedel.reload.number).to eq(5)
           end
 
           it "does not update non matching docs" do
-            pfluger.reload.number.should be_nil
+            expect(pfluger.reload.number).to be_nil
           end
         end
 
@@ -1166,7 +2777,7 @@ describe Mongoid::Contextual::Memory do
           end
 
           it "does not error on the update" do
-            hobrecht.number.should eq(5)
+            expect(hobrecht.number).to eq(5)
           end
         end
       end
@@ -1174,7 +2785,7 @@ describe Mongoid::Contextual::Memory do
       context "when no attributes are provided" do
 
         it "returns false" do
-          context.update_all.should be_false
+          expect(context.update_all).to be false
         end
       end
     end
@@ -1182,11 +2793,11 @@ describe Mongoid::Contextual::Memory do
     context "when the documents are embedded multiple levels" do
 
       let!(:home) do
-        hobrecht.locations.create(name: "home")
+        hobrecht.locations.create!(name: "home")
       end
 
       let!(:work) do
-        hobrecht.locations.create(name: "work")
+        hobrecht.locations.create!(name: "work")
       end
 
       let(:criteria) do
@@ -1206,21 +2817,21 @@ describe Mongoid::Contextual::Memory do
         end
 
         it "updates the first matching document" do
-          work.number.should eq(5)
+          expect(work.number).to eq(5)
         end
 
         it "does not update non matching docs" do
-          home.number.should be_nil
+          expect(home.number).to be_nil
         end
 
         context "when reloading the embedded documents" do
 
           it "updates the first matching document" do
-            work.reload.number.should eq(5)
+            expect(work.reload.number).to eq(5)
           end
 
           it "does not update non matching docs" do
-            home.reload.number.should be_nil
+            expect(home.reload.number).to be_nil
           end
         end
       end
@@ -1228,7 +2839,7 @@ describe Mongoid::Contextual::Memory do
       context "when no attributes are provided" do
 
         it "returns false" do
-          context.update_all.should be_false
+          expect(context.update_all).to be false
         end
       end
     end