mongoid 3.1.6 → 4.0.2

data/spec/mongoid/contextual/mongo_spec.rb

@@ -21,7 +21,7 @@ describe Mongoid::Contextual::Mongo do
         end
 
         it "returns true" do
-          context.send(method).should be_true
+          expect(context.send(method)).to be true
         end
       end
 
@@ -36,7 +36,7 @@ describe Mongoid::Contextual::Mongo do
         end
 
         it "returns false" do
-          context.send(method).should be_false
+          expect(context.send(method)).to be false
         end
       end
     end
@@ -55,7 +55,7 @@ describe Mongoid::Contextual::Mongo do
       end
 
       it "returns true" do
-        context.should be_cached
+        expect(context).to be_cached
       end
     end
 
@@ -70,7 +70,7 @@ describe Mongoid::Contextual::Mongo do
       end
 
       it "returns false" do
-        context.should_not be_cached
+        expect(context).to_not be_cached
       end
     end
   end
@@ -96,7 +96,7 @@ describe Mongoid::Contextual::Mongo do
       end
 
       it "returns the number of documents that match" do
-        context.count.should eq(1)
+        expect(context.count).to eq(1)
       end
     end
 
@@ -107,11 +107,11 @@ describe Mongoid::Contextual::Mongo do
       end
 
       before do
-        context.query.should_receive(:count).once.and_return(1)
+        expect(context.query).to receive(:count).once.and_return(1)
       end
 
       it "returns the count cached value after first call" do
-        2.times { context.count.should eq(1) }
+        2.times { expect(context.count).to eq(1) }
       end
     end
 
@@ -126,7 +126,7 @@ describe Mongoid::Contextual::Mongo do
       end
 
       it "returns the number of documents that match" do
-        count.should eq(1)
+        expect(count).to eq(1)
       end
     end
 
@@ -143,7 +143,7 @@ describe Mongoid::Contextual::Mongo do
       end
 
       it "returns the number of documents that match" do
-        count.should eq(1)
+        expect(count).to eq(1)
       end
 
       context "and a limit true" do
@@ -159,7 +159,7 @@ describe Mongoid::Contextual::Mongo do
         end
 
         it "returns the number of documents that match" do
-          count.should eq(1)
+          expect(count).to eq(1)
         end
       end
     end
@@ -179,7 +179,7 @@ describe Mongoid::Contextual::Mongo do
       end
 
       it "returns the number of documents that match" do
-        count.should eq(2)
+        expect(count).to eq(2)
       end
     end
   end
@@ -211,15 +211,15 @@ describe Mongoid::Contextual::Mongo do
         end
 
         it "deletes the matching documents" do
-          Band.find(new_order.id).should eq(new_order)
+          expect(Band.find(new_order.id)).to eq(new_order)
         end
 
         it "deletes the correct number of documents" do
-          Band.count.should eq(1)
+          expect(Band.count).to eq(1)
         end
 
         it "returns the number of documents deleted" do
-          deleted.should eq(1)
+          expect(deleted).to eq(1)
         end
       end
 
@@ -238,7 +238,7 @@ describe Mongoid::Contextual::Mongo do
         end
 
         it "deletes all the documents" do
-          Band.count.should eq(0)
+          expect(Band.count).to eq(0)
         end
       end
     end
@@ -271,15 +271,15 @@ describe Mongoid::Contextual::Mongo do
         end
 
         it "destroys the matching documents" do
-          Band.find(new_order.id).should eq(new_order)
+          expect(Band.find(new_order.id)).to eq(new_order)
         end
 
         it "destroys the correct number of documents" do
-          Band.count.should eq(1)
+          expect(Band.count).to eq(1)
         end
 
         it "returns the number of documents destroyed" do
-          destroyed.should eq(1)
+          expect(destroyed).to eq(1)
         end
       end
 
@@ -298,7 +298,7 @@ describe Mongoid::Contextual::Mongo do
         end
 
         it "destroys all the documents" do
-          Band.count.should eq(0)
+          expect(Band.count).to eq(0)
         end
       end
     end
