mongo 2.20.1 → 2.21.1

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

@@ -1,2283 +0,0 @@
-# frozen_string_literal: true
-# rubocop:todo all
-
-require 'spec_helper'
-
-describe Mongo::Collection::View::Readable do
-
-  let(:selector) do
-    {}
-  end
-
-  let(:options) do
-    {}
-  end
-
-  let(:view) do
-    Mongo::Collection::View.new(authorized_collection, selector, options)
-  end
-
-  before do
-    authorized_collection.delete_many
-  end
-
-  shared_examples_for 'a read concern aware operation' do
-
-    context 'when a read concern is provided' do
-      min_server_fcv '3.2'
-
-      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
-      view.allow_partial_results
-    end
-
-    it 'sets the flag' do
-      expect(new_view.options[:allow_partial_results]).to be true
-    end
-
-    it 'returns a new View' do
-      expect(new_view).not_to be(view)
-    end
-  end
-
-  describe '#allow_disk_use' do
-    let(:new_view) do
-      view.allow_disk_use
-    end
-
-    it 'sets the flag' do
-      expect(new_view.options[:allow_disk_use]).to be true
-    end
-
-    it 'returns the new View' do
-      expect(new_view).not_to be(view)
-    end
-  end
-
-  describe '#aggregate' do
-
-    let(:documents) do
-      [
-        { city: "Berlin", pop: 18913, neighborhood: "Kreuzberg" },
-        { city: "Berlin", pop: 84143, neighborhood: "Mitte" },
-        { city: "New York", pop: 40270, neighborhood: "Brooklyn" }
-      ]
-    end
-
-    let(:pipeline) do
-      [{
-        "$group" => {
-          "_id" => "$city",
-          "totalpop" => { "$sum" => "$pop" }
-        }
-      }]
-    end
-
-    before do
-      authorized_collection.insert_many(documents)
-    end
-
-    let(:aggregation) 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
-        expect(aggregation).to be_a(Mongo::Collection::View::Aggregation)
-      end
-    end
-
-    context 'when iterating the aggregation' do
-
-      it 'yields to each document' do
-        aggregation.each do |doc|
-          expect(doc[:totalpop]).to_not be_nil
-        end
-      end
-    end
-
-    context 'when options are specified' do
-
-      let(:agg_options) do
-        { :max_time_ms => 500 }
-      end
-
-      let(:aggregation) do
-        view.aggregate(pipeline, agg_options)
-      end
-
-      it 'passes the option to the Aggregation object' do
-        expect(aggregation.options[:max_time_ms]).to eq(agg_options[:max_time_ms])
-      end
-    end
-
-    context "when using methods to set aggregate options" do
-
-      context "when the broken_view_options flag is off" do
-        config_override :broken_view_options, false
-
-        let(:aggregate) do
-          view.send(opt, param).aggregate(pipeline, options)
-        end
-
-        context "when a :allow_disk_use is given" do
-          let(:aggregate) do
-            view.allow_disk_use.aggregate(pipeline, options)
-          end
-          let(:opt) { :allow_disk_use }
-
-          it "sets the option correctly" do
-            expect(aggregate.options[opt]).to eq(true)
-          end
-        end
-
-        context "when a :batch_size is given" do
-          let(:opt) { :batch_size }
-          let(:param) { 2 }
-
-          it "sets the option correctly" do
-            expect(aggregate.options[opt]).to eq(param)
-          end
-        end
-
-        context "when a :max_time_ms is given" do
-          let(:opt) { :max_time_ms }
-          let(:param) { 2 }
-
-          it "sets the option correctly" do
-            expect(aggregate.options[opt]).to eq(param)
-          end
-        end
-
-        context "when a :max_await_time_ms is given" do
-          let(:opt) { :max_await_time_ms }
-          let(:param) { 2 }
-
-          it "sets the option correctly" do
-            expect(aggregate.options[opt]).to eq(param)
-          end
-        end
-
-        context "when a :comment is given" do
-          let(:opt) { :comment }
-          let(:param) { "comment" }
-
-          it "sets the option correctly" do
-            expect(aggregate.options[opt]).to eq(param)
-          end
-        end
-
-        context "when a :hint is given" do
-          let(:opt) { :hint }
-          let(:param) { "_id_" }
-
-          it "sets the option correctly" do
-            expect(aggregate.options[opt]).to eq(param)
-          end
-        end
-
-        context "when a :session is given on the view" do
-          let(:opt) { :session }
-          let(:param) { authorized_client.start_session }
-          let(:aggregate) do
-            authorized_collection.find({}, session: param).aggregate(pipeline, options)
-          end
-
-          after do
-            param.end_session
-          end
-
-          context "when broken_view_options is false" do
-            config_override :broken_view_options, false
-
-            it "sets the option correctly" do
-              expect(aggregate.options[opt]).to eq(param)
-            end
-          end
-
-          context "when broken_view_options is true" do
-            config_override :broken_view_options, true
-
-            it "does not set the option" do
-              expect(aggregate.options[opt]).to be nil
-            end
-          end
-        end
-
-        context "when also including in options" do
-
-          let(:aggregate) do
-            view.limit(1).aggregate(pipeline, { limit: 2 })
-          end
-
-          it "sets the option correctly" do
-            expect(aggregate.options[:limit]).to eq(2)
-          end
-        end
-      end
-
-      context "when the broken_view_options flag is on" do
-        config_override :broken_view_options, true
-
-        let(:aggregate) do
-          view.send(opt, param).aggregate(pipeline, options)
-        end
-
-        context "when a :allow_disk_use is given" do
-          let(:aggregate) do
-            view.allow_disk_use.aggregate(pipeline, options)
-          end
-          let(:opt) { :allow_disk_use }
-
-          it "doesn't set the option correctly" do
-            expect(aggregate.options[opt]).to be_nil
-          end
-        end
-
-        context "when a :batch_size is given" do
-          let(:opt) { :batch_size }
-          let(:param) { 2 }
-
-          it "doesn't set the option correctly" do
-            expect(aggregate.options[opt]).to be_nil
-          end
-        end
-
-        context "when a :max_time_ms is given" do
-          let(:opt) { :max_time_ms }
-          let(:param) { 2 }
-
-          it "doesn't set the option correctly" do
-            expect(aggregate.options[opt]).to be_nil
-          end
-        end
-
-        context "when a :max_await_time_ms is given" do
-          let(:opt) { :max_await_time_ms }
-          let(:param) { 2 }
-
-          it "doesn't set the option correctly" do
-            expect(aggregate.options[opt]).to be_nil
-          end
-        end
-
-        context "when a :comment is given" do
-          let(:opt) { :comment }
-          let(:param) { "comment" }
-
-          it "doesn't set the option correctly" do
-            expect(aggregate.options[opt]).to be_nil
-          end
-        end
-
-        context "when a :hint is given" do
-          let(:opt) { :hint }
-          let(:param) { "_id_" }
-
-          it "doesn't set the option correctly" do
-            expect(aggregate.options[opt]).to be_nil
-          end
-        end
-
-        context "when also including in options" do
-
-          let(:aggregate) do
-            view.limit(1).aggregate(pipeline, { limit: 2 })
-          end
-
-          it "sets the option correctly" do
-            expect(aggregate.options[:limit]).to eq(2)
-          end
-        end
-      end
-    end
-  end
-
-  describe '#map_reduce' do
-
-    let(:map) do
-    %Q{
-    function() {
-      emit(this.name, { population: this.population });
-    }}
-    end
-
-    let(:reduce) do
-      %Q{
-      function(key, values) {
-        var result = { population: 0 };
-        values.forEach(function(value) {
-          result.population += value.population;
-        });
-        return result;
-      }}
-    end
-
-    let(:documents) do
-      [
-        { name: 'Berlin', population: 3000000 },
-        { name: 'London', population: 9000000 }
-      ]
-    end
-
-    before do
-      authorized_collection.insert_many(documents)
-    end
-
-    let(:map_reduce) 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 a session supporting causal consistency is used' do
-
-      let(:view) do
-        Mongo::Collection::View.new(collection, selector, session: session)
-      end
-
-      let(:operation) do
-        begin; view.map_reduce(map, reduce).to_a; rescue; end
-      end
-
-      let(:command) do
-        operation
-        subscriber.started_events.find { |cmd| cmd.command_name == 'mapReduce' }.command
-      end
-
-      it_behaves_like 'an operation supporting causally consistent reads'
-    end
-
-    context 'when not iterating the map/reduce' do
-
-      it 'returns the map/reduce object' do
-        expect(map_reduce).to be_a(Mongo::Collection::View::MapReduce)
-      end
-    end
-
-    context 'when iterating the map/reduce' do
-
-      it 'yields to each document' do
-        map_reduce.each do |doc|
-          expect(doc[:_id]).to_not be_nil
-        end
-      end
-    end
-
-    context "when using methods to set map_reduce options" do
-
-      let(:map_reduce) do
-        view.send(opt, param).map_reduce(map, reduce, options)
-      end
-
-      context "when a :limit is given" do
-        let(:opt) { :limit }
-        let(:param) { 1 }
-
-        it "sets the option correctly" do
-          expect(map_reduce.options[opt]).to eq(param)
-        end
-      end
-
-      context "when a :sort is given" do
-        let(:opt) { :sort }
-        let(:param) { { 'x' => Mongo::Index::ASCENDING } }
-
-        it "sets the option correctly" do
-          expect(map_reduce.options[opt]).to eq(param)
-        end
-      end
-
-      context "when also including in options" do
-
-        let(:map_reduce) do
-          view.limit(1).map_reduce(map, reduce, { limit: 2})
-        end
-
-        it "sets the option correctly" do
-          expect(map_reduce.options[:limit]).to eq(2)
-        end
-      end
-
-      context "when a :session is given on the view" do
-        let(:opt) { :session }
-        let(:param) { authorized_client.start_session }
-        let(:map_reduce) do
-          authorized_collection.find({}, session: param).map_reduce(map, reduce, options)
-        end
-
-        after do
-          param.end_session
-        end
-
-        with_config_values :broken_view_options, true, false do
-          it "sets the option correctly" do
-            expect(map_reduce.options[opt]).to eq(param)
-          end
-        end
-      end
-    end
-  end
-
-  describe '#batch_size' do
-
-    let(:options) do
-      { :batch_size => 13 }
-    end
-
-    context 'when a batch size is specified' do
-
-      let(:new_batch_size) do
-        15
-      end
-
-      it 'sets the batch size' do
-        new_view = view.batch_size(new_batch_size)
-        expect(new_view.batch_size).to eq(new_batch_size)
-      end
-
-      it 'returns a new View' do
-        expect(view.batch_size(new_batch_size)).not_to be(view)
-      end
-    end
-
-    context 'when a batch size is not specified' do
-
-      it 'returns the batch_size' do
-        expect(view.batch_size).to eq(options[:batch_size])
-      end
-    end
-  end
-
-  describe '#comment' do
-
-    let(:options) do
-      { :comment => 'test1' }
-    end
-
-    context 'when a comment is specified' do
-
-      let(:new_comment) do
-        'test2'
-      end
-
-      it 'sets the comment' do
-        new_view = view.comment(new_comment)
-        expect(new_view.comment).to eq(new_comment)
-      end
-
-      it 'returns a new View' do
-        expect(view.comment(new_comment)).not_to be(view)
-      end
-    end
-
-    context 'when a comment is not specified' do
-
-      it 'returns the comment' do
-        expect(view.comment).to eq(options[:comment])
-      end
-    end
-  end
-
-  describe '#count' do
-
-    let(:documents) do
-      (1..10).map{ |i| { field: "test#{i}" }}
-    end
-
-    before do
-      authorized_collection.delete_many
-      authorized_collection.insert_many(documents)
-    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
-        { field: 'test1' }
-      end
-
-      it 'returns the count of matching documents' do
-        expect(view.count).to eq(1)
-      end
-
-      it 'returns an integer' do
-        expect(view.count).to be_a(Integer)
-      end
-    end
-
-    context 'when no selector is provided' do
-
-      it 'returns the count of matching documents' do
-        expect(view.count).to eq(10)
-      end
-    end
-
-    context 'not sharded' do
-      require_topology :single, :replica_set
-
-      it 'takes a read preference option' do
-        # Secondary may be delayed, since this tests wants 10 documents
-        # it must query the primary
-        expect(view.count(read: { mode: :primary })).to eq(10)
-      end
-    end
-
-    context 'when a read preference is set on the view' do
-      require_topology :single, :replica_set
-
-      let(:client) do
-        # Set a timeout otherwise, the test will hang for 30 seconds.
-        authorized_client.with(server_selection_timeout: 1)
-      end
-
-      let(:collection) do
-        client[authorized_collection.name]
-      end
-
-      before do
-        allow(client.cluster).to receive(:single?).and_return(false)
-      end
-
-      let(:view) do
-        Mongo::Collection::View.new(collection, selector, options)
-      end
-
-      let(:view_with_read_pref) do
-        view.read(:mode => :secondary, :tag_sets => [{ 'non' => 'existent' }])
-      end
-
-      let(:result) do
-        view_with_read_pref.count
-      end
-
-      it 'uses the read preference setting on the view' do
-        expect {
-          result
-        }.to raise_exception(Mongo::Error::NoServerAvailable)
-      end
-    end
-
-    context 'when the collection has a read preference set' do
-
-      let(:client) do
-        # Set a timeout in case the collection read_preference does get used.
-        # Otherwise, the test will hang for 30 seconds.
-        authorized_client.with(server_selection_timeout: 1)
-      end
-
-      let(:read_preference) do
-        { :mode => :secondary, :tag_sets => [{ 'non' => 'existent' }] }
-      end
-
-      let(:collection) do
-        client[authorized_collection.name, read: read_preference]
-      end
-
-      let(:view) do
-        Mongo::Collection::View.new(collection, selector, options)
-      end
-
-      context 'when a read preference argument is provided' do
-
-        let(:result) do
-          view.count(read: { mode: :primary })
-        end
-
-        it 'uses the read preference passed to the method' do
-          expect(result).to eq(10)
-        end
-      end
-
-      context 'when a read preference is set on the view' do
-
-        let(:view_with_read_pref) do
-          view.read(mode: :primary)
-        end
-
-        let(:result) do
-          view_with_read_pref.count
-        end
-
-        it 'uses the read preference of the view' do
-          expect(result).to eq(10)
-        end
-      end
-
-      context 'when no read preference argument is provided' do
-        require_topology :single, :replica_set
-
-        before do
-          allow(view.collection.client.cluster).to receive(:single?).and_return(false)
-        end
-
-        let(:result) do
-          view.count
-        end
-
-        it 'uses the read preference of the collection' do
-          expect {
-            result
-          }.to raise_exception(Mongo::Error::NoServerAvailable)
-        end
-      end
-
-      context 'when the collection does not have a read preference set' do
-        require_topology :single, :replica_set
-
-        let(:client) do
-          authorized_client.with(server_selection_timeout: 1)
-        end
-
-        before do
-          allow(view.collection.client.cluster).to receive(:single?).and_return(false)
-        end
-
-        let(:collection) do
-          client[authorized_collection.name]
-        end
-
-        let(:view) do
-          Mongo::Collection::View.new(collection, selector, options)
-        end
-
-        let(:result) do
-          read_preference = { :mode => :secondary, :tag_sets => [{ 'non' => 'existent' }] }
-          view.count(read: read_preference)
-        end
-
-        it 'uses the read preference passed to the method' do
-          expect {
-            result
-          }.to raise_exception(Mongo::Error::NoServerAvailable)
-        end
-      end
-
-      context 'when a read preference is set on the view' do
-
-        let(:view_with_read_pref) do
-          view.read(:mode => :primary)
-        end
-
-        let(:result) do
-          view_with_read_pref.count
-        end
-
-        it 'uses the read preference passed to the method' do
-          expect(result).to eq(10)
-        end
-      end
-    end
-
-    it 'takes a max_time_ms option' do
-      expect {
-        view.count(max_time_ms: 0.1)
-      }.to raise_error(Mongo::Error::OperationFailure)
-    end
-
-    it 'sets the max_time_ms option on the command' do
-      expect(view.count(max_time_ms: 100)).to eq(10)
-    end
-
-    context 'when a collation is specified' do
-
-      let(:selector) do
-        { name: 'BANG' }
-      end
-
-      let(:result) do
-        view.count
-      end
-
-      before do
-        authorized_collection.insert_one(name: 'bang')
-      end
-
-      let(:options) do
-        { collation: { locale: 'en_US', strength: 2 } }
-      end
-
-      context 'when the server selected supports collations' do
-        min_server_fcv '3.4'
-
-        it 'applies the collation to the count' do
-          expect(result).to eq(1)
-        end
-      end
-
-      context 'when the server selected does not support collations' do
-        max_server_version '3.2'
-
-        it 'raises an exception' do
-          expect {
-            result
-          }.to raise_exception(Mongo::Error::UnsupportedCollation)
-        end
-
-        context 'when a String key is used' do
-
-          let(:options) do
-            { 'collation' => { locale: 'en_US', strength: 2 } }
-          end
-
-          it 'raises an exception' do
-            expect {
-              result
-            }.to raise_exception(Mongo::Error::UnsupportedCollation)
-          end
-        end
-      end
-    end
-
-    context 'when a collation is specified in the method options' do
-
-      let(:selector) do
-        { name: 'BANG' }
-      end
-
-      let(:result) do
-        view.count(count_options)
-      end
-
-      before do
-        authorized_collection.insert_one(name: 'bang')
-      end
-
-      let(:count_options) do
-        { collation: { locale: 'en_US', strength: 2 } }
-      end
-
-      context 'when the server selected supports collations' do
-        min_server_fcv '3.4'
-
-        it 'applies the collation to the count' do
-          expect(result).to eq(1)
-        end
-      end
-
-      context 'when the server selected does not support collations' do
-        max_server_version '3.2'
-
-        it 'raises an exception' do
-          expect {
-            result
-          }.to raise_exception(Mongo::Error::UnsupportedCollation)
-        end
-
-        context 'when a String key is used' do
-
-          let(:count_options) do
-            { 'collation' => { locale: 'en_US', strength: 2 } }
-          end
-
-          it 'raises an exception' do
-            expect {
-              result
-            }.to raise_exception(Mongo::Error::UnsupportedCollation)
-          end
-        end
-      end
-    end
-
-    context "when using methods to set count options" do
-      let(:obj_path) { [:selector, opt] }
-
-      shared_examples "a count option" do
-
-        context "when the broken_view_options flag is off" do
-          config_override :broken_view_options, false
-
-          it "sets the option correctly" do
-            expect(Mongo::Operation::Count).to receive(:new).once.and_wrap_original do |m, *args|
-              opts = args.first.slice(*args.first.keys - [:session])
-              expect(opts.dig(*obj_path)).to eq(param)
-              m.call(*args)
-            end
-            view.send(opt, param).count(options)
-          end
-        end
-
-        context "when the broken_view_options flag is on" do
-          config_override :broken_view_options, true
-
-          it "doesn't set the option correctly" do
-            expect(Mongo::Operation::Count).to receive(:new).once.and_wrap_original do |m, *args|
-              opts = args.first.slice(*args.first.keys - [:session])
-              expect(opts.dig(*obj_path)).to be_nil
-              m.call(*args)
-            end
-            view.send(opt, param).count(options)
-          end
-        end
-      end
-
-      context "when a :hint is given" do
-        let(:opt) { :hint }
-        let(:param) { "_id_" }
-
-        it_behaves_like "a count option"
-      end
-
-      context "when a :max_time_ms is given" do
-        let(:opt) { :max_time_ms }
-        let(:param) { 5000 }
-        let(:obj_path) { [:selector, :maxTimeMS] }
-
-        it_behaves_like "a count option"
-      end
-
-      context "when a :comment is given" do
-        let(:opt) { :comment }
-        let(:param) { "comment" }
-        let(:obj_path) { opt }
-
-        it_behaves_like "a count option"
-      end
-
-      context "when a :limit is given" do
-        let(:opt) { :limit }
-        let(:param) { 1 }
-
-        it_behaves_like "a count option"
-      end
-
-      context "when a :skip is given" do
-        let(:opt) { :skip }
-        let(:param) { 1 }
-
-        it_behaves_like "a count option"
-      end
-
-      context "when a :session is given on the view" do
-
-        let(:opt) { :session }
-        let(:param) { authorized_client.start_session }
-        let(:aggregate) do
-          authorized_collection.find({}, session: param).aggregate(pipeline, options)
-        end
-
-        after do
-          param.end_session
-        end
-
-        with_config_values :broken_view_options, true, false do
-          it "sets the option correctly" do
-            expect(Mongo::Operation::Count).to receive(:new).once.and_wrap_original do |m, *args|
-              expect(args.first[opt]).to eq(param)
-              m.call(*args)
-            end
-            authorized_collection.find({}, session: param).count(options)
-          end
-        end
-      end
-
-      context "when also including in options" do
-
-        with_config_values :broken_view_options, true, false do
-          it "gives options higher precedence" do
-            expect(Mongo::Operation::Count).to receive(:new).once.and_wrap_original do |m, *args|
-              opts = args.first.slice(:selector)
-              expect(opts.dig(:selector, :limit)).to eq(2)
-              m.call(*args)
-            end
-            view.limit(1).count({ limit: 2 })
-          end
-        end
-      end
-    end
-  end
-
-  describe "#estimated_document_count" do
-
-    let(:result) do
-      view.estimated_document_count(options)
-    end
-
-    context 'when limit is set' do
-      it 'raises an error' do
-        expect {
-          view.limit(5).estimated_document_count(options)
-        }.to raise_error(ArgumentError, "Cannot call estimated_document_count when querying with limit")
-      end
-    end
-
-    context 'when skip is set' do
-      it 'raises an error' do
-        expect {
-          view.skip(5).estimated_document_count(options)
-        }.to raise_error(ArgumentError, "Cannot call estimated_document_count when querying with skip")
-      end
-    end
-
-    context 'when limit passed as an option' do
-      it 'raises an error' do
-        expect {
-          view.estimated_document_count(options.merge(limit: 5))
-        }.to raise_error(ArgumentError, "Cannot call estimated_document_count when querying with limit")
-      end
-    end
-
-    context 'when skip passed as an option' do
-      it 'raises an error' do
-        expect {
-          view.estimated_document_count(options.merge(skip: 5))
-        }.to raise_error(ArgumentError, "Cannot call estimated_document_count when querying with skip")
-      end
-    end
-
-    context 'when collection has documents' do
-      let(:documents) do
-        (1..10).map{ |i| { field: "test#{i}" }}
-      end
-
-      before do
-        authorized_collection.delete_many
-        authorized_collection.insert_many(documents)
-      end
-
-      context 'when a selector is provided' do
-
-        let(:selector) do
-          { field: 'test1' }
-        end
-
-        it 'raises an error' do
-          expect {
-            result
-          }.to raise_error(ArgumentError, "Cannot call estimated_document_count when querying with a filter")
-        end
-      end
-
-      context 'when no selector is provided' do
-
-        it 'returns the estimated count of matching documents' do
-          expect(view.estimated_document_count).to eq(10)
-        end
-      end
-    end
-
-    context 'when collection does not exist' do
-
-      let(:view) do
-        Mongo::Collection::View.new(
-          authorized_client['nonexistent-collection-for-estimated-document-count'], selector, options)
-      end
-
-      it 'returns 0' do
-        view.estimated_document_count.should == 0
-      end
-    end
-
-    context "when using methods to set options" do
-
-      context "when the broken_view_options flag is on" do
-        config_override :broken_view_options, true
-
-        context "when a :max_time_ms is given" do
-          let(:opt) { :max_time_ms }
-          let(:param) { 5000 }
-
-          it "doesn't set the option correctly" do
-            expect(Mongo::Operation::Count).to receive(:new).once.and_wrap_original do |m, *args|
-              opts = args.first.slice(*args.first.keys - [:session])
-              expect(opts.dig(:selector, :maxTimeMS)).to be_nil
-              m.call(*args)
-            end
-            view.send(opt, param).estimated_document_count(options)
-          end
-        end
-
-        context "when a :comment is given" do
-          let(:opt) { :comment }
-          let(:param) { "comment" }
-          let(:obj_path) { opt }
-
-          it "doesn't set the option correctly" do
-            expect(Mongo::Operation::Count).to receive(:new).once.and_wrap_original do |m, *args|
-              opts = args.first.slice(*args.first.keys - [:session])
-              expect(opts[opt]).to be_nil
-              m.call(*args)
-            end
-            view.send(opt, param).estimated_document_count(options)
-          end
-        end
-      end
-
-      context "when the broken_view_options flag is off" do
-        config_override :broken_view_options, false
-
-        context "when a :max_time_ms is given" do
-          let(:opt) { :max_time_ms }
-          let(:param) { 5000 }
-
-          it "sets the option correctly" do
-            expect(Mongo::Operation::Count).to receive(:new).once.and_wrap_original do |m, *args|
-              opts = args.first.slice(*args.first.keys - [:session])
-              expect(opts.dig(:selector, :maxTimeMS)).to eq(param)
-              m.call(*args)
-            end
-            view.send(opt, param).estimated_document_count(options)
-          end
-        end
-
-        context "when a :comment is given" do
-          let(:opt) { :comment }
-          let(:param) { "comment" }
-          let(:obj_path) { opt }
-
-          it "sets the option correctly" do
-            expect(Mongo::Operation::Count).to receive(:new).once.and_wrap_original do |m, *args|
-              opts = args.first.slice(*args.first.keys - [:session])
-              expect(opts[opt]).to eq(param)
-              m.call(*args)
-            end
-            view.send(opt, param).estimated_document_count(options)
-          end
-        end
-
-        context "when a :session is given on the view" do
-          let(:opt) { :session }
-          let(:param) { authorized_client.start_session }
-
-          after do
-            param.end_session
-          end
-
-          with_config_values :broken_view_options, true, false do
-            it "sets the option correctly" do
-              expect(Mongo::Operation::Count).to receive(:new).once.and_wrap_original do |m, *args|
-                expect(args.first[opt]).to eq(param)
-                m.call(*args)
-              end
-              authorized_collection.find({}, session: param).estimated_document_count(options)
-            end
-          end
-        end
-
-        context "when also including in options" do
-
-          with_config_values :broken_view_options, true, false do
-            it "gives options higher precedence" do
-              expect(Mongo::Operation::Count).to receive(:new).once.and_wrap_original do |m, *args|
-                opts = args.first.slice(:selector)
-                expect(opts.dig(:selector, :maxTimeMS)).to eq(2000)
-                m.call(*args)
-              end
-              view.max_time_ms(1500).estimated_document_count({ max_time_ms: 2000 })
-            end
-          end
-        end
-      end
-    end
-  end
-
-  describe '#count_documents' do
-
-    context 'when session is given' do
-      min_server_fcv '3.6'
-
-      let(:subscriber) { Mrss::EventSubscriber.new }
-
-      before do
-        authorized_collection.client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
-      end
-
-      let(:connection) do
-        double('connection').tap do |connection|
-          allow(connection).to receive_message_chain(:server, :cluster).and_return(authorized_client.cluster)
-        end
-      end
-
-      it 'passes the session' do
-        authorized_collection.client.with_session do |session|
-          session.materialize_if_needed
-          session_id = session.session_id
-
-          authorized_collection.count_documents({}, session: session)
-
-          event = subscriber.single_command_started_event('aggregate')
-          event.command['lsid'].should == session_id
-        end
-      end
-    end
-
-    context "when using methods to set count options" do
-      shared_examples "a count option" do
-        context "when the broken_view_options flag is on" do
-          config_override :broken_view_options, true
-
-          it "doesn't set the option correctly" do
-            expect_any_instance_of(Mongo::Collection::View).to receive(:aggregate).once.and_wrap_original do |m, *args|
-              opts = args[1]
-              expect(opts[opt]).to be_nil
-              m.call(*args)
-            end
-            view.send(opt, param).count_documents(options)
-          end
-        end
-
-        context "when the broken_view_options flag is off" do
-          config_override :broken_view_options, false
-
-          it "sets the option correctly" do
-            expect_any_instance_of(Mongo::Collection::View).to receive(:aggregate).once.and_wrap_original do |m, *args|
-              opts = args[1]
-              expect(opts[opt]).to eq(param)
-              m.call(*args)
-            end
-            view.send(opt, param).count_documents(options)
-          end
-        end
-      end
-
-      context "when a :hint is given" do
-        let(:opt) { :hint }
-        let(:param) { "_id_" }
-
-        it_behaves_like "a count option"
-      end
-
-      context "when a :max_time_ms is given" do
-        let(:opt) { :max_time_ms }
-        let(:param) { 5000 }
-
-        it_behaves_like "a count option"
-      end
-
-      context "when a :comment is given" do
-        let(:opt) { :comment }
-        let(:param) { "comment" }
-
-        it_behaves_like "a count option"
-      end
-
-      context "when a :limit is given" do
-        context "when the broken_view_options flag is false" do
-          config_override :broken_view_options, false
-
-          it "sets the option correctly" do
-            expect_any_instance_of(Mongo::Collection::View).to receive(:aggregate).once.and_wrap_original do |m, *args|
-              pipeline, opts = args
-              expect(pipeline[1][:'$limit']).to eq(1)
-              m.call(*args)
-            end
-            view.limit(1).count_documents(options)
-          end
-        end
-
-        context "when the broken_view_options flag is on" do
-          config_override :broken_view_options, true
-
-          it "doesn't set the option correctly" do
-            expect_any_instance_of(Mongo::Collection::View).to receive(:aggregate).once.and_wrap_original do |m, *args|
-              pipeline, opts = args
-              expect(pipeline[1][:'$limit']).to be_nil
-              m.call(*args)
-            end
-            view.limit(1).count_documents(options)
-          end
-        end
-      end
-
-      context "when a :skip is given" do
-        context "when the broken_view_options flag is on" do
-          config_override :broken_view_options, true
-
-          it "doesn't set the option correctly" do
-            expect_any_instance_of(Mongo::Collection::View).to receive(:aggregate).once.and_wrap_original do |m, *args|
-              pipeline, opts = args
-              expect(pipeline[1][:'$skip']).to be_nil
-              m.call(*args)
-            end
-            view.skip(1).count_documents(options)
-          end
-        end
-
-        context "when the broken_view_options flag is off" do
-          config_override :broken_view_options, false
-
-          it "sets the option correctly" do
-            expect_any_instance_of(Mongo::Collection::View).to receive(:aggregate).once.and_wrap_original do |m, *args|
-              pipeline, opts = args
-              expect(pipeline[1][:'$skip']).to eq(1)
-              m.call(*args)
-            end
-            view.skip(1).count_documents(options)
-          end
-        end
-      end
-
-      context "when a :session is given on the view" do
-        let(:opt) { :session }
-        let(:param) { authorized_client.start_session }
-
-        after do
-          param.end_session
-        end
-
-        context "when broken_view_options is false" do
-          config_override :broken_view_options, false
-          it "sets the option correctly" do
-            expect_any_instance_of(Mongo::Collection::View).to receive(:aggregate).once.and_wrap_original do |m, *args|
-              expect(args[1][opt]).to eq(param)
-              m.call(*args)
-            end
-            authorized_collection.find({}, session: param).count_documents(options)
-          end
-        end
-
-        context "when broken_view_options is true" do
-          config_override :broken_view_options, true
-          it "does not set the option" do
-            expect_any_instance_of(Mongo::Collection::View).to receive(:aggregate).once.and_wrap_original do |m, *args|
-              expect(args[1][opt]).to be nil
-              m.call(*args)
-            end
-            authorized_collection.find({}, session: param).count_documents(options)
-          end
-        end
-      end
-
-      context "when also including in options" do
-
-        with_config_values :broken_view_options, true, false do
-          it "gives options higher precedence" do
-            expect_any_instance_of(Mongo::Collection::View).to receive(:aggregate).once.and_wrap_original do |m, *args|
-              pipeline, opts = args
-              expect(pipeline[1][:'$limit']).to eq(2)
-              m.call(*args)
-            end
-            view.limit(1).count_documents({ limit: 2 })
-          end
-        end
-      end
-    end
-  end
-
-  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
-        { field: 'test' }
-      end
-
-      let(:documents) do
-        (1..3).map{ |i| { field: "test" }}
-      end
-
-      before do
-        authorized_collection.insert_many(documents)
-      end
-
-      context 'when the field is a symbol' do
-
-        let(:distinct) do
-          view.distinct(:field)
-        end
-
-        it 'returns the distinct values' do
-          expect(distinct).to eq([ 'test' ])
-        end
-      end
-
-      context 'when the field is a string' do
-
-        let(:distinct) do
-          view.distinct('field')
-        end
-
-        it 'returns the distinct values' do
-          expect(distinct).to eq([ 'test' ])
-        end
-      end
-
-      context 'when the field is nil' do
-
-        let(:distinct) do
-          view.distinct(nil)
-        end
-
-        it 'raises ArgumentError' do
-          expect do
-            distinct
-          end.to raise_error(ArgumentError, 'Field name for distinct operation must be not nil')
-        end
-      end
-
-      context 'when the field does not exist' do
-
-        let(:distinct) do
-          view.distinct(:doesnotexist)
-        end
-
-        it 'returns an empty array' do
-          expect(distinct).to be_empty
-        end
-      end
-    end
-
-    context 'when no selector is provided' do
-
-      let(:documents) do
-        (1..3).map{ |i| { field: "test#{i}" }}
-      end
-
-      before do
-        authorized_collection.insert_many(documents)
-      end
-
-      context 'when the field is a symbol' do
-
-        let(:distinct) do
-          view.distinct(:field)
-        end
-
-        it 'returns the distinct values' do
-          expect(distinct.sort).to eq([ 'test1', 'test2', 'test3' ])
-        end
-      end
-
-      context 'when the field is a string' do
-
-        let(:distinct) do
-          view.distinct('field')
-        end
-
-        it 'returns the distinct values' do
-          expect(distinct.sort).to eq([ 'test1', 'test2', 'test3' ])
-        end
-      end
-
-      context 'when the field is nil' do
-
-        let(:distinct) do
-          view.distinct(nil)
-        end
-
-        it 'raises ArgumentError' do
-          expect do
-            distinct
-          end.to raise_error(ArgumentError, 'Field name for distinct operation must be not nil')
-        end
-      end
-    end
-
-    context 'when a read preference is set on the view' do
-      require_topology :single, :replica_set
-
-      let(:client) do
-        # Set a timeout otherwise, the test will hang for 30 seconds.
-        authorized_client.with(server_selection_timeout: 1)
-      end
-
-      let(:collection) do
-        client[authorized_collection.name]
-      end
-
-      before do
-        allow(client.cluster).to receive(:single?).and_return(false)
-      end
-
-      let(:view) do
-        Mongo::Collection::View.new(collection, selector, options)
-      end
-
-      let(:view_with_read_pref) do
-        view.read(:mode => :secondary, :tag_sets => [{ 'non' => 'existent' }])
-      end
-
-      let(:result) do
-        view_with_read_pref.distinct(:field)
-      end
-
-      it 'uses the read preference setting on the view' do
-        expect {
-          result
-        }.to raise_exception(Mongo::Error::NoServerAvailable)
-      end
-    end
-
-    context 'when the collection has a read preference set' do
-
-      let(:documents) do
-        (1..3).map{ |i| { field: "test#{i}" }}
-      end
-
-      before do
-        authorized_collection.insert_many(documents)
-      end
-
-      let(:client) do
-        # Set a timeout in case the collection read_preference does get used.
-        # Otherwise, the test will hang for 30 seconds.
-        authorized_client.with(server_selection_timeout: 1)
-      end
-
-      let(:read_preference) do
-        { :mode => :secondary, :tag_sets => [{ 'non' => 'existent' }] }
-      end
-
-      let(:collection) do
-        client[authorized_collection.name, read: read_preference]
-      end
-
-      let(:view) do
-        Mongo::Collection::View.new(collection, selector, options)
-      end
-
-      context 'when a read preference argument is provided' do
-
-        let(:distinct) do
-          view.distinct(:field, read: { mode: :primary })
-        end
-
-        it 'uses the read preference passed to the method' do
-          expect(distinct.sort).to eq([ 'test1', 'test2', 'test3' ])
-        end
-      end
-
-      context 'when no read preference argument is provided' do
-        require_topology :single, :replica_set
-
-        before do
-          allow(view.collection.client.cluster).to receive(:single?).and_return(false)
-        end
-
-        let(:distinct) do
-          view.distinct(:field)
-        end
-
-        it 'uses the read preference of the collection' do
-          expect {
-            distinct
-          }.to raise_exception(Mongo::Error::NoServerAvailable)
-        end
-      end
-
-      context 'when the collection does not have a read preference set' do
-        require_topology :single, :replica_set
-
-        let(:documents) do
-          (1..3).map{ |i| { field: "test#{i}" }}
-        end
-
-        before do
-          authorized_collection.insert_many(documents)
-          allow(view.collection.client.cluster).to receive(:single?).and_return(false)
-        end
-
-        let(:client) do
-          authorized_client.with(server_selection_timeout: 1)
-        end
-
-        let(:collection) do
-          client[authorized_collection.name]
-        end
-
-        let(:view) do
-          Mongo::Collection::View.new(collection, selector, options)
-        end
-
-        let(:distinct) do
-          read_preference = { :mode => :secondary, :tag_sets => [{ 'non' => 'existent' }] }
-          view.distinct(:field, read: read_preference)
-        end
-
-        it 'uses the read preference passed to the method' do
-          expect {
-            distinct
-          }.to raise_exception(Mongo::Error::NoServerAvailable)
-        end
-      end
-
-      context 'when a read preference is set on the view' do
-
-        let(:view_with_read_pref) do
-          view.read(:mode => :secondary, :tag_sets => [{ 'non' => 'existent' }])
-        end
-
-        let(:distinct) do
-          view_with_read_pref.distinct(:field, read: { mode: :primary })
-        end
-
-        it 'uses the read preference passed to the method' do
-          expect(distinct.sort).to eq([ 'test1', 'test2', 'test3' ])
-        end
-      end
-    end
-
-    context 'when a max_time_ms is specified' do
-
-      let(:documents) do
-        (1..3).map{ |i| { field: "test" }}
-      end
-
-      before do
-        authorized_collection.insert_many(documents)
-      end
-
-      it 'sets the max_time_ms option on the command' do
-        expect {
-          view.distinct(:field, max_time_ms: 0.1)
-        }.to raise_error(Mongo::Error::OperationFailure)
-      end
-
-      it 'sets the max_time_ms option on the command' do
-        expect(view.distinct(:field, max_time_ms: 100)).to eq([ 'test' ])
-      end
-    end
-
-    context 'when the field does not exist' do
-
-      it 'returns an empty array' do
-        expect(view.distinct(:nofieldexists)).to be_empty
-      end
-    end
-
-    context 'when a collation is specified on the view' do
-
-      let(:result) do
-        view.distinct(:name)
-      end
-
-      before do
-        authorized_collection.insert_one(name: 'bang')
-        authorized_collection.insert_one(name: 'BANG')
-      end
-
-      let(:options) do
-        { collation: { locale: 'en_US', strength: 2 } }
-      end
-
-      context 'when the server selected supports collations' do
-        min_server_fcv '3.4'
-
-        it 'applies the collation to the distinct' do
-          expect(result).to eq(['bang'])
-        end
-      end
-
-      context 'when the server selected does not support collations' do
-        max_server_version '3.2'
-
-        it 'raises an exception' do
-          expect {
-            result
-          }.to raise_exception(Mongo::Error::UnsupportedCollation)
-        end
-
-        context 'when a String key is used' do
-
-          let(:options) do
-            { 'collation' => { locale: 'en_US', strength: 2 } }
-          end
-
-          it 'raises an exception' do
-            expect {
-              result
-            }.to raise_exception(Mongo::Error::UnsupportedCollation)
-          end
-        end
-      end
-    end
-
-    context 'when a collation is specified in the method options' do
-
-      let(:result) do
-        view.distinct(:name, distinct_options)
-      end
-
-      before do
-        authorized_collection.insert_one(name: 'bang')
-        authorized_collection.insert_one(name: 'BANG')
-      end
-
-      let(:distinct_options) do
-        { collation: { locale: 'en_US', strength: 2 } }
-      end
-
-      context 'when the server selected supports collations' do
-        min_server_fcv '3.4'
-
-        it 'applies the collation to the distinct' do
-          expect(result).to eq(['bang'])
-        end
-      end
-
-      context 'when the server selected does not support collations' do
-        max_server_version '3.2'
-
-        it 'raises an exception' do
-          expect {
-            result
-          }.to raise_exception(Mongo::Error::UnsupportedCollation)
-        end
-
-        context 'when a String key is used' do
-
-          let(:distinct_options) do
-            { 'collation' => { locale: 'en_US', strength: 2 } }
-          end
-
-          it 'raises an exception' do
-            expect {
-              result
-            }.to raise_exception(Mongo::Error::UnsupportedCollation)
-          end
-        end
-      end
-    end
-
-    context 'when a collation is not specified' do
-
-      let(:result) do
-        view.distinct(:name)
-      end
-
-      before do
-        authorized_collection.insert_one(name: 'bang')
-        authorized_collection.insert_one(name: 'BANG')
-      end
-
-      it 'does not apply the collation to the distinct' do
-        expect(result).to match_array(['bang', 'BANG'])
-      end
-    end
-
-    context "when using methods to set options" do
-
-      context "when a :max_time_ms is given" do
-        let(:opt) { :max_time_ms }
-        let(:param) { 5000 }
-
-        context "when the broken_view_options flag is on" do
-          config_override :broken_view_options, true
-
-          it "doesn't set the option correctly" do
-            expect(Mongo::Operation::Distinct).to receive(:new).once.and_wrap_original do |m, *args|
-              opts = args.first.slice(*args.first.keys - [:session])
-              expect(opts.dig(:selector, :maxTimeMS)).to be_nil
-              m.call(*args)
-            end
-            view.send(opt, param).distinct(:name, options)
-          end
-        end
-
-        context "when the broken_view_options flag is off" do
-          config_override :broken_view_options, false
-
-          it "sets the option correctly" do
-            expect(Mongo::Operation::Distinct).to receive(:new).once.and_wrap_original do |m, *args|
-              opts = args.first.slice(*args.first.keys - [:session])
-              expect(opts.dig(:selector, :maxTimeMS)).to eq(param)
-              m.call(*args)
-            end
-            view.send(opt, param).distinct(:name, options)
-          end
-        end
-      end
-
-      context "when a :comment is given" do
-        let(:opt) { :comment }
-        let(:param) { "comment" }
-        let(:obj_path) { opt }
-
-        context "when the broken_view_options flag is on" do
-          config_override :broken_view_options, true
-
-          it "doesn't set the option correctly" do
-            expect(Mongo::Operation::Distinct).to receive(:new).once.and_wrap_original do |m, *args|
-              opts = args.first.slice(*args.first.keys - [:session])
-              expect(opts[opt]).to be_nil
-              m.call(*args)
-            end
-            view.send(opt, param).distinct(:name, options)
-          end
-        end
-
-        context "when the broken_view_options flag is off" do
-          config_override :broken_view_options, false
-
-          it "sets the option correctly" do
-            expect(Mongo::Operation::Distinct).to receive(:new).once.and_wrap_original do |m, *args|
-              opts = args.first.slice(*args.first.keys - [:session])
-              expect(opts[opt]).to eq(param)
-              m.call(*args)
-            end
-            view.send(opt, param).distinct(:name, options)
-          end
-        end
-      end
-
-      context "when a :session is given on the view" do
-        let(:opt) { :session }
-        let(:param) { authorized_client.start_session }
-
-        after do
-          param.end_session
-        end
-
-        with_config_values :broken_view_options, true, false do
-          it "sets the option correctly" do
-            expect(Mongo::Operation::Distinct).to receive(:new).once.and_wrap_original do |m, *args|
-              expect(args.first[opt]).to eq(param)
-              m.call(*args)
-            end
-            authorized_collection.find({}, session: param).distinct(options)
-          end
-        end
-      end
-
-      context "when also including in options" do
-
-        with_config_values :broken_view_options, true, false do
-          it "gives options higher precedence" do
-            expect(Mongo::Operation::Distinct).to receive(:new).once.and_wrap_original do |m, *args|
-              opts = args.first.slice(:selector)
-              expect(opts.dig(:selector, :maxTimeMS)).to eq(2000)
-              m.call(*args)
-            end
-            view.max_time_ms(1500).distinct(:name, { max_time_ms: 2000 })
-          end
-        end
-      end
-    end
-  end
-
-  describe '#hint' do
-
-    context 'when a hint is specified' do
-
-      let(:options) do
-        { :hint => { 'x' => Mongo::Index::ASCENDING } }
-      end
-
-      let(:new_hint) do
-        { 'x' => Mongo::Index::DESCENDING }
-      end
-
-      it 'sets the hint' do
-        new_view = view.hint(new_hint)
-        expect(new_view.hint).to eq(new_hint)
-      end
-
-      it 'returns a new View' do
-        expect(view.hint(new_hint)).not_to be(view)
-      end
-    end
-
-    context 'when a hint is not specified' do
-
-      let(:options) do
-        { :hint => 'x' }
-      end
-
-      it 'returns the hint' do
-        expect(view.hint).to eq(options[:hint])
-      end
-    end
-  end
-
-  describe '#limit' do
-
-    context 'when a limit is specified' do
-
-      let(:options) do
-        { :limit => 5 }
-      end
-
-      let(:new_limit) do
-        10
-      end
-
-      it 'sets the limit' do
-        new_view = view.limit(new_limit)
-        expect(new_view.limit).to eq(new_limit)
-      end
-
-      it 'returns a new View' do
-        expect(view.limit(new_limit)).not_to be(view)
-      end
-    end
-
-    context 'when a limit is not specified' do
-
-      let(:options) do
-        { :limit => 5 }
-      end
-
-      it 'returns the limit' do
-        expect(view.limit).to eq(options[:limit])
-      end
-    end
-  end
-
-  describe '#max_scan' do
-
-    let(:new_view) do
-      view.max_scan(10)
-    end
-
-    it 'sets the value in the options' do
-      expect(new_view.max_scan).to eq(10)
-    end
-  end
-
-  describe '#max_value' do
-
-    let(:new_view) do
-      view.max_value(_id: 1)
-    end
-
-    it 'sets the value in the options' do
-      expect(new_view.max_value).to eq('_id' => 1)
-    end
-  end
-
-  describe '#min_value' do
-
-    let(:new_view) do
-      view.min_value(_id: 1)
-    end
-
-    it 'sets the value in the options' do
-      expect(new_view.min_value).to eq('_id' => 1)
-    end
-  end
-
-  describe '#no_cursor_timeout' do
-
-    let(:new_view) do
-      view.no_cursor_timeout
-    end
-
-    it 'sets the flag' do
-      expect(new_view.options[:no_cursor_timeout]).to be true
-    end
-
-    it 'returns a new View' do
-      expect(new_view).not_to be(view)
-    end
-
-    context 'when sending to server' do
-      let(:subscriber) { Mrss::EventSubscriber.new }
-
-      before do
-        authorized_collection.client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
-      end
-
-      let(:event) do
-        subscriber.single_command_started_event('find')
-      end
-
-      it 'is sent to server' do
-        new_view.to_a
-        event.command.slice('noCursorTimeout').should == {'noCursorTimeout' => true}
-      end
-    end
-
-    context 'integration test' do
-      require_topology :single
-
-      # The number of open cursors with the option set to prevent timeout.
-      def current_no_timeout_count
-        root_authorized_client
-          .command(serverStatus: 1)
-          .documents
-          .first
-          .fetch('metrics')
-          .fetch('cursor')
-          .fetch('open')
-          .fetch('noTimeout')
-      end
-
-      it 'is applied on the server' do
-        # Initialize collection with two documents.
-        new_view.collection.insert_many([{}, {}])
-
-        expect(new_view.count).to be == 2
-
-        # Initial "noTimeout" count should be zero.
-        states = [current_no_timeout_count]
-
-        # The "noTimeout" count should be one while iterating.
-        new_view.batch_size(1).each { states << current_no_timeout_count }
-
-        # Final "noTimeout" count should be back to zero.
-        states << current_no_timeout_count
-
-        # This succeeds on:
-        #   commit aab776ebdfb15ddb9765039f7300e15796de0c5c
-        #
-        # This starts failing with [0, 0, 0, 0] from:
-        #   commit 2d9f0217ec904a1952a1ada2136502eefbca562e
-        expect(states).to be == [0, 1, 1, 0]
-      end
-    end
-  end
-
-  describe '#projection' do
-
-    let(:options) do
-      { :projection => { 'x' => 1 } }
-    end
-
-    context 'when projection are specified' do
-
-      let(:new_projection) 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)
-      end
-
-      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
-
-      it 'returns the projection' do
-        expect(view.projection).to eq(options[:projection])
-      end
-    end
-
-    context 'when projection is not a document' do
-
-      let(:new_projection) do
-        'y'
-      end
-
-      it 'raises an error' do
-        expect do
-          view.projection(new_projection)
-        end.to raise_error(Mongo::Error::InvalidDocument)
-      end
-    end
-  end
-
-  describe '#read' do
-
-    context 'when a read pref is specified' do
-
-      let(:options) do
-        { :read => { :mode => :secondary } }
-      end
-
-      let(:new_read) do
-        { :mode => :secondary_preferred }
-      end
-
-      it 'sets the read preference' do
-        new_view = view.read(new_read)
-        expect(new_view.read).to eq(BSON::Document.new(new_read))
-      end
-
-      it 'returns a new View' do
-        expect(view.read(new_read)).not_to be(view)
-      end
-    end
-
-    context 'when a read pref is not specified' do
-
-      let(:options) do
-        { :read =>  {:mode => :secondary} }
-      end
-
-      it 'returns the read preference' do
-        expect(view.read).to eq(BSON::Document.new(options[:read]))
-      end
-
-      context 'when no read pref is set on initialization' do
-
-        let(:options) do
-          {}
-        end
-
-        it 'returns the collection read preference' do
-          expect(view.read).to eq(authorized_collection.read_preference)
-        end
-      end
-    end
-  end
-
-  describe '#show_disk_loc' do
-
-    let(:options) do
-      { :show_disk_loc => true }
-    end
-
-    context 'when show_disk_loc is specified' do
-
-      let(:new_show_disk_loc) do
-        false
-      end
-
-      it 'sets the show_disk_loc value' do
-        new_view = view.show_disk_loc(new_show_disk_loc)
-        expect(new_view.show_disk_loc).to eq(new_show_disk_loc)
-      end
-
-      it 'returns a new View' do
-        expect(view.show_disk_loc(new_show_disk_loc)).not_to be(view)
-      end
-    end
-
-    context 'when show_disk_loc is not specified' do
-
-      it 'returns the show_disk_loc value' do
-        expect(view.show_disk_loc).to eq(options[:show_disk_loc])
-      end
-    end
-  end
-
-  describe '#modifiers' do
-
-    let(:options) do
-      { :modifiers => { '$orderby' => 1 } }
-    end
-
-    context 'when a modifiers document is specified' do
-
-      let(:new_modifiers) do
-        { '$orderby' => -1 }
-      end
-
-      it 'sets the new_modifiers document' do
-        new_view = view.modifiers(new_modifiers)
-        expect(new_view.modifiers).to eq(new_modifiers)
-      end
-
-      it 'returns a new View' do
-        expect(view.modifiers(new_modifiers)).not_to be(view)
-      end
-    end
-
-    context 'when a modifiers document is not specified' do
-
-      it 'returns the modifiers value' do
-        expect(view.modifiers).to eq(options[:modifiers])
-      end
-    end
-  end
-
-  describe '#max_time_ms' do
-
-    let(:options) do
-      { :max_time_ms => 200 }
-    end
-
-    context 'when max_time_ms is specified' do
-
-      let(:new_max_time_ms) do
-        300
-      end
-
-      it 'sets the max_time_ms value' do
-        new_view = view.max_time_ms(new_max_time_ms)
-        expect(new_view.max_time_ms).to eq(new_max_time_ms)
-      end
-
-      it 'returns a new View' do
-        expect(view.max_time_ms(new_max_time_ms)).not_to be(view)
-      end
-    end
-
-    context 'when max_time_ms is not specified' do
-
-      it 'returns the max_time_ms value' do
-        expect(view.max_time_ms).to eq(options[:max_time_ms])
-      end
-    end
-  end
-
-  describe '#cusor_type' do
-
-    let(:options) do
-      { :cursor_type => :tailable }
-    end
-
-    context 'when cursor_type is specified' do
-
-      let(:new_cursor_type) do
-        :tailable_await
-      end
-
-      it 'sets the cursor_type value' do
-        new_view = view.cursor_type(new_cursor_type)
-        expect(new_view.cursor_type).to eq(new_cursor_type)
-      end
-
-      it 'returns a new View' do
-        expect(view.cursor_type(new_cursor_type)).not_to be(view)
-      end
-    end
-
-    context 'when cursor_type is not specified' do
-
-      it 'returns the cursor_type value' do
-        expect(view.cursor_type).to eq(options[:cursor_type])
-      end
-    end
-  end
-
-  describe '#skip' do
-
-    context 'when a skip is specified' do
-
-      let(:options) do
-        { :skip => 5 }
-      end
-
-      let(:new_skip) do
-        10
-      end
-
-      it 'sets the skip value' do
-        new_view = view.skip(new_skip)
-        expect(new_view.skip).to eq(new_skip)
-      end
-
-      it 'returns a new View' do
-        expect(view.skip(new_skip)).not_to be(view)
-      end
-    end
-
-    context 'when a skip is not specified' do
-
-      let(:options) do
-        { :skip => 5 }
-      end
-
-      it 'returns the skip value' do
-        expect(view.skip).to eq(options[:skip])
-      end
-    end
-  end
-
-  describe '#snapshot' do
-
-    let(:new_view) do
-      view.snapshot(true)
-    end
-
-    it 'sets the value in the options' do
-      expect(new_view.snapshot).to be true
-    end
-  end
-
-  describe '#sort' do
-
-    context 'when a sort is specified' do
-
-      let(:options) do
-        { :sort => { 'x' => Mongo::Index::ASCENDING }}
-      end
-
-      let(:new_sort) do
-        { 'x' => Mongo::Index::DESCENDING }
-      end
-
-      it 'sets the sort option' do
-        new_view = view.sort(new_sort)
-        expect(new_view.sort).to eq(new_sort)
-      end
-
-      it 'returns a new View' do
-        expect(view.sort(new_sort)).not_to be(view)
-      end
-    end
-
-    context 'when a sort is not specified' do
-
-      let(:options) do
-        { :sort => { 'x' => Mongo::Index::ASCENDING }}
-      end
-
-      it 'returns the sort' do
-        expect(view.sort).to eq(options[:sort])
-      end
-    end
-  end
-end