mongoid 7.0.5 → 8.1.0

data/spec/mongoid/criteria_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Mongoid::Criteria do
@@ -38,7 +40,7 @@ describe Mongoid::Criteria do
       context "when the entries are the same" do
 
         let!(:band) do
-          Band.create(name: "Depeche Mode")
+          Band.create!(name: "Depeche Mode")
         end
 
         let(:other) do
@@ -53,11 +55,11 @@ describe Mongoid::Criteria do
       context "when the entries are not the same" do
 
         let!(:band) do
-          Band.create(name: "Depeche Mode")
+          Band.create!(name: "Depeche Mode")
         end
 
         let!(:other_band) do
-          Band.create(name: "Tool")
+          Band.create!(name: "Tool")
         end
 
         let(:other) do
@@ -102,21 +104,21 @@ describe Mongoid::Criteria do
   describe "#asc" do
 
     let(:person) do
-      Person.create
+      Person.create!
     end
 
     context "when the documents are embedded" do
 
       let!(:hobrecht) do
-        person.addresses.create(street: "hobrecht", name: "hobrecht")
+        person.addresses.create!(street: "hobrecht", name: "hobrecht")
       end
 
       let!(:friedel) do
-        person.addresses.create(street: "friedel", name: "friedel")
+        person.addresses.create!(street: "friedel", name: "friedel")
       end
 
       let!(:pfluger) do
-        person.addresses.create(street: "pfluger", name: "pfluger")
+        person.addresses.create!(street: "pfluger", name: "pfluger")
       end
 
       let(:criteria) do
@@ -132,7 +134,7 @@ describe Mongoid::Criteria do
   describe "#batch_size" do
 
     let(:person) do
-      Person.create
+      Person.create!
     end
 
     let(:criteria) do
@@ -151,7 +153,7 @@ describe Mongoid::Criteria do
   describe "#read" do
 
     let(:person) do
-      Person.create
+      Person.create!
     end
 
     let(:criteria) do
@@ -168,11 +170,11 @@ describe Mongoid::Criteria do
     context "when provided a single field" do
 
       let!(:depeche) do
-        Band.create(name: "Depeche Mode", likes: 1000)
+        Band.create!(name: "Depeche Mode", likes: 1000)
       end
 
       let!(:tool) do
-        Band.create(name: "Tool", likes: 500)
+        Band.create!(name: "Tool", likes: 500)
       end
 
       let(:criteria) do
@@ -210,11 +212,11 @@ describe Mongoid::Criteria do
     context "when provided a single field" do
 
       let!(:depeche) do
-        Band.create(name: "Depeche Mode", likes: 1000)
+        Band.create!(name: "Depeche Mode", likes: 1000)
       end
 
       let!(:tool) do
-        Band.create(name: "Tool", likes: 500)
+        Band.create!(name: "Tool", likes: 500)
       end
 
       let(:criteria) do
@@ -236,11 +238,11 @@ describe Mongoid::Criteria do
     describe "\##{method}" do
 
       let!(:match) do
-        Band.create(genres: [ "electro", "dub" ])
+        Band.create!(genres: [ "electro", "dub" ])
       end
 
       let!(:non_match) do
-        Band.create(genres: [ "house" ])
+        Band.create!(genres: [ "house" ])
       end
 
       let(:criteria) do
@@ -258,11 +260,11 @@ describe Mongoid::Criteria do
     describe "\##{method}" do
 
       let!(:match) do
-        Band.create(name: "Depeche Mode", genres: [ "electro" ])
+        Band.create!(name: "Depeche Mode", genres: [ "electro" ])
       end
 
       let!(:non_match) do
-        Band.create(genres: [ "house" ])
+        Band.create!(genres: [ "house" ])
       end
 
       let(:criteria) do
@@ -278,7 +280,7 @@ describe Mongoid::Criteria do
   describe "#as_json" do
 
     let!(:band) do
-      Band.create(name: "Depeche Mode")
+      Band.create!(name: "Depeche Mode")
     end
 
     let(:criteria) do
@@ -308,11 +310,11 @@ describe Mongoid::Criteria do
   describe "#between" do
 
     let!(:match) do
-      Band.create(member_count: 3)
+      Band.create!(member_count: 3)
     end
 
     let!(:non_match) do
-      Band.create(member_count: 10)
+      Band.create!(member_count: 10)
     end
 
     let(:criteria) do
@@ -378,13 +380,14 @@ describe Mongoid::Criteria do
   describe "#cache" do
 
     let!(:person) do
-      Person.create
+      Person.create!
     end
 
-    context "when no eager loading is involved" do
+    context "when the query cache is enabled" do
+      query_cache_enabled
 
       let(:criteria) do
-        Person.all.cache
+        Person.all
       end
 
       before do
@@ -392,17 +395,19 @@ describe Mongoid::Criteria do
       end
 
       it "does not hit the database after first iteration" do
-        expect(criteria.context.view).to receive(:each).never
-        criteria.each do |doc|
-          expect(doc).to eq(person)
+        expect_no_queries do
+          criteria.each do |doc|
+            expect(doc).to eq(person)
+          end
         end
       end
     end
 
     context "when the criteria is eager loading" do
+      query_cache_enabled
 
       let(:criteria) do
-        Person.includes(:posts).cache
+        Person.includes(:posts)
       end
 
       before do
@@ -410,9 +415,10 @@ describe Mongoid::Criteria do
       end
 
       it "does not hit the database after first iteration" do
-        expect(criteria.context.view).to receive(:each).never
-        criteria.each do |doc|
-          expect(doc).to eq(person)
+        expect_no_queries do
+          criteria.each do |doc|
+            expect(doc).to eq(person)
+          end
         end
       end
     end
@@ -489,17 +495,6 @@ describe Mongoid::Criteria do
     end
   end
 
-  describe "#cache" do
-
-    let(:criteria) do
-      Band.where(name: "Depeche Mode")
-    end
-
-    it "sets the cache option to true" do
-      expect(criteria.cache).to be_cached
-    end
-  end
-
   describe "#context" do
 
     context "when the model is embedded" do
@@ -530,11 +525,11 @@ describe Mongoid::Criteria do
   describe "#delete" do
 
     let(:depeche) do
-      Band.create(name: "Depeche Mode")
+      Band.create!(name: "Depeche Mode")
     end
 
     let(:tool) do
-      Band.create(name: "Tool")
+      Band.create!(name: "Tool")
     end
 
     context "when no selector is provided" do
@@ -588,7 +583,7 @@ describe Mongoid::Criteria do
   describe "#each" do
 
     let!(:band) do
-      Band.create(name: "Depeche Mode")
+      Band.create!(name: "Depeche Mode")
     end
 
     context "when provided a block" do
@@ -608,14 +603,14 @@ describe Mongoid::Criteria do
   describe "#elem_match" do
 
     let!(:match) do
-      Band.create(name: "Depeche Mode").tap do |band|
+      Band.create!(name: "Depeche Mode").tap do |band|
         r = band.records
-        r.create(name: "101")
+        r.create!(name: "101")
       end
     end
 
     let!(:non_match) do
-      Band.create(genres: [ "house" ])
+      Band.create!(genres: [ "house" ])
     end
 
     let(:criteria) do
@@ -661,7 +656,7 @@ describe Mongoid::Criteria do
     context "when matching documents exist" do
 
       let!(:match) do
-        Band.create(name: "Depeche Mode")
+        Band.create!(name: "Depeche Mode")
       end
 
       let(:criteria) do
@@ -676,7 +671,7 @@ describe Mongoid::Criteria do
     context "when no matching documents exist" do
 
       let!(:nonmatch) do
-        Band.create(name: "New Order")
+        Band.create!(name: "New Order")
       end
 
       let(:criteria) do
@@ -692,11 +687,11 @@ describe Mongoid::Criteria do
   describe "#exists" do
 
     let!(:match) do
-      Band.create(name: "Depeche Mode")
+      Band.create!(name: "Depeche Mode")
     end
 
     let!(:non_match) do
-      Band.create
+      Band.create!
     end
 
     let(:criteria) do
@@ -713,7 +708,7 @@ describe Mongoid::Criteria do
     context "when matching documents exist" do
 
       let!(:match) do
-        Band.create(name: "Depeche Mode")
+        Band.create!(name: "Depeche Mode")
       end
 
       let(:criteria) do
@@ -783,23 +778,83 @@ describe Mongoid::Criteria do
 
   describe "#field_list" do
 
+    context "when using the default discriminator key" do
+      let(:criteria) do
+        Doctor.only(:_id)
+      end
+
+      it "returns the fields with required _id minus type" do
+        expect(criteria.field_list).to eq([ "_id" ])
+      end
+    end
+
+    context "when using a custom discriminator key" do
+      before do
+        Person.discriminator_key = "dkey"
+      end
+
+      after do
+        Person.discriminator_key = nil
+      end
+
+      let(:criteria) do
+        Doctor.only(:_id, :_type)
+      end
+
+      it "returns the fields with type without dkey" do
+        expect(criteria.field_list).to eq([ "_id", "_type" ])
+      end
+    end
+  end
+
+  describe "#find" do
+    let!(:depeche) do
+      Band.create!(name: "Depeche Mode")
+    end
+
     let(:criteria) do
-      Band.only(:name)
+      Band.where(name: "Depeche Mode")
+    end
+
+    context "when given a block" do
+      it "behaves as Enumerable" do
+        result = criteria.find { |c| c.name == "Depeche Mode" }
+        expect(result).to eq(depeche)
+      end
+    end
+
+    context "when given a Proc and a block" do
+      it "behaves as Enumerable" do
+        result = criteria.find(-> {"default"}) { |c| c.name == "Not Depeche Mode" }
+        expect(result).to eq("default")
+      end
+    end
+
+    context "when given a Proc without a block" do
+      it "raises an error" do
+        lambda do
+          criteria.find(-> {"default"})
+        # Proc is not serializable to a BSON type
+        end.should raise_error(BSON::Error::UnserializableClass)
+      end
     end
 
-    it "returns the fields with required _id minus type" do
-      expect(criteria.field_list).to eq([ "_id", "name" ])
+    context "when given an id" do
+      it "behaves as Findable" do
+        result = criteria.find(depeche.id)
+        expect(result).to eq(depeche)
+      end
     end
   end
 
   describe "#find_one_and_update" do
 
     let!(:depeche) do
-      Band.create(name: "Depeche Mode")
+      Band.create!(name: "Depeche Mode")
     end
 
     let!(:tool) do
-      Band.create(name: "Tool")
+      Band.create!(name: "Tool")
     end
 
     context "when the selector matches" do
@@ -938,7 +993,7 @@ describe Mongoid::Criteria do
         it "deletes the document from the database" do
           expect {
             depeche.reload
-          }.to raise_error(Mongoid::Errors::DocumentNotFound)
+          }.to raise_error(Mongoid::Errors::DocumentNotFound, /Document\(s\) not found for class Band with id\(s\)/)
         end
       end
     end
@@ -997,7 +1052,7 @@ describe Mongoid::Criteria do
     end
 
     let!(:match) do
-      Bar.create(location: [ 52.30, 13.25 ])
+      Bar.create!(location: [ 52.30, 13.25 ])
     end
 
     let(:criteria) do
@@ -1009,7 +1064,7 @@ describe Mongoid::Criteria do
     end
   end
 
-  describe "#gt" do
+  describe "#eq" do
 
     let!(:match) do
       Band.create(member_count: 5)
@@ -1019,6 +1074,25 @@ describe Mongoid::Criteria do
       Band.create(member_count: 1)
     end
 