@@ -322,7 +322,7 @@ describe Mongoid::Contextual::Mongo do
       end
 
       it "returns the distinct matching fields" do
-        context.distinct(:name).should eq([ "Depeche Mode" ])
+        expect(context.distinct(:name)).to eq([ "Depeche Mode" ])
       end
     end
 
@@ -337,7 +337,7 @@ describe Mongoid::Contextual::Mongo do
       end
 
       it "returns the distinct field values" do
-        context.distinct(:name).should eq([ "Depeche Mode", "New Order" ])
+        expect(context.distinct(:name)).to eq([ "Depeche Mode", "New Order" ])
       end
     end
 
@@ -352,7 +352,7 @@ describe Mongoid::Contextual::Mongo do
       end
 
       it "returns the distinct field values" do
-        context.distinct(:years).should eq([ 30, 25 ])
+        expect(context.distinct(:years)).to eq([ 30, 25 ])
       end
     end
   end
@@ -375,18 +375,18 @@ describe Mongoid::Contextual::Mongo do
 
       it "yields mongoid documents to the block" do
         context.each do |doc|
-          doc.should be_a(Mongoid::Document)
+          expect(doc).to be_a(Mongoid::Document)
         end
       end
 
       it "iterates over the matching documents" do
         context.each do |doc|
-          doc.name.should eq("Depeche Mode")
+          expect(doc.name).to eq("Depeche Mode")
         end
       end
 
       it "returns self" do
-        context.each{}.should be(context)
+        expect(context.each{}).to be(context)
       end
     end
 
@@ -397,7 +397,7 @@ describe Mongoid::Contextual::Mongo do
       end
 
       it "returns an enumerator" do
-        enum.should be_a(Enumerator)
+        expect(enum).to be_a(Enumerator)
       end
 
       context "when iterating over the enumerator" do
@@ -406,7 +406,7 @@ describe Mongoid::Contextual::Mongo do
 
           it "yields mongoid documents to the block" do
             enum.each do |doc|
-              doc.should be_a(Mongoid::Document)
+              expect(doc).to be_a(Mongoid::Document)
             end
           end
         end
@@ -414,7 +414,7 @@ describe Mongoid::Contextual::Mongo do
         context "when iterating with next" do
 
           it "yields mongoid documents" do
-            enum.next.should be_a(Mongoid::Document)
+            expect(enum.next).to be_a(Mongoid::Document)
           end
         end
       end
@@ -438,7 +438,7 @@ describe Mongoid::Contextual::Mongo do
       end
 
       it "does not make any additional database queries" do
-        game_metadata.should_receive(:eager_load).never
+        expect(game_metadata).to receive(:eager_load).never
         context.send(:eager_load, [])
       end
     end
@@ -461,7 +461,7 @@ describe Mongoid::Contextual::Mongo do
       end
 
       it "returns false" do
-        context.should_not be_exists
+        expect(context).to_not be_exists
       end
     end
 
@@ -476,7 +476,30 @@ describe Mongoid::Contextual::Mongo do
       end
 
       it "returns true" do
-        context.should be_exists
+        expect(context).to be_exists
+      end
+    end
+
+    context "when caching is not enabled" do
+
+      let(:criteria) do
+        Band.where(name: "Depeche Mode")
+      end
+
+      let(:context) do
+        described_class.new(criteria)
+      end
+
+      context "when exists? already called" do
+
+        before do
+          context.exists?
+        end
+
+        it "hits the database again" do
+          expect(context).to receive(:query).once.and_call_original
+          expect(context).to be_exists
+        end
       end
     end
 
@@ -497,8 +520,8 @@ describe Mongoid::Contextual::Mongo do
         end
 
         it "does not hit the database" do
-          context.should_receive(:query).never
-          context.should be_exists
+          expect(context).to receive(:query).never
+          expect(context).to be_exists
         end
       end
 
@@ -511,8 +534,8 @@ describe Mongoid::Contextual::Mongo do
           end
 
           it "does not hit the database" do
-            context.should_receive(:query).never
-            context.should be_exists
+            expect(context).to receive(:query).never
+            expect(context).to be_exists
           end
         end
       end
