mongo 2.15.0 → 2.16.0.alpha1

data/spec/integration/client_spec.rb

@@ -21,6 +21,8 @@ describe 'Client' do
     end
 
     context 'after all servers are marked unknown' do
+      require_topology :single, :replica_set, :sharded
+
       before do
         client.cluster.servers.each do |server|
           server.unknown!

data/spec/integration/command_monitoring_spec.rb

@@ -5,7 +5,7 @@ require 'spec_helper'
 
 describe 'Command monitoring' do
 
-  let(:subscriber) { EventSubscriber.new }
+  let(:subscriber) { Mrss::EventSubscriber.new }
 
   let(:client) do
     authorized_client.with(app_name: 'command monitoring spec').tap do |client|

data/spec/integration/command_spec.rb

@@ -5,7 +5,7 @@ require 'spec_helper'
 
 describe 'Command' do
 
-  let(:subscriber) { EventSubscriber.new }
+  let(:subscriber) { Mrss::EventSubscriber.new }
 
   describe 'payload' do
     let(:server) { authorized_client.cluster.next_primary }

data/spec/integration/connection_spec.rb

@@ -50,7 +50,7 @@ describe 'Connections' do
 
       context 'with sdam event subscription' do
 
-        let(:subscriber) { EventSubscriber.new }
+        let(:subscriber) { Mrss::EventSubscriber.new }
         let(:client) do
           ClientRegistry.instance.global_client('authorized').with(app_name: 'connection_integration').tap do |client|
             client.subscribe(Mongo::Monitoring::SERVER_OPENING, subscriber)
@@ -246,43 +246,60 @@ describe 'Connections' do
 
       let(:client) { ClientRegistry.instance.global_client('authorized').with(app_name: 'wire_protocol_update') }
 
-      it 'updates on hello response from non-monitoring connections' do
-        # connect server
-        client['test'].insert_one(test: 1)
+      context 'non-lb' do
+        require_topology :single, :replica_set, :sharded
 
-        # kill background threads so that they are not interfering with
-        # our mocked hello response
-        client.cluster.servers.each do |server|
-          server.monitor.stop!
+        it 'updates on handshake response from non-monitoring connections' do
+          # connect server
+          client['test'].insert_one(test: 1)
+
+          # kill background threads so that they are not interfering with
+          # our mocked hello response
+          client.cluster.servers.each do |server|
+            server.monitor.stop!
+          end
+
+          server = client.cluster.servers.first
+          expect(server.features.server_wire_versions.max >= 4).to be true
+          max_version = server.features.server_wire_versions.max
+
+          # Depending on server version, handshake here may return a
+          # description that compares equal to the one we got from a
+          # monitoring connection (pre-4.2) or not (4.2+).
+          # Since we do run SDAM flow on handshake responses on
+          # non-monitoring connections, force descriptions to be different
+          # by setting the existing description here to unknown.
+          server.monitor.instance_variable_set('@description',
+            Mongo::Server::Description.new(server.address))
+
+          RSpec::Mocks.with_temporary_scope do
+            # now pretend a handshake returned a different range
+            features = Mongo::Server::Description::Features.new(0..3)
+            # One Features instantiation is for SDAM event publication, this
+            # one always happens. The second one happens on servers
+            # where we do not negotiate auth mechanism.
+            expect(Mongo::Server::Description::Features).to receive(:new).at_least(:once).and_return(features)
+
+            connection = Mongo::Server::Connection.new(server, server.options)
+            expect(connection.connect!).to be true
+
+            # hello response should update server description via sdam flow,
+            # which includes wire version range
+            expect(server.features.server_wire_versions.max).to eq(3)
+          end
         end
+      end
+
+      context 'lb' do
+        require_topology :load_balanced
+
+        it 'does not update on handshake response from non-monitoring connections since there are not any' do
+          # connect server
+          client['test'].insert_one(test: 1)
 
