mongo 2.1.2 → 2.2.0.rc0

data/spec/mongo/collection/view/explainable_spec.rb

@@ -25,8 +25,7 @@ describe Mongo::Collection::View::Explainable do
     end
 
     it 'executes an explain' do
-      expect(explain[:cursor] == 'BasicCursor' ||
-             explain[:queryPlanner]).to be_truthy
+      expect(explain[:cursor] == 'BasicCursor' || explain[:queryPlanner]).to be_truthy
     end
   end
 end

data/spec/mongo/collection/view/immutable_spec.rb

@@ -20,10 +20,10 @@ describe Mongo::Collection::View::Immutable do
 
   describe '#configure' do
 
-    context 'when the options has a modifiers document' do
+    context 'when the options have modifiers' do
 
       let(:options) do
-        { modifiers: { :$maxTimeMS => 500 } }
+        { :max_time_ms => 500 }
       end
 
       let(:new_view) do
@@ -43,56 +43,7 @@ describe Mongo::Collection::View::Immutable do
       end
 
       it 'sets the option' do
-        expect(new_view.projection).to eq(_id: 1)
-      end
-
-      it 'creates a new modifiers document' do
-        expect(view.modifiers).not_to be(new_view.modifiers)
-      end
-    end
-  end
-
-  describe '#configure_modifier' do
-
-    let(:new_view) do
-      view.sort('x' => Mongo::Index::ASCENDING)
-    end
-
-    context 'when the options does not have a modifiers document' do
-
-      it 'returns a new view' do
-        expect(view).not_to be(new_view)
-      end
-
-      it 'returns a new view with the modifiers document containing the option' do
-        expect(new_view.modifiers[:$orderby]).to eq({ 'x' => Mongo::Index::ASCENDING })
-      end
-    end
-
-    context 'when the options has a modifiers document' do
-
-      let(:options) do
-        { modifiers: { :$maxTimeMS => 500 } }
-      end
-
-      it 'returns a new view' do
-        expect(view).not_to be(new_view)
-      end
-
-      it 'creates a new options hash' do
-        expect(view.options).not_to be(new_view.options)
-      end
-
-      it 'keeps the fields already in the options hash and merges in the new one' do
-        expect(new_view.modifiers[:$maxTimeMS]).to eq(500)
-      end
-
-      it 'sets the new value in the new view modifier document' do
-        expect(new_view.modifiers[:$orderby]).to eq('x' => Mongo::Index::ASCENDING)
-      end
-
-      it 'returns that value when the corresponding option method is called' do
-        expect(new_view.sort).to eq({ 'x' => Mongo::Index::ASCENDING })
+        expect(new_view.projection).to eq('_id' => 1)
       end
 
       it 'creates a new modifiers document' do

data/spec/mongo/collection/view/map_reduce_spec.rb

@@ -186,7 +186,7 @@ describe Mongo::Collection::View::MapReduce do
       context 'when the selector is basic' do
 
         let(:selector) do
-          { name: 'Berlin' }
+          { 'name' => 'Berlin' }
         end
 
         it 'applies the selector to the map/reduce' do
@@ -203,7 +203,7 @@ describe Mongo::Collection::View::MapReduce do
       context 'when the selector is advanced' do
 
         let(:selector) do
-          { :$query => { name: 'Berlin' }}
+          { :$query => { 'name' => 'Berlin' }}
         end
 
         it 'applies the selector to the map/reduce' do
@@ -213,7 +213,7 @@ describe Mongo::Collection::View::MapReduce do
         end
 
         it 'includes the selector in the operation spec' do
-          expect(map_reduce.send(:map_reduce_spec)[:selector][:query]).to eq(BSON::Document.new(selector[:$query]))
+          expect(map_reduce.send(:map_reduce_spec)[:selector][:query]).to eq(selector[:$query])
         end
       end
     end
@@ -273,7 +273,7 @@ describe Mongo::Collection::View::MapReduce do
   describe '#out' do
 
     let(:location) do
-      { replace: 'testing' }
+      { 'replace' => 'testing' }
     end
 
     let(:new_map_reduce) do
@@ -285,20 +285,20 @@ describe Mongo::Collection::View::MapReduce do
     end
 
     it 'includes the out value in the operation spec' do
-      expect(new_map_reduce.send(:map_reduce_spec)[:selector][:out]).to be(location)
+      expect(new_map_reduce.send(:map_reduce_spec)[:selector][:out]).to eq(location)
     end
 
     context 'when out is not defined' do
 
       it 'defaults to inline' do
-        expect(map_reduce.send(:map_reduce_spec)[:selector][:out]).to eq(inline: 1)
+        expect(map_reduce.send(:map_reduce_spec)[:selector][:out]).to eq('inline' => 1)
       end
     end
 
     context 'when out is specified in the options' do
 
       let(:location) do
