mongo 2.17.4 → 2.21.0

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

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require 'spec_helper'
 
@@ -87,7 +87,7 @@ describe Mongo::Collection::View::Readable do
 
   describe '#aggregate' do
 
-     let(:documents) do
+    let(:documents) do
       [
         { city: "Berlin", pop: 18913, neighborhood: "Kreuzberg" },
         { city: "Berlin", pop: 84143, neighborhood: "Mitte" },
@@ -151,6 +151,187 @@ describe Mongo::Collection::View::Readable 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
@@ -230,6 +411,60 @@ describe Mongo::Collection::View::Readable do
         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
@@ -603,6 +838,113 @@ describe Mongo::Collection::View::Readable do
         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
@@ -627,6 +969,22 @@ describe Mongo::Collection::View::Readable do
       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}" }}
@@ -669,6 +1027,291 @@ describe Mongo::Collection::View::Readable 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
@@ -1070,6 +1713,105 @@ describe Mongo::Collection::View::Readable 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