-        server = client.cluster.servers.first
-        expect(server.features.server_wire_versions.max >= 4).to be true
-        max_version = server.features.server_wire_versions.max
-
-        # Depending on server version, hello here may return a
-        # description that compares equal to the one we got from a
-        # monitoring connection (pre-4.2) or not (4.2+).
-        # Since we do run SDAM flow on hello responses on
-        # non-monitoring connections, force descriptions to be different
-        # by setting the existing description here to unknown.
-        server.monitor.instance_variable_set('@description',
-          Mongo::Server::Description.new(server.address))
-
-        RSpec::Mocks.with_temporary_scope do
-          # now pretend a hello returned a different range
-          features = Mongo::Server::Description::Features.new(0..3)
-          # One Features instantiation is for SDAM event publication, this
-          # one always happens. The second one happens on servers
-          # where we do not negotiate auth mechanism.
-          expect(Mongo::Server::Description::Features).to receive(:new).at_least(:once).and_return(features)
-
-          connection = Mongo::Server::Connection.new(server, server.options)
-          expect(connection.connect!).to be true
-
-          # hello response should update server description via sdam flow,
-          # which includes wire version range
-          expect(server.features.server_wire_versions.max).to eq(3)
+          server = client.cluster.servers.first
+          server.load_balancer?.should be true
+          server.features.server_wire_versions.max.should be 0
         end
       end
     end

data/spec/integration/crud_spec.rb

@@ -4,7 +4,8 @@
 require 'spec_helper'
 
 describe 'CRUD operations' do
-  let(:collection) { authorized_client['crud_integration'] }
+  let(:client) { authorized_client }
+  let(:collection) { client['crud_integration'] }
 
   before do
     collection.delete_many
@@ -64,6 +65,178 @@ describe 'CRUD operations' do
         end
       end
     end
