mongo 2.11.2 → 2.13.0.beta1

data/spec/mongo/cluster/cursor_reaper_spec.rb

@@ -91,18 +91,16 @@ describe Mongo::Cluster::CursorReaper do
 
   describe '#register_cursor' do
 
-    before do
-      reaper.register_cursor(cursor_id)
-    end
-
     context 'when the cursor id is nil' do
 
       let(:cursor_id) do
         nil
       end
 
-      it 'does not register the cursor' do
-        expect(active_cursors.size).to be(0)
+      it 'raises exception' do
+        expect do
+          reaper.register_cursor(cursor_id)
+        end.to raise_error(ArgumentError, /register_cursor called with nil cursor_id/)
       end
     end
 
@@ -112,8 +110,10 @@ describe Mongo::Cluster::CursorReaper do
         0
       end
 
-      it 'does not register the cursor' do
-        expect(active_cursors.size).to be(0)
+      it 'raises exception' do
+        expect do
+          reaper.register_cursor(cursor_id)
+        end.to raise_error(ArgumentError, /register_cursor called with cursor_id=0/)
       end
     end
 
@@ -123,6 +123,10 @@ describe Mongo::Cluster::CursorReaper do
         2
       end
 
+      before do
+        reaper.register_cursor(cursor_id)
+      end
+
       it 'registers the cursor id as active' do
         expect(active_cursors).to eq(Set.new([2]))
       end

data/spec/mongo/cluster/socket_reaper_spec.rb

@@ -20,13 +20,24 @@ describe Mongo::Cluster::SocketReaper do
   describe '#execute' do
 
     before do
-      cluster.servers.each do |s|
-        expect(s.pool).to receive(:close_idle_sockets).and_call_original
+      # Ensure all servers are discovered
+      cluster.servers_list.each do |server|
+        server.scan!
       end
+
+      # Stop the reaper that is attached to the cluster, since it
+      # runs the same code we are running and can interfere with our assertions
+      cluster.instance_variable_get('@periodic_executor').stop!
     end
 
     it 'calls close_idle_sockets on each connection pool in the cluster' do
-      reaper.execute
+      RSpec::Mocks.with_temporary_scope do
+        cluster.servers.each do |s|
+          expect(s.pool).to receive(:close_idle_sockets).and_call_original
+        end
+
+        reaper.execute
+      end
     end
   end
 end

data/spec/mongo/cluster_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require 'runners/sdam_monitoring'
 
 describe Mongo::Cluster do
 
@@ -14,12 +15,32 @@ describe Mongo::Cluster do
   end
 
   let(:cluster_without_io) do
-    described_class.new(SpecConfig.instance.addresses, monitoring,
-      SpecConfig.instance.test_options.merge(monitoring_io: false))
+    register_cluster(
+      described_class.new(SpecConfig.instance.addresses, monitoring,
+        SpecConfig.instance.test_options.merge(monitoring_io: false)))
   end
 
   let(:cluster) { cluster_without_io }
 
+  describe 'initialize' do
+
+    context 'when there are duplicate addresses' do
+
+      let(:addresses) do
+        SpecConfig.instance.addresses + SpecConfig.instance.addresses
+      end
+      let(:cluster_with_dup_addresses) do
+        register_cluster(
+          described_class.new(addresses, monitoring, SpecConfig.instance.test_options))
+      end
+
+      it 'does not raise an exception' do
+        expect { cluster_with_dup_addresses }.not_to raise_error
+      end
+    end
+
+  end
+
   describe '#==' do
 
     context 'when the other is a cluster' do

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

@@ -232,8 +232,12 @@ describe Mongo::Collection::View::Aggregation do
         { session: session }
       end
 
+      let(:subscriber) { EventSubscriber.new }
+
       let(:client) do
-        subscribed_client
+        authorized_client.tap do |client|
+          client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+        end
       end
 
       let(:session) do
@@ -246,7 +250,7 @@ describe Mongo::Collection::View::Aggregation do
 
       let(:command) do
         aggregation.explain
-        EventSubscriber.started_events.find { |c| c.command_name == 'aggregate'}.command
+        subscriber.started_events.find { |c| c.command_name == 'aggregate'}.command
       end
 
       it 'sends the session id' do
@@ -306,8 +310,6 @@ describe Mongo::Collection::View::Aggregation do
           min_server_fcv '4.2'
 
           let(:result) do
-            skip 'RUBY-1827 / upgrading evergreen 4.1 server binary'
-
             aggregation.explain['queryPlanner']['collation']['locale']
           end
 

data/spec/mongo/collection/view/builder/find_command_spec.rb

@@ -1,11 +1,17 @@
-require 'spec_helper'
+require 'lite_spec_helper'
 
 describe Mongo::Collection::View::Builder::FindCommand do
 
+  let(:client) do
+    new_local_client_nmio(['127.0.0.1:27017'])
+  end
+
+  let(:base_collection) { client['find-command-spec'] }
+
   describe '#specification' do
 
     let(:view) do