@@ -530,7 +553,7 @@ describe Mongoid::Contextual::Mongo do
     end
 
     it "returns the criteria explain path" do
-      context.explain["cursor"].should eq("BasicCursor")
+      expect(context.explain["cursor"]).to eq("BasicCursor")
     end
   end
 
@@ -561,11 +584,11 @@ describe Mongoid::Contextual::Mongo do
         end
 
         it "returns the first matching document" do
-          result.should eq(depeche)
+          expect(result).to eq(depeche)
         end
 
         it "updates the document in the database" do
-          depeche.reload.likes.should eq(1)
+          expect(depeche.reload.likes).to eq(1)
         end
       end
 
@@ -584,11 +607,11 @@ describe Mongoid::Contextual::Mongo do
         end
 
         it "returns the first matching document" do
-          result.should eq(tool)
+          expect(result).to eq(tool)
         end
 
         it "updates the document in the database" do
-          tool.reload.likes.should eq(1)
+          expect(tool.reload.likes).to eq(1)
         end
       end
 
@@ -607,15 +630,15 @@ describe Mongoid::Contextual::Mongo do
         end
 
         it "returns the first matching document" do
-          result.should eq(depeche)
+          expect(result).to eq(depeche)
         end
 
         it "limits the returned fields" do
-          result.name.should be_nil
+          expect(result.name).to be_nil
         end
 
         it "updates the document in the database" do
-          depeche.reload.likes.should eq(1)
+          expect(depeche.reload.likes).to eq(1)
         end
       end
 
@@ -634,11 +657,11 @@ describe Mongoid::Contextual::Mongo do
         end
 
         it "returns the first matching document" do
-          result.should eq(depeche)
+          expect(result).to eq(depeche)
         end
 
         it "returns the updated document" do
-          result.likes.should eq(1)
+          expect(result.likes).to eq(1)
         end
       end
 
@@ -657,7 +680,7 @@ describe Mongoid::Contextual::Mongo do
         end
 
         it "returns the first matching document" do
-          result.should eq(depeche)
+          expect(result).to eq(depeche)
         end
 
         it "deletes the document from the database" do
@@ -683,7 +706,7 @@ describe Mongoid::Contextual::Mongo do
       end
 
       it "returns nil" do
-        result.should be_nil
+        expect(result).to be_nil
       end
     end
   end
@@ -711,7 +734,7 @@ describe Mongoid::Contextual::Mongo do
         end
 
         it "returns the first matching document" do
-          context.send(method).should eq(depeche_mode)
+          expect(context.send(method)).to eq(depeche_mode)
         end
       end
 
@@ -728,15 +751,15 @@ describe Mongoid::Contextual::Mongo do
         context "when there is sort on the context" do
 
           it "follows the main sort" do
-            context.send(method).should eq(new_order)
+            expect(context.send(method)).to eq(new_order)
           end
         end
 
         context "when subsequently calling #last" do
 
           it "returns the correnct document" do
-            context.send(method).should eq(new_order)
-            context.last.should eq(depeche_mode)
+            expect(context.send(method)).to eq(new_order)
+            expect(context.last).to eq(depeche_mode)
           end
         end
       end
@@ -754,15 +777,15 @@ describe Mongoid::Contextual::Mongo do
         context "when there is sort on the context" do
 
           it "follows the main sort" do
-            context.send(method).should eq(new_order)
+            expect(context.send(method)).to eq(new_order)
           end
         end
 
         context "when subsequently calling #last" do
 
           it "returns the correnct document" do
-            context.send(method).should eq(new_order)
-            context.last.should eq(depeche_mode)
+            expect(context.send(method)).to eq(new_order)
+            expect(context.last).to eq(depeche_mode)
           end
         end
       end
@@ -784,8 +807,20 @@ describe Mongoid::Contextual::Mongo do
           end
 
           it "returns the first document without touching the database" do
-            context.should_receive(:query).never
-            context.send(method).should eq(depeche_mode)
+            expect(context).to receive(:query).never
+            expect(context.send(method)).to eq(depeche_mode)
+          end
+        end
+
+        context "when first method was called before" do
+
+          before do
+            context.first
+          end
+
+          it "returns the first document without touching the database" do
+            expect(context).to receive(:query).never
+            expect(context.send(method)).to eq(depeche_mode)
           end
         end
       end