+    let(:criteria) do
+      Band.eq(member_count: 5)
+    end
+
+    it "returns the matching documents" do
+      expect(criteria).to eq([ match ])
+    end
+  end
+
+  describe "#gt" do
+
+    let!(:match) do
+      Band.create!(member_count: 5)
+    end
+
+    let!(:non_match) do
+      Band.create!(member_count: 1)
+    end
+
     let(:criteria) do
       Band.gt(member_count: 4)
     end
@@ -1031,11 +1105,11 @@ describe Mongoid::Criteria do
   describe "#gte" do
 
     let!(:match) do
-      Band.create(member_count: 5)
+      Band.create!(member_count: 5)
     end
 
     let!(:non_match) do
-      Band.create(member_count: 1)
+      Band.create!(member_count: 1)
     end
 
     let(:criteria) do
@@ -1054,11 +1128,11 @@ describe Mongoid::Criteria do
       context "when querying on a normal field" do
 
         let!(:match) do
-          Band.create(genres: [ "electro", "dub" ])
+          Band.create!(genres: [ "electro", "dub" ])
         end
 
         let!(:non_match) do
-          Band.create(genres: [ "house" ])
+          Band.create!(genres: [ "house" ])
         end
 
         let(:criteria) do
@@ -1077,7 +1151,7 @@ describe Mongoid::Criteria do
         end
 
         let!(:match_one) do
-          Person.create(preference_ids: [ id ])
+          Person.create!(preference_ids: [ id ])
         end
 
         context "when providing valid ids" do
@@ -1118,7 +1192,7 @@ describe Mongoid::Criteria do
           context "when the relation is a one to one" do
 
             let!(:game) do
-              Game.create
+              Game.create!
             end
 
             let(:criteria) do
@@ -1153,1312 +1227,204 @@ describe Mongoid::Criteria do
     end
   end
 
-  describe "#includes" do
+  describe "#lt" do
 
-    let!(:person) do
-      Person.create(age: 1)
+    let!(:match) do
+      Band.create!(member_count: 1)
     end
 
-    context "when providing a name that is not a relation" do
-
-      it "raises an error" do
-        expect {
-          Person.includes(:members)
-        }.to raise_error(Mongoid::Errors::InvalidIncludes)
-      end
+    let!(:non_match) do
+      Band.create!(member_count: 5)
     end
 
-    context "when providing one association" do
-
-      let!(:user) do
-        User.create(posts: [ post1 ])
-      end
-
-      let!(:post1) do
-        Post.create
-      end
-
-      let(:result) do
-        User.includes(:posts).first
-      end
-
-      it "executes the query" do
-        expect(result).to eq(user)
-      end
-
-      it "includes the related objects" do
-        expect(result.posts).to eq([ post1 ])
-      end
+    let(:criteria) do
+      Band.lt(member_count: 4)
     end
 
-    context "when providing a list of associations" do
-
-      let!(:user) do
-        User.create(posts: [ post1 ], descriptions: [ description1 ])
-      end
-
-      let!(:post1) do
-        Post.create
-      end
-
-      let!(:description1) do
-        Description.create(details: 1)
-      end
+    it "returns the matching documents" do
+      expect(criteria).to eq([ match ])
+    end
+  end
 
-      let(:result) do
-        User.includes(:posts, :descriptions).first
-      end
+  describe "#lte" do
 
-      it "executes the query" do
-        expect(result).to eq(user)
-      end
+    let!(:match) do
+      Band.create!(member_count: 4)
+    end
 
-      it "includes the related objects" do
-        expect(result.posts).to eq([ post1 ])
-        expect(result.descriptions).to eq([ description1 ])
-      end
+    let!(:non_match) do
+      Band.create!(member_count: 5)
     end
 
-    context "when providing a nested association" do
+    let(:criteria) do
+      Band.lte(member_count: 4)
+    end
 
-      let!(:user) do
-        User.create
-      end
+    it "returns the matching documents" do
+      expect(criteria).to eq([ match ])
+    end
+  end
 
-      before do
-        p = Post.create(alerts: [ Alert.create ])
-        user.posts = [ p ]
-        user.save
-      end
+  describe "#map_reduce" do
 
-      let(:result) do
-        User.includes(:posts => [:alerts]).first
-      end
+    let(:map) do
+      %Q{
+      function() {
+        emit(this.name, { likes: this.likes });
+      }}
+    end
 
-      it "executes the query" do
-        expect(result).to eq(user)
-      end
+    let(:reduce) do
+      %Q{
+      function(key, values) {
+        var result = { likes: 0 };
+        values.forEach(function(value) {
+          result.likes += value.likes;
+        });
+        return result;
+      }}
+    end
 
-      it "includes the related objects" do
-        expect(result.posts.size).to eq(1)
-        expect(result.posts.first.alerts.size).to eq(1)
-      end
+    let!(:depeche_mode) do
+      Band.create!(name: "Depeche Mode", likes: 200)
     end
 
-    context "when providing a deeply nested association" do
+    let!(:tool) do
+      Band.create!(name: "Tool", likes: 100)
+    end
 
-      let!(:user) do
-        User.create
-      end
+    context "when no timeout options are provided" do
 
-      let(:results) do
-        User.includes(:posts => [{ :alerts => :items }]).to_a
+      let(:map_reduce) do
+        Band.limit(2).map_reduce(map, reduce).out(inline: 1)
       end
 
-      it "executes the query" do
-        expect(results.first).to eq(user)
+      it "returns the map/reduce results" do
+        expect(map_reduce.sort_by { |doc| doc['_id'] }).to eq([
+          { "_id" => "Depeche Mode", "value" => { "likes" => 200 }},
+          { "_id" => "Tool", "value" => { "likes" => 100 }}
+        ])
       end
     end
+  end
 
-    context "when the models are inherited" do
+  describe "#max" do
 
-      before(:all) do
-        class A
-          include Mongoid::Document
-        end
+    context "when provided a single field" do
 
-        class B < A
-          belongs_to :c
-        end
+      let!(:depeche) do
+        Band.create!(name: "Depeche Mode", likes: 1000)
+      end
 
-        class C
-          include Mongoid::Document
-          has_one :b
-        end
+      let!(:tool) do
+        Band.create!(name: "Tool", likes: 500)
       end
 
-      after(:all) do
-        Object.send(:remove_const, :A)
-        Object.send(:remove_const, :B)
-        Object.send(:remove_const, :C)
+      let(:criteria) do
+        Band.all
       end
 
-      context "when the includes is on the subclass" do
+      context "when provided a symbol" do
 
-        let!(:c_one) do
-          C.create
+        let(:max) do
+          criteria.max(:likes)
         end
 
-        let!(:c_two) do
-          C.create
+        it "returns the max of the provided field" do
+          expect(max).to eq(1000)
         end
+      end
 
-        let!(:b) do
-          B.create(c: c_two)
-        end
+      context "when provided a block" do
 
-        let!(:results) do
-          C.includes(:b).to_a.detect do |c|
-            c.id == c_two.id
+        let(:max) do
+          criteria.max do |a, b|
+            a.likes <=> b.likes
           end
         end
 
-        it "returns the correct documents" do
-          expect(results).to eq(c_two)
-        end
-
-        it "does not query the db" do
-          expect_query(0) do
-            results.b
-          end
+        it "returns the document with the max value for the field" do
+          expect(max).to eq(depeche)
         end
       end
     end
+  end
 
-    context "when the models are inherited from another one model" do
+  describe "#max_distance" do
 
-      context "when the relation is a has_one" do
+    before do
+      Bar.create_indexes
+    end
 
-        before(:all) do
-          class A
-            include Mongoid::Document
-          end
+    let!(:match) do
+      Bar.create!(location: [ 52.30, 13.25 ])
+    end
 
-          class B < A
-            belongs_to :d
-          end
+    let!(:non_match) do
+      Bar.create!(location: [ 19.26, 99.70 ])
+    end
 
-          class C < A
-            belongs_to :d
-          end
+    let(:criteria) do
+      Bar.near(location: [ 52, 13 ]).max_distance(location: 5)
+    end
 
-          class D
-            include Mongoid::Document
-            has_one :b
-            has_one :c
-          end
-        end
+    it "returns the matching documents" do
+      expect(criteria).to eq([ match ])
+    end
+  end
 
-        after(:all) do
-          Object.send(:remove_const, :A)
-          Object.send(:remove_const, :B)
-          Object.send(:remove_const, :C)
-          Object.send(:remove_const, :D)
-        end
+  describe "#merge" do
 
-        context "when the includes is on the several relations" do
+    let(:band) do
+      Band.new
+    end
 
-          let!(:d_one) do
-            D.create
-          end
+    let(:criteria) do
+      Band.scoped.where(name: "Depeche Mode").asc(:name)
+    end
 
-          let!(:d_two) do
-            D.create
-          end
+    context "when merging with another criteria" do
 
-          let!(:b) do
-            B.create(d: d_two)
-          end
+      let(:mergeable) do
+        Band.includes(:records).tap do |crit|
+          crit.documents = [ band ]
+        end
+      end
 
-          let!(:c) do
-            C.create(d: d_two)
-          end
+      let(:association) do
+        Band.relations["records"]
+      end
 
-          let!(:results) do
-            D.includes(:b, :c).entries.detect do |d|
-              d.id == d_two.id
-            end
-          end
+      let(:merged) do
+        criteria.merge(mergeable)
+      end
 
-          it "returns the correct documents" do
-            expect(results).to eq(d_two)
-          end
+      it "merges the selector" do
+        expect(merged.selector).to eq({ "name" => "Depeche Mode" })
+      end
 
-          it "does not query the db on b" do
-            expect_query(0) do
-              results.b
-            end
-          end
+      it "merges the options" do
+        expect(merged.options).to eq({ sort: { "name" => 1 }})
+      end
 
-          it "does not query the db on c" do
-            expect_query(0) do
-              results.b
-            end
-          end
-        end
+      it "merges the documents" do
+        expect(merged.documents).to eq([ band ])
       end
 
-      context "when the relation is a has_many" do
+      it "merges the scoping options" do
+        expect(merged.scoping_options).to eq([ nil, nil ])
+      end
 
-        before(:all) do
-          class A
-            include Mongoid::Document
-          end
+      it "merges the inclusions" do
+        expect(merged.inclusions).to eq([ association ])
+      end
 
-          class B < A
-            belongs_to :d
-          end
+      it "returns a new criteria" do
+        expect(merged).to_not equal(criteria)
+      end
+    end
 