-        { replace: 'testing' }
+        { 'replace' => 'testing' }
       end
 
       let(:options) do
@@ -310,14 +310,14 @@ describe Mongo::Collection::View::MapReduce do
       end
 
       it 'includes the out value in the operation spec' do
-        expect(map_reduce.send(:map_reduce_spec)[:selector][:out]).to be(location)
+        expect(map_reduce.send(:map_reduce_spec)[:selector][:out]).to eq(location)
       end
     end
 
     context 'when out is not inline' do
 
       let(:location) do
-        { replace: 'testing' }
+        { 'replace' => 'testing' }
       end
 
       let(:options) do
@@ -325,7 +325,7 @@ describe Mongo::Collection::View::MapReduce do
       end
 
       it 'does not allow the operation on a secondary' do
-        expect(map_reduce.send(:secondary_ok?)).to be(false)
+        expect(map_reduce.send(:secondary_ok?)).to be false
       end
 
       context 'when the context is not a valid server for writing' do
@@ -350,7 +350,7 @@ describe Mongo::Collection::View::MapReduce do
   describe '#scope' do
 
     let(:object) do
-      { value: 'testing' }
+      { 'value' => 'testing' }
     end
 
     let(:new_map_reduce) do
@@ -362,7 +362,7 @@ describe Mongo::Collection::View::MapReduce do
     end
 
     it 'includes the scope object in the operation spec' do
-      expect(new_map_reduce.send(:map_reduce_spec)[:selector][:scope]).to be(object)
+      expect(new_map_reduce.send(:map_reduce_spec)[:selector][:scope]).to eq(object)
     end
   end
 

data/spec/mongo/collection/view/readable_spec.rb

@@ -18,6 +18,40 @@ describe Mongo::Collection::View::Readable do
     authorized_collection.delete_many
   end
 
+  shared_examples_for 'a read concern aware operation' do
+
+    context 'when a read concern is provided', if: find_command_enabled? do
+
+      let(:new_view) do
+        Mongo::Collection::View.new(new_collection, selector, options)
+      end
+
+      context 'when the read concern is valid' do
+
+        let(:new_collection) do
+          authorized_collection.with(read_concern: { level: 'local' })
+        end
+
+        it 'sends the read concern' do
+          expect { result }.to_not raise_error
+        end
+      end
+
+      context 'when the read concern is not valid' do
+
+        let(:new_collection) do
+          authorized_collection.with(read_concern: { level: 'na' })
+        end
+
+        it 'raises an exception' do
+          expect {
+            result
+          }.to raise_error(Mongo::Error::OperationFailure)
+        end
+      end
+    end
+  end
+
   describe '#allow_partial_results' do
 
     let(:new_view) do
@@ -25,7 +59,7 @@ describe Mongo::Collection::View::Readable do
     end
 
     it 'sets the flag' do
-      expect(new_view.send(:flags)).to include(:partial)
+      expect(new_view.options[:allow_partial_results]).to be true
     end
 
     it 'returns a new View' do
@@ -60,6 +94,15 @@ describe Mongo::Collection::View::Readable do
       view.aggregate(pipeline)
     end
 
+    context 'when incorporating read concern' do
+
+      let(:result) do
+        new_view.aggregate(pipeline, options).to_a
+      end
+
+      it_behaves_like 'a read concern aware operation'
+    end
+
     context 'when not iterating the aggregation' do
 
       it 'returns the aggregation object' do
@@ -127,6 +170,15 @@ describe Mongo::Collection::View::Readable do
       view.map_reduce(map, reduce)
     end
 
+    context 'when incorporating read concern' do
+
+      let(:result) do
+        new_view.map_reduce(map, reduce, options).to_a
+      end
+
+      it_behaves_like 'a read concern aware operation'
+    end
+
     context 'when not iterating the map/reduce' do
 
       it 'returns the map/reduce object' do
@@ -218,6 +270,19 @@ describe Mongo::Collection::View::Readable do
       authorized_collection.delete_many
     end
 
+    let(:result) do
+      view.count(options)
+    end
+
+    context 'when incorporating read concern' do
+
+      let(:result) do
+        new_view.count(options)
+      end
+
+      it_behaves_like 'a read concern aware operation'
+    end
+
     context 'when a selector is provided' do
 
       let(:selector) do
@@ -257,6 +322,15 @@ describe Mongo::Collection::View::Readable do
 
   describe '#distinct' do
 
+    context 'when incorporating read concern' do
+
+      let(:result) do
+        new_view.distinct(:field, options)
+      end
+
+      it_behaves_like 'a read concern aware operation'
+    end
+
     context 'when a selector is provided' do
 
       let(:selector) do
