mongoid 6.4.8 → 7.5.4

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,26 +280,41 @@ 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
       Band.where(name: "Depeche Mode")
     end
 
-    it "returns the criteria as a json hash" do
-      expect(criteria.as_json).to eq([ band.serializable_hash ])
+    # as_json changed in rails 6 to call as_json on serializable_hash.
+    # https://github.com/rails/rails/commit/2e5cb980a448e7f4ab00df6e9ad4c1cc456616aa
+
+    context 'rails < 6' do
+      max_rails_version '5.2'
+
+      it "returns the criteria as a json hash" do
+        expect(criteria.as_json).to eq([ band.serializable_hash ])
+      end
+    end
+
+    context 'rails >= 6' do
+      min_rails_version '6.0'
+
+      it "returns the criteria as a json hash" do
+        expect(criteria.as_json).to eq([ band.serializable_hash.as_json ])
+      end
     end
   end
 
   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
@@ -363,7 +380,7 @@ describe Mongoid::Criteria do
   describe "#cache" do
 
     let!(:person) do
-      Person.create
+      Person.create!
     end
 
     context "when no eager loading is involved" do
@@ -515,11 +532,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
@@ -573,7 +590,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
@@ -593,14 +610,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
@@ -646,7 +663,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
@@ -661,7 +678,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
@@ -677,11 +694,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
@@ -698,7 +715,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
@@ -768,23 +785,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" do
+      it "behaves as Enumerable" 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
@@ -982,7 +1059,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
@@ -994,7 +1071,7 @@ describe Mongoid::Criteria do
     end
   end
 
-  describe "#gt" do
+  describe "#eq" do
 
     let!(:match) do
       Band.create(member_count: 5)
@@ -1004,6 +1081,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
@@ -1016,11 +1112,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
@@ -1039,11 +1135,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
@@ -1062,7 +1158,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
@@ -1103,7 +1199,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
@@ -1141,7 +1237,7 @@ describe Mongoid::Criteria do
   describe "#includes" do
 
     let!(:person) do
-      Person.create(age: 1)
+      Person.create!(age: 1)
     end
 
     context "when providing a name that is not a relation" do
@@ -1156,11 +1252,11 @@ describe Mongoid::Criteria do
     context "when providing one association" do
 
       let!(:user) do
-        User.create(posts: [ post1 ])
+        User.create!(posts: [ post1 ])
       end
 
       let!(:post1) do
-        Post.create
+        Post.create!
       end
 
       let(:result) do
@@ -1179,15 +1275,15 @@ describe Mongoid::Criteria do
     context "when providing a list of associations" do
 
       let!(:user) do
-        User.create(posts: [ post1 ], descriptions: [ description1 ])
+        User.create!(posts: [ post1 ], descriptions: [ description1 ])
       end
 
       let!(:post1) do
-        Post.create
+        Post.create!
       end
 
       let!(:description1) do
-        Description.create(details: 1)
+        Description.create!(details: 1)
       end
 
       let(:result) do
@@ -1207,13 +1303,13 @@ describe Mongoid::Criteria do
     context "when providing a nested association" do
 
       let!(:user) do
-        User.create
+        User.create!
       end
 
       before do
-        p = Post.create(alerts: [ Alert.create ])
+        p = Post.create!(alerts: [ Alert.create! ])
         user.posts = [ p ]
-        user.save
+        user.save!
       end
 
       let(:result) do
@@ -1233,7 +1329,7 @@ describe Mongoid::Criteria do
     context "when providing a deeply nested association" do
 
       let!(:user) do
-        User.create
+        User.create!
       end
 
       let(:results) do
@@ -1271,15 +1367,15 @@ describe Mongoid::Criteria do
       context "when the includes is on the subclass" do
 
         let!(:c_one) do
-          C.create
+          C.create!
         end
 
         let!(:c_two) do
-          C.create
+          C.create!
         end
 
         let!(:b) do
-          B.create(c: c_two)
+          B.create!(c: c_two)
         end
 
         let!(:results) do