-          class C < A
-            belongs_to :d
-          end
-
-          class D
-            include Mongoid::Document
-            has_many :b
-            has_many :c
-          end
-        end
-
-        after(:all) do
-          Object.send(:remove_const, :A)
-          Object.send(:remove_const, :B)
-          Object.send(:remove_const, :C)
-          Object.send(:remove_const, :D)
-        end
-
-        context "when the includes is on the several relations" do
-
-          let!(:d_one) do
-            D.create
-          end
-
-          let!(:d_two) do
-            D.create
-          end
-
-          let!(:bs) do
-            2.times.map { B.create(d: d_two) }
-          end
-
-          let!(:cs) do
-            2.times.map { C.create(d: d_two) }
-          end
-
-          let!(:results) do
-            D.includes(:b, :c).entries.detect do |d|
-              d.id == d_two.id
-            end
-          end
-
-          it "returns the correct documents" do
-            expect(results).to eq(d_two)
-          end
-
-          it "does not query the db on b" do
-            expect_query(0) do
-              results.b
-            end
-          end
-
-          it "does not query the db on c" do
-            expect_query(0) do
-              results.b
-            end
-          end
-        end
-      end
-    end
-
-    context "when including the same association multiple times" do
-
-      let(:criteria) do
-        Person.all.includes(:posts, :posts).includes(:posts)
-      end
-
-      let(:association) do
-        Person.reflect_on_association(:posts)
-      end
-
-      it "does not duplicate the association in the inclusions" do
-        expect(criteria.inclusions).to eq([ association ])
-      end
-    end
-
-    context "when mapping the results more than once" do
-
-      let!(:post) do
-        person.posts.create(title: "one")
-      end
-
-      let(:criteria) do
-        Post.includes(:person)
-      end
-
-      let!(:results) do
-        criteria.map { |doc| doc }
-        criteria.map { |doc| doc }
-      end
-
-      it "returns the proper results" do
-        expect(results.first.title).to eq("one")
-      end
-    end
-
-    context "when including a belongs to relation" do
-
-      context "when the criteria is from the root" do
-
-        let!(:person_two) do
-          Person.create(age: 2)
-        end
-
-        let!(:post_one) do
-          person.posts.create(title: "one")
-        end
-
-        let!(:post_two) do
-          person_two.posts.create(title: "two")
-        end
-
-        context "when calling first" do
-
-          let(:criteria) do
-            Post.includes(:person)
-          end
-
-          let!(:document) do
-            criteria.first
-          end
-
-          it "eager loads the first document" do
-            expect_query(0) do
-              expect(document.person).to eq(person)
-            end
-          end
-
-          it "returns the first document" do
-            expect(document).to eq(post_one)
-          end
-        end
-
-        context "when calling last" do
-
-          let!(:criteria) do
-            Post.asc(:_id).includes(:person)
-          end
-
-          let!(:document) do
-            criteria.last
-          end
-
-          it "eager loads the last document" do
-            expect_query(0) do
-              expect(document.person).to eq(person_two)
-            end
-          end
-
-          it "returns the last document" do
-            expect(document).to eq(post_two)
-          end
-        end
-      end
-
-      context "when the criteria is from an embedded relation" do
-
-        let(:peep) do
-          Person.create
-        end
-
-        let!(:address_one) do
-          peep.addresses.create(street: "rosenthaler")
-        end
-
-        let!(:address_two) do
-          peep.addresses.create(street: "weinmeister")
-        end
-
-        let!(:depeche) do
-          Band.create!(name: "Depeche Mode")
-        end
-
-        let!(:tool) do
-          Band.create!(name: "Tool")
-        end
-
-        before do
-          address_one.band = depeche
-          address_two.band = tool
-          address_one.save
-          address_two.save
-        end
-
-        context "when calling first" do
-
-          let(:criteria) do
-            peep.reload.addresses.includes(:band)
-          end
-
-          let(:context) do
-            criteria.context
-          end
-
-          let!(:document) do
-            criteria.first
-          end
-
-          it "eager loads the first document" do
-            expect_query(0) do
-              expect(document.band).to eq(depeche)
-            end
-          end
-
-          it "returns the document" do
-            expect(document).to eq(address_one)
-          end
-        end
-
-        context "when calling last" do
-
-          let(:criteria) do
-            peep.reload.addresses.includes(:band)
-          end
-
-          let(:context) do
-            criteria.context
-          end
-
-          let!(:document) do
-            criteria.last
-          end
-
-          it "eager loads the last document" do
-            expect_query(0) do
-              expect(document.band).to eq(tool)
-            end
-          end
-
-          it "returns the document" do
-            expect(document).to eq(address_two)
-          end
-        end
-
-        context "when iterating all documents" do
-
-          let(:criteria) do
-            peep.reload.addresses.includes(:band)
-          end
-
-          let(:context) do
-            criteria.context
-          end
-
-          let!(:documents) do
-            criteria.to_a
-          end
-
-          it "eager loads the first document" do
-            expect_query(0) do
-              expect(documents.first.band).to eq(depeche)
-            end
-          end
-
-          it "eager loads the last document" do
-            expect_query(0) do
-              expect(documents.last.band).to eq(tool)
-            end
-          end
-
-          it "returns the documents" do
-            expect(documents).to eq([ address_one, address_two ])
-          end
-        end
-      end
-    end
-
-    context "when providing inclusions to the default scope" do
-
-      before do
-        Person.default_scope(->{ Person.includes(:posts) })
-      end
-
-      after do
-        Person.default_scoping = nil
-      end
-
-      let!(:post_one) do
-        person.posts.create(title: "one")
-      end
-
-      let!(:post_two) do
-        person.posts.create(title: "two")
-      end
-
-      context "when the criteria has no options" do
-
-        let!(:criteria) do
-          Person.asc(:age).all
-        end
-
-        let!(:documents) do
-          criteria.entries
-        end
-
-        it "returns the correct documents" do
-          expect(documents).to eq([ person ])
-        end
-
-        it "eager loads the first document" do
-          expect_query(0) do
-            expect(documents.first.posts.first).to eq(post_one)
-          end
-        end
-
-        it "eager loads the last document" do
-          expect_query(0) do
-            expect(documents.first.posts.last).to eq(post_two)
-          end
-        end
-
-        context "when executing the query twice" do
-
-          let!(:new_criteria) do
-            Person.where(id: person.id)
-          end
-
-          let!(:new_context) do
-            new_criteria.context
-          end
-
-          before do
-            expect(new_context).to receive(:eager_load).with([person]).once.and_call_original
-          end
-
-          let!(:from_db) do
-            new_criteria.first
-          end
-
-          it "does not duplicate documents in the relation" do
-            expect(person.posts.size).to eq(2)
-          end
-        end
-      end
-
-      context "when calling first on the criteria" do
-
-        let(:criteria) do
-          Person.asc(:age).all
-        end
-
-        let!(:from_db) do
-          criteria.first
-        end
-
-        it "returns the correct documents" do
-          expect(from_db).to eq(person)
-        end
-
-        it "eager loads the first document" do
-          expect_query(0) do
-            expect(from_db.posts.first).to eq(post_one)
-          end
-        end
-
-        it "eager loads the last document" do
-          expect_query(0) do
-            expect(from_db.posts.last).to eq(post_two)
-          end
-        end
-      end
-
-      context "when calling last on the criteria" do
-
-        let(:criteria) do
-          Person.asc(:age).all
-        end
-
-        let!(:context) do
-          criteria.context
-        end
-
-        before do
-          expect(context).to receive(:eager_load).with([person]).once.and_call_original
-        end
-
-        let!(:from_db) do
-          criteria.last
-        end
-
-        it "returns the correct documents" do
-          expect(from_db).to eq(person)
-        end
-
-        it "eager loads the first document" do
-          expect_query(0) do
-            expect(from_db.posts.first).to eq(post_one)
-          end
-        end
-
-        it "eager loads the last document" do
-          expect_query(0) do
-            expect(from_db.posts.last).to eq(post_two)
-          end
-        end
-      end
-
-      context "when the criteria has limiting options" do
-
-        let!(:person_two) do
-          Person.create
-        end
-
-        let!(:post_three) do
-          person_two.posts.create(title: "three")
-        end
-
-        let!(:criteria) do
-          Person.asc(:age).limit(1)
-        end
-
-        let!(:documents) do
-          criteria.entries
-        end
-
-        it "returns the correct documents" do
-          expect(criteria).to eq([ person ])
-        end
-
-        it "eager loads the first document" do
-          expect_query(0) do
-            expect(documents.first.posts.first).to eq(post_one)
-          end
-        end
-
-        it "eager loads the second document" do
-          expect_query(0) do
-            expect(documents.first.posts.last).to eq(post_two)
-          end
-        end
-      end
-    end
-
-    context "when including a has and belongs to many" do
-
-      let!(:preference_one) do
-        person.preferences.create(name: "one")
-      end
-
-      let!(:preference_two) do
-        person.preferences.create(name: "two")
-      end
-
-      context "when one of the related items is deleted" do
-
-        before do
-          person.preferences = [ preference_one, preference_two ]
-          preference_two.delete
-        end
-
-        let(:criteria) do
-          Person.where(id: person.id).includes(:preferences)
-        end
-
-        it "only loads the existing related items" do
-          expect(criteria.entries.first.preferences).to eq([ preference_one ])
-        end
-      end
-
-      context "when the criteria has no options" do
-
-        let!(:criteria) do
-          Person.asc(:age).includes(:preferences)
-        end
-
-        let!(:documents) do
-          criteria.entries
-        end
-
-        it "returns the correct documents" do
-          expect(documents).to eq([ person ])
-        end
-
-        it "eager loads the first document" do
-          expect_query(0) do
-            expect(documents.first.preferences.first).to eq(preference_one)
-          end
-        end
-
-        it "eager loads the last document" do
-          expect_query(0) do
-            expect(documents.first.preferences.last).to eq(preference_two)
-          end
-        end
-      end
-
-      context "when calling first on the criteria" do
-
-        let!(:criteria) do
-          Person.asc(:age).includes(:preferences)
-        end
-
-        let!(:from_db) do
-          criteria.first
-        end
-
-        it "returns the correct documents" do
-          expect(from_db).to eq(person)
-        end
-
-        it "eager loads the first document" do
-          expect_query(0) do
-            expect(from_db.preferences.first).to eq(preference_one)
-          end
-        end
-
-        it "eager loads the last document" do
-          expect_query(0) do
-            expect(from_db.preferences.last).to eq(preference_two)
-          end
-        end
-      end
-
-      context "when calling last on the criteria" do
-
-        let!(:criteria) do
-          Person.asc(:age).includes(:preferences)
-        end
-
-        let!(:from_db) do
-          criteria.last
-        end
-
-        it "returns the correct documents" do
-          expect(from_db).to eq(person)
-        end
-
-        it "eager loads the first document" do
-          expect_query(0) do
-            expect(from_db.preferences.first).to eq(preference_one)
-          end
-        end
-
-        it "eager loads the last document" do
-          expect_query(0) do
-            expect(from_db.preferences.last).to eq(preference_two)
-          end
-        end
-      end
-    end
-
-    context "when including a has many" do
-
-      let!(:post_one) do
-        person.posts.create(title: "one")
-      end
-
-      let!(:post_two) do
-        person.posts.create(title: "two")
-      end
-
-      context "when the criteria has no options" do
-
-        let!(:criteria) do
-          Person.asc(:age).includes(:posts)
-        end
-
-        let!(:documents) do
-          criteria.entries
-        end
-
-        it "returns the correct documents" do
-          expect(documents).to eq([ person ])
-        end
-
-        it "eager loads the first document" do
-          expect_query(0) do
-            expect(documents.first.posts.first).to eq(post_one)
-          end
-        end
-
-        it "eager loads the last document" do
-          expect_query(0) do
-            expect(documents.first.posts.last).to eq(post_two)
-          end
-        end
-      end
-
-      context "when calling first on the criteria" do
-
-        let!(:criteria) do
-          Person.asc(:age).includes(:posts)
-        end
-
-        let!(:from_db) do
-          criteria.first
-        end
-
-        it "returns the correct documents" do
-          expect(from_db).to eq(person)
-        end
-
-        context "when subsequently getting all documents" do
-
-          let!(:documents) do
-            criteria.entries
-          end
-
-          it "returns the correct documents" do
-            expect(documents).to eq([ person ])
-          end
-        end
-      end
-
-      context "when calling last on the criteria" do
-
-        let!(:criteria) do
-          Person.asc(:age).includes(:posts)
-        end
-
-        let!(:from_db) do
-          criteria.last
-        end
-
-        it "returns the correct documents" do
-          expect(from_db).to eq(person)
-        end
-
-        context "when subsequently getting all documents" do
-
-          let!(:documents) do
-            criteria.entries
-          end
-
-          it "returns the correct documents" do
-            expect(documents).to eq([ person ])
-          end
-        end
-      end
-
-      context "when the criteria has limiting options" do
-
-        let!(:person_two) do
-          Person.create
-        end
-
-        let!(:post_three) do
-          person_two.posts.create(title: "three")
-        end
-
-        let!(:criteria) do
-          Person.includes(:posts).asc(:age).limit(1)
-        end
-
-        let(:context) do
-          criteria.context
-        end
-
-        before do
-          expect(context).to receive(:eager_load).with([ person ]).once.and_call_original
-        end
-
-        let!(:documents) do
-          criteria.entries
-        end
-
-        it "returns the correct documents" do
-          expect(documents).to eq([ person ])
-        end
-      end
-    end
-
-    context "when including a has one" do
-
-      let!(:game_one) do
-        person.create_game(name: "one")
-      end
-
-      let!(:game_two) do
-        person.create_game(name: "two")
-      end
-
-      context "when the criteria has no options" do
-
-        let!(:criteria) do
-          Person.asc(:age).includes(:game)
-        end
-
-        let(:context) do
-          criteria.context
-        end
-
-        before do
-          expect(context).to receive(:eager_load).with([ person ]).once.and_call_original
-        end
-
-        let!(:documents) do
-          criteria.entries
-        end
-
-        it "returns the correct documents" do
-          expect(documents).to eq([ person ])
-        end
-      end
-
-      context "when the criteria has limiting options" do
-
-        let!(:person_two) do
-          Person.create(age: 2)
-        end
-
-        let!(:game_three) do
-          person_two.create_game(name: "Skyrim")
-        end
-
-        let!(:criteria) do
-          Person.where(id: person.id).includes(:game).asc(:age).limit(1)
-        end
-
-        let(:context) do
-          criteria.context
-        end
-
-        before do
-          expect(context).to receive(:eager_load).with([ person ]).once.and_call_original
-        end
-
-        let!(:documents) do
-          criteria.entries
-        end
-
-        it "returns the correct documents" do
-          expect(documents).to eq([ person ])
-        end
-      end
-    end
-
-    context "when including a belongs to" do
-
-      let(:person_two) do
-        Person.create(age: 2)
-      end
-
-      let!(:game_one) do
-        person.create_game(name: "one")
-      end
-
-      let!(:game_two) do
-        person_two.create_game(name: "two")
-      end
-
-      context "when providing no options" do
-
-        let!(:criteria) do
-          Game.includes(:person)
-        end
-
-        let(:context) do
-          criteria.context
-        end
-
-        before do
-          expect(context).to receive(:preload).twice.and_call_original
-        end
-
-        let!(:documents) do
-          criteria.entries
-        end
-
-        it "returns the correct documents" do
-          expect(criteria).to eq([ game_one, game_two ])
-        end
-      end
-
-      context "when the criteria has limiting options" do
-
-        let!(:criteria) do
-          Game.where(id: game_one.id).includes(:person).asc(:_id).limit(1)
-        end
-
-        let(:context) do
-          criteria.context
-        end
-
-        before do
-          expect(context).to receive(:eager_load).with([ game_one ]).once.and_call_original
-        end
-
-        let!(:documents) do
-          criteria.entries
-        end
-
-        it "returns the correct documents" do
-          expect(documents).to eq([ game_one ])
-        end
-      end
-    end
-
-    context "when including multiples in the same criteria" do
-
-      let!(:post_one) do
-        person.posts.create(title: "one")
-      end
-
-      let!(:post_two) do
-        person.posts.create(title: "two")
-      end
-
-      let!(:game_one) do
-        person.create_game(name: "one")
-      end
-
-      let!(:game_two) do
-        person.create_game(name: "two")
-      end
-
-      let!(:criteria) do
-        Person.includes(:posts, :game).asc(:age)
-      end
-
-      let(:context) do
-        criteria.context
-      end
-
-      before do
-        expect(context).to receive(:preload).twice.and_call_original
-      end
-
-      let!(:documents) do
-        criteria.entries
-      end
-
-      it "returns the correct documents" do
-        expect(criteria).to eq([ person ])
-      end
-    end
-  end
-
-  describe "#inclusions" do
-
-    let(:criteria) do
-      Band.includes(:records)
-    end
-
-    let(:association) do
-      Band.relations["records"]
-    end
-
-    it "returns the inclusions" do
-      expect(criteria.inclusions).to eq([ association ])
-    end
-  end
-
-  describe "#inclusions=" do
-
-    let(:criteria) do
-      Band.all
-    end
-
-    let(:association) do
-      Band.relations["records"]
-    end
-
-    before do
-      criteria.inclusions = [ association ]
-    end
-
-    it "sets the inclusions" do
-      expect(criteria.inclusions).to eq([ association ])
-    end
-  end
-
-  describe "#lt" do
-
-    let!(:match) do
-      Band.create(member_count: 1)
-    end
-
-    let!(:non_match) do
-      Band.create(member_count: 5)
-    end
-
-    let(:criteria) do
-      Band.lt(member_count: 4)
-    end
-
-    it "returns the matching documents" do
-      expect(criteria).to eq([ match ])
-    end
-  end
-
-  describe "#lte" do
-
-    let!(:match) do
-      Band.create(member_count: 4)
-    end
-
-    let!(:non_match) do
-      Band.create(member_count: 5)
-    end
-
-    let(:criteria) do
-      Band.lte(member_count: 4)
-    end
-
-    it "returns the matching documents" do
-      expect(criteria).to eq([ match ])
-    end
-  end
-
-  describe "#map_reduce" do
-
-    let(:map) do
-      %Q{
-      function() {
-        emit(this.name, { likes: this.likes });
-      }}
-    end
-
-    let(:reduce) do
-      %Q{
-      function(key, values) {
-        var result = { likes: 0 };
-        values.forEach(function(value) {
-          result.likes += value.likes;
-        });
-        return result;
-      }}
-    end
-
-    let!(:depeche_mode) do
-      Band.create(name: "Depeche Mode", likes: 200)
-    end
-
-    let!(:tool) do
-      Band.create(name: "Tool", likes: 100)
-    end
-
-    context "when no timeout options are provided" do
-
-      let(:map_reduce) do
-        Band.limit(2).map_reduce(map, reduce).out(inline: 1)
-      end
-
-      it "returns the map/reduce results" do
-        expect(map_reduce).to eq([
-          { "_id" => "Depeche Mode", "value" => { "likes" => 200 }},
-          { "_id" => "Tool", "value" => { "likes" => 100 }}
-        ])
-      end
-    end
-  end
-
-  describe "#max" do
-
-    context "when provided a single field" do
-
-      let!(:depeche) do
-        Band.create(name: "Depeche Mode", likes: 1000)
-      end
-
-      let!(:tool) do
-        Band.create(name: "Tool", likes: 500)
-      end
-
-      let(:criteria) do
-        Band.all
-      end
-
-      context "when provided a symbol" do
-
-        let(:max) do
-          criteria.max(:likes)
-        end
-
-        it "returns the max of the provided field" do
-          expect(max).to eq(1000)
-        end
-      end
-
-      context "when provided a block" do
-
-        let(:max) do
-          criteria.max do |a, b|
-            a.likes <=> b.likes
-          end
-        end
-
-        it "returns the document with the max value for the field" do
-          expect(max).to eq(depeche)
-        end
-      end
-    end
-  end
-
-  describe "#max_distance" do
-
-    before do
-      Bar.create_indexes
-    end
-
-    let!(:match) do
-      Bar.create(location: [ 52.30, 13.25 ])
-    end
-
-    let!(:non_match) do
-      Bar.create(location: [ 19.26, 99.70 ])
-    end
-
-    let(:criteria) do
-      Bar.near(location: [ 52, 13 ]).max_distance(location: 5)
-    end
-
-    it "returns the matching documents" do
-      expect(criteria).to eq([ match ])
-    end
-  end
-
-  describe "#merge" do
-
-    let(:band) do
-      Band.new
-    end
-
-    let(:criteria) do
-      Band.scoped.where(name: "Depeche Mode").asc(:name)
-    end
-
-    context "when merging with another criteria" do
-
-      let(:mergeable) do
-        Band.includes(:records).tap do |crit|
-          crit.documents = [ band ]
-        end
-      end
-
-      let(:association) do
-        Band.relations["records"]
-      end
-
-      let(:merged) do
-        criteria.merge(mergeable)
-      end
-
-      it "merges the selector" do
-        expect(merged.selector).to eq({ "name" => "Depeche Mode" })
-      end
-
-      it "merges the options" do
-        expect(merged.options).to eq({ sort: { "name" => 1 }})
-      end
-
-      it "merges the documents" do
-        expect(merged.documents).to eq([ band ])
-      end
-
-      it "merges the scoping options" do
-        expect(merged.scoping_options).to eq([ nil, nil ])
-      end
-
-      it "merges the inclusions" do
-        expect(merged.inclusions).to eq([ association ])
-      end
-
-      it "returns a new criteria" do
-        expect(merged).to_not equal(criteria)
-      end
-    end
-
-    context "when merging with a hash" do
+    context "when merging with a hash" do
 
       let(:mergeable) do
         { klass: Band, includes: [ :records ] }