@@ -498,7 +572,7 @@ describe Mongo::Collection::View::Readable do
     end
 
     it 'sets the flag' do
-      expect(new_view.send(:flags)).to include(:no_cursor_timeout)
+      expect(new_view.options[:no_cursor_timeout]).to be true
     end
 
     it 'returns a new View' do
@@ -518,6 +592,10 @@ describe Mongo::Collection::View::Readable do
         { 'y' => 1 }
       end
 
+      before do
+        authorized_collection.insert_one(y: 'value', a: 'other_value')
+      end
+
       it 'sets the projection' do
         new_view = view.projection(new_projection)
         expect(new_view.projection).to eq(new_projection)
@@ -526,6 +604,10 @@ describe Mongo::Collection::View::Readable do
       it 'returns a new View' do
         expect(view.projection(new_projection)).not_to be(view)
       end
+
+      it 'returns only that field on the collection' do
+        expect(view.projection(new_projection).first.keys).to match_array(['_id', 'y'])
+      end
     end
 
     context 'when projection is not specified' do
@@ -636,13 +718,13 @@ describe Mongo::Collection::View::Readable do
   describe '#modifiers' do
 
     let(:options) do
-      { :modifiers => { :$orderby => Mongo::Index::ASCENDING } }
+      { :modifiers => { '$orderby' => 1 } }
     end
 
     context 'when a modifiers document is specified' do
 
       let(:new_modifiers) do
-        { :modifiers => { :$orderby => Mongo::Index::DESCENDING } }
+        { '$orderby' => -1 }
       end
 
       it 'sets the new_modifiers document' do
@@ -770,81 +852,5 @@ describe Mongo::Collection::View::Readable do
         expect(view.sort).to eq(options[:sort])
       end
     end
-
-    context 'when an option is a cursor flag' do
-
-      let(:query_spec_options) do
-        view.send(:query_spec)[:options]
-      end
-
-      context 'when allow_partial_results is set as an option' do
-
-        let(:options) do
-          { :allow_partial_results => true }
-        end
-
-        it 'sets the cursor flag' do
-          expect(query_spec_options[:flags]).to eq([:partial])
-        end
-
-        context 'when allow_partial_results is also called as a method' do
-
-          before do
-            view.allow_partial_results
-          end
-
-          it 'sets only one cursor flag' do
-            expect(query_spec_options[:flags]).to eq([:partial])
-          end
-        end
-      end
-
-      context 'when oplog_replay is set as an option' do
-
-        let(:options) do
-          { :oplog_replay => true }
-        end
-
-        it 'sets the cursor flag' do
-          expect(query_spec_options[:flags]).to eq([:oplog_replay])
-        end
-      end
-
-      context 'when no_cursor_timeout is set as an option' do
-
-        let(:options) do
-          { :no_cursor_timeout => true }
-        end
-
-        it 'sets the cursor flag' do
-          expect(query_spec_options[:flags]).to eq([:no_cursor_timeout])
-        end
-      end
-
-      context 'when cursor_type is set as an option' do
-
-        context 'when :tailable is the cursor type' do
-
-          let(:options) do
-            { :cursor_type => :tailable }
-          end
-
-          it 'sets the cursor flag' do
-            expect(query_spec_options[:flags]).to eq([:tailable_cursor])
-          end
-        end
-
-        context 'when :tailable_await is the cursor type' do
-
-          let(:options) do
-            { :cursor_type => :tailable_await }
-          end
-
-          it 'sets the cursor flags' do
-            expect(query_spec_options[:flags]).to eq([:await_data, :tailable_cursor])
-          end
-        end
-      end
-    end
   end
 end

data/spec/mongo/collection/view_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe Mongo::Collection::View do
 
-  let(:selector) do
+  let(:filter) do
     {}
   end
 
@@ -11,187 +11,13 @@ describe Mongo::Collection::View do
   end
 
   let(:view) do
-    described_class.new(authorized_collection, selector, options)
+    described_class.new(authorized_collection, filter, options)
   end
 
   after do
     authorized_collection.delete_many
   end
 
