mongo 2.5.3 → 2.6.0

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

@@ -19,10 +19,11 @@ describe Mongo::Collection::View::ChangeStream, if: test_change_streams? do
   end
 
   let(:change_stream) do
-    described_class.new(view, pipeline, options)
+    described_class.new(view, pipeline, nil, options)
   end
 
   let(:change_stream_document) do
+    change_stream.send(:instance_variable_set, '@resuming', false)
     change_stream.send(:pipeline)[0]['$changeStream']
   end
 
@@ -39,6 +40,7 @@ describe Mongo::Collection::View::ChangeStream, if: test_change_streams? do
   end
 
   let(:command_spec) do
+    change_stream.send(:instance_variable_set, '@resuming', false)
     change_stream.send(:aggregate_spec, double('session'))
   end
 
@@ -372,7 +374,7 @@ describe Mongo::Collection::View::ChangeStream, if: test_change_streams? do
       end
     end
 
-    context 'when some documents have been retrieved and the stream is closed before sending getmore' do
+    context 'when some documents have been retrieved and the stream is closed before sending getMore' do
 
       before do
         change_stream
@@ -434,103 +436,29 @@ describe Mongo::Collection::View::ChangeStream, if: test_change_streams? do
   end
 
   context 'when an error is encountered the first time the command is run' do
+    include PrimarySocket
 
-    let(:primary_socket) do
-      primary = authorized_collection.client.cluster.servers.find { |s| s.primary? }
-      connection = primary.pool.checkout
-      primary.pool.checkin(connection)
-      connection.send(:socket)
-    end
-
-    context 'when the error is a resumable error' do
-
-      shared_examples_for 'a resumable change stream' do
-
-        before do
-          expect(primary_socket).to receive(:write).and_raise(error).once
-          expect(view.send(:server_selector)).to receive(:select_server).twice.and_call_original
-          change_stream
-          authorized_collection.insert_one(a: 1)
-        end
-
-        let(:document) do
-          change_stream.to_enum.next
-        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
-            authorized_client.start_session
-          end
-
-          before do
-            change_stream.to_enum.next
-          end
+    let(:client) { authorized_collection.client }
 
-          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 resumable change stream'
-      end
-
-      context 'when the error is a SocketTimeoutError' do
-
-        let(:error) do
-          Mongo::Error::SocketTimeoutError
-        end
-
-        it_behaves_like 'a resumable 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 resumable change stream'
-      end
-
-      context "when the error is a 'cursor not found (43)' error" do
-
-        let(:error) do
-          Mongo::Error::OperationFailure.new('cursor not found (43)')
-        end
+    before do
+      expect(primary_socket).to receive(:write).and_raise(error).once
+    end
 
-        it_behaves_like 'a resumable change stream'
-      end
+    let(:document) do
+      change_stream.to_enum.next
     end
 
-    context 'when the error is another server error' do
+    shared_examples_for 'a resumable change stream' do
 
       before do
-        expect(primary_socket).to receive(:write).and_raise(Mongo::Error::OperationFailure)
-        #expect twice because of kill_cursors in after block
         expect(view.send(:server_selector)).to receive(:select_server).twice.and_call_original
+        change_stream
+        authorized_collection.insert_one(a: 1)
       end
 
-      it 'does not run the command again and instead raises the error' do
-        expect {
-          change_stream
-        }.to raise_exception(Mongo::Error::OperationFailure)
+      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
@@ -544,7 +472,7 @@ describe Mongo::Collection::View::ChangeStream, if: test_change_streams? do
         end
 
         before do
-          begin; change_stream; rescue; end
+          change_stream.to_enum.next
         end
 
         it 'does not close the session' do
@@ -552,64 +480,24 @@ describe Mongo::Collection::View::ChangeStream, if: test_change_streams? do
         end
       end
     end
-  end
 
-  context 'when a server error is encountered during a getmore' do
+    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
 