@@ -803,23 +838,23 @@ describe Mongoid::Contextual::Mongo do
     end
 
     it "sets the criteria" do
-      context.criteria.should eq(criteria)
+      expect(context.criteria).to eq(criteria)
     end
 
     it "sets the klass" do
-      context.klass.should eq(Band)
+      expect(context.klass).to eq(Band)
     end
 
     it "sets the query" do
-      context.query.should be_a(Moped::Query)
+      expect(context.query).to be_a(Moped::Query)
     end
 
     it "sets the query selector" do
-      context.query.selector.should eq({ "name" => "Depeche Mode" })
+      expect(context.query.selector).to eq({ "name" => "Depeche Mode" })
     end
 
     it "sets timeout options" do
-      context.query.operation.flags.should eq([ :no_cursor_timeout ])
+      expect(context.query.operation.flags).to eq([ :no_cursor_timeout ])
     end
   end
 
@@ -844,7 +879,7 @@ describe Mongoid::Contextual::Mongo do
       end
 
       it "returns the last matching document" do
-        context.last.should eq(new_order)
+        expect(context.last).to eq(new_order)
       end
     end
 
@@ -867,7 +902,7 @@ describe Mongoid::Contextual::Mongo do
       end
 
       it "respects default scope" do
-        context.last.should eq(palm)
+        expect(context.last).to eq(palm)
       end
     end
 
@@ -890,8 +925,8 @@ describe Mongoid::Contextual::Mongo do
       end
 
       it "returns the correnct document" do
-        context.last.should eq(new_order)
-        context.first.should eq(depeche_mode)
+        expect(context.last).to eq(new_order)
+        expect(context.first).to eq(depeche_mode)
       end
     end
   end
@@ -916,17 +951,17 @@ describe Mongoid::Contextual::Mongo do
         end
 
         it "returns the number of documents that match" do
-          context.send(method).should eq(2)
+          expect(context.send(method)).to eq(2)
         end
 
         context "when calling more than once" do
 
           before do
-            context.query.should_receive(:count).once.and_return(2)
+            expect(context.query).to receive(:count).once.and_return(2)
           end
 
           it "returns the cached value for subsequent calls" do
-            2.times { context.send(method).should eq(2) }
+            2.times { expect(context.send(method)).to eq(2) }
           end
         end
 
@@ -934,11 +969,11 @@ describe Mongoid::Contextual::Mongo do
 
           before do
             context.entries
-            context.query.should_receive(:count).once.and_return(2)
+            expect(context.query).to receive(:count).once.and_return(2)
           end
 
           it "returns the cached value for all calls" do
-            context.send(method).should eq(2)
+            expect(context.send(method)).to eq(2)
           end
 
           context "when the results have been iterated over multiple times" do
@@ -948,7 +983,7 @@ describe Mongoid::Contextual::Mongo do
             end
 
             it "resets the length on each full iteration" do
-              context.should have(2).items
+              expect(context.size).to eq(2)
             end
           end
         end
@@ -965,17 +1000,17 @@ describe Mongoid::Contextual::Mongo do
         end
 
         it "returns the number of documents that match" do
-          context.send(method).should eq(1)
+          expect(context.send(method)).to eq(1)
         end
 
         context "when calling more than once" do
 
           before do
-            context.query.should_receive(:count).once.and_return(1)
+            expect(context.query).to receive(:count).once.and_return(1)
           end
 
           it "returns the cached value for subsequent calls" do
-            2.times { context.send(method).should eq(1) }
+            2.times { expect(context.send(method)).to eq(1) }
           end
         end
 
@@ -983,11 +1018,11 @@ describe Mongoid::Contextual::Mongo do
 
           before do
             context.entries
-            context.query.should_receive(:count).once.and_return(1)
+            expect(context.query).to receive(:count).once.and_return(1)
           end
 
           it "returns the cached value for all calls" do
-            context.send(method).should eq(1)
+            expect(context.send(method)).to eq(1)
           end
 
           context "when the results have been iterated over multiple times" do