-  context 'when query modifiers are provided' do
-
-    context 'when a selector has a query modifier' do
-
-      let(:options) do
-        {}
-      end
-
-      let(:expected_modifiers) do
-        BSON::Document.new(selector)
-      end
-
-      let(:parsed_selector) do
-        {}
-      end
-
-      let(:query_selector) do
-        BSON::Document.new(selector)
-      end
-
-      context 'when the $query key is a string' do
-
-        let(:selector) do
-          { "$query" => { a: 1 }, :$someMod => 100 }
-        end
-
-        let(:expected_modifiers) do
-          BSON::Document.new(selector)
-        end
-
-        it 'sets the modifiers' do
-          expect(view.instance_variable_get(:@modifiers)).to eq(expected_modifiers)
-        end
-
-        it 'removes the modifiers from the selector' do
-          expect(view.selector).to eq(parsed_selector)
-        end
-
-        it 'creates the correct query selector' do
-          expect(view.send(:query_spec)[:selector]).to eq(query_selector)
-        end
-
-      end
-
-      context 'when the $query key is a symbol' do
-
-        let(:selector) do
-          { :$query => { a: 1 }, :$someMod => 100 }
-        end
-
-        let(:expected_modifiers) do
-          BSON::Document.new(selector)
-        end
-
-        it 'sets the modifiers' do
-          expect(view.instance_variable_get(:@modifiers)).to eq(expected_modifiers)
-        end
-
-        it 'removes the modifiers from the selector' do
-          expect(view.selector).to eq(parsed_selector)
-        end
-
-        it 'creates the correct query selector' do
-          expect(view.send(:query_spec)[:selector]).to eq(query_selector)
-        end
-      end
-    end
-
-    context 'when a modifiers document is provided in the options' do
-
-      let(:selector) do
-        { a: 1 }
-      end
-
-      let(:options) do
-        { :modifiers => { :$someMod => 100 } }
-      end
-
-      let(:expected_modifiers) do
-        options[:modifiers]
-      end
-
-      let(:parsed_selector) do
-        { a: 1 }
-      end
-
-      let(:query_selector) do
-        BSON::Document.new(:$query => { a: 1 }, :$someMod => 100)
-      end
-
-      it 'sets the modifiers' do
-        expect(view.instance_variable_get(:@modifiers)).to eq(expected_modifiers)
-      end
-
-      it 'removes the modifiers from the selector' do
-        expect(view.selector).to eq(parsed_selector)
-      end
-
-      it 'creates the correct query selector' do
-        expect(view.send(:query_spec)[:selector]).to eq(query_selector)
-      end
-
-      context 'when modifiers and options are both provided' do
-
-        let(:selector) do
-          { a: 1 }
-        end
-
-        let(:options) do
-          { :sort =>  { a: Mongo::Index::ASCENDING }, :modifiers => { :$orderby => { a: Mongo::Index::DESCENDING } } }
-        end
-
-        let(:expected_modifiers) do
-          { :$orderby => options[:sort] }
-        end
-
-        let(:parsed_selector) do
-          { a: 1 }
-        end
-
-        let(:query_selector) do
-          BSON::Document.new(:$query => selector, :$orderby => { a: Mongo::Index::ASCENDING })
-        end
-
-        it 'sets the modifiers' do
-          expect(view.instance_variable_get(:@modifiers)).to eq(expected_modifiers)
-        end
-
-        it 'removes the modifiers from the selector' do
-          expect(view.selector).to eq(parsed_selector)
-        end
-
-        it 'creates the correct query selector' do
-          expect(view.send(:query_spec)[:selector]).to eq(query_selector)
-        end
-      end
-
-      context 'when modifiers, options and a query modifier are provided' do
-
-        let(:selector) do
-          { b: 2, :$query => { a: 1 }, :$someMod => 100 }
-        end
-
-        let(:options) do
-          { :sort =>  { a: Mongo::Index::ASCENDING }, :modifiers => { :$someMod => true, :$orderby => { a: Mongo::Index::DESCENDING } } }
-        end
-
-        let(:expected_modifiers) do
-          { :$query => { a: 1 }, :$orderby => { a: Mongo::Index::ASCENDING }, :$someMod => 100 }
-        end
-
-        let(:parsed_selector) do
-          { b: 2 }
-        end
-
-        let(:query_selector) do
-          BSON::Document.new(:$query => { a: 1 }, :$someMod => 100, :$orderby => { a: Mongo::Index::ASCENDING })
-        end
-
-        it 'sets the modifiers' do
-          expect(view.instance_variable_get(:@modifiers)).to eq(expected_modifiers)
-        end
-
-        it 'removes the modifiers from the selector' do
-          expect(view.selector).to eq(parsed_selector)
-        end
-
-        it 'creates the correct query selector' do
-          expect(view.send(:query_spec)[:selector]).to eq(query_selector)
-        end
-      end
-    end
-  end
-
   describe '#==' do
 
     context 'when the other object is not a collection view' do
@@ -203,10 +29,10 @@ describe Mongo::Collection::View do
       end
     end
 
-    context 'when the views have the same collection, selector, and options' do
+    context 'when the views have the same collection, filter, and options' do
 
       let(:other) do
-        described_class.new(authorized_collection, selector, options)
+        described_class.new(authorized_collection, filter, options)
       end
 
       it 'returns true' do
@@ -221,7 +47,7 @@ describe Mongo::Collection::View do
       end
 
       let(:other) do