@@ -2548,11 +1514,11 @@ describe Mongoid::Criteria do
     context "when provided a single field" do
 
       let!(:depeche) do
-        Band.create(name: "Depeche Mode", likes: 1000)
+        Band.create!(name: "Depeche Mode", likes: 1000)
       end
 
       let!(:tool) do
-        Band.create(name: "Tool", likes: 500)
+        Band.create!(name: "Tool", likes: 500)
       end
 
       let(:criteria) do
@@ -2588,11 +1554,11 @@ describe Mongoid::Criteria do
   describe "#mod" do
 
     let!(:match) do
-      Band.create(member_count: 5)
+      Band.create!(member_count: 5)
     end
 
     let!(:non_match) do
-      Band.create(member_count: 2)
+      Band.create!(member_count: 2)
     end
 
     let(:criteria) do
@@ -2607,11 +1573,11 @@ describe Mongoid::Criteria do
   describe "#ne" do
 
     let!(:match) do
-      Band.create(name: "Depeche Mode")
+      Band.create!(name: "Depeche Mode")
     end
 
     let!(:non_match) do
-      Band.create(name: "Tool")
+      Band.create!(name: "Tool")
     end
 
     let(:criteria) do
@@ -2630,286 +1596,72 @@ describe Mongoid::Criteria do
     end
 
     let!(:match) do
-      Bar.create(location: [ 52.30, 13.25 ])
+      Bar.create!(location: [ 52.30, 13.25 ])
     end
 
     let(:criteria) do
       Bar.near(location: [ 52, 13 ])