@@ -997,7 +1032,7 @@ describe Mongoid::Contextual::Mongo do
             end
 
             it "resets the length on each full iteration" do
-              context.should have(1).item
+              expect(context.size).to eq(1)
             end
           end
         end
@@ -1024,7 +1059,7 @@ describe Mongoid::Contextual::Mongo do
     end
 
     it "limits the results" do
-      context.limit(1).entries.should eq([ depeche_mode ])
+      expect(context.limit(1).entries).to eq([ depeche_mode ])
     end
   end
 
@@ -1046,19 +1081,19 @@ describe Mongoid::Contextual::Mongo do
     context "when passed the symbol field name" do
 
       it "limits query to that field" do
-        criteria.should_receive(:only).with(:name).and_call_original
+        expect(criteria).to receive(:only).with(:name).and_call_original
         context.map(:name)
       end
 
       it "performs mapping" do
-        context.map(:name).should eq ["Depeche Mode", "New Order"]
+        expect(context.map(:name)).to eq ["Depeche Mode", "New Order"]
       end
     end
 
     context "when passed a block" do
 
       it "performs mapping" do
-        context.map(&:name).should eq ["Depeche Mode", "New Order"]
+        expect(context.map(&:name)).to eq ["Depeche Mode", "New Order"]
       end
     end
   end
@@ -1106,52 +1141,52 @@ describe Mongoid::Contextual::Mongo do
       end
 
       it "returns the first aggregate result" do