-        described_class.new(other_collection, selector, options)
+        described_class.new(other_collection, filter, options)
       end
 
       it 'returns false' do
@@ -229,14 +55,14 @@ describe Mongo::Collection::View do
       end
     end
 
-    context 'when two views have a different selector' do
+    context 'when two views have a different filter' do
 
-      let(:other_selector) do
+      let(:other_filter) do
         { 'name' => 'Emily' }
       end
 
       let(:other) do
-        described_class.new(authorized_collection, other_selector, options)
+        described_class.new(authorized_collection, other_filter, options)
       end
 
       it 'returns false' do
@@ -251,7 +77,7 @@ describe Mongo::Collection::View do
       end
 
       let(:other) do
-        described_class.new(authorized_collection, selector, other_options)
+        described_class.new(authorized_collection, filter, other_options)
       end
 
       it 'returns false' do
@@ -270,8 +96,8 @@ describe Mongo::Collection::View do
       expect(view.options).not_to be(view_clone.options)
     end
 
-    it 'dups the selector' do
-      expect(view.selector).not_to be(view_clone.selector)
+    it 'dups the filter' do
+      expect(view.filter).not_to be(view_clone.filter)
     end
 
     it 'references the same collection' do
@@ -293,487 +119,6 @@ describe Mongo::Collection::View do
       authorized_collection.delete_many
     end
 