-    end
-
-    it "returns the matching documents" do
-      expect(criteria).to eq([ match ])
-    end
-  end
-
-  describe "#near_sphere" do
-
-    before do
-      Bar.create_indexes
-    end
-
-    let!(:match) do
-      Bar.create(location: [ 52.30, 13.25 ])
-    end
-
-    let(:criteria) do
-      Bar.near_sphere(location: [ 52, 13 ])
-    end
-
-    it "returns the matching documents" do
-      expect(criteria).to eq([ match ])
-    end
-  end
-
-  describe "#nin" do
-
-    let!(:match) do
-      Band.create(name: "Depeche Mode")
-    end
-
-    let!(:non_match) do
-      Band.create(name: "Tool")
-    end
-
-    let(:criteria) do
-      Band.nin(name: [ "Tool" ])
-    end
-
-    it "returns the matching documents" do
-      expect(criteria).to eq([ match ])
-    end
-  end
-
-  describe "#nor" do
-
-    let!(:match) do
-      Band.create(name: "Depeche Mode")
-    end
-
-    let!(:non_match) do
-      Band.create(name: "Tool")
-    end
-
-    let(:criteria) do
-      Band.nor({ name: "Tool" }, { name: "New Order" })
-    end
-
-    it "returns the matching documents" do
-      expect(criteria).to eq([ match ])
-    end
-  end
-
-  describe "#only" do
-
-    let!(:band) do
-      Band.create(name: "Depeche Mode", likes: 3, views: 10)
-    end
-
-    context "when not using inheritance" do
-
-      context "when passing splat args" do
-
-        let(:criteria) do
-          Band.only(:_id)
-        end
-
-        it "limits the returned fields" do
-          expect {
-            criteria.first.name
-          }.to raise_error(ActiveModel::MissingAttributeError)
-        end
-
-        it "does not add _type to the fields" do
-          expect(criteria.options[:fields]["_type"]).to be_nil
-        end
-      end
-
-      context "when not including id" do
-
-        let(:criteria) do
-          Band.only(:name)
-        end
-
-        it "responds to id anyway" do
-          expect {
-            criteria.first.id
-          }.to_not raise_error
-        end
-      end
-
-      context "when passing an array" do
-
-        let(:criteria) do
-          Band.only([ :name, :likes ])
-        end
-
-        it "includes the limited fields" do
-          expect(criteria.first.name).to_not be_nil
-        end
-
-        it "excludes the non included fields" do
-          expect {
-            criteria.first.active
-          }.to raise_error(ActiveModel::MissingAttributeError)
-        end
-
-        it "does not add _type to the fields" do
-          expect(criteria.options[:fields]["_type"]).to be_nil
-        end
-      end
-
-      context "when instantiating a class of another type inside the iteration" do
-
-        let(:criteria) do
-          Band.only(:name)
-        end
-
-        it "only limits the fields on the correct model" do
-          criteria.each do |band|
-            expect(Person.new.age).to eq(100)
-          end
-        end
-      end
-
-      context "when instantiating a document not in the result set" do
-
-        let(:criteria) do
-          Band.only(:name)
-        end
-
-        it "only limits the fields on the correct criteria" do
-          criteria.each do |band|
-            expect(Band.new.active).to be true
-          end
-        end
-      end
-
-      context "when nesting a criteria within a criteria" do
-
-        let(:criteria) do
-          Band.only(:name)
-        end
-
-        it "only limits the fields on the correct criteria" do
-          criteria.each do |band|
-            Band.all.each do |b|
-              expect(b.active).to be true
-            end
-          end
-        end
-      end
-    end
-
-    context "when using inheritance" do
-
-      let(:criteria) do
-        Doctor.only(:_id)
-      end
-
-      it "adds _type to the fields" do
-        expect(criteria.options[:fields]["_type"]).to eq(1)
-      end
-    end
-
-    context "when limiting to embedded documents" do
-
-      context "when the embedded documents are aliased" do
-
-        let(:criteria) do
-          Person.only(:phones)
-        end
-
-        it "properly uses the database field name" do
-          expect(criteria.options).to eq(fields: { "_id" => 1, "mobile_phones" => 1 })
-        end
-      end
-    end
-
-    context 'when the field is localized' 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
-
-      context 'when entire field is included' do
+    end
 
-        let(:dictionary) do
-          Dictionary.only(:description).first
+    it "returns the matching documents" do
+      expect(criteria).to eq([ match ])
+    end
+  end
 
-        end
+  describe "#near_sphere" do
 
-        it 'loads all translations' do
-          expect(dictionary.description_translations.keys).to include('de', 'en')
-        end
+    before do
+      Bar.create_indexes
+    end
 
-        it 'returns the field value for the current locale' do
-          I18n.locale = :en
-          expect(dictionary.description).to eq('english-text')
-          I18n.locale = :de
-          expect(dictionary.description).to eq('deutsch-text')
-        end
-      end
+    let!(:match) do
+      Bar.create!(location: [ 52.30, 13.25 ])
+    end
 
-      context 'when a specific locale is included' do
+    let(:criteria) do
+      Bar.near_sphere(location: [ 52, 13 ])
+    end
 
-        let(:dictionary) do
-          Dictionary.only(:'description.de').first
-        end
+    it "returns the matching documents" do
+      expect(criteria).to eq([ match ])
+    end
+  end
 
-        it 'loads translations only for the included locale' do
-          expect(dictionary.description_translations.keys).to include('de')
-          expect(dictionary.description_translations.keys).to_not include('en')
-        end
+  describe "#nin" do
 
-        it 'returns the field value for the included locale' do
-          I18n.locale = :en
-          expect(dictionary.description).to be_nil
-          I18n.locale = :de
-          expect(dictionary.description).to eq('deutsch-text')
-        end
-      end
+    let!(:match) do
+      Band.create!(name: "Depeche Mode")
+    end
 
-      context 'when entire field is excluded' do
+    let!(:non_match) do
+      Band.create!(name: "Tool")
+    end
 
-        let(:dictionary) do
-          Dictionary.without(:description).first
-        end
+    let(:criteria) do
+      Band.nin(name: [ "Tool" ])
+    end
 
-        it 'does not load all translations' do
-          expect(dictionary.description_translations.keys).to_not include('de', 'en')
-        end
+    it "returns the matching documents" do
+      expect(criteria).to eq([ match ])
+    end
+  end
 
-        it 'raises an ActiveModel::MissingAttributeError when attempting to access the field' do
-          expect{dictionary.description}.to raise_error ActiveModel::MissingAttributeError
-        end
-      end
+  describe "#nor" do
 
-      context 'when a specific locale is excluded' do
+    let!(:match) do
+      Band.create!(name: "Depeche Mode")
+    end
 
-        let(:dictionary) do
-          Dictionary.without(:'description.de').first
-        end
+    let!(:non_match) do
+      Band.create!(name: "Tool")
+    end
 
-        it 'does not load excluded translations' do
-          expect(dictionary.description_translations.keys).to_not include('de')
-          expect(dictionary.description_translations.keys).to include('en')
-        end
+    let(:criteria) do
+      Band.nor({ name: "Tool" }, { name: "New Order" })
+    end
 
-        it 'returns nil for excluded translations' do
-          I18n.locale = :en
-          expect(dictionary.description).to eq('english-text')
-          I18n.locale = :de
-          expect(dictionary.description).to be_nil
-        end
-      end
+    it "returns the matching documents" do
+      expect(criteria).to eq([ match ])
     end
   end
 
@@ -2918,11 +1670,11 @@ describe Mongoid::Criteria do
     describe "\##{method}" do
 
       let!(:match) do
-        Band.create(name: "Depeche Mode")
+        Band.create!(name: "Depeche Mode")
       end
 
       let!(:non_match) do
-        Band.create(name: "Tool")
+        Band.create!(name: "Tool")
       end
 
       context "when sending a normal $or criterion" do
@@ -2952,25 +1704,29 @@ describe Mongoid::Criteria do
   describe "#pluck" do
 
     let!(:depeche) do
-      Band.create(name: "Depeche Mode", likes: 3)
+      Band.create!(name: "Depeche Mode", likes: 3)
     end
 
     let!(:tool) do
-      Band.create(name: "Tool", likes: 3)
+      Band.create!(name: "Tool", likes: 3)
     end
 
     let!(:photek) do
-      Band.create(name: "Photek", likes: 1)
+      Band.create!(name: "Photek", likes: 1)
+    end
+
+    let(:maniacs) do
+      Band.create!(name: "10,000 Maniacs", likes: 1, sales: "1E2")
     end
 
     context "when the field is aliased" do
 
       let!(:expensive) do
-        Product.create(price: 100000)
+        Product.create!(price: 100000)
       end
 
       let!(:cheap) do
-        Product.create(price: 1)
+        Product.create!(price: 1)
       end
 
       context "when using alias_attribute" do
@@ -2979,8 +1735,10 @@ describe Mongoid::Criteria do
           Product.pluck(:price)
         end
 
-        it "uses the aliases" do
-          expect(plucked).to eq([ 100000, 1 ])
+        with_config_values :legacy_pluck_distinct, true, false do
+          it "uses the aliases" do
+            expect(plucked).to eq([ 100000, 1 ])
+          end
         end
       end
     end
@@ -2997,14 +1755,18 @@ describe Mongoid::Criteria do
           criteria.pluck(:name)
         end
 
-        it "returns the values" do
-          expect(plucked).to contain_exactly("Depeche Mode", "Tool", "Photek")
+        with_config_values :legacy_pluck_distinct, true, false do
+          it "returns the values" do
+            expect(plucked).to contain_exactly("Depeche Mode", "Tool", "Photek")
+          end
         end
 
         context "when subsequently executing the criteria without a pluck" do
 
-          it "does not limit the fields" do
-            expect(criteria.first.likes).to eq(3)
+          with_config_values :legacy_pluck_distinct, true, false do
+            it "does not limit the fields" do
+              expect(criteria.first.likes).to eq(3)
+            end
           end
         end
 
@@ -3015,51 +1777,83 @@ describe Mongoid::Criteria do
           end
 
           context 'when a top-level field and a subdocument field are plucked' do
-
             before do
-              Band.create(name: 'FKA Twigs')
-              Band.create(name: 'FKA Twigs', records: [ Record.new(name: 'LP1') ])
+              Band.create!(name: 'FKA Twigs')
+              Band.create!(name: 'FKA Twigs', records: [ Record.new(name: 'LP1') ])
             end
 
             let(:embedded_pluck) do
               criteria.pluck(:name, 'records.name')
             end
 
-            let(:expected) do
-              [
-                ["FKA Twigs", nil],
-                ['FKA Twigs', [{ "name" => "LP1" }]]
-              ]
+            context "when legacy_pluck_distinct is set" do
+              config_override :legacy_pluck_distinct, true
+              let(:expected) do
+                [
+                  ["FKA Twigs", nil],
+                  ['FKA Twigs', [{ "name" => "LP1" }]]
+                ]
+              end
+
+              it 'returns the list of top-level field and subdocument values' do
+                expect(embedded_pluck).to eq(expected)
+              end
             end
 
-            it 'returns the list of top-level field and subdocument values' do
-              expect(embedded_pluck). to eq(expected)
+            context "when legacy_pluck_distinct is not set" do
+              config_override :legacy_pluck_distinct, false
+              let(:expected) do
+                [
+                  ["FKA Twigs", nil],
+                  ['FKA Twigs', ["LP1"]]
+                ]
+              end
+
+              it 'returns the list of top-level field and subdocument values' do
+                expect(embedded_pluck).to eq(expected)
+              end
             end
           end
 
           context 'when only a subdocument field is plucked' do
 
             before do
-              Band.create(name: 'FKA Twigs')
-              Band.create(name: 'FKA Twigs', records: [ Record.new(name: 'LP1') ])
+              Band.create!(name: 'FKA Twigs')
+              Band.create!(name: 'FKA Twigs', records: [ Record.new(name: 'LP1') ])
             end
 
             let(:embedded_pluck) do
               criteria.pluck('records.name')
             end
 
-            let(:expected) do
-              [
-                nil,
-                [{ "name" => "LP1" }]
-              ]
+            context "when legacy_pluck_distinct is set" do
+              config_override :legacy_pluck_distinct, true
+              let(:expected) do
+                [
+                  nil,
+                  [{ "name" => "LP1" }]
+                ]
+              end
+
+              it 'returns the list of subdocument values' do
+                expect(embedded_pluck).to eq(expected)
+              end
             end
 
-            it 'returns the list of subdocument values' do
-              expect(embedded_pluck). to eq(expected)
+            context "when legacy_pluck_distinct is not set" do
+              config_override :legacy_pluck_distinct, false
+              let(:expected) do
+                [
+                  nil,
+                  ["LP1"]
+                ]
+              end
+
+              it 'returns the list of subdocument values' do
+                expect(embedded_pluck).to eq(expected)
+              end
             end
           end
-
         end
       end
 
@@ -3069,8 +1863,10 @@ describe Mongoid::Criteria do
           Band.where(:name.exists => true).pluck(:name, :likes)
         end
 
-        it "returns the values" do
-          expect(plucked).to contain_exactly(["Depeche Mode", 3], ["Tool", 3], ["Photek", 1])
+        with_config_values :legacy_pluck_distinct, true, false do
+          it "returns the values" do
+            expect(plucked).to contain_exactly(["Depeche Mode", 3], ["Tool", 3], ["Photek", 1])
+          end
         end
       end
 