-        results.should include(
+        expect(results).to include(
           { "_id" => "Depeche Mode", "value" => { "likes" => 200 }}
         )
       end
 
       it "returns the second aggregate result" do
-        results.should include(
+        expect(results).to include(
           { "_id" => "Tool", "value" => { "likes" => 100 }}
         )
       end
 
       it "returns the correct number of documents" do
-        results.count.should eq(2)
+        expect(results.count).to eq(2)
       end
 
       it "contains the entire raw results" do
-        results["results"].should eq([
+        expect(results["results"]).to eq([
           { "_id" => "Depeche Mode", "value" => { "likes" => 200 }},
           { "_id" => "Tool", "value" => { "likes" => 100 }}
         ])
       end
 
       it "contains the execution time" do
-        results.time.should_not be_nil
+        expect(results.time).to_not be_nil
       end
 
       it "contains the count statistics" do
-        results["counts"].should eq({
+        expect(results["counts"]).to eq({
           "input" => 2, "emit" => 2, "reduce" => 0, "output" => 2
         })
       end
 
       it "contains the input count" do
-        results.input.should eq(2)
+        expect(results.input).to eq(2)
       end
 
       it "contains the emitted count" do
-        results.emitted.should eq(2)
+        expect(results.emitted).to eq(2)
       end
 
       it "contains the reduced count" do
-        results.reduced.should eq(0)
+        expect(results.reduced).to eq(0)
       end
 
       it "contains the output count" do
-        results.output.should eq(2)
+        expect(results.output).to eq(2)
       end
     end
 
@@ -1170,45 +1205,45 @@ describe Mongoid::Contextual::Mongo do
       end
 
       it "includes the aggregate result" do
-        results.should include(
+        expect(results).to include(
           { "_id" => "Depeche Mode", "value" => { "likes" => 200 }}
         )
       end
 
       it "returns the correct number of documents" do
-        results.count.should eq(1)
+        expect(results.count).to eq(1)
       end
 
       it "contains the entire raw results" do
-        results["results"].should eq([
+        expect(results["results"]).to eq([
           { "_id" => "Depeche Mode", "value" => { "likes" => 200 }}
         ])
       end
 
       it "contains the execution time" do
-        results.time.should_not be_nil
+        expect(results.time).to_not be_nil
       end
 
       it "contains the count statistics" do
-        results["counts"].should eq({
+        expect(results["counts"]).to eq({
           "input" => 1, "emit" => 1, "reduce" => 0, "output" => 1
         })
       end
 
       it "contains the input count" do
-        results.input.should eq(1)
+        expect(results.input).to eq(1)
       end
 
       it "contains the emitted count" do
-        results.emitted.should eq(1)
+        expect(results.emitted).to eq(1)
       end
 
       it "contains the reduced count" do
-        results.reduced.should eq(0)
+        expect(results.reduced).to eq(0)
       end
 
       it "contains the output count" do
-        results.output.should eq(1)
+        expect(results.output).to eq(1)
       end
     end
 
@@ -1232,23 +1267,23 @@ describe Mongoid::Contextual::Mongo do
       end
 
       it "returns the first aggregate result" do
-        results.should include(
+        expect(results).to include(
           { "_id" => "Tool", "value" => { "likes" => 100 }}
         )
       end
 
       it "returns the second aggregate result" do
-        results.should include(
+        expect(results).to include(
           { "_id" => "Depeche Mode", "value" => { "likes" => 200 }}
         )
       end
 
       it "returns the correct number of documents" do
-        results.count.should eq(2)
+        expect(results.count).to eq(2)
       end
 
       it "contains the entire raw results" do
-        results["results"].should eq([
+        expect(results["results"]).to eq([
           { "_id" => "Depeche Mode", "value" => { "likes" => 200 }},
           { "_id" => "Tool", "value" => { "likes" => 100 }}
         ])
@@ -1270,17 +1305,17 @@ describe Mongoid::Contextual::Mongo do
       end
 
       it "returns the first aggregate result" do
-        results.should include(
+        expect(results).to include(
           { "_id" => "Depeche Mode", "value" => { "likes" => 200 }}
         )
       end
 
       it "returns the correct number of documents" do
-        results.count.should eq(1)
+        expect(results.count).to eq(1)
       end
 
       it "contains the entire raw results" do
-        results["results"].should eq([
+        expect(results["results"]).to eq([
           { "_id" => "Depeche Mode", "value" => { "likes" => 200 }}
         ])
       end
@@ -1301,11 +1336,11 @@ describe Mongoid::Contextual::Mongo do
       end
 
       it "returns the correct number of documents" do
-        results.count.should eq(1)
+        expect(results.count).to eq(1)
       end
 
       it "contains the entire results" do
-        results.should eq([
+        expect(results).to eq([
           { "_id" => "Depeche Mode", "value" => { "likes" => 200 }}
         ])
       end
@@ -1326,11 +1361,11 @@ describe Mongoid::Contextual::Mongo do
       end
 
       it "returns the correct number of documents" do
-        results.count.should eq(1)
+        expect(results.count).to eq(1)
       end
 
       it "contains the entire results" do
-        results.should eq([
+        expect(results).to eq([
           { "_id" => "Depeche Mode", "value" => { "likes" => 200 }}
         ])
       end
@@ -1351,11 +1386,11 @@ describe Mongoid::Contextual::Mongo do
       end
 
       it "returns the correct number of documents" do
-        results.count.should eq(1)
+        expect(results.count).to eq(1)
       end
 
       it "contains the entire results" do
-        results.should eq([
+        expect(results).to eq([
           { "_id" => "Depeche Mode", "value" => { "likes" => 200 }}
         ])
       end
@@ -1405,11 +1440,11 @@ describe Mongoid::Contextual::Mongo do
       end
 
       it "returns the correct number of documents" do
-        results.count.should eq(1)
+        expect(results.count).to eq(1)
       end
 
       it "contains the entire results" do
-        results.should eq([
+        expect(results).to eq([
           { "_id" => "Depeche Mode", "value" => { "likes" => 200, "extra" => true }}
         ])
       end
@@ -1435,7 +1470,7 @@ describe Mongoid::Contextual::Mongo do
     end
 
     it "limits the results" do
-      context.skip(1).entries.should eq([ new_order ])
+      expect(context.skip(1).entries).to eq([ new_order ])
     end
   end
 
@@ -1460,11 +1495,11 @@ describe Mongoid::Contextual::Mongo do
     context "when providing a spec" do
 
       it "sorts the results" do
-        context.sort(name: -1).entries.should eq([ new_order, depeche_mode ])
+        expect(context.sort(name: -1).entries).to eq([ new_order, depeche_mode ])
       end
 
       it "returns the context" do
-        context.sort(name: 1).should eq(context)
+        expect(context.sort(name: 1)).to eq(context)
       end
     end
 
@@ -1477,7 +1512,60 @@ describe Mongoid::Contextual::Mongo do
       end
 
       it "sorts the results in memory" do
-        sorted.should eq([ new_order, depeche_mode ])
+        expect(sorted).to eq([ new_order, depeche_mode ])
+      end
+    end
+  end
+
+  describe "#text_search" do
+
+    let(:criteria) do
+      Word.all
+    end
+
+    let(:context) do
+      described_class.new(criteria)
+    end
+
+    before do
+      Word.with(database: "admin").mongo_session.command(setParameter: 1, textSearchEnabled: true)
+      Word.create_indexes
+      Word.create!(name: "phase", origin: "latin")
+    end
+
+    after(:all) do
+      Word.remove_indexes
+    end
+
+    context "when the search is projecting" do
+
+      let(:search) do
+        context.text_search("phase").project(name: 1)
+      end
+
+      let(:documents) do
+        search.entries
+      end
+
+      it "limits the fields to the projection" do
+        expect {
+          documents.first.origin
+        }.to raise_error(ActiveModel::MissingAttributeError)
+      end
+    end
+
+    context "when the search is not projecting" do
+
+      let(:search) do
+        context.text_search("phase")
+      end
+
+      let(:documents) do
+        search.entries
+      end
+
+      it "returns all fields" do
+        expect(documents.first.origin).to eq("latin")
       end
     end
   end
@@ -1529,11 +1617,11 @@ describe Mongoid::Contextual::Mongo do
         end
 
         it "updates only the first matching document" do
-          depeche_mode.reload.name.should eq("Smiths")
+          expect(depeche_mode.reload.name).to eq("Smiths")
         end
 
         it "does not update the last matching document" do
-          new_order.reload.name.should eq("New Order")
+          expect(new_order.reload.name).to eq("New Order")
         end
       end
 
@@ -1546,11 +1634,11 @@ describe Mongoid::Contextual::Mongo do
           end
 
           it "updates the first matching document" do
-            depeche_mode.reload.member_count.should eq(1)
+            expect(depeche_mode.reload.member_count).to eq(1)
           end
 
           it "does not update the last matching document" do
-            new_order.reload.member_count.should be_nil
+            expect(new_order.reload.member_count).to be_nil
           end
         end
 
@@ -1561,11 +1649,11 @@ describe Mongoid::Contextual::Mongo do
           end
 
           it "updates the first matching document" do
-            depeche_mode.reload.founded.should eq(Date.new(1979, 1, 1))
+            expect(depeche_mode.reload.founded).to eq(Date.new(1979, 1, 1))
           end
 
           it "does not update the last matching document" do
-            new_order.reload.founded.should be_nil
+            expect(new_order.reload.founded).to be_nil
           end
         end
       end
@@ -1582,11 +1670,11 @@ describe Mongoid::Contextual::Mongo do
           end
 
           it "updates the first matching document" do
-            depeche_mode.reload.name.should eq("Smiths")
+            expect(depeche_mode.reload.name).to eq("Smiths")
           end
 
           it "does not update the last matching document" do
-            new_order.reload.name.should eq("New Order")
+            expect(new_order.reload.name).to eq("New Order")
           end
         end
 
@@ -1597,11 +1685,11 @@ describe Mongoid::Contextual::Mongo do
           end
 
           it "updates the first matching document" do
-            depeche_mode.reload.member_count.should eq(1)
+            expect(depeche_mode.reload.member_count).to eq(1)
           end
 
           it "does not update the last matching document" do
-            new_order.reload.member_count.should be_nil
+            expect(new_order.reload.member_count).to be_nil
           end
         end
       end
@@ -1613,19 +1701,19 @@ describe Mongoid::Contextual::Mongo do
         end
 
         it "updates the first matching document's set" do
-          depeche_mode.reload.name.should eq("Smiths")
+          expect(depeche_mode.reload.name).to eq("Smiths")
         end
 
         it "updates the first matching document's updates" do
-          depeche_mode.reload.likes.should eq(100)
+          expect(depeche_mode.reload.likes).to eq(100)
         end
 
         it "does not update the last matching document's set" do
-          new_order.reload.name.should eq("New Order")
+          expect(new_order.reload.name).to eq("New Order")
         end
 
         it "does not update the last matching document's updates" do
-          new_order.reload.likes.should be_nil
+          expect(new_order.reload.likes).to be_nil
         end
       end
     end
@@ -1633,7 +1721,7 @@ describe Mongoid::Contextual::Mongo do
     context "when providing no attributes" do
 
       it "returns false" do
-        context.update.should be_false
+        expect(context.update).to be false
       end
     end
   end
@@ -1665,15 +1753,15 @@ describe Mongoid::Contextual::Mongo do
         end
 
         it "updates the first matching document" do
-          depeche_mode.reload.name.should eq("Smiths")
+          expect(depeche_mode.reload.name).to eq("Smiths")
         end
 
         it "does not clear out other attributes" do
-          depeche_mode.reload.origin.should eq("Essex")
+          expect(depeche_mode.reload.origin).to eq("Essex")
         end
 
         it "updates the last matching document" do
-          new_order.reload.name.should eq("Smiths")
+          expect(new_order.reload.name).to eq("Smiths")
         end
       end
 
@@ -1684,11 +1772,11 @@ describe Mongoid::Contextual::Mongo do
         end
 
         it "updates the first matching document" do
-          depeche_mode.reload.member_count.should eq(1)
+          expect(depeche_mode.reload.member_count).to eq(1)
         end
 
         it "updates the last matching document" do
-          new_order.reload.member_count.should eq(1)
+          expect(new_order.reload.member_count).to eq(1)
         end
       end
 
@@ -1699,11 +1787,11 @@ describe Mongoid::Contextual::Mongo do
         end
 
         it "updates the first matching document" do
-          depeche_mode.reload.years.should eq(100)
+          expect(depeche_mode.reload.years).to eq(100)
         end
 
         it "updates the last matching document" do
-          new_order.reload.years.should eq(100)
+          expect(new_order.reload.years).to eq(100)
         end
       end
     end
@@ -1719,11 +1807,11 @@ describe Mongoid::Contextual::Mongo do
           end
 
           it "updates the first matching document" do
-            depeche_mode.reload.name.should eq("Smiths")
+            expect(depeche_mode.reload.name).to eq("Smiths")
           end
 
           it "updates the last matching document" do
-            new_order.reload.name.should eq("Smiths")
+            expect(new_order.reload.name).to eq("Smiths")
           end
         end
 
@@ -1734,11 +1822,11 @@ describe Mongoid::Contextual::Mongo do
           end
 
           it "updates the first matching document" do
-            depeche_mode.reload.member_count.should eq(1)
+            expect(depeche_mode.reload.member_count).to eq(1)
           end
 
           it "updates the last matching document" do
-            new_order.reload.member_count.should eq(1)
+            expect(new_order.reload.member_count).to eq(1)
           end
         end
       end
@@ -1750,19 +1838,19 @@ describe Mongoid::Contextual::Mongo do
         end
 
         it "updates the first matching document's set" do
-          depeche_mode.reload.name.should eq("Smiths")
+          expect(depeche_mode.reload.name).to eq("Smiths")
         end
 
         it "updates the first matching document's updates" do
-          depeche_mode.reload.likes.should eq(100)
+          expect(depeche_mode.reload.likes).to eq(100)
         end
 
         it "updates the last matching document's set" do
-          new_order.reload.name.should eq("Smiths")
+          expect(new_order.reload.name).to eq("Smiths")
         end
 
         it "updates the last matching document's updates" do
-          new_order.reload.likes.should eq(100)
+          expect(new_order.reload.likes).to eq(100)
         end
       end
     end
@@ -1770,7 +1858,7 @@ describe Mongoid::Contextual::Mongo do
     context "when providing no attributes" do
 
       it "returns false" do
-        context.update_all.should be_false
+        expect(context.update_all).to be false
       end
     end
   end