mongo 2.10.5 → 2.15.1

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

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Mongo::Collection::View::ChangeStream do
@@ -118,8 +121,8 @@ describe Mongo::Collection::View::ChangeStream do
 
     context 'when full_document is not provided' do
 
-      it "defaults to use the 'default' value" do
-        expect(change_stream_document[:fullDocument]).to eq('default')
+      it "does not set fullDocument" do
+        expect(change_stream_document).not_to have_key(:fullDocument)
       end
     end
 
@@ -369,10 +372,23 @@ describe Mongo::Collection::View::ChangeStream do
 
   describe '#close' do
 
+    context 'ignores any exceptions or errors' do
+      [
+        Mongo::Error::OperationFailure,
+        Mongo::Error::SocketError,
+        Mongo::Error::SocketTimeoutError
+      ].each do |err|
+        it "ignores #{err}" do
+          expect(cursor).to receive(:close).and_raise(err)
+          change_stream.close
+        end
+      end
+    end
+
     context 'when documents have not been retrieved and the stream is closed' do
 
       before do
-        expect(cursor).to receive(:kill_cursors)
+        expect(cursor).to receive(:close).and_call_original
         change_stream.close
       end
 
@@ -448,7 +464,7 @@ describe Mongo::Collection::View::ChangeStream do
       max_server_version '4.0'
 
       it 'driver raises an exception and closes the cursor' do
-        expect(cursor).to receive(:kill_cursors).and_call_original
+        expect(cursor).to receive(:close).and_call_original
         expect {
           change_stream.to_enum.next
         }.to raise_exception(Mongo::Error::MissingResumeToken)
@@ -459,7 +475,7 @@ describe Mongo::Collection::View::ChangeStream do
       min_server_fcv '4.2'
 
       it 'server errors, driver closes the cursor' do
-        expect(cursor).to receive(:kill_cursors).and_call_original
+        expect(cursor).to receive(:close).and_call_original
         expect {
           change_stream.to_enum.next
         }.to raise_exception(Mongo::Error::OperationFailure, /Encountered an event whose _id field, which contains the resume token, was modified by the pipeline. Modifying the _id field of an event makes it impossible to resume the stream from that point. Only transformations that retain the unmodified _id field are allowed./)
@@ -467,324 +483,6 @@ describe Mongo::Collection::View::ChangeStream do
     end
   end
 