-      Mongo::Collection::View.new(authorized_collection, filter, options)
+      Mongo::Collection::View.new(base_collection, filter, options)
     end
 
     let(:builder) do
@@ -68,7 +74,7 @@ describe Mongo::Collection::View::Builder::FindCommand do
       end
 
       it 'maps the collection name' do
-        expect(selector['find']).to eq(authorized_collection.name)
+        expect(selector['find']).to eq(base_collection.name)
       end
 
       it 'maps the filter' do
@@ -139,10 +145,15 @@ describe Mongo::Collection::View::Builder::FindCommand do
         expect(selector['tailable']).to be true
       end
 
-      it 'maps oplog replay' do
+      it 'maps oplog_replay' do
         expect(selector['oplogReplay']).to be true
       end
 
+      it 'warns when using oplog_replay' do
+        client.should receive(:log_warn).with('oplogReplay is deprecated and ignored by MongoDB 4.4 and later')
+        selector
+      end
+
       it 'maps no cursor timeout' do
         expect(selector['noCursorTimeout']).to be true
       end
@@ -465,7 +476,7 @@ describe Mongo::Collection::View::Builder::FindCommand do
     context 'when the collection has a read concern defined' do
 
       let(:collection) do
-        authorized_collection.with(read_concern: { level: 'invalid' })
+        base_collection.with(read_concern: { level: 'invalid' })
       end
 
       let(:view) do
@@ -479,7 +490,7 @@ describe Mongo::Collection::View::Builder::FindCommand do
       context 'when explain is called for the find' do
 
         let(:collection) do
-          authorized_collection.with(read_concern: { level: 'invalid' })
+          base_collection.with(read_concern: { level: 'invalid' })
         end
 
         let(:view) do

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

@@ -0,0 +1,392 @@
+require 'spec_helper'
+
+describe Mongo::Collection::View::ChangeStream do
+  require_wired_tiger
+  min_server_fcv '3.6'
+  require_topology :replica_set
+  max_example_run_time 7
+
+  let(:pipeline) do
+    []
+  end
+
+  let(:options) do
+    {}
+  end
+
+  let(:view_options) do
+    {}
+  end
+
+  let(:client) do
+    authorized_client_without_any_retry_reads
+  end
+
+  let(:collection) do
+    client['mcv-change-stream']
+  end
+
+  let(:view) do
+    Mongo::Collection::View.new(collection, {}, view_options)
+  end
+
+  let(:change_stream) do
+    @change_stream = described_class.new(view, pipeline, nil, options)
+  end
+
+  let(:cursor) do
+    change_stream.instance_variable_get(:@cursor)
+  end
+
+  let(:change_stream_document) do
+    change_stream.send(:instance_variable_set, '@resuming', false)
+    change_stream.send(:pipeline)[0]['$changeStream']
+  end
+
+  let(:connection_description) do
+    Mongo::Server::Description.new(double('description address'),
+      'minWireVersion' => 0, 'maxWireVersion' => 2)
+  end
+
+  let(:result) do
+    Mongo::Operation::GetMore::Result.new(
+      Mongo::Protocol::Message.new,
+      connection_description,
+    )
+  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 'propagates cursor not found error' do
+        original_cursor_id = cursor.id
+
+        client.use(:admin).command({
+          killCursors: collection.name,
+          cursors: [cursor.id]
+        })
+
+        lambda do
+          enum.next
+        end.should raise_error(Mongo::Error::OperationFailure, /cursor.*not found/)
+      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 'propagates cursor not found error' do
+        original_cursor_id = cursor.id
+
+        client.use(:admin).command({
+          killCursors: collection.name,
+          cursors: [cursor.id]
+        })
+
+        lambda do
+          change_stream.try_next
+        end.should raise_error(Mongo::Error::OperationFailure, /cursor.*not found/)
+      end
+    end
+  end
+
+  context 'when a server error is encountered during a getMore' do
+    fails_on_jruby
+
+    shared_examples_for 'a change stream that is not resumed' 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)
+      end
+
+      let(:enum) do
+        change_stream.to_enum
+      end
+
+      let(:document) do
+        enum.next
+      end
+
+      it 'is not resumed' do
+        expect do
+          document
+        end.to raise_error(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
+          collection.insert_one(a: 1)
+          enum.next
+          collection.insert_one(a: 2)
+          expect(cursor).to receive(:get_more).once.and_raise(error)
+        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(cursor).to receive(:close).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
+
+          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', result)
+        end
+
+        it_behaves_like 'a change stream that is not resumed'
+      end
+
+      context "when the error is 'node is recovering'" do
+
+        let(:error) do
+          Mongo::Error::OperationFailure.new('node is recovering', result)
+        end
+
+        it_behaves_like 'a change stream that is not resumed'
+      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(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
+end