@@ -3080,8 +1876,10 @@ describe Mongoid::Criteria do
           Band.where(:name.exists => true).pluck(:likes)
         end
 
-        it "returns the duplicates" do
-          expect(plucked).to contain_exactly(3, 3, 1)
+        with_config_values :legacy_pluck_distinct, true, false do
+          it "returns the duplicates" do
+            expect(plucked).to contain_exactly(3, 3, 1)
+          end
         end
       end
     end
@@ -3092,8 +1890,10 @@ describe Mongoid::Criteria do
         Band.where(name: "New Order").pluck(:_id)
       end
 
-      it "returns an empty array" do
-        expect(plucked).to be_empty
+      with_config_values :legacy_pluck_distinct, true, false do
+        it "returns an empty array" do
+          expect(plucked).to be_empty
+        end
       end
     end
 
@@ -3103,8 +1903,10 @@ describe Mongoid::Criteria do
         Band.all.pluck(:id)
       end
 
-      it "returns the field values" do
-        expect(plucked).to eq([ depeche.id, tool.id, photek.id ])
+      with_config_values :legacy_pluck_distinct, true, false do
+        it "returns the field values" do
+          expect(plucked).to eq([ depeche.id, tool.id, photek.id ])
+        end
       end
     end
 
@@ -3114,8 +1916,10 @@ describe Mongoid::Criteria do
         Band.all.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] ])
+      with_config_values :legacy_pluck_distinct, true, false do
+        it "returns nil for the field that doesnt exist" do
+          expect(plucked).to eq([[depeche.id, nil], [tool.id, nil], [photek.id, nil] ])
+        end
       end
     end
 
@@ -3127,8 +1931,10 @@ describe Mongoid::Criteria do
           Band.all.pluck(:foo)
         end
 
-        it "returns a array with nil values" do
-          expect(plucked).to eq([nil, nil, nil])
+        with_config_values :legacy_pluck_distinct, true, false do
+          it "returns an array with nil values" do
+            expect(plucked).to eq([nil, nil, nil])
+          end
         end
       end
 
@@ -3138,46 +1944,389 @@ describe Mongoid::Criteria do
           Band.all.pluck(:foo, :bar)
         end
 
-        it "returns a nil arrays" do
-          expect(plucked).to eq([[nil, nil], [nil, nil], [nil, nil]])
+        with_config_values :legacy_pluck_distinct, true, false do
+          it "returns an array of arrays with nil values" do
+            expect(plucked).to eq([[nil, nil], [nil, nil], [nil, nil]])
+          end
         end
       end
     end
 
     context 'when plucking a localized field' do
+      with_default_i18n_configs
 
       before do
         I18n.locale = :en
-        d = Dictionary.create(description: 'english-text')
+        d = Dictionary.create!(description: 'english-text')
         I18n.locale = :de
         d.description = 'deutsch-text'
-        d.save
+        d.save!
       end
 
-      after do
-        I18n.locale = :en
+      context 'when plucking the entire field' do
+        let(:plucked) do
+          Dictionary.all.pluck(:description)
+        end
+
+        let(:plucked_translations) do
+          Dictionary.all.pluck(:description_translations)
+        end
+
+        let(:plucked_translations_both) do
+          Dictionary.all.pluck(:description_translations, :description)
+        end
+
+        context "when legacy_pluck_distinct is set" do
+          config_override :legacy_pluck_distinct, true
+
+          it 'returns the non-demongoized translations' do
+            expect(plucked.first).to eq({"de"=>"deutsch-text", "en"=>"english-text"})
+          end
+
+          it 'returns nil' do
+            expect(plucked_translations.first).to eq(nil)
+          end
+
+          it 'returns nil for _translations' do
+            expect(plucked_translations_both.first).to eq([nil, {"de"=>"deutsch-text", "en"=>"english-text"}])
+          end
+        end
+
+        context "when legacy_pluck_distinct is not set" do
+          config_override :legacy_pluck_distinct, false
+
+          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
       end
 
-      context 'when plucking the entire field' do
+      context 'when plucking a specific locale' do
 
         let(:plucked) do
-          Dictionary.all.pluck(:description)
+          Dictionary.all.pluck(:'description.de')
+        end
+
+        context "when legacy_pluck_distinct is set" do
+          config_override :legacy_pluck_distinct, true
+
+          it 'returns the specific translations' do
+            expect(plucked.first).to eq({'de' => 'deutsch-text'})
+          end
+        end
+
+        context "when legacy_pluck_distinct is not set" do
+          config_override :legacy_pluck_distinct, false
+
+          it 'returns the specific translations' do
+            expect(plucked.first).to eq('deutsch-text')
+          end
+        end
+      end
+
+      context 'when plucking a specific locale from _translations field' do
+
+        let(:plucked) do
+          Dictionary.all.pluck(:'description_translations.de')
+        end
+
+        context "when legacy_pluck_distinct is set" do
+          config_override :legacy_pluck_distinct, true
+
+          it 'returns the specific translations' do
+            expect(plucked.first).to eq(nil)
+          end
+        end
+
+        context "when legacy_pluck_distinct is not set" do
+          config_override :legacy_pluck_distinct, false
+
+          it 'returns the specific translations' do
+            expect(plucked.first).to eq('deutsch-text')
+          end
+        end
+      end
+
+      context 'when fallbacks are enabled with a locale list' do
+        require_fallbacks
+
+        before do
+          I18n.fallbacks[:he] = [ :en ]
+        end
+
+        let(:plucked) do
+          Dictionary.all.pluck(:description).first
+        end
+
+        context "when legacy_pluck_distinct is set" do
+          config_override :legacy_pluck_distinct, true
+
+          it "does not correctly use the fallback" do
+            plucked.should == {"de"=>"deutsch-text", "en"=>"english-text"}
+          end
+        end
+
+        context "when legacy_pluck_distinct is not set" do
+          config_override :legacy_pluck_distinct, false
+
+          it "correctly uses the fallback" do
+            I18n.locale = :en
+            d = Dictionary.create!(description: 'english-text')
+            I18n.locale = :he
+            plucked.should == "english-text"
+          end
+        end
+      end
+
+      context "when the localized field is embedded" do
+        with_default_i18n_configs
+
+        before do
+          p = Passport.new
+          I18n.locale = :en
+          p.name = "Neil"
+          I18n.locale = :he
+          p.name = "Nissim"
+
+          Person.create!(passport: p, employer_id: 12345)
+        end
+
+        let(:plucked) do
+          Person.where(employer_id: 12345).pluck("pass.name").first
+        end
+
+        let(:plucked_translations) do
+          Person.where(employer_id: 12345).pluck("pass.name_translations").first
+        end
+
+        let(:plucked_translations_field) do
+          Person.where(employer_id: 12345).pluck("pass.name_translations.en").first
+        end
+
+        context "when legacy_pluck_distinct is set" do
+          config_override :legacy_pluck_distinct, true
+
+          it "returns the full hash embedded" do
+            expect(plucked).to eq({ "name" => { "en" => "Neil", "he" => "Nissim" } })
+          end
+
+          it "returns the empty hash" do
+            expect(plucked_translations).to eq({})
+          end
+
+          it "returns the empty hash" do
+            expect(plucked_translations_field).to eq({})
+          end
+        end
+
+        context "when legacy_pluck_distinct is not set" do
+          config_override :legacy_pluck_distinct, false
+
+          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
+    end
+
+    context 'when plucking a field to be demongoized' do
+
+      let(:plucked) do
+        Band.where(name: maniacs.name).pluck(:sales)
+      end
+
+      context "when legacy_pluck_distinct is set" do
+        config_override :legacy_pluck_distinct, true
+
+        context 'when value is stored as string' do
+          config_override :map_big_decimal_to_decimal128, false
+
+          it "does not demongoize the field" do
+            expect(plucked.first).to be_a(String)
+            expect(plucked.first).to eq("1E2")
+          end
+        end
+
+        context 'when value is stored as decimal128' do
+          config_override :map_big_decimal_to_decimal128, true
+          max_bson_version '4.99.99'
+
+          it "does not demongoize the field" do
+            expect(plucked.first).to be_a(BSON::Decimal128)
+            expect(plucked.first).to eq(BSON::Decimal128.new("1E2"))
+          end
+        end
+      end
+
+      context "when legacy_pluck_distinct is not set" do
+        config_override :legacy_pluck_distinct, false
+
+        context 'when value is stored as string' do
+          config_override :map_big_decimal_to_decimal128, false
+
+          it "demongoizes the field" do
+            expect(plucked.first).to be_a(BigDecimal)
+            expect(plucked.first).to eq(BigDecimal("1E2"))
+          end
+        end
+
+        context 'when value is stored as decimal128' do
+          config_override :map_big_decimal_to_decimal128, true
+
+          it "demongoizes the field" do
+            expect(plucked.first).to be_a(BigDecimal)
+            expect(plucked.first).to eq(BigDecimal("1E2"))
+          end
+        end
+      end
+    end
+
+    context "when plucking an embedded field" do
+      let(:label) { Label.new(sales: "1E2") }
+      let!(:band) { Band.create!(label: label) }
+
+      let(:plucked) { Band.where(_id: band.id).pluck("label.sales") }
+
+      context "when legacy_pluck_distinct is set" do
+        config_override :legacy_pluck_distinct, true
+        config_override :map_big_decimal_to_decimal128, true
+        max_bson_version '4.99.99'
+
+        it "returns a hash with a non-demongoized field" do
+          expect(plucked.first).to eq({ 'sales' => BSON::Decimal128.new('1E+2') })
+        end
+      end
+
+      context "when legacy_pluck_distinct is not set" do
+        config_override :legacy_pluck_distinct, false
+
+        it "demongoizes the field" do
+          expect(plucked).to eq([ BigDecimal("1E2") ])
+        end
+      end
+    end
+
+    context "when plucking an embeds_many field" do
+      let(:label) { Label.new(sales: "1E2") }
+      let!(:band) { Band.create!(labels: [label]) }
+
+      let(:plucked) { Band.where(_id: band.id).pluck("labels.sales") }
+
+      context "when legacy_pluck_distinct is set" do
+        config_override :legacy_pluck_distinct, true
+        config_override :map_big_decimal_to_decimal128, true
+        max_bson_version '4.99.99'
+
+        it "returns a hash with a non-demongoized field" do
+          expect(plucked.first).to eq([{ 'sales' => BSON::Decimal128.new('1E+2') }])
+        end
+      end
+
+      context "when legacy_pluck_distinct is not set" do
+        config_override :legacy_pluck_distinct, false
+
+        it "demongoizes the field" do
+          expect(plucked.first).to eq([ BigDecimal("1E2") ])
+        end
+      end
+    end
+
+    context "when plucking a nonexistent embedded field" do
+      let(:label) { Label.new(sales: "1E2") }
+      let!(:band) { Band.create!(label: label) }
+
+      let(:plucked) { Band.where(_id: band.id).pluck("label.qwerty") }
+
+      context "when legacy_pluck_distinct is set" do
+        config_override :legacy_pluck_distinct, true
+
+        it "returns an empty hash" do
+          expect(plucked.first).to eq({})
         end
+      end
+
+      context "when legacy_pluck_distinct is not set" do
+        config_override :legacy_pluck_distinct, false
+
+        it "returns nil" do
+          expect(plucked.first).to eq(nil)
+        end
+      end
+    end
+
+    context "when tallying deeply nested arrays/embedded associations" do
+
+      before do
+        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
+
+      let(:plucked) do
+        Person.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
+
+  describe "#pick" do
+
+    let!(:depeche) do
+      Band.create!(name: "Depeche Mode", likes: 3)
+    end
+
+    let!(:tool) do
+      Band.create!(name: "Tool", likes: 3)
+    end
+
+    context "when picking a field" do
+
+      let(:criteria) do
+        Band.all
+      end
+
+      let(:picked) do
+        criteria.pick(:name)
+      end
 