-  context 'when an error is encountered the first time the command is run' do
-    include PrimarySocket
-
-    before do
-      expect(primary_socket).to receive(:write).and_raise(error).once
-    end
-
-    let(:document) do
-      change_stream.to_enum.next
-    end
-
-    shared_examples_for 'a resumable change stream' do
-
-      before do
-        expect(view.send(:server_selector)).to receive(:select_server).twice.and_call_original
-        change_stream
-        collection.insert_one(a: 1)
-      end
-
-      it 'runs the command again while using the same read preference and caches the resume token' do
-        expect(document[:fullDocument][:a]).to eq(1)
-        expect(change_stream_document[:resumeAfter]).to eq(document[:_id])
-      end
-
-      context 'when provided a session' do
-
-        let(:options) do
-          { session: session}
-        end
-
-        let(:session) do
-          client.start_session
-        end
-
-        before do
-          change_stream.to_enum.next
-        end
-
-        it 'does not close the session' do
-          expect(session.ended?).to be(false)
-        end
-      end
-    end
-
-    shared_examples_for 'a non-resumed change stream' do
-      it 'does not run the command again and instead raises the error' do
-        expect do
-          document
-        end.to raise_exception(error)
-      end
-    end
-
-    context 'when the error is a resumable error' do
-
-      context 'when the error is a SocketError' do
-
-        let(:error) do
-          Mongo::Error::SocketError
-        end
-
-        it_behaves_like 'a non-resumed change stream'
-      end
-
-      context 'when the error is a SocketTimeoutError' do
-
-        let(:error) do
-          Mongo::Error::SocketTimeoutError
-        end
-
-        it_behaves_like 'a non-resumed change stream'
-      end
-
-      context "when the error is a 'not master' error" do
-
-        let(:error) do
-          Mongo::Error::OperationFailure.new('not master')
-        end
-
-        it_behaves_like 'a non-resumed change stream'
-      end
-
-      context "when the error is a 'node is recovering' error" do
-
-        let(:error) do
-          Mongo::Error::OperationFailure.new('node is recovering')
-        end
-
-        it_behaves_like 'a non-resumed change stream'
-      end
-    end
-
-    context 'when the error is another server error' do
-
-      let(:error) do
-        Mongo::Error::MissingResumeToken
-      end
-
-      before do
-        expect(view.send(:server_selector)).to receive(:select_server).and_call_original
-      end
-
-      it_behaves_like 'a non-resumed change stream'
-
-      context 'when provided a session' do
-
-        let(:options) do
-          { session: session}
-        end
-
-        let(:session) do
-          client.start_session
-        end
-
-        before do
-          expect do
-            change_stream
-          end.to raise_error(error)
-        end
-
-        it 'does not close the session' do
-          expect(session.ended?).to be(false)
-        end
-      end
-    end
-  end
-
-  context 'when a killCursors command is issued for the cursor' do
-    context 'using Enumerable' do
-      only_mri
-
-      before do
-        change_stream
-        collection.insert_one(a:1)
-        enum.next
-        collection.insert_one(a:2)
-      end
-
-      let(:enum) do
-        change_stream.to_enum
-      end
-
-      it 'should create a new cursor and resume' do
-        original_cursor_id = cursor.id
-
-        client.use(:admin).command({
-          killCursors: collection.name,
-          cursors: [cursor.id]
-        })
-
-        document = enum.next
-        expect(document[:fullDocument][:a]).to eq(2)
-
-        new_cursor_id = change_stream.instance_variable_get(:@cursor).id
-        expect(new_cursor_id).not_to eq(original_cursor_id)
-      end
-    end
-
-    context 'using try_next' do
-      before do
-        change_stream
-        collection.insert_one(a:1)
-        expect(change_stream.try_next).to be_a(BSON::Document)
-        collection.insert_one(a:2)
-      end
-
-      it 'should create a new cursor and resume' do
-        original_cursor_id = cursor.id
-
-        client.use(:admin).command({
-          killCursors: collection.name,
-          cursors: [cursor.id]
-        })
-
-        document = change_stream.try_next
-        expect(document).to be_a(BSON::Document)
-        expect(document[:fullDocument][:a]).to eq(2)
-
-        new_cursor_id = change_stream.instance_variable_get(:@cursor).id
-        expect(new_cursor_id).not_to eq(original_cursor_id)
-      end
-    end
-  end
-
-  context 'when a server error is encountered during a getMore' do
-    fails_on_jruby
-
-    context 'when the error is a resumable error' do
-
-      shared_examples_for 'a change stream that encounters an error from a getMore' do
-
-        before do
-          change_stream
-          collection.insert_one(a: 1)
-          enum.next
-          collection.insert_one(a: 2)
-          expect(cursor).to receive(:get_more).once.and_raise(error)
-          expect(cursor).to receive(:kill_cursors).and_call_original
-          expect(view.send(:server_selector)).to receive(:select_server).once.and_call_original
-          expect(Mongo::Operation::Aggregate).to receive(:new).and_call_original
-        end
-
-        let(:enum) do
-          change_stream.to_enum
-        end
-
-        let(:document) do
-          enum.next
-        end
-
-        it 'runs the command again while using the same read preference and caching the resume token' do
-          expect(document[:fullDocument][:a]).to eq(2)
-          expect(change_stream_document[:resumeAfter]).to eq(document[:_id])
-        end
-
-        context 'when provided a session' do
-
-          let(:options) do
-            { session: session}
-          end
-
-          let(:session) do
-            client.start_session
-          end
-
-          before do
-            enum.next
-          end
-
-          it 'does not close the session' do
-            expect(session.ended?).to be(false)
-          end
-        end
-      end
-
-      context 'when the error is a SocketError' do
-
-        let(:error) do
-          Mongo::Error::SocketError
-        end
-
-        it_behaves_like 'a change stream that encounters an error from a getMore'
-      end
-
-      context 'when the error is a SocketTimeoutError' do
-
-        let(:error) do
-          Mongo::Error::SocketTimeoutError
-        end
-
-        it_behaves_like 'a change stream that encounters an error from a getMore'
-      end
-
-      context "when the error is 'not master'" do
-
-        let(:error) do
-          Mongo::Error::OperationFailure.new('not master',
-            Mongo::Operation::GetMore::Result.new([]))
-        end
-
-        it_behaves_like 'a change stream that encounters an error from a getMore'
-      end
-
-      context "when the error is 'node is recovering'" do
-
-        let(:error) do
-          Mongo::Error::OperationFailure.new('node is recovering',
-            Mongo::Operation::GetMore::Result.new([]))
-        end
-
-        it_behaves_like 'a change stream that encounters an error from a getMore'
-      end
-    end
-
-    context 'when the error is another server error' do
-
-      before do
-        change_stream
-        collection.insert_one(a: 1)
-        enum.next
-        collection.insert_one(a: 2)
-        expect(cursor).to receive(:get_more).and_raise(Mongo::Error::MissingResumeToken)
-        expect(cursor).to receive(:kill_cursors).and_call_original
-        expect(Mongo::Operation::Aggregate).not_to receive(:new)
-      end
-
-      let(:enum) do
-        change_stream.to_enum
-      end
-
-      it 'does not run the command again and instead raises the error' do
-        expect {
-          enum.next
-        }.to raise_exception(Mongo::Error::MissingResumeToken)
-      end
-
-      context 'when provided a session' do
-
-        let(:options) do
-          { session: session}
-        end
-
-        let(:session) do
-          client.start_session
-        end
-
-        before do
-          expect do
-            enum.next
-          end.to raise_error(Mongo::Error::MissingResumeToken)
-        end
-
-        it 'does not close the session' do
-          expect(session.ended?).to be(false)
-        end
-      end
-    end
-  end
-
   describe '#inspect' do
 
     it 'includes the Ruby object_id in the formatted string' do

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

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Mongo::Collection::View::Explainable do
@@ -20,12 +23,95 @@ describe Mongo::Collection::View::Explainable do
 
   describe '#explain' do
 