-    context 'when sending the initial query' do
-
-      let(:returned) do
-        view.to_a
-      end
-
-      let(:query_spec) do
-        view.send(:query_spec)
-      end
-
-      context 'when limit is specified' do
-
-        let(:options) do
-          { :limit => 5 }
-        end
-
-        let(:returned) do
-          view.to_a
-        end
-
-        it 'sets the limit on the initial query' do
-          expect(query_spec[:options][:limit]).to eq(options[:limit])
-        end
-
-        it 'returns limited documents' do
-          expect(returned.count).to eq(5)
-        end
-
-        it 'iterates over all of the documents' do
-          returned.each do |doc|
-            expect(doc).to have_key('field')
-          end
-        end
-      end
-
-      context 'when batch size is specified' do
-
-        let(:options) do
-          { :batch_size => 5 }
-        end
-
-        let(:returned) do
-          view.to_a
-        end
-
-        it 'sets the batch size on the initial query' do
-          expect(query_spec[:options][:batch_size]).to eq(options[:batch_size])
-        end
-
-        it 'returns all the documents' do
-          expect(returned.count).to eq(10)
-        end
-
-        it 'iterates over all of the documents' do
-          returned.each do |doc|
-            expect(doc).to have_key('field')
-          end
-        end
-      end
-
-      context 'when no limit is specified' do
-
-        it 'does not set a limit on the initial query' do
-          expect(query_spec[:options][:limit]).to be_nil
-        end
-
-        it 'returns all the documents' do
-          expect(returned.count).to eq(10)
-        end
-
-        it 'iterates over all of the documents' do
-          returned.each do |doc|
-            expect(doc).to have_key('field')
-          end
-        end
-      end
-
-      context 'when batch size is greater than limit' do
-
-        let(:options) do
-          { :batch_size => 5, :limit => 3 }
-        end
-
-        let(:returned) do
-          view.to_a
-        end
-
-        it 'sets the limit on the initial query' do
-          expect(query_spec[:options][:limit]).to eq(options[:limit])
-        end
-
-        it 'returns the limit of documents' do
-          expect(returned.count).to eq(3)
-        end
-
-        it 'iterates over all of the documents' do
-          returned.each do |doc|
-            expect(doc).to have_key('field')
-          end
-        end
-      end
-
-      context 'when limit is greater than batch size' do
-
-        let(:options) do
-          { :limit => 5, :batch_size => 3 }
-        end
-
-        let(:returned) do
-          view.to_a
-        end
-
-        it 'sets the batch size on the initial query' do
-          expect(query_spec[:options][:batch_size]).to eq(options[:batch_size])
-        end
-
-        it 'sets the limit on the initial query' do
-          expect(query_spec[:options][:limit]).to eq(options[:limit])
-        end
-
-        it 'returns the limit of documents' do
-          expect(returned.count).to eq(5)
-        end
-
-        it 'iterates over all of the documents' do
-          returned.each do |doc|
-            expect(doc).to have_key('field')
-          end
-        end
-      end
-
-      context 'when the selector has special fields' do
-
-        context 'when a snapshot option is specified' do
-
-          let(:options) do
-            { :snapshot => true }
-          end
-
-          before do
-            expect(view).to receive(:special_selector).and_call_original
-          end
-
-          it 'creates a special query selector' do
-            expect(query_spec[:selector][:$snapshot]).to eq(options[:snapshot])
-          end
-
-          it 'iterates over all of the documents' do
-            returned.each do |doc|
-              expect(doc).to have_key('field')
-            end
-          end
-        end
-
-        context 'when a max_scan option is provided' do
-
-          let(:options) do
-            { :max_scan => 100 }
-          end
-
-          before do
-            expect(view).to receive(:special_selector).and_call_original
-          end
-
-          it 'creates a special query selector' do
-            expect(query_spec[:selector][:$maxScan]).to eq(options[:max_scan])
-          end
-
-          it 'iterates over all of the documents' do
-            returned.each do |doc|
-              expect(doc).to have_key('field')
-            end
-          end
-        end
-
-        context 'when a max_time_ms option is provided' do
-
-          let(:options) do
-            { :max_time_ms => 100 }
-          end
-
-          before do
-            expect(view).to receive(:special_selector).and_call_original
-          end
-
-          it 'creates a special query selector' do
-            expect(query_spec[:selector][:$maxTimeMS]).to eq(options[:max_time_ms])
-          end
-
-          it 'iterates over all of the documents' do
-            returned.each do |doc|
-              expect(doc).to have_key('field')
-            end
-          end
-        end
-
-        context 'when a show_disk_loc option is provided' do
-
-          let(:options) do
-            { :show_disk_loc => true }
-          end
-
-          before do
-            expect(view).to receive(:special_selector).and_call_original
-          end
-
-          it 'creates a special query selector' do
-            expect(query_spec[:selector][:$showDiskLoc]).to eq(options[:show_disk_loc])
-          end
-
-          it 'iterates over all of the documents' do
-            returned.each do |doc|
-              expect(doc).to have_key('field')
-            end
-          end
-        end
-      end
-
-      context 'when sorting' do
-
-        let(:options) do
-          { :sort => {'x' => Mongo::Index::ASCENDING }}
-        end
-
-        before do
-          expect(view).to receive(:special_selector).and_call_original
-        end
-
-        it 'creates a special query selector' do
-          expect(query_spec[:selector][:$orderby]).to eq(options[:sort])
-        end
-
-        it 'iterates over all of the documents' do
-          returned.each do |doc|
-            expect(doc).to have_key('field')
-          end
-        end
-      end
-
-      context 'when providing a hint' do
-
-        context 'when the hint is bad' do
-
-          let(:options) do
-            { :hint => { 'x' => Mongo::Index::ASCENDING }}
-          end
-
-          before do
-            expect(view).to receive(:special_selector).and_call_original
-          end
-
-          it 'creates a special query selector' do
-            expect(query_spec[:selector][:$hint]).to eq(options[:hint])
-          end
-        end
-      end
-
-      context 'when providing a comment' do
-
-        let(:options) do
-          { :comment => 'query1' }
-        end
-
-        before do
-          expect(view).to receive(:special_selector).and_call_original
-        end
-
-        it 'creates a special query selector' do
-          expect(query_spec[:selector][:$comment]).to eq(options[:comment])
-        end
-
-        it 'iterates over all of the documents' do
-          returned.each do |doc|
-            expect(doc).to have_key('field')
-          end
-        end
-      end
-
-      context 'when the cluster is sharded', if: sharded? do
-
-        before do
-          expect(view).to receive(:special_selector).and_call_original
-        end
-
-        it 'iterates over all of the documents' do
-          view.each do |doc|
-            expect(doc).to have_key('field')
-          end
-        end
-
-        context 'when there is a read preference' do
-
-          let(:collection) do
-            authorized_collection.with(read: { mode: :secondary})
-          end
-
-          let(:view) do
-            described_class.new(collection, selector, options)
-          end
-
-          let(:formatted_read_pref) do
-            BSON::Document.new(Mongo::ServerSelector.get(mode: :secondary).to_mongos)
-          end
-
-          it 'adds the formatted read preference to the selector' do
-            expect(view.send(:query_spec)[:selector][:$readPreference]).to eq(formatted_read_pref)
-          end
-        end
-
-        context 'when the read preference is primary' do
-
-          let(:collection) do
-            authorized_collection.with(read: { mode: :primary})
-          end
-
-          let(:view) do
-            described_class.new(collection, selector, options)
-          end
-
-          it 'does not add the formatted read preference to the selector' do
-            expect(view.send(:query_spec)[:selector][:$readPreference]).to be(nil)
-          end
-        end
-      end
-
-      context 'when a modifier document is provided' do
-
-        let(:options) do
-          { :modifiers => {
-                            :$orderby => {'x' => Mongo::Index::ASCENDING }
-                          }
-          }
-        end
-
-        before do
-          expect(view).to receive(:special_selector).and_call_original
-        end
-
-        it 'creates a special query selector' do
-          expect(query_spec[:selector][:$orderby]).to eq(options[:modifiers][:$orderby])
-        end
-
-        it 'iterates over all of the documents' do
-          view.each do |doc|
-            expect(doc).to have_key('field')
-          end
-        end
-
-        context 'when $explain is specified' do
-          let(:options) do
-            { :modifiers => {
-                             :$explain => 1
-                            }
-            }
-          end
-
-          let(:explain) do
-            view.to_a.first
-          end
-
-          it 'executes an explain' do
-            expect(explain['cursor'] == 'BasicCursor' ||
-                       explain['queryPlanner']).to be_truthy
-          end
-
-        end
-
-        context 'when an option is also provided' do
-
-          context 'when $orderby and sort are specified' do
-
-            let(:options) do
-              { :modifiers => {
-                               :$orderby => { 'x' => Mongo::Index::ASCENDING }
-                              },
-                :sort => { 'x' => Mongo::Index::DESCENDING }
-              }
-            end
-
-            it 'overrides the modifier value with the option value' do
-              expect(query_spec[:selector][:$orderby]).to eq(options[:sort])
-            end
-          end
-
-          context 'when $comment and comment are specified' do
-
-            let(:options) do
-              { :modifiers => {
-                               :$comment => 'query1'
-                              },
-                :comment => 'query2'
-              }
-            end
-
-            it 'overrides the modifier value with the option value' do
-              expect(query_spec[:selector][:$comment]).to eq(options[:comment])
-            end
-          end
-
-          context 'when $hint and hint are specified' do
-
-            let(:options) do
-              { :modifiers => {
-                               :$hint => 'x'
-                              },
-                :hint => 'y'
-              }
-            end
-
-            it 'overrides the modifier value with the option value' do
-              expect(query_spec[:selector][:$hint]).to eq(options[:hint])
-            end
-
-          end
-
-          context 'when $maxScan and max_scan are specified' do
-
-            let(:options) do
-              { :modifiers => {
-                               :$maxScan => 4
-                              },
-                :max_scan => 5
-              }
-            end
-
-            it 'overrides the modifier value with the option value' do
-              expect(query_spec[:selector][:$maxScan]).to eq(options[:max_scan])
-            end
-          end
-
-          context 'when $maxTimeMS and max_time_ms are specified' do
-
-            let(:options) do
-              { :modifiers => {
-                               :$maxTimeMS => 100
-                              },
-                :max_time_ms => 200
-              }
-            end
-
-            it 'overrides the modifier value with the option value' do
-              expect(query_spec[:selector][:$maxTimeMS]).to eq(options[:max_time_ms])
-            end
-          end
-
-          context 'when $query and a selector are specified' do
-
-            let(:selector) do
-              { 'y' => 1 }
-            end
-
-            let(:options) do
-              { :modifiers => {
-                                :$query => { 'field' => 1 }
-                              }
-              }
-            end
-
-            it 'overrides the modifier value with the option value' do
-              expect(query_spec[:selector][:$query]).to eq(options[:modifiers][:$query])
-            end
-          end
-        end
-      end
-    end
-
-    context 'when there are no special fields' do
-
-      before do
-        expect(Mongo::Operation::Read::Query).to receive(:new) do |spec|
-          expect(spec[:selector]).to eq(selector)
-        end.and_call_original
-      end
-
-      it 'creates a normal query spec' do
-        view.each do |doc|
-          expect(doc).to have_key('field')
-        end
-      end
-    end
-
     context 'when a block is not provided' do
 
       let(:enumerator) do