@@ -1334,19 +1430,19 @@ describe Mongoid::Criteria do
         context "when the includes is on the several relations" do
 
           let!(:d_one) do
-            D.create
+            D.create!
           end
 
           let!(:d_two) do
-            D.create
+            D.create!
           end
 
           let!(:b) do
-            B.create(d: d_two)
+            B.create!(d: d_two)
           end
 
           let!(:c) do
-            C.create(d: d_two)
+            C.create!(d: d_two)
           end
 
           let!(:results) do
@@ -1405,19 +1501,19 @@ describe Mongoid::Criteria do
         context "when the includes is on the several relations" do
 
           let!(:d_one) do
-            D.create
+            D.create!
           end
 
           let!(:d_two) do
-            D.create
+            D.create!
           end
 
           let!(:bs) do
-            2.times.map { B.create(d: d_two) }
+            2.times.map { B.create!(d: d_two) }
           end
 
           let!(:cs) do
-            2.times.map { C.create(d: d_two) }
+            2.times.map { C.create!(d: d_two) }
           end
 
           let!(:results) do
@@ -1445,25 +1541,25 @@ describe Mongoid::Criteria do
       end
     end
 
-    context "when including the same metadata multiple times" do
+    context "when including the same association multiple times" do
 
       let(:criteria) do
         Person.all.includes(:posts, :posts).includes(:posts)
       end
 
-      let(:metadata) do
+      let(:association) do
         Person.reflect_on_association(:posts)
       end
 
-      it "does not duplicate the metadata in the inclusions" do
-        expect(criteria.inclusions).to eq([ metadata ])
+      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")
+        person.posts.create!(title: "one")
       end
 
       let(:criteria) do
@@ -1485,15 +1581,15 @@ describe Mongoid::Criteria do
       context "when the criteria is from the root" do
 
         let!(:person_two) do
-          Person.create(age: 2)
+          Person.create!(age: 2)
         end
 
         let!(:post_one) do
-          person.posts.create(title: "one")
+          person.posts.create!(title: "one")
         end
 
         let!(:post_two) do
-          person_two.posts.create(title: "two")
+          person_two.posts.create!(title: "two")
         end
 
         context "when calling first" do
@@ -1542,15 +1638,15 @@ describe Mongoid::Criteria do
       context "when the criteria is from an embedded relation" do
 
         let(:peep) do
-          Person.create
+          Person.create!
         end
 
         let!(:address_one) do
-          peep.addresses.create(street: "rosenthaler")
+          peep.addresses.create!(street: "rosenthaler")
         end
 
         let!(:address_two) do
-          peep.addresses.create(street: "weinmeister")
+          peep.addresses.create!(street: "weinmeister")
         end
 
         let!(:depeche) do
@@ -1564,8 +1660,8 @@ describe Mongoid::Criteria do
         before do
           address_one.band = depeche
           address_two.band = tool
-          address_one.save
-          address_two.save
+          address_one.save!
+          address_two.save!
         end
 
         context "when calling first" do
@@ -1662,11 +1758,11 @@ describe Mongoid::Criteria do
       end
 
       let!(:post_one) do
-        person.posts.create(title: "one")
+        person.posts.create!(title: "one")
       end
 
       let!(:post_two) do
-        person.posts.create(title: "two")
+        person.posts.create!(title: "two")
       end
 
       context "when the criteria has no options" do
@@ -1784,11 +1880,11 @@ describe Mongoid::Criteria do
       context "when the criteria has limiting options" do
 
         let!(:person_two) do
-          Person.create
+          Person.create!
         end
 
         let!(:post_three) do
-          person_two.posts.create(title: "three")
+          person_two.posts.create!(title: "three")
         end
 
         let!(:criteria) do
@@ -1820,11 +1916,11 @@ describe Mongoid::Criteria do
     context "when including a has and belongs to many" do
 
       let!(:preference_one) do
-        person.preferences.create(name: "one")
+        person.preferences.create!(name: "one")
       end
 
       let!(:preference_two) do
-        person.preferences.create(name: "two")
+        person.preferences.create!(name: "two")
       end
 
       context "when one of the related items is deleted" do