-        it 'returns all translations' do
-          expect(plucked.first).to eq({'en' => 'english-text', 'de' => 'deutsch-text'})
-        end
+      it "returns one element" do
+        expect(picked).to eq("Depeche Mode")
       end
+    end
 
-      context 'when plucking a specific locale' do
+    context "when picking multiple fields" do
 
-        let(:plucked) do
-          Dictionary.all.pluck(:'description.de')
-        end
+      let(:criteria) do
+        Band.all
+      end
 
-        it 'returns the specific translations' do
-          expect(plucked.first).to eq({'de' => 'deutsch-text'})
-        end
+      let(:picked) do
+        criteria.pick(:name, :likes)
+      end
+
+      it "returns an array" do
+        expect(picked).to eq([ "Depeche Mode", 3 ])
       end
     end
   end
@@ -3263,11 +2412,11 @@ describe Mongoid::Criteria do
   describe "#sort" do
 
     let!(:depeche) do
-      Band.create(name: "Depeche Mode", likes: 1000)
+      Band.create!(name: "Depeche Mode", likes: 1000)
     end
 
     let!(:tool) do
-      Band.create(name: "Tool", likes: 500)
+      Band.create!(name: "Tool", likes: 500)
     end
 
     let(:sorted) do
@@ -3286,11 +2435,11 @@ describe Mongoid::Criteria do
     context "when provided a single field" do
 
       let!(:depeche) do
-        Band.create(name: "Depeche Mode", likes: 1000)
+        Band.create!(name: "Depeche Mode", likes: 1000)
       end
 
       let!(:tool) do
-        Band.create(name: "Tool", likes: 500)
+        Band.create!(name: "Tool", likes: 500)
       end
 
       let(:criteria) do
@@ -3324,7 +2473,7 @@ describe Mongoid::Criteria do
   describe "#to_ary" do
 
     let!(:band) do
-      Band.create(name: "Depeche Mode")
+      Band.create!(name: "Depeche Mode")
     end
 
     let(:criteria) do
@@ -3340,11 +2489,11 @@ describe Mongoid::Criteria do
     max_server_version '4.0'
 
     let!(:band) do
-      Band.create(name: "Depeche Mode")
+      Band.create!(name: "Depeche Mode")
     end
 
     let!(:band2) do
-      Band.create(name: "Tool")
+      Band.create!(name: "Tool")
     end
 
     let(:criteria) do
@@ -3383,34 +2532,75 @@ describe Mongoid::Criteria do
   end
 
   describe "#type" do
+    context "when using the default discriminator_key" do
+      context "when the type is a string" do
 
-    context "when the type is a string" do
+        let!(:browser) do
+          Browser.create!
+        end
 
-      let!(:browser) do
-        Browser.create
-      end
+        let(:criteria) do
+          Canvas.all.type("Browser")
+        end
 
-      let(:criteria) do
-        Canvas.all.type("Browser")
+        it "returns documents with the provided type" do
+          expect(criteria).to eq([ browser ])
+        end
       end
 
-      it "returns documents with the provided type" do
-        expect(criteria).to eq([ browser ])
+      context "when the type is an Array of type" do
+
+        let!(:browser) do
+          Firefox.create!
+        end
+
+        let(:criteria) do
+          Canvas.all.type([ "Browser", "Firefox" ])
+        end
+
+        it "returns documents with the provided types" do
+          expect(criteria).to eq([ browser ])
+        end
       end
     end
 
-    context "when the type is an Array of type" do
+    context "when using a custom discriminator_key" do
+      before do
+        Canvas.discriminator_key = "dkey"
+      end
 
-      let!(:browser) do
-        Firefox.create
+      after do
+        Canvas.discriminator_key = nil
       end
 
-      let(:criteria) do
-        Canvas.all.type([ "Browser", "Firefox" ])
+      context "when the type is a string" do
+
+        let!(:browser) do
+          Browser.create!
+        end
+
+        let(:criteria) do
+          Canvas.all.type("Browser")
+        end
+
+        it "returns documents with the provided type" do
+          expect(criteria).to eq([ browser ])
+        end
       end
 
-      it "returns documents with the provided types" do
-        expect(criteria).to eq([ browser ])
+      context "when the type is an Array of type" do
+
+        let!(:browser) do
+          Firefox.create!
+        end
+
+        let(:criteria) do
+          Canvas.all.type([ "Browser", "Firefox" ])
+        end
+
+        it "returns documents with the provided types" do
+          expect(criteria).to eq([ browser ])
+        end
       end
     end
   end
@@ -3418,11 +2608,43 @@ describe Mongoid::Criteria do
   describe "#where" do
 
     let!(:match) do
-      Band.create(name: "Depeche Mode")
+      Band.create!(name: "Depeche Mode")
     end
 
     let!(:non_match) do
-      Band.create(name: "Tool")
+      Band.create!(name: "Tool")
+    end
+
+    context 'when provided no arguments' do
+      context 'on a model class' do
+        it 'returns an empty criteria' do
+          Band.where.selector.should == {}
+        end
+      end
+
+      context 'on an association' do
+        it 'returns an empty criteria' do
+          match.records.where.selector.should == {}
+        end
+      end
+    end
+
+    context 'when provided multiple arguments' do
+      context 'on a model class' do
+        it 'raises ArgumentError' do
+          lambda do
+            Band.where({foo: 1}, {bar: 2})
+          end.should raise_error(ArgumentError, /where requires zero or one arguments/)
+        end
+      end
+
+      context 'on an association' do
+        it 'raises ArgumentError' do
+          lambda do
+            match.records.where({foo: 1}, {bar: 2})
+          end.should raise_error(ArgumentError, /where requires zero or one arguments/)
+        end
+      end
     end
 
     context "when provided a string" do
@@ -3482,31 +2704,121 @@ describe Mongoid::Criteria do
 
       context "when querying on a big decimal" do
 
-        let(:sales) do
-          BigDecimal('0.1')
+        context 'when map_big_decimal_to_decimal128 is false' do
+          config_override :map_big_decimal_to_decimal128, false
+
+          let(:sales) do
+            BigDecimal('0.1')
+          end
+
+          let!(:band) do
+            Band.create!(name: "Boards of Canada", sales: sales)
+          end
+
+          let(:from_db) do
+            Band.where(sales: sales).first
+          end
+
+          it "finds the document by the big decimal value" do
+            expect(from_db).to eq(band)
+          end
         end
 
-        let!(:band) do
-          Band.create(name: "Boards of Canada", sales: sales)
+        context 'when map_big_decimal_to_decimal128 is true' do
+          config_override :map_big_decimal_to_decimal128, true
+
+          let(:sales) do
+            BigDecimal('0.1')
+          end
+
+          let!(:band) do
+            Band.create!(name: "Boards of Canada", sales: sales)
+          end
+
+          let(:from_db) do
+            Band.where(sales: sales).first
+          end
+
+          it "finds the document by the big decimal value" do
+            expect(from_db).to eq(band)
+          end
         end
 
-        let(:from_db) do
-          Band.where(sales: sales).first
+        context 'when map_big_decimal_to_decimal128 was false and is now true' do
+          config_override :map_big_decimal_to_decimal128, false
+
+          let(:sales) do
+            BigDecimal('0.1')
+          end
+
+          let!(:band) do
+            Mongoid.map_big_decimal_to_decimal128 = false
+            Band.create!(name: "Boards of Canada", sales: sales)
+          end
+
+          let(:from_db) do
+            Mongoid.map_big_decimal_to_decimal128 = true
+            Band.where(sales: sales.to_s).first
+          end
+
+          it "finds the document by the big decimal value" do
+            expect(from_db).to eq(band)
+          end
         end
+      end
 
-        it "finds the document by the big decimal value" do
-          expect(from_db).to eq(band)
+      context "when querying on a big decimal from a dynamic field" do
+
+        context 'when map_big_decimal_to_decimal128 is false' do
+          config_override :map_big_decimal_to_decimal128, false
+
+          let(:fans) do
+            BigDecimal('139432.0002')
+          end
+
+          let!(:band) do
+            Band.create!(name: "Boards of Canada", fans: fans)
+          end
+
+          let(:from_db) do
+            Band.where(fans: fans.to_s).first
+          end
+
+          it "finds the document by the big decimal value" do
+            expect(from_db).to eq(band)
+          end
+        end
+
+        context 'when map_big_decimal_to_decimal128 is true' do
+          config_override :map_big_decimal_to_decimal128, true
+
+          let(:fans) do
+            BigDecimal('139432.0002')
+          end
+
+          let!(:band) do
+            Band.create!(name: "Boards of Canada", fans: fans)
+          end
+
+          let(:from_db) do
+            Band.where(fans: fans).first
+          end
+
+          it "only finds the document by the string value" do
+            expect(from_db).to eq(band)
+          end
         end
       end
 
-      context "when querying on a BSON::Decimal128", if: decimal128_supported? do
+      context "when querying on a BSON::Decimal128" do
+        min_server_version '3.4'
 
         let(:decimal) do
           BSON::Decimal128.new("0.0005")
         end
 
         let!(:band) do
-          Band.create(name: "Boards of Canada", decimal: decimal)
+          Band.create!(name: "Boards of Canada", decimal: decimal)
         end
 
         let(:from_db) do
@@ -3521,7 +2833,7 @@ describe Mongoid::Criteria do
       context 'when querying on a polymorphic relation' do
 
         let(:movie) do
-          Movie.create
+          Movie.create!
         end
 
         let(:selector) do
@@ -3533,12 +2845,289 @@ describe Mongoid::Criteria do
         end
       end
     end