@@ -793,14 +138,17 @@ describe Mongo::Collection::View do
         { :batch_size => 1 }
       end
 
+      let(:cursor) do
+        view.instance_variable_get(:@cursor)
+      end
+
       before do
-        e = view.to_enum
-        e.next
-        cursor = view.instance_variable_get(:@cursor)
-        expect(cursor).to receive(:kill_cursors).and_call_original
+        view.to_enum.next
+        cursor.instance_variable_set(:@cursor_id, 1) unless find_command_enabled?
       end
 
       it 'sends a kill cursors command for the cursor' do
+        expect(cursor).to receive(:kill_cursors).and_call_original
         view.close_query
       end
     end
@@ -809,10 +157,10 @@ describe Mongo::Collection::View do
   describe '#hash' do
 
     let(:other) do
-      described_class.new(authorized_collection, selector, options)
+      described_class.new(authorized_collection, filter, options)
     end
 
-    it 'returns a unique value based on collection, selector, options' do
+    it 'returns a unique value based on collection, filter, options' do
       expect(view.hash).to eq(other.hash)
     end
 
@@ -823,7 +171,7 @@ describe Mongo::Collection::View do
       end
 
       let(:other) do
-        described_class.new(other_collection, selector, options)
+        described_class.new(other_collection, filter, options)
       end
 
       it 'returns different hash values' do