-    let(:explain) do
-      view.explain
+    shared_examples 'executes the explain' do
+      context '3.0+ server' do
+        min_server_fcv '3.0'
+
+        context 'not sharded' do
+          require_topology :single, :replica_set
+
+          it 'executes the explain' do
+            explain[:queryPlanner][:namespace].should == authorized_collection.namespace
+          end
+        end
+
+        context 'sharded' do
+          require_topology :sharded
+
+          context 'pre-3.2 server' do
+            max_server_version '3.0'
+
+            it 'executes the explain' do
+              explain[:queryPlanner][:parsedQuery].should be_a(Hash)
+            end
+          end
+
+          context '3.2+ server' do
+            min_server_fcv '3.2'
+
+            it 'executes the explain' do
+              explain[:queryPlanner][:mongosPlannerVersion].should == 1
+            end
+          end
+        end
+      end
+
+      context '2.6 server' do
+        max_server_version '2.6'
+
+        it 'executes the explain' do
+          explain[:cursor].should == 'BasicCursor'
+        end
+      end
     end
 
-    it 'executes an explain' do
-      expect(explain[:cursor] == 'BasicCursor' || explain[:queryPlanner]).to be_truthy
+    context 'without arguments' do
+      let(:explain) do
+        view.explain
+      end
+
+      include_examples 'executes the explain'
+    end
+
+    context 'with verbosity argument' do
+      let(:explain) do
+        view.explain(verbosity: verbosity)
+      end
+
+      shared_examples 'triggers server error' do
+        # 3.0 does not produce the error.
+        min_server_fcv '3.2'
+
+        it 'triggers server error' do
+          lambda do
+            explain
+          end.should raise_error(Mongo::Error::OperationFailure, /verbosity string must be|value .* for field .*verbosity.* is not a valid value/)
+        end
+      end
+
+      context 'valid symbol value' do
+        let(:verbosity) { :query_planner }
+
+        include_examples 'executes the explain'
+      end
+
+      context 'valid string value' do
+        let(:verbosity) { 'executionStats' }
+
+        include_examples 'executes the explain'
+      end
+
+      context 'invalid symbol value' do
+        let(:verbosity) { :bogus }
+
+        include_examples 'triggers server error'
+      end
+
+      context 'invalid string value' do
+        let(:verbosity) { 'bogus' }
+
+        include_examples 'triggers server error'
+      end
     end
   end
 end

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

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Mongo::Collection::View::Immutable do

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Mongo::Collection::View::Iterable 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.drop
+  end
+
+  describe '#each' do
+    context 'when allow_disk_use is provided' do
+      let(:options) { { allow_disk_use: true } }
+
+      # Other cases are adequately covered by spec tests.
+      context 'on server versions < 3.2' do
+        max_server_fcv '3.0'
+
+        it 'raises an exception' do
+          expect do
+            view.each do |document|
+              #Do nothing
+            end
+          end.to raise_error(Mongo::Error::UnsupportedOption, /The MongoDB server handling this request does not support the allow_disk_use option on this command/)
+        end
+      end
+    end
+  end
+end

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

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Mongo::Collection::View::MapReduce do
@@ -66,7 +69,7 @@ describe Mongo::Collection::View::MapReduce do
 
   describe '#reduce_function' do
 