+
+    context 'when given multiple keys in separate calls' do
+      let(:criteria) { Band.where(foo: 1).where(bar: 2) }
+
+      it 'combines criteria' do
+        expect(criteria.selector).to eq('foo' => 1, 'bar' => 2)
+      end
+    end
+
+    context 'when given same key in separate calls' do
+      let(:criteria) { Band.where(foo: 1).where(foo: 2) }
+
+      it 'combines criteria' do
+        expect(criteria.selector).to eq('foo' => 1, '$and' => [{'foo' => 2}])
+      end
+    end
+
+    context 'when given same key in separate calls and there are other criteria' do
+      let(:criteria) { Band.where(foo: 1, bar: 3).where(foo: 2) }
+
+      it 'combines criteria' do
+        expect(criteria.selector).to eq(
+          'foo' => 1, '$and' => [{'foo' => 2}], 'bar' => 3)
+      end
+    end
+
+    context 'when given same key in separate calls and other criteria are added later' do
+      let(:criteria) { Band.where(foo: 1).where(foo: 2).where(bar: 3) }
+
+      it 'combines criteria' do
+        expect(criteria.selector).to eq(
+          'foo' => 1, '$and' => [{'foo' => 2}], 'bar' => 3)
+      end
+    end
+
+    context "when duplicating where conditions" do
+      let(:criteria) { Sound.where(active: true).where(active: true) }
+
+      it 'does not duplicate criteria' do
+        expect(criteria.selector).to eq('active' => true)
+      end
+    end
+
+    context "when duplicating where conditions with different values" do
+      let(:criteria) { Sound.where(active: true).where(active: false).where(active: true).where(active: false) }
+
+      it 'does not duplicate criteria' do
+        expect(criteria.selector).to eq(
+          'active' => true, '$and' => [{'active' => false}])
+      end
+    end
+
+    # Used to test MONGOID-5251 where the find command was adding unnecessary
+    # and clauses. Since the find command creates the criteria and executes it,
+    # it is difficult to analyze the criteria used. For this reason, I have
+    # extracted the crux of the issue, adding an _id to the the criteria twice,
+    # and used that for the test case.
+    context "when searching by _id twice" do
+      let(:_id) { BSON::ObjectId.new }
+      let(:criteria) { Band.where(_id: _id) }
+      let(:dup_criteria) { criteria.where(_id: _id)}
+
+      it "does not duplicate the criteria" do
+        expect(dup_criteria.selector).to eq({ "_id" => _id })
+      end
+    end
+
+    context "when querying an embedded field" do
+      let(:criteria) { Band.where("label.name": 12345) }
+
+      it "mongoizes the embedded field in the selector" do
+        expect(criteria.selector).to eq("label.name" => "12345")
+      end
+    end
+
+    context "when querying with a range" do
+
+      context "when querying an embeds_many association" do
+        let(:criteria) do
+          Band.where("labels" => 10..15)
+        end
+
+        it "correctly uses elemMatch without an inner key" do
+          expect(criteria.selector).to eq(
+            "labels" => {
+              "$elemMatch" => { "$gte" => 10, "$lte" => 15 }
+            }
+          )
+        end
+      end
+
+      context "when querying an element in an embeds_many association" do
+        let(:criteria) do
+          Band.where("labels.age" => 10..15)
+        end
+
+        it "correctly uses elemMatch" do
+          expect(criteria.selector).to eq(
+            "labels" => {
+              "$elemMatch" => {
+                "age" => { "$gte" => 10, "$lte" => 15 }
+              }
+            }
+          )
+        end
+      end
+
+      context "when querying a field of type array" do
+        let(:criteria) do
+          Band.where("genres" => 10..15)
+        end
+
+        it "correctly uses elemMatch without an inner key" do
+          expect(criteria.selector).to eq(
+            "genres" => {
+              "$elemMatch" => { "$gte" => 10, "$lte" => 15 }
+            }
+          )
+        end
+      end
+
+      context "when querying an aliased field of type array" do
+        let(:criteria) do
+          Person.where("array" => 10..15)
+        end
+
+        it "correctly uses the aliased field and elemMatch" do
+          expect(criteria.selector).to eq(
+            "a" => {
+              "$elemMatch" => { "$gte" => 10, "$lte" => 15 }
+            }
+          )
+        end
+      end
+
+      context "when querying a field inside an array" do
+        let(:criteria) do
+          Band.where("genres.age" => 10..15)
+        end
+
+        it "correctly uses elemMatch" do
+          expect(criteria.selector).to eq(
+            "genres" => {
+              "$elemMatch" => {
+                "age" => { "$gte" => 10, "$lte" => 15 }
+              }
+            }
+          )
+        end
+      end
+
+      context "when there are no embeds_manys or Arrays" do
+        let(:criteria) do
+          Band.where("fans.info.age" => 10..15)
+        end
+
+        it "does not use elemMatch" do
+          expect(criteria.selector).to eq(
+            "fans.info.age" => { "$gte" => 10, "$lte" => 15 }
+          )
+        end
+      end
+
+      context "when querying a nested element in an embeds_many association" do
+        let(:criteria) do
+          Band.where("labels.age.number" => 10..15)
+        end
+
+        it "correctly uses elemMatch" do
+          expect(criteria.selector).to eq(
+            "labels" => {
+              "$elemMatch" => {
+                "age.number" => { "$gte" => 10, "$lte" => 15 }
+              }
+            }
+          )
+        end
+      end
+
+      context "when querying a nested element in an Array" do
+        let(:criteria) do
+          Band.where("genres.name.length" => 10..15)
+        end
+
+        it "correctly uses elemMatch" do
+          expect(criteria.selector).to eq(
+            "genres" => {
+              "$elemMatch" => {
+                "name.length" => { "$gte" => 10, "$lte" => 15 }
+              }
+            }
+          )
+        end
+      end
+
+      context "when querying a nested element in a nested embeds_many association" do
+        context "when the outer association is an embeds_many" do
+          let(:criteria) do
+            Band.where("records.tracks.name.length" => 10..15)
+          end
+
+          it "correctly uses elemMatch" do
+            expect(criteria.selector).to eq(
+              "records.tracks" => {
+                "$elemMatch" => {
+                  "name.length" => { "$gte" => 10, "$lte" => 15 }
+                }
+              }
+            )
+          end
+        end
+
+        context "when the outer association is an embeds_one" do
+          let(:criteria) do
+            Person.where("name.translations.language.length" => 10..15)
+          end
+
+          it "correctly uses elemMatch" do
+            expect(criteria.selector).to eq(
+              "name.translations" => {
+                "$elemMatch" => {
+                  "language.length" => { "$gte" => 10, "$lte" => 15 }
+                }
+              }
+            )
+          end
+        end
+      end
+
+      context "when querying a deeply nested array" do
+        let(:criteria) do
+          Person.where("addresses.code.deepest.array.element.item" => 10..15)
+        end
+
+        it "correctly uses elemMatch" do
+          expect(criteria.selector).to eq(
+            "addresses.code.deepest.array" => {
+              "$elemMatch" => {
+                "element.item" => { "$gte" => 10, "$lte" => 15 }
+              }
+            }
+          )
+        end
+      end
+
+      context "when there are multiple conditions" do
+        let(:criteria) do
+          Band.where("$or" => [{"labels.age" => 10..15}, {labels: 8}])
+        end
+
+        it "correctly combines the conditions" do
+          expect(criteria.selector).to eq("$or" => [
+            { "labels" => {
+              "$elemMatch" => {
+                "age" => { "$gte" => 10, "$lte" => 15 }
+              } } },
+            { "labels" => 8 }
+          ])
+        end
+      end
+
+      context "when the association is aliased" do
+        let(:criteria) do
+          Person.where("passport.passport_pages.num_stamps" => 10..18)
+        end
+
+        it "correctly uses the aliased association" do
+          expect(criteria.selector).to eq(
+            "pass.passport_pages" => {
+              "$elemMatch" => {
+                "num_stamps" => { "$gte" => 10, "$lte" => 18 }
+              }
+            }
+          )
+        end
+      end
+    end
   end
 
   describe "#for_js" do
 
     let!(:match) do
-      Band.create(name: "Depeche Mode")
+      Band.create!(name: "Depeche Mode")
     end
 
     context "when the code has no scope" do
@@ -3553,6 +3142,7 @@ describe Mongoid::Criteria do
     end
 
     context "when the code has scope" do
+      max_server_version '4.2'
 
       let(:criteria) do
         Band.for_js("this.name == param", param: "Depeche Mode")
@@ -3574,10 +3164,14 @@ describe Mongoid::Criteria do
 
       before do
         expect(Person).to receive(:minor).and_call_original
+        expect(Person).to receive(:older_than).and_call_original
       end
 
       it "calls the method on the class" do
         expect(criteria.minor).to be_empty
+        expect do
+          criteria.older_than(age: 25)
+        end.not_to raise_error
       end
     end
 
@@ -3620,11 +3214,11 @@ describe Mongoid::Criteria do
   describe "#uniq" do
 
     let!(:band_one) do
-      Band.create(name: "New Order")
+      Band.create!(name: "New Order")
     end
 
     let!(:band_two) do
-      Band.create(name: "New Order")
+      Band.create!(name: "New Order")
     end
 
     let(:criteria) do
@@ -3664,7 +3258,7 @@ describe Mongoid::Criteria do
     end
   end
 
-  describe "#geo_spacial" do
+  describe "#geo_spatial" do
 
     context "when checking within a polygon" do
 
@@ -3673,11 +3267,11 @@ describe Mongoid::Criteria do
       end
 
       let!(:match) do
-        Bar.create(location: [ 52.30, 13.25 ])
+        Bar.create!(location: [ 52.30, 13.25 ])
       end
 
       let(:criteria) do
-        Bar.geo_spacial(
+        Bar.geo_spatial(
           :location.within_polygon => [[[ 50, 10 ], [ 50, 20 ], [ 60, 20 ], [ 60, 10 ], [ 50, 10 ]]]
         )
       end
@@ -3691,11 +3285,11 @@ describe Mongoid::Criteria do
   describe "#with_size" do
 
     let!(:match) do
-      Band.create(genres: [ "electro", "dub" ])
+      Band.create!(genres: [ "electro", "dub" ])
     end
 
     let!(:non_match) do
-      Band.create(genres: [ "house" ])
+      Band.create!(genres: [ "house" ])
     end
 
     let(:criteria) do
@@ -3710,7 +3304,7 @@ describe Mongoid::Criteria do
   describe "#with_type" do
 
     let!(:match) do
-      Band.create(name: "Depeche Mode")
+      Band.create!(name: "Depeche Mode")
     end
 
     let(:criteria) do
@@ -3722,73 +3316,76 @@ describe Mongoid::Criteria do
     end
   end
 
-  describe "#without" do
+  describe "#type_selection" do
+    context "when using the default discriminator_key" do
+      context "when only one subclass exists" do
 
-    let!(:person) do
-      Person.create!(username: "davinci", age: 50, pets: false)
-    end
+        let(:criteria) do
+          described_class.new(Firefox)
+        end
 
-    context "when omitting to embedded documents" do
+        let(:selection) do
+          criteria.send(:type_selection)
+        end
+
+        it "does not use an $in query" do
+          expect(selection).to eq({ _type: "Firefox" })
+        end
+      end
 
-      context "when the embedded documents are aliased" do
+      context "when more than one subclass exists" do
 
         let(:criteria) do
-          Person.without(:phones)
+          described_class.new(Browser)
         end
 
-        it "properly uses the database field name" do
-          expect(criteria.options).to eq(fields: { "mobile_phones" => 0 })
+        let(:selection) do
+          criteria.send(:type_selection)
         end
-      end
-    end
 
-    context "when excluding id" do
-
-      let(:criteria) do
-        Person.without(:_id, :id, "_id", "id")
+        it "does not use an $in query" do
+          expect(selection).to eq({ _type: { "$in" => [ "Firefox", "Browser" ]}})
+        end
       end
+    end
 
-      it "does not raise error" do
-        expect {
-          criteria.first.id
-        }.to_not raise_error
+    context "when using a custom discriminator_key" do
+      before do
+        Canvas.discriminator_key = "dkey"
       end
 
-      it "returns id anyway" do
-        expect(criteria.first.id).to_not be_nil
+      after do
+        Canvas.discriminator_key = nil
       end
-    end
-  end
-
-  describe "#type_selection" do
 
-    context "when only one subclass exists" do
+      context "when only one subclass exists" do
 
-      let(:criteria) do
-        described_class.new(Firefox)
-      end
+        let(:criteria) do
+          described_class.new(Firefox)
+        end
 
-      let(:selection) do
-        criteria.send(:type_selection)
-      end
+        let(:selection) do
+          criteria.send(:type_selection)
+        end
 
-      it "does not use an $in query" do
-        expect(selection).to eq({ _type: "Firefox" })
+        it "does not use an $in query" do
+          expect(selection).to eq({ dkey: "Firefox" })
+        end
       end
-    end
 
-    context "when more than one subclass exists" do
+      context "when more than one subclass exists" do
 
-      let(:criteria) do
-        described_class.new(Browser)
-      end
+        let(:criteria) do
+          described_class.new(Browser)
+        end
 
-      let(:selection) do
-        criteria.send(:type_selection)
-      end
+        let(:selection) do
+          criteria.send(:type_selection)
+        end
 
-      it "does not use an $in query" do
-        expect(selection).to eq({ _type: { "$in" => [ "Firefox", "Browser" ]}})
+        it "does not use an $in query" do
+          expect(selection).to eq({ dkey: { "$in" => [ "Firefox", "Browser" ]}})
+        end
       end
     end
   end