+
+    context 'with read concern' do
+      # Read concern requires 3.2+ server.
+      min_server_fcv '3.2'
+
+      context 'with read concern specified on operation level' do
+
+        it 'passes the read concern' do
+          event = Utils.get_command_event(client, 'find') do |client|
+            client['foo'].find({}, read_concern: {level: :local}).to_a
+          end
+          event.command.fetch('readConcern').should == {'level' => 'local'}
+        end
+      end
+
+      context 'with read concern specified on collection level' do
+
+        it 'passes the read concern' do
+          event = Utils.get_command_event(client, 'find') do |client|
+            client['foo', read_concern: {level: :local}].find.to_a
+          end
+          event.command.fetch('readConcern').should == {'level' => 'local'}
+        end
+      end
+
+      context 'with read concern specified on client level' do
+
+        let(:client) { authorized_client.with(read_concern: {level: :local}) }
+
+        it 'passes the read concern' do
+          event = Utils.get_command_event(client, 'find') do |client|
+            client['foo'].find.to_a
+          end
+          event.command.fetch('readConcern').should == {'level' => 'local'}
+        end
+      end
+    end
+
+    context 'with oplog_replay option' do
+      let(:collection_name) { 'crud_integration_oplog_replay' }
+
+      let(:oplog_query) do
+        {ts: {'$gt' => 1}}
+      end
+
+      context 'passed to operation' do
+        it 'passes the option' do
+          event = Utils.get_command_event(client, 'find') do |client|
+            client[collection_name].find(oplog_query, oplog_replay: true).to_a
+          end
+          event.command.fetch('oplogReplay').should be true
+        end
+
+        it 'warns' do
+          client.should receive(:log_warn).with('The :oplog_replay option is deprecated and ignored by MongoDB 4.4 and later')
+          client[collection_name].find(oplog_query, oplog_replay: true).to_a
+        end
+      end
+
+      context 'set on collection' do
+        it 'passes the option' do
+          event = Utils.get_command_event(client, 'find') do |client|
+            client[collection_name, oplog_replay: true].find(oplog_query).to_a
+          end
+          event.command.fetch('oplogReplay').should be true
+        end
+
+        it 'warns' do
+          client.should receive(:log_warn).with('The :oplog_replay option is deprecated and ignored by MongoDB 4.4 and later')
+          client[collection_name, oplog_replay: true].find(oplog_query).to_a
+        end
+      end
+    end
+  end
+
+  describe 'explain' do
+    context 'with explicit session' do
+      min_server_fcv '3.6'
+
+      it 'passes the session' do
+        client.start_session do |session|
+          event = Utils.get_command_event(client, 'explain') do |client|
+            client['foo'].find({}, session: session).explain.should be_explain_output
+          end
+          event.command.fetch('lsid').should == session.session_id
+        end
+      end
+    end
+
+    context 'with read preference specified on operation level' do
+      require_topology :sharded
+
+      # RUBY-2706
+      min_server_fcv '3.6'
+
+      it 'passes the read preference' do
+        event = Utils.get_command_event(client, 'explain') do |client|
+          client['foo'].find({}, read: {mode: :secondary_preferred}).explain.should be_explain_output
+        end
+        event.command.fetch('$readPreference').should == {'mode' => 'secondaryPreferred'}
+      end
+    end
+
+    context 'with read preference specified on collection level' do
+      require_topology :sharded
+
+      # RUBY-2706
+      min_server_fcv '3.6'
+
+      it 'passes the read preference' do
+        event = Utils.get_command_event(client, 'explain') do |client|
+          client['foo', read: {mode: :secondary_preferred}].find.explain.should be_explain_output
+        end
+        event.command.fetch('$readPreference').should == {'mode' => 'secondaryPreferred'}
+      end
+    end
+
+    context 'with read preference specified on client level' do
+      require_topology :sharded
+
+      # RUBY-2706
+      min_server_fcv '3.6'
+
+      let(:client) { authorized_client.with(read: {mode: :secondary_preferred}) }
+
+      it 'passes the read preference' do
+        event = Utils.get_command_event(client, 'explain') do |client|
+          client['foo'].find.explain.should be_explain_output
+        end
+        event.command.fetch('$readPreference').should == {'mode' => 'secondaryPreferred'}
+      end
+    end
+
+    context 'with read concern' do
+      # Read concern requires 3.2+ server.
+      min_server_fcv '3.2'
+
+      context 'with read concern specifed on operation level' do
+
+        # Read concern is not allowed in explain command, driver drops it.
+        it 'drops the read concern' do
+          event = Utils.get_command_event(client, 'explain') do |client|
+            client['foo'].find({}, read_concern: {level: :local}).explain.should have_key('queryPlanner')
+          end
+          event.command.should_not have_key('readConcern')
+        end
+      end
+
+      context 'with read concern specifed on collection level' do
+
+        # Read concern is not allowed in explain command, driver drops it.
+        it 'drops the read concern' do
+          event = Utils.get_command_event(client, 'explain') do |client|
+            client['foo', read_concern: {level: :local}].find.explain.should have_key('queryPlanner')
+          end
+          event.command.should_not have_key('readConcern')
+        end
+      end
+
+      context 'with read concern specifed on client level' do
+
+        let(:client) { authorized_client.with(read_concern: {level: :local}) }
+
+        # Read concern is not allowed in explain command, driver drops it.
+        it 'drops the read concern' do
+          event = Utils.get_command_event(client, 'explain') do |client|
+            client['foo'].find.explain.should have_key('queryPlanner')
+          end
+          event.command.should_not have_key('readConcern')
+        end
+      end
+    end
   end
 
   describe 'insert' do