-      shared_examples_for 'a change stream that encounters an error from a getmore' do
-
-        before do
-          change_stream
-          authorized_collection.insert_one(a: 1)
-          enum.next
-          authorized_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(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
-            authorized_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'
+        it_behaves_like 'a non-resumed change stream'
       end
 
       context 'when the error is a SocketTimeoutError' do
@@ -618,49 +506,40 @@ describe Mongo::Collection::View::ChangeStream, if: test_change_streams? do
           Mongo::Error::SocketTimeoutError
         end
 
-        it_behaves_like 'a change stream that encounters an error from a getmore'
+        it_behaves_like 'a non-resumed change stream'
       end
 
-      context "when the error is a not 'master error'" do
+      context "when the error is a 'not master' error" do
 
         let(:error) do
           Mongo::Error::OperationFailure.new('not master')
         end
 
-        it_behaves_like 'a change stream that encounters an error from a getmore'
+        it_behaves_like 'a non-resumed change stream'
       end
 
-      context "when the error is a not 'cursor not found error'" do
+      context "when the error is a 'node is recovering' error" do
 
         let(:error) do
-          Mongo::Error::OperationFailure.new('cursor not found (43)')
+          Mongo::Error::OperationFailure.new('node is recovering')
         end
 
-        it_behaves_like 'a change stream that encounters an error from a getmore'
+        it_behaves_like 'a non-resumed change stream'
       end
     end
 
     context 'when the error is another server error' do
 
-      before do
-        change_stream
-        authorized_collection.insert_one(a: 1)
-        enum.next
-        authorized_collection.insert_one(a: 2)
-        expect(cursor).to receive(:get_more).and_raise(Mongo::Error::OperationFailure)
-        expect(cursor).to receive(:kill_cursors).and_call_original
-        expect(Mongo::Operation::Aggregate).not_to receive(:new)
+      let(:error) do
+        Mongo::Error::MissingResumeToken
       end
 
-      let(:enum) do
-        change_stream.to_enum
+      before do
+        #expect twice because of kill_cursors in after block
+        expect(view.send(:server_selector)).to receive(:select_server).twice.and_call_original
       end
 
-      it 'does not run the command again and instead raises the error' do
-        expect {
-          enum.next
-        }.to raise_exception(Mongo::Error::OperationFailure)
-      end
+      it_behaves_like 'a non-resumed change stream'
 
       context 'when provided a session' do
 
@@ -673,7 +552,9 @@ describe Mongo::Collection::View::ChangeStream, if: test_change_streams? do
         end
 
         before do
-          begin; enum.next; rescue; end
+          expect do
+            change_stream
+          end.to raise_error(error)
         end
 
         it 'does not close the session' do
@@ -683,20 +564,20 @@ describe Mongo::Collection::View::ChangeStream, if: test_change_streams? do
     end
   end
 
-  context 'when a server error is encountered during the command following an error during getmore' do
+  context 'when a server error is encountered during a getMore' do
 
     context 'when the error is a resumable error' do
 
-      shared_examples_for 'a change stream that sent getmores, that then encounters an error when resuming' do
+      shared_examples_for 'a change stream that encounters an error from a getMore' do
 
         before do
           change_stream
           authorized_collection.insert_one(a: 1)
           enum.next
           authorized_collection.insert_one(a: 2)
-          expect(cursor).to receive(:get_more).and_raise(error)
+          expect(cursor).to receive(:get_more).once.and_raise(error)
           expect(cursor).to receive(:kill_cursors).and_call_original
-          expect(change_stream).to receive(:send_initial_query).and_raise(error).once.ordered
+          expect(Mongo::Operation::Aggregate).to receive(:new).and_call_original
         end
 
         let(:enum) do
@@ -707,10 +588,9 @@ describe Mongo::Collection::View::ChangeStream, if: test_change_streams? do
           enum.next
         end
 
-        it 'raises the error' do
-          expect {
-            document
-          }.to raise_exception(error)
+        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
@@ -724,7 +604,7 @@ describe Mongo::Collection::View::ChangeStream, if: test_change_streams? do
           end
 
           before do
-            begin; document; rescue; end
+            enum.next
           end
 
           it 'does not close the session' do
@@ -739,7 +619,7 @@ describe Mongo::Collection::View::ChangeStream, if: test_change_streams? do
           Mongo::Error::SocketError
         end
 
-        it_behaves_like 'a change stream that sent getmores, that then encounters an error when resuming'
+        it_behaves_like 'a change stream that encounters an error from a getMore'
       end
 
       context 'when the error is a SocketTimeoutError' do
@@ -748,25 +628,27 @@ describe Mongo::Collection::View::ChangeStream, if: test_change_streams? do
           Mongo::Error::SocketTimeoutError
         end
 
-        it_behaves_like 'a change stream that sent getmores, that then encounters an error when resuming'
+        it_behaves_like 'a change stream that encounters an error from a getMore'
       end
 
-      context "when the error is a 'not master error'" do
+      context "when the error is 'not master'" do
 
         let(:error) do
-          Mongo::Error::OperationFailure.new('not master')
+          Mongo::Error::OperationFailure.new('not master',
+            Mongo::Operation::GetMore::Result.new([]))
         end
 
-        it_behaves_like 'a change stream that sent getmores, that then encounters an error when resuming'
+        it_behaves_like 'a change stream that encounters an error from a getMore'
       end
 
-      context "when the error is a not 'cursor not found error'" do
+      context "when the error is 'node is recovering'" do
 
         let(:error) do
-          Mongo::Error::OperationFailure.new('cursor not found (43)')
+          Mongo::Error::OperationFailure.new('node is recovering',
+            Mongo::Operation::GetMore::Result.new([]))
         end
 
-        it_behaves_like 'a change stream that sent getmores, that then encounters an error when resuming'
+        it_behaves_like 'a change stream that encounters an error from a getMore'
       end
     end
 
@@ -777,9 +659,9 @@ describe Mongo::Collection::View::ChangeStream, if: test_change_streams? do
         authorized_collection.insert_one(a: 1)
         enum.next
         authorized_collection.insert_one(a: 2)
-        expect(cursor).to receive(:get_more).and_raise(Mongo::Error::OperationFailure.new('not master'))
+        expect(cursor).to receive(:get_more).and_raise(Mongo::Error::MissingResumeToken)
         expect(cursor).to receive(:kill_cursors).and_call_original
-        expect(change_stream).to receive(:send_initial_query).and_raise(Mongo::Error::OperationFailure).once.ordered
+        expect(Mongo::Operation::Aggregate).not_to receive(:new)
       end
 
       let(:enum) do
@@ -789,7 +671,7 @@ describe Mongo::Collection::View::ChangeStream, if: test_change_streams? do
       it 'does not run the command again and instead raises the error' do
         expect {
           enum.next
-        }.to raise_exception(Mongo::Error::OperationFailure)
+        }.to raise_exception(Mongo::Error::MissingResumeToken)
       end
 
       context 'when provided a session' do