@@ -831,14 +179,14 @@ describe Mongo::Collection::View do
       end
     end
 
-    context 'when two views only have different selectors' do
+    context 'when two views only have different filter' do
 
-      let(:other_selector) do
+      let(:other_filter) do
         { 'name' => 'Emily' }
       end
 
       let(:other) do
-        described_class.new(authorized_collection, other_selector, options)
+        described_class.new(authorized_collection, other_filter, options)
       end
 
       it 'returns different hash values' do
@@ -853,7 +201,7 @@ describe Mongo::Collection::View do
       end
 
       let(:other) do
-        described_class.new(authorized_collection, selector, other_options)
+        described_class.new(authorized_collection, filter, other_options)
       end
 
       it 'returns different hash values' do
@@ -864,53 +212,111 @@ describe Mongo::Collection::View do
 
   describe '#initialize' do
 
-    let(:options) do
-      { :limit => 5 }
-    end
+    context 'when the filter is not a valid document' do
 
-    it 'sets the collection' do
-      expect(view.collection).to eq(authorized_collection)
-    end
+      let(:filter) do
+        'y'
+      end
 
-    it 'sets the selector' do
-      expect(view.selector).to eq(selector)
+      let(:options) do
+        { limit: 5 }
+      end
+
+      it 'raises an error' do
+        expect do
+          view
+        end.to raise_error(Mongo::Error::InvalidDocument)
+      end
     end
 
-    it 'dups the selector' do
-      expect(view.selector).not_to be(selector)
+    context 'when the filter and options are standard' do
+
+      let(:filter) do
+        { 'name' => 'test' }
+      end
+
+      let(:options) do
+        { 'sort' => { 'name' => 1 }}
+      end
+
+      it 'parses a standard filter' do
+        expect(view.filter).to eq(filter)
+      end
+
+      it 'parses standard options' do
+        expect(view.options).to eq(options)
+      end
     end
 
-    it 'sets the options' do
-      expect(view.options).to eq(options)
+    context 'when the filter contains modifiers' do
+
+      let(:filter) do
+        { :$query => { :name => 'test' }, :$comment => 'testing' }
+      end
+
+      let(:options) do
+        { :sort => { name: 1 }}
+      end
+
+      it 'parses a standard filter' do
+        expect(view.filter).to eq('name' => 'test')
+      end
+
+      it 'parses standard options' do
+        expect(view.options).to eq('sort' => { 'name' => 1 }, 'comment' => 'testing')
+      end
     end
 
-    it 'dups the options' do
-      expect(view.options).not_to be(options)
+    context 'when the options contain modifiers' do
+
+      let(:filter) do
+        { 'name' => 'test' }
+      end
+
+      let(:options) do
+        { :sort => { name: 1 }, :modifiers => { :$comment => 'testing'}}
+      end
+
+      it 'parses a standard filter' do
+        expect(view.filter).to eq('name' => 'test')
+      end
+
+      it 'parses standard options' do
+        expect(view.options).to eq('sort' => { 'name' => 1 }, 'comment' => 'testing')
+      end
     end
 
-    context 'when the selector is not a valid document' do
+    context 'when the filter and options both contain modifiers' do
 
-      let(:selector) do
-        'y'
+      let(:filter) do
+        { :$query => { 'name' => 'test' }, :$hint => { name: 1 }}
       end
 
-      it 'raises an error' do
-        expect do
-          view
-        end.to raise_error(Mongo::Error::InvalidDocument)
+      let(:options) do
+        { :sort => { name: 1 }, :modifiers => { :$comment => 'testing' }}
+      end
+
+      it 'parses a standard filter' do
+        expect(view.filter).to eq('name' => 'test')
+      end
+
+      it 'parses standard options' do
+        expect(view.options).to eq(
+          'sort' => { 'name' => 1 }, 'comment' => 'testing', 'hint' => { 'name' => 1 }
+        )
       end
     end
   end
 
   describe '#inspect' do
 
-    context 'when there is a namespace, selector, and options' do
+    context 'when there is a namespace, filter, and options' do
 
       let(:options) do
-        { :limit => 5 }
+        { 'limit' => 5 }
       end
 
-      let(:selector) do
+      let(:filter) do
         { 'name' => 'Emily' }
       end
 
@@ -922,8 +328,8 @@ describe Mongo::Collection::View do
         expect(view.inspect).to match(/.*#{authorized_collection.namespace}.*/)
       end
 
-      it 'returns a string containing the selector' do
-        expect(view.inspect).to match(/.*#{selector.inspect}.*/)
+      it 'returns a string containing the filter' do
+        expect(view.inspect).to match(/.*#{filter.inspect}.*/)
       end
 
       it 'returns a string containing the options' do