data/spec/integration/cursor_pinning_spec.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe 'Cursor pinning' do
+  let(:client) { authorized_client }
+  let(:collection_name) { 'cursor_pinning' }
+  let(:collection) { client[collection_name] }
+
+  before do
+    authorized_client[collection_name].insert_many([{test: 1}] * 200)
+  end
+
+  let(:server) { client.cluster.next_primary }
+
+  clean_slate
+
+  context 'non-lb' do
+    require_topology :single, :replica_set, :sharded
+    require_no_multi_mongos
+
+    # When not in load-balanced topology, iterating a cursor creates
+    # new connections as needed.
+
+    it 'creates new connections for iteration' do
+      server.pool.size.should == 0
+
+      # Use batch_size of 2 until RUBY-2727 is fixed.
+      enum = collection.find({}, batch_size: 2).to_enum
+      # Still zero because we haven't iterated
+      server.pool.size.should == 0
+
+      enum.next
+      enum.next
+      server.pool.size.should == 1
+
+      # Grab the connection that was used
+      server.with_connection do
+        # This requires a new connection
+        enum.next
+
+        server.pool.size.should == 2
+      end
+    end
+  end
+
+  context 'lb' do
+    require_topology :load_balanced
+
+    # In load-balanced topology, we cannot create new connections to a
+    # particular service.
+
+    context 'when no connection is available' do
+
+      it 'raises ConnectionCheckOutTimeout' do
+        server.pool.size.should == 0
+
+        enum = collection.find({}, batch_size: 1).to_enum
+        # Still zero because we haven't iterated
+        server.pool.size.should == 0
+
+        enum.next
+        server.pool.size.should == 1
+
+        # Grab the connection that was used
+        server.with_connection do
+          # This requires a new connection, but we cannot make one.
+          lambda do
+            enum.next
+          end.should raise_error(Mongo::Error::ConnectionCheckOutTimeout)
+
+          server.pool.size.should == 1
+        end
+      end
+    end
+
+    context 'when connection is available' do
+      require_multi_mongos
+
+      let(:client) { authorized_client.with(max_pool_size: 4) }
+
+      it 'uses the available connection' do
+        server.pool.size.should == 0
+
+        # Create 4 connections.
+
+        enums = []
+        connections = []
+        service_ids = []
+
+        4.times do
+          view = collection.find({}, batch_size: 1)
+          enum = view.to_enum
+
+          enum.next
+
+          enums << enum
+          service_ids << view.cursor.initial_result.connection_description.service_id
+          connections << server.pool.check_out
+        end
+
+        service_ids.uniq.length.should be > 1
+
+        server.pool.size.should == 4
+
+        connections.each do |c|
+          server.pool.check_in(c)
+        end
+
+        # At this point, in theory, all connections are equally likely to
+        # be chosen, but we have cursors referencing more than one
+        # distinct service.
+        # Iterate each cursor to ensure they all continue to work.
+        enums.each do |enum|
+          enum.next
+        end
+      end
+    end
+  end
+end

data/spec/integration/cursor_reaping_spec.rb

@@ -8,6 +8,8 @@ describe 'Cursor reaping' do
   # in MRI, I don't currently know how to force GC to run in JRuby
   require_mri
 
+# Uncomment for debugging this test.
+=begin
   around(:all) do |example|
     saved_level = Mongo::Logger.logger.level
     Mongo::Logger.logger.level = Logger::DEBUG
@@ -17,8 +19,9 @@ describe 'Cursor reaping' do
       Mongo::Logger.logger.level = saved_level
     end
   end
+=end
 
-  let(:subscriber) { EventSubscriber.new }
+  let(:subscriber) { Mrss::EventSubscriber.new }
 
   let(:client) do
     authorized_client.tap do |client|
@@ -57,10 +60,11 @@ describe 'Cursor reaping' do
         10.times do
           scope = collection.find.batch_size(2).no_cursor_timeout
 
-          # there is no API for retrieving the cursor
+          # Begin iteration, creating the cursor
           scope.each.first
-          # and keep the first cursor
-          cursor_ids << scope.instance_variable_get('@cursor').id
+
+          scope.cursor.should_not be nil
+          cursor_ids << scope.cursor.id
         end
       end
     end