data/spec/mongo/collection_spec.rb

@@ -691,7 +691,11 @@ describe Mongo::Collection do
         end
 
         it_behaves_like 'an operation using a session'
-        it_behaves_like 'a failed operation using a session'
+
+        # Due to how rspec interprets nested `if: condition` guards, we can't use one to skip this
+        # test in the case that the server will override the write concern (preventing the expected
+        # failure), so we're forced to use a traditional conditional to avoid defining the test.
+        it_behaves_like 'a failed operation using a session' if can_set_write_concern?
       end
 
       context 'when the collection does not have a write concern set' do
@@ -708,7 +712,7 @@ describe Mongo::Collection do
           expect(database.collection_names).to_not include('specs')
         end
 
-        context 'when the collection does not exist' do
+        context 'when the collection does not exist', if: can_set_write_concern? do
 
           it 'does not raise an error' do
             expect(database['non-existent-coll'].drop).to be(false)
@@ -732,7 +736,7 @@ describe Mongo::Collection do
           collection.drop
         end
 
-        context 'when the server supports write concern on the drop command', if: collation_enabled? do
+        context 'when the server supports write concern on the drop command', if: collation_enabled? && can_set_write_concern? do
 
           it 'applies the write concern' do
             expect{
@@ -750,7 +754,7 @@ describe Mongo::Collection do
       end
     end
 
-    context 'when the collection does not exist' do
+    context 'when the collection does not exist', if: can_set_write_concern? do
 
       it 'returns false' do
         expect(collection.drop).to be(false)
@@ -913,14 +917,14 @@ describe Mongo::Collection do
 
         let(:command) do
           client[TEST_COLL].find({}, session: session).explain
-          EventSubscriber.started_events.find { |c| c.command_name == :explain }.command
+          EventSubscriber.started_events.find { |c| c.command_name == 'explain' }.command
         end
 
         it 'sends the session id' do
           expect(command['lsid']).to eq(session.session_id)
         end
       end
-      
+
       context 'when a session supporting causal consistency is used' do
 
         let(:operation) do
@@ -1228,7 +1232,7 @@ describe Mongo::Collection do
       end
 
       let(:insert_events) do
-        EventSubscriber.started_events.select { |e| e.command_name == :insert }
+        EventSubscriber.started_events.select { |e| e.command_name == 'insert' }
       end
 
       it 'sends the documents in one OP_MSG' do
@@ -1551,7 +1555,7 @@ describe Mongo::Collection do
       it_behaves_like 'a failed operation using a session'
     end
 
-    context 'when batch size is specified' do
+    context 'when batch size is specified', unless: need_to_skip_on_sharded_auth_40? do
 
       let(:batch_size) { 1 }
 
@@ -1752,7 +1756,7 @@ describe Mongo::Collection do
 
         let(:command) do
           operation
-          EventSubscriber.started_events.find { |cmd| cmd.command_name == :count }.command
+          EventSubscriber.started_events.find { |cmd| cmd.command_name == 'count' }.command
         end
 
         it_behaves_like 'an operation supporting causally consistent reads'
@@ -1866,7 +1870,7 @@ describe Mongo::Collection do
 
       let(:command) do
         operation
-        EventSubscriber.started_events.find { |cmd| cmd.command_name == :distinct }.command
+        EventSubscriber.started_events.find { |cmd| cmd.command_name == 'distinct' }.command
       end
 
       it_behaves_like 'an operation supporting causally consistent reads'
@@ -2372,6 +2376,33 @@ describe Mongo::Collection do
       it_behaves_like 'a failed operation using a session'
     end
 
+    context 'when a session is not provided' do
+      let(:client) { subscribed_client }
+      let(:collection) { client['test'] }
+
+      let(:cursors) do
+        collection.parallel_scan(2)
+      end
+
+      let(:operation) do
+        cursors.reduce(0) { |total, cursor| total + cursor.to_a.size }
+      end
+
+      let(:failed_operation) do
+        collection.parallel_scan(-2)
+      end
+
+      let(:command) do
+        operation
+        event = EventSubscriber.started_events.find { |cmd| cmd.command_name == 'parallelCollectionScan' }
+        expect(event).not_to be_nil
+        event.command
+      end
+
+      it_behaves_like 'an operation not using a session'
+      it_behaves_like 'a failed operation not using a session'
+    end
+
     context 'when a session supporting causal consistency is used' do
 
       let(:cursors) do
@@ -2384,7 +2415,9 @@ describe Mongo::Collection do
 
       let(:command) do
         operation
-        EventSubscriber.started_events.find { |cmd| cmd.command_name == :parallelCollectionScan }.command
+        event = EventSubscriber.started_events.find { |cmd| cmd.command_name == 'parallelCollectionScan' }
+        expect(event).not_to be_nil
+        event.command
       end
 
       it_behaves_like 'an operation supporting causally consistent reads'
@@ -3569,7 +3602,7 @@ describe Mongo::Collection do
       end
 
       let(:update_events) do
-        EventSubscriber.started_events.select { |e| e.command_name == :update }
+        EventSubscriber.started_events.select { |e| e.command_name == 'update' }
       end
 
       it 'sends the documents in one OP_MSG' do