-    it 'returns the map function' do
+    it 'returns the reduce function' do
       expect(map_reduce.reduce_function).to eq(reduce)
     end
   end
@@ -80,7 +83,7 @@ describe Mongo::Collection::View::MapReduce do
     end
 
     it 'calls the Enumerable method' do
-      expect(results).to eq(map_reduce.to_a)
+      expect(results.sort_by { |d| d['_id'] }).to eq(map_reduce.to_a.sort_by { |d| d['_id'] })
     end
   end
 
@@ -186,7 +189,7 @@ describe Mongo::Collection::View::MapReduce do
         end
 
         it 'executes the map reduce' do
-          expect(map_reduce.to_a).to eq(new_map_reduce.to_a)
+          expect(new_map_reduce.to_a.sort_by { |d| d['_id'] }).to eq(map_reduce.to_a.sort_by { |d| d['_id'] })
         end
       end
 
@@ -239,12 +242,16 @@ describe Mongo::Collection::View::MapReduce do
             Mongo::Collection::View.new(client[TEST_COLL], selector, view_options)
           end
 
+          let(:subscriber) { EventSubscriber.new }
+
           let(:client) do
-            subscribed_client
+            authorized_client.tap do |client|
+              client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+            end
           end
 
           let(:find_command) do
-            EventSubscriber.started_events[-1].command
+            subscriber.started_events[-1].command
           end
 
           before do
@@ -575,14 +582,22 @@ describe Mongo::Collection::View::MapReduce do
         expect(map_reduce.send(:secondary_ok?)).to be false
       end
 
-      context 'when the server is not a valid for writing' do
+      context 'when the server is not valid for writing' do
+        clean_slate
+        require_warning_clean
+
+        before do
+          stop_monitoring(authorized_client)
+        end
 
         it 'reroutes the operation to a primary' do
-          allow(map_reduce).to receive(:valid_server?).and_return(false)
-          expect(Mongo::Logger.logger).to receive(:warn).once do |msg|
-            expect(msg).to include('Rerouting the MapReduce operation to the primary server')
+          RSpec::Mocks.with_temporary_scope do
+            allow(map_reduce).to receive(:valid_server?).and_return(false)
+            expect(Mongo::Logger.logger).to receive(:warn).once do |msg|
+              expect(msg).to include('Rerouting the MapReduce operation to the primary server')
+            end
+            map_reduce.to_a
           end
-          map_reduce.to_a
         end
 
         context 'when the view has a write concern' do
@@ -649,12 +664,11 @@ describe Mongo::Collection::View::MapReduce do
       end
 
       context 'when the server is a valid for writing' do
+        clean_slate
+        require_warning_clean
+
         before do
-          # We are inspecting server state - kill monitor threads so that
-          # server state is not changed in background due to intermittent
-          # connectivity issues in Evergreen
-          ClientRegistry.instance.close_all_clients
-          authorized_collection.client.cluster.disconnect!
+          stop_monitoring(authorized_client)
         end
 
         it 'does not reroute the operation to a primary' do