@@ -1928,11 +2024,11 @@ describe Mongoid::Criteria do
     context "when including a has many" do
 
       let!(:post_one) do
-        person.posts.create(title: "one")
+        person.posts.create!(title: "one")
       end
 
       let!(:post_two) do
-        person.posts.create(title: "two")
+        person.posts.create!(title: "two")
       end
 
       context "when the criteria has no options" do
@@ -2017,11 +2113,11 @@ describe Mongoid::Criteria do
       context "when the criteria has limiting options" do
 
         let!(:person_two) do
-          Person.create
+          Person.create!
         end
 
         let!(:post_three) do
-          person_two.posts.create(title: "three")
+          person_two.posts.create!(title: "three")
         end
 
         let!(:criteria) do
@@ -2082,7 +2178,7 @@ describe Mongoid::Criteria do
       context "when the criteria has limiting options" do
 
         let!(:person_two) do
-          Person.create(age: 2)
+          Person.create!(age: 2)
         end
 
         let!(:game_three) do
@@ -2114,7 +2210,7 @@ describe Mongoid::Criteria do
     context "when including a belongs to" do
 
       let(:person_two) do
-        Person.create(age: 2)
+        Person.create!(age: 2)
       end
 
       let!(:game_one) do
@@ -2175,11 +2271,11 @@ describe Mongoid::Criteria do
     context "when including multiples in the same criteria" do
 
       let!(:post_one) do
-        person.posts.create(title: "one")
+        person.posts.create!(title: "one")
       end
 
       let!(:post_two) do
-        person.posts.create(title: "two")
+        person.posts.create!(title: "two")
       end
 
       let!(:game_one) do
@@ -2218,12 +2314,12 @@ describe Mongoid::Criteria do
       Band.includes(:records)
     end
 
-    let(:metadata) do
+    let(:association) do
       Band.relations["records"]
     end
 
     it "returns the inclusions" do
-      expect(criteria.inclusions).to eq([ metadata ])
+      expect(criteria.inclusions).to eq([ association ])
     end
   end
 
@@ -2233,27 +2329,27 @@ describe Mongoid::Criteria do
       Band.all
     end
 
-    let(:metadata) do
+    let(:association) do
       Band.relations["records"]
     end
 
     before do
-      criteria.inclusions = [ metadata ]
+      criteria.inclusions = [ association ]
     end
 
     it "sets the inclusions" do
-      expect(criteria.inclusions).to eq([ metadata ])
+      expect(criteria.inclusions).to eq([ association ])
     end
   end
 
   describe "#lt" do
 
     let!(:match) do
-      Band.create(member_count: 1)
+      Band.create!(member_count: 1)
     end
 
     let!(:non_match) do
-      Band.create(member_count: 5)
+      Band.create!(member_count: 5)
     end
 
     let(:criteria) do
@@ -2268,11 +2364,11 @@ describe Mongoid::Criteria do
   describe "#lte" do
 
     let!(:match) do
-      Band.create(member_count: 4)
+      Band.create!(member_count: 4)
     end
 
     let!(:non_match) do
-      Band.create(member_count: 5)
+      Band.create!(member_count: 5)
     end
 
     let(:criteria) do
@@ -2305,11 +2401,11 @@ describe Mongoid::Criteria do
     end
 
     let!(:depeche_mode) do
-      Band.create(name: "Depeche Mode", likes: 200)
+      Band.create!(name: "Depeche Mode", likes: 200)
     end
 
     let!(:tool) do
-      Band.create(name: "Tool", likes: 100)
+      Band.create!(name: "Tool", likes: 100)
     end
 
     context "when no timeout options are provided" do
@@ -2319,7 +2415,7 @@ describe Mongoid::Criteria do
       end
 
       it "returns the map/reduce results" do
-        expect(map_reduce).to eq([
+        expect(map_reduce.sort_by { |doc| doc['_id'] }).to eq([
           { "_id" => "Depeche Mode", "value" => { "likes" => 200 }},
           { "_id" => "Tool", "value" => { "likes" => 100 }}
         ])
@@ -2332,11 +2428,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
@@ -2376,11 +2472,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!(:non_match) do
-      Bar.create(location: [ 19.26, 99.70 ])
+      Bar.create!(location: [ 19.26, 99.70 ])
     end
 
     let(:criteria) do
@@ -2410,7 +2506,7 @@ describe Mongoid::Criteria do
         end
       end
 
-      let(:metadata) do
+      let(:association) do
         Band.relations["records"]
       end
 
@@ -2435,7 +2531,7 @@ describe Mongoid::Criteria do
       end
 
       it "merges the inclusions" do
-        expect(merged.inclusions).to eq([ metadata ])
+        expect(merged.inclusions).to eq([ association ])
       end
 
       it "returns a new criteria" do
@@ -2449,7 +2545,7 @@ describe Mongoid::Criteria do
         { klass: Band, includes: [ :records ] }
       end
 
-      let(:metadata) do
+      let(:association) do
         Band.relations["records"]
       end
 
@@ -2470,7 +2566,7 @@ describe Mongoid::Criteria do
       end
 
       it "merges the inclusions" do
-        expect(merged.inclusions).to eq([ metadata ])
+        expect(merged.inclusions).to eq([ association ])
       end
 
       it "returns a new criteria" do
@@ -2495,7 +2591,7 @@ describe Mongoid::Criteria do
       end
     end
 
-    let(:metadata) do
+    let(:association) do
       Band.relations["records"]
     end
 
@@ -2520,7 +2616,7 @@ describe Mongoid::Criteria do
     end
 
     it "merges the inclusions" do
-      expect(merged.inclusions).to eq([ metadata ])
+      expect(merged.inclusions).to eq([ association ])
     end
 
     it "returns the same criteria" do
@@ -2533,11 +2629,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
@@ -2573,11 +2669,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
@@ -2592,11 +2688,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
@@ -2615,7 +2711,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
@@ -2634,7 +2730,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
@@ -2649,11 +2745,11 @@ describe Mongoid::Criteria do
   describe "#nin" 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
@@ -2668,11 +2764,11 @@ describe Mongoid::Criteria do
   describe "#nor" 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
@@ -2684,230 +2780,16 @@ describe Mongoid::Criteria do
     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
-
-        let(:dictionary) do
-          Dictionary.only(:description).first
-
-        end
-
-        it 'loads all translations' do
-          expect(dictionary.description_translations.keys).to include('de', 'en')
-        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
-
-      context 'when a specific locale is included' do
-
-        let(:dictionary) do
-          Dictionary.only(:'description.de').first
-        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
-
-        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
-
-      context 'when entire field is excluded' do
-
-        let(:dictionary) do
-          Dictionary.without(:description).first
-        end
-
-        it 'does not load all translations' do
-          expect(dictionary.description_translations.keys).to_not include('de', 'en')
-        end
-
-        it 'raises an ActiveModel::MissingAttributeError when attempting to access the field' do
-          expect{dictionary.description}.to raise_error ActiveModel::MissingAttributeError
-        end
-      end
-
-      context 'when a specific locale is excluded' do
-
-        let(:dictionary) do
-          Dictionary.without(:'description.de').first
-        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
-
-        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
-    end
-  end
-
   [ :or, :any_of ].each do |method|
 
     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
@@ -2937,25 +2819,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
@@ -2964,8 +2850,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
@@ -2982,14 +2870,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
 
@@ -3000,51 +2892,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
 
@@ -3054,8 +2978,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
 
@@ -3065,8 +2991,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
@@ -3077,8 +3005,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
 
@@ -3088,8 +3018,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
 
@@ -3099,8 +3031,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
 
@@ -3112,8 +3046,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 a array with nil values" do
+            expect(plucked).to eq([nil, nil, nil])
+          end
         end
       end
 
@@ -3123,8 +3059,10 @@ 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 a nil arrays" do
+            expect(plucked).to eq([[nil, nil], [nil, nil], [nil, nil]])
+          end
         end
       end
     end
@@ -3133,10 +3071,10 @@ describe Mongoid::Criteria do
 
       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
@@ -3144,13 +3082,48 @@ describe Mongoid::Criteria do
       end
 
       context 'when plucking the entire field' do
-
         let(:plucked) do
           Dictionary.all.pluck(:description)
         end
 
-        it 'returns all translations' do
-          expect(plucked.first).to eq({'en' => 'english-text', 'de' => 'deutsch-text'})
+        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
 
@@ -3160,8 +3133,235 @@ describe Mongoid::Criteria do
           Dictionary.all.pluck(:'description.de')
         end
 
-        it 'returns the specific translations' do
-          expect(plucked.first).to eq({'de' => 'deutsch-text'})
+        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
+
+        around(:all) do |example|
+          prev_fallbacks = I18n.fallbacks.dup
+          I18n.fallbacks[:he] = [ :en ]
+          example.run
+          I18n.fallbacks = prev_fallbacks
+        end
+
+        after do
+          I18n.locale = :en
+        end
+
+        let(:plucked) do
+          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
+        before do
+          p = Passport.new
+          I18n.locale = :en
+          p.name = "Neil"
+          I18n.locale = :he
+          p.name = "Nissim"
+
+          Person.create!(passport: p, employer_id: 12345)
+        end
+
+        after do
+          I18n.locale = :en
+        end
+
+        let(:plucked) do
+          Person.where(employer_id: 12345).pluck("pass.name").first
+        end
+
+        let(:plucked_translations) do
+          Person.where(employer_id: 12345).pluck("pass.name_translations").first
+        end
+
+        let(:plucked_translations_field) do
+          Person.where(employer_id: 12345).pluck("pass.name_translations.en").first
+        end
+
+        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
+
+        it "does not demongoize the field" do
+          expect(plucked.first).to be_a(String)
+          expect(plucked.first).to eq("1E2")
+        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 be_a(BigDecimal)
+          expect(plucked.first).to eq(BigDecimal("1E2"))
+        end
+      end
+    end
+
+    context "when plucking an embedded field" do
+      let(:label) { Label.new(sales: "1E2") }
+      let!(:band) { Band.create!(label: label) }
+
+      let(:plucked) { Band.where(_id: band.id).pluck("label.sales") }
+
+      context "when legacy_pluck_distinct is set" do
+        config_override :legacy_pluck_distinct, true
+
+        it "returns a hash with a non-demongoized field" do
+          expect(plucked.first).to eq({ 'sales' => "1E2" })
+        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 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
+
+        it "returns a hash with a non-demongoized field" do
+          expect(plucked.first).to eq([{ 'sales' => "1E2" }])
+        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
@@ -3248,11 +3448,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
@@ -3271,11 +3471,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
@@ -3309,7 +3509,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
@@ -3325,11 +3525,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
@@ -3368,34 +3568,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
@@ -3403,11 +3644,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
@@ -3472,7 +3745,7 @@ describe Mongoid::Criteria do
         end
 
         let!(:band) do
-          Band.create(name: "Boards of Canada", sales: sales)
+          Band.create!(name: "Boards of Canada", sales: sales)
         end
 
         let(:from_db) do
@@ -3484,14 +3757,15 @@ describe Mongoid::Criteria do
         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
@@ -3506,7 +3780,7 @@ describe Mongoid::Criteria do
       context 'when querying on a polymorphic relation' do
 
         let(:movie) do
-          Movie.create
+          Movie.create!
         end
 
         let(:selector) do
@@ -3518,12 +3792,78 @@ 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
   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
@@ -3538,6 +3878,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")
@@ -3559,10 +3900,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
 
@@ -3605,11 +3950,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
@@ -3649,7 +3994,7 @@ describe Mongoid::Criteria do
     end
   end
 
-  describe "#geo_spacial" do
+  describe "#geo_spatial" do
 
     context "when checking within a polygon" do
 
@@ -3658,11 +4003,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
@@ -3676,11 +4021,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
@@ -3695,7 +4040,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
@@ -3707,73 +4052,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