mongo 2.17.4 → 2.21.0

data/spec/mongo/client_spec.rb

@@ -1,32 +1,39 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require 'spec_helper'
 
+DEFAULT_LOCAL_HOST = '127.0.0.1:27017'
+ALT_LOCAL_HOST = '127.0.0.1:27010'
+
 # NB: tests for .new, #initialize, #use, #with and #dup are in
 # client_construction_spec.rb.
 
 describe Mongo::Client do
+  let(:subscriber) { Mrss::EventSubscriber.new }
 
-  describe '#==' do
+  let(:monitored_client) do
+    root_authorized_client.tap do |client|
+      client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+    end
+  end
 
+  describe '#==' do
     let(:client) do
       new_local_client_nmio(
-        ['127.0.0.1:27017'],
-        :read => { :mode => :primary },
-        :database => SpecConfig.instance.test_db
+        [ DEFAULT_LOCAL_HOST ],
+        read: { mode: :primary },
+        database: SpecConfig.instance.test_db
       )
     end
 
     context 'when the other is a client' do
-
       context 'when the options and cluster are equal' do
-
         let(:other) do
           new_local_client_nmio(
-            ['127.0.0.1:27017'],
-            :read => { :mode => :primary },
-            :database => SpecConfig.instance.test_db
+            [ DEFAULT_LOCAL_HOST ],
+            read: { mode: :primary },
+            database: SpecConfig.instance.test_db
           )
         end
 
@@ -36,12 +43,11 @@ describe Mongo::Client do
       end
 
       context 'when the options are not equal' do
-
         let(:other) do
           new_local_client_nmio(
-            ['127.0.0.1:27017'],
-            :read => { :mode => :secondary },
-            :database => SpecConfig.instance.test_db
+            [ DEFAULT_LOCAL_HOST ],
+            read: { mode: :secondary },
+            database: SpecConfig.instance.test_db
           )
         end
 
@@ -51,12 +57,11 @@ describe Mongo::Client do
       end
 
       context 'when cluster is not equal' do
-
         let(:other) do
           new_local_client_nmio(
-            ['127.0.0.1:27010'],
-            :read => { :mode => :primary },
-            :database => SpecConfig.instance.test_db
+            [ ALT_LOCAL_HOST ],
+            read: { mode: :primary },
+            database: SpecConfig.instance.test_db
           )
         end
 
@@ -67,7 +72,6 @@ describe Mongo::Client do
     end
 
     context 'when the other is not a client' do
-
       it 'returns false' do
         expect(client).not_to eq('test')
       end
@@ -75,14 +79,12 @@ describe Mongo::Client do
   end
 
   describe '#[]' do
-
     let(:client) do
-      new_local_client_nmio(['127.0.0.1:27017'],
-        :database => SpecConfig.instance.test_db)
+      new_local_client_nmio([ DEFAULT_LOCAL_HOST ],
+        database: SpecConfig.instance.test_db)
     end
 
     shared_examples_for 'a collection switching object' do
-
       before do
         client.use(:dbtest)
       end
@@ -93,7 +95,6 @@ describe Mongo::Client do
     end
 
     context 'when provided a string' do
-
       let(:collection) do
         client['users']
       end
@@ -102,7 +103,6 @@ describe Mongo::Client do
     end
 
     context 'when provided a symbol' do
-
       let(:collection) do
         client[:users]
       end
@@ -112,24 +112,21 @@ describe Mongo::Client do
   end
 
   describe '#eql' do
-
     let(:client) do
       new_local_client_nmio(
-        ['127.0.0.1:27017'],
-        :read => { :mode => :primary },
-        :database => SpecConfig.instance.test_db
+        [ DEFAULT_LOCAL_HOST ],
+        read: { mode: :primary },
+        database: SpecConfig.instance.test_db
       )
     end
 
     context 'when the other is a client' do
-
       context 'when the options and cluster are equal' do
-
         let(:other) do
           new_local_client_nmio(
-            ['127.0.0.1:27017'],
-            :read => { :mode => :primary },
-            :database => SpecConfig.instance.test_db
+            [ DEFAULT_LOCAL_HOST ],
+            read: { mode: :primary },
+            database: SpecConfig.instance.test_db
           )
         end
 
@@ -139,12 +136,11 @@ describe Mongo::Client do
       end
 
       context 'when the options are not equal' do
-
         let(:other) do
           new_local_client_nmio(
-            ['127.0.0.1:27017'],
-            :read => { :mode => :secondary },
-            :database => SpecConfig.instance.test_db
+            [ DEFAULT_LOCAL_HOST ],
+            read: { mode: :secondary },
+            database: SpecConfig.instance.test_db
           )
         end
 
@@ -154,12 +150,11 @@ describe Mongo::Client do
       end
 
       context 'when the cluster is not equal' do
-
         let(:other) do
           new_local_client_nmio(
-            ['127.0.0.1:27010'],
-            :read => { :mode => :primary },
-            :database => SpecConfig.instance.test_db
+            [ ALT_LOCAL_HOST ],
+            read: { mode: :primary },
+            database: SpecConfig.instance.test_db
           )
         end
 
@@ -170,12 +165,11 @@ describe Mongo::Client do
     end
 
     context 'when the other is not a client' do
-
       let(:client) do
         new_local_client_nmio(
-          ['127.0.0.1:27017'],
-          :read => { :mode => :primary },
-          :database => SpecConfig.instance.test_db
+          [ DEFAULT_LOCAL_HOST ],
+          read: { mode: :primary },
+          database: SpecConfig.instance.test_db
         )
       end
 
@@ -186,14 +180,13 @@ describe Mongo::Client do
   end
 
   describe '#hash' do
-
     let(:client) do
       new_local_client_nmio(
-        ['127.0.0.1:27017'],
-        :read => { :mode => :primary },
-        :local_threshold => 0.010,
-        :server_selection_timeout => 10000,
-        :database => SpecConfig.instance.test_db
+        [ DEFAULT_LOCAL_HOST ],
+        read: { mode: :primary },
+        local_threshold: 0.010,
+        server_selection_timeout: 10000,
+        database: SpecConfig.instance.test_db
       )
     end
 
@@ -201,14 +194,14 @@ describe Mongo::Client do
       retry_writes: true, retry_reads: true, monitoring_io: false) }
 
     let(:options) do
-      Mongo::Options::Redacted.new(:read => { :mode => :primary },
-                                    :local_threshold => 0.010,
-                                    :server_selection_timeout => 10000,
-                                    :database => SpecConfig.instance.test_db)
+      Mongo::Options::Redacted.new(read: { mode: :primary },
+                                    local_threshold: 0.010,
+                                    server_selection_timeout: 10000,
+                                    database: SpecConfig.instance.test_db)
     end
 
     let(:expected) do
-      [client.cluster, default_options.merge(options)].hash
+      [ client.cluster, default_options.merge(options) ].hash
     end
 
     it 'returns a hash of the cluster and options' do
@@ -217,12 +210,11 @@ describe Mongo::Client do
   end
 
   describe '#inspect' do
-
     let(:client) do
       new_local_client_nmio(
-        ['127.0.0.1:27017'],
-        :read => { :mode => :primary },
-        :database => SpecConfig.instance.test_db
+        [ DEFAULT_LOCAL_HOST ],
+        read: { mode: :primary },
+        database: SpecConfig.instance.test_db
       )
     end
 
@@ -231,14 +223,13 @@ describe Mongo::Client do
     end
 
     context 'when there is sensitive data in the options' do
-
       let(:client) do
         new_local_client_nmio(
-            ['127.0.0.1:27017'],
-            :read => { :mode => :primary },
-            :database => SpecConfig.instance.test_db,
-            :password => 'some_password',
-            :user => 'emily'
+            [ DEFAULT_LOCAL_HOST ],
+            read: { mode: :primary },
+            database: SpecConfig.instance.test_db,
+            password: 'some_password',
+            user: 'emily'
         )
       end
 
@@ -249,14 +240,12 @@ describe Mongo::Client do
   end
 
   describe '#server_selector' do
-
     context 'when there is a read preference set' do
-
       let(:client) do
-        new_local_client_nmio(['127.0.0.1:27017'],
-                            :database => SpecConfig.instance.test_db,
-                            :read => mode,
-                            :server_selection_timeout => 2)
+        new_local_client_nmio([ DEFAULT_LOCAL_HOST ],
+                            database: SpecConfig.instance.test_db,
+                            read: mode,
+                            server_selection_timeout: 2)
       end
 
       let(:server_selector) do
@@ -264,9 +253,8 @@ describe Mongo::Client do
       end
 
       context 'when mode is primary' do
-
         let(:mode) do
-          { :mode => :primary }
+          { mode: :primary }
         end
 
         it 'returns a primary server selector' do
@@ -279,9 +267,8 @@ describe Mongo::Client do
       end
 
       context 'when mode is primary_preferred' do
-
         let(:mode) do
-          { :mode => :primary_preferred }
+          { mode: :primary_preferred }
         end
 
         it 'returns a primary preferred server selector' do
@@ -290,9 +277,8 @@ describe Mongo::Client do
       end
 
       context 'when mode is secondary' do
-
         let(:mode) do
-          { :mode => :secondary }
+          { mode: :secondary }
         end
 
         it 'uses a Secondary server selector' do
@@ -301,9 +287,8 @@ describe Mongo::Client do
       end
 
       context 'when mode is secondary preferred' do
-
         let(:mode) do
-          { :mode => :secondary_preferred }
+          { mode: :secondary_preferred }
         end
 
         it 'uses a Secondary server selector' do
@@ -312,9 +297,8 @@ describe Mongo::Client do
       end
 
       context 'when mode is nearest' do
-
         let(:mode) do
-          { :mode => :nearest }
+          { mode: :nearest }
         end
 
         it 'uses a Secondary server selector' do
@@ -323,11 +307,10 @@ describe Mongo::Client do
       end
 
       context 'when no mode provided' do
-
         let(:client) do
-          new_local_client_nmio(['127.0.0.1:27017'],
-                              :database => SpecConfig.instance.test_db,
-                              :server_selection_timeout => 2)
+          new_local_client_nmio([ DEFAULT_LOCAL_HOST ],
+                              database: SpecConfig.instance.test_db,
+                              server_selection_timeout: 2)
         end
 
         it 'returns a primary server selector' do
@@ -336,7 +319,6 @@ describe Mongo::Client do
       end
 
       context 'when the read preference is printed' do
-
         let(:client) do
           new_local_client_nmio(SpecConfig.instance.addresses, options)
         end
@@ -352,7 +334,7 @@ describe Mongo::Client do
         let(:error) do
           begin
             client.database.command(ping: 1)
-          rescue => e
+          rescue StandardError => e
             e
           end
         end
@@ -365,12 +347,11 @@ describe Mongo::Client do
   end
 
   describe '#read_preference' do
-
     let(:client) do
-      new_local_client_nmio(['127.0.0.1:27017'],
-                          :database => SpecConfig.instance.test_db,
-                          :read => mode,
-                          :server_selection_timeout => 2)
+      new_local_client_nmio([ DEFAULT_LOCAL_HOST ],
+                          database: SpecConfig.instance.test_db,
+                          read: mode,
+                          server_selection_timeout: 2)
     end
 
     let(:preference) do
@@ -378,9 +359,8 @@ describe Mongo::Client do
     end
 
     context 'when mode is primary' do
-
       let(:mode) do
-        { :mode => :primary }
+        { mode: :primary }
       end
 
       it 'returns a primary read preference' do
@@ -389,9 +369,8 @@ describe Mongo::Client do
     end
 
     context 'when mode is primary_preferred' do
-
       let(:mode) do
-        { :mode => :primary_preferred }
+        { mode: :primary_preferred }
       end
 
       it 'returns a primary preferred read preference' do
@@ -400,9 +379,8 @@ describe Mongo::Client do
     end
 
     context 'when mode is secondary' do
-
       let(:mode) do
-        { :mode => :secondary }
+        { mode: :secondary }
       end
 
       it 'returns a secondary read preference' do
@@ -411,9 +389,8 @@ describe Mongo::Client do
     end
 
     context 'when mode is secondary preferred' do
-
       let(:mode) do
-        { :mode => :secondary_preferred }
+        { mode: :secondary_preferred }
       end
 
       it 'returns a secondary preferred read preference' do
@@ -422,9 +399,8 @@ describe Mongo::Client do
     end
 
     context 'when mode is nearest' do
-
       let(:mode) do
-        { :mode => :nearest }
+        { mode: :nearest }
       end
 
       it 'returns a nearest read preference' do
@@ -433,11 +409,10 @@ describe Mongo::Client do
     end
 
     context 'when no mode provided' do
-
       let(:client) do
-        new_local_client_nmio(['127.0.0.1:27017'],
-                            :database => SpecConfig.instance.test_db,
-                            :server_selection_timeout => 2)
+        new_local_client_nmio([ DEFAULT_LOCAL_HOST ],
+                            database: SpecConfig.instance.test_db,
+                            server_selection_timeout: 2)
       end
 
       it 'returns nil' do
@@ -447,12 +422,10 @@ describe Mongo::Client do
   end
 
   describe '#write_concern' do
-
     let(:concern) { client.write_concern }
 
     context 'when no option was provided to the client' do
-
-      let(:client) { new_local_client_nmio(['127.0.0.1:27017'], :database => SpecConfig.instance.test_db) }
+      let(:client) { new_local_client_nmio([ DEFAULT_LOCAL_HOST ], database: SpecConfig.instance.test_db) }
 
       it 'does not set the write concern' do
         expect(concern).to be_nil
@@ -460,24 +433,20 @@ describe Mongo::Client do
     end
 
     context 'when an option is provided' do
-
       context 'when the option is acknowledged' do
-
         let(:client) do
-          new_local_client_nmio(['127.0.0.1:27017'], :write => { :j => true }, :database => SpecConfig.instance.test_db)
+          new_local_client_nmio([ DEFAULT_LOCAL_HOST ], write: { j: true }, database: SpecConfig.instance.test_db)
         end
 
         it 'returns a acknowledged write concern' do
-          expect(concern.get_last_error).to eq(:getlasterror => 1, :j => true)
+          expect(concern.get_last_error).to eq(getlasterror: 1, j: true)
         end
       end
 
       context 'when the option is unacknowledged' do
-
         context 'when the w is 0' do
-
           let(:client) do
-            new_local_client_nmio(['127.0.0.1:27017'], :write => { :w => 0 }, :database => SpecConfig.instance.test_db)
+            new_local_client_nmio([ DEFAULT_LOCAL_HOST ], write: { w: 0 }, database: SpecConfig.instance.test_db)
           end
 
           it 'returns an unacknowledged write concern' do
@@ -486,9 +455,8 @@ describe Mongo::Client do
         end
 
         context 'when the w is -1' do
-
           let(:client) do
-            new_local_client_nmio(['127.0.0.1:27017'], :write => { :w => -1 }, :database => SpecConfig.instance.test_db)
+            new_local_client_nmio([ DEFAULT_LOCAL_HOST ], write: { w: -1 }, database: SpecConfig.instance.test_db)
           end
 
           it 'raises an error' do
@@ -502,15 +470,15 @@ describe Mongo::Client do
   end
 
   [
-    [:max_read_retries, 1],
-    [:read_retry_interval, 5],
-    [:max_write_retries, 1],
+    [ :max_read_retries, 1 ],
+    [ :read_retry_interval, 5 ],
+    [ :max_write_retries, 1 ],
   ].each do |opt, default|
     describe "##{opt}" do
       let(:client_options) { {} }
 
       let(:client) do
-        new_local_client_nmio(['127.0.0.1:27017'], client_options)
+        new_local_client_nmio([ DEFAULT_LOCAL_HOST ], client_options)
       end
 
       it "defaults to #{default}" do
@@ -520,7 +488,7 @@ describe Mongo::Client do
       end
 
       context 'specified on client' do
-        let(:client_options) { {opt => 2} }
+        let(:client_options) { { opt => 2 } }
 
         it 'inherits from client' do
           expect(client.options[opt]).to eq(2)
@@ -542,24 +510,21 @@ describe Mongo::Client do
   end
 
   describe '#database' do
-
     let(:database) { client.database }
 
     context 'when client has :server_api option' do
-
       let(:client) do
-        new_local_client_nmio(['localhost'], server_api: {version: '1'})
+        new_local_client_nmio([ 'localhost' ], server_api: { version: '1' })
       end
 
       it 'is not transfered to the collection' do
-        database.options[:server_api].should be nil
+        expect(database.options[:server_api]).to be_nil
       end
     end
 
   end
 
   describe '#database_names' do
-
     it 'returns a list of database names' do
       expect(root_authorized_client.database_names).to include(
         'admin'
@@ -584,10 +549,90 @@ describe Mongo::Client do
         expect(result.first).to eq(filter[:name])
       end
     end
+
+    context 'with comment' do
+      min_server_version '4.4'
+
+      it 'returns a list of database names and send comment' do
+        result = monitored_client.database_names({}, comment: 'comment')
+        expect(result).to include('admin')
+        command = subscriber.command_started_events('listDatabases').last&.command
+        expect(command).not_to be_nil
+        expect(command['comment']).to eq('comment')
+      end
+    end
+
+    context 'with timeout_ms' do
+      # To make it easier with failCommand
+      require_topology :single
+      min_server_version '4.4'
+
+      before do
+        root_authorized_client.use('admin').command({
+          configureFailPoint: "failCommand",
+          mode: "alwaysOn",
+          data: {
+              failCommands: ["listDatabases"],
+              blockConnection: true,
+              blockTimeMS: 100
+            }
+        })
+      end
+
+      after do
+        root_authorized_client.use('admin').command({
+          configureFailPoint: "failCommand",
+          mode: "off"
+        })
+      end
+
+      context 'when timeout_ms is set on command level' do
+        context 'when there is not enough time' do
+          it 'raises' do
+            expect do
+              monitored_client.database_names({}, timeout_ms: 50)
+            end.to raise_error(Mongo::Error::TimeoutError)
+          end
+        end
+
+        context 'when there is enough time' do
+          it 'does not raise' do
+            expect do
+              monitored_client.database_names({}, timeout_ms: 200)
+            end.not_to raise_error
+          end
+        end
+      end
+
+      context 'when timeout_ms is set on client level' do
+        context 'when there is not enough time' do
+          let(:client) do
+            root_authorized_client.with(timeout_ms: 50)
+          end
+
+          it 'raises' do
+            expect do
+              client.database_names({})
+            end.to raise_error(Mongo::Error::TimeoutError)
+          end
+        end
+
+        context 'when there is enough time' do
+          let(:client) do
+            root_authorized_client.with(timeout_ms: 200)
+          end
+
+          it 'does not raise' do
+            expect do
+              monitored_client.database_names({})
+            end.not_to raise_error
+          end
+        end
+      end
+    end
   end
 
   describe '#list_databases' do
-
     it 'returns a list of database info documents' do
       expect(
         root_authorized_client.list_databases.collect do |i|
@@ -596,8 +641,6 @@ describe Mongo::Client do
     end
 
     context 'when filter criteria is present' do
-      min_server_fcv '3.6'
-
       include_context 'ensure test db exists'
 
       let(:result) do
@@ -615,8 +658,6 @@ describe Mongo::Client do
     end
 
     context 'when name_only is true' do
-      min_server_fcv '3.6'
-
       let(:command) do
         Utils.get_command_event(root_authorized_client, 'listDatabases') do |client|
           client.list_databases({}, true)
@@ -677,10 +718,92 @@ describe Mongo::Client do
         expect(command[:authorizedDatabases]).to be_nil
       end
     end
+
+    context 'with comment' do
+      min_server_version '4.4'
+
+      it 'returns a list of database names and send comment' do
+        result = monitored_client.list_databases({}, false, comment: 'comment').collect do |i|
+          i['name']
+        end
+        expect(result).to include('admin')
+        command = subscriber.command_started_events('listDatabases').last&.command
+        expect(command).not_to be_nil
+        expect(command['comment']).to eq('comment')
+      end
+    end
+
+    context 'with timeout_ms' do
+      # To make it easier with failCommand
+      require_topology :single
+      min_server_version '4.4'
+
+      before do
+        root_authorized_client.use('admin').command({
+          configureFailPoint: "failCommand",
+          mode: "alwaysOn",
+          data: {
+              failCommands: ["listDatabases"],
+              blockConnection: true,
+              blockTimeMS: 100
+            }
+        })
+      end
+
+      after do
+        root_authorized_client.use('admin').command({
+          configureFailPoint: "failCommand",
+          mode: "off"
+        })
+      end
+
+      context 'when timeout_ms is set on command level' do
+        context 'when there is not enough time' do
+          it 'raises' do
+            expect do
+              monitored_client.list_databases({}, false, timeout_ms: 50)
+            end.to raise_error(Mongo::Error::TimeoutError)
+          end
+        end
+
+        context 'when there is enough time' do
+          it 'does not raise' do
+            expect do
+              monitored_client.list_databases({}, false, timeout_ms: 200)
+            end.not_to raise_error
+          end
+        end
+      end
+
+      context 'when timeout_ms is set on client level' do
+        context 'when there is not enough time' do
+          let(:client) do
+            root_authorized_client.with(timeout_ms: 50)
+          end
+
+          it 'raises' do
+            expect do
+              client.list_databases({})
+            end.to raise_error(Mongo::Error::TimeoutError)
+          end
+        end
+
+        context 'when there is enough time' do
+          let(:client) do
+            root_authorized_client.with(timeout_ms: 200)
+          end
+
+          it 'does not raise' do
+            expect do
+              monitored_client.list_databases({})
+            end.not_to raise_error
+          end
+        end
+      end
+    end
   end
 
   describe '#list_mongo_databases' do
-
     let(:options) do
       { read: { mode: :secondary } }
     end
@@ -719,25 +842,36 @@ describe Mongo::Client do
         expect(result.first.name).to eq(filter[:name])
       end
     end
+
+    context 'with comment' do
+      min_server_version '4.4'
+
+      it 'returns a list of database names and send comment' do
+        result = monitored_client.list_mongo_databases({}, comment: 'comment')
+        expect(result).to all(be_a(Mongo::Database))
+        command = subscriber.command_started_events('listDatabases').last&.command
+        expect(command).not_to be_nil
+        expect(command['comment']).to eq('comment')
+      end
+    end
   end
 
   describe '#close' do
     let(:client) do
-      new_local_client_nmio(['127.0.0.1:27017'])
+      new_local_client_nmio([ DEFAULT_LOCAL_HOST ])
     end
 
     it 'disconnects the cluster and returns true' do
       RSpec::Mocks.with_temporary_scope do
-        expect(client.cluster).to receive(:disconnect!).and_call_original
+        expect(client.cluster).to receive(:close).and_call_original
         expect(client.close).to be(true)
       end
     end
   end
 
   describe '#reconnect' do
-
     let(:client) do
-      new_local_client_nmio([ClusterConfig.instance.primary_address_str])
+      new_local_client_nmio([ ClusterConfig.instance.primary_address_str ])
     end
 
     it 'replaces the cluster' do
@@ -760,7 +894,6 @@ describe Mongo::Client do
   end
 
   describe '#collections' do
-
     before do
       authorized_client.database[:users].drop
       authorized_client.database[:users].create
@@ -777,7 +910,6 @@ describe Mongo::Client do
   end
 
   describe '#start_session' do
-
     let(:session) do
       authorized_client.start_session
     end
@@ -790,12 +922,12 @@ describe Mongo::Client do
         expect(session).to be_a(Mongo::Session)
       end
 
-      it 'sets the last use field to the current time', retry: 4 do
+      retry_test tries: 4
+      it 'sets the last use field to the current time' do
         expect(session.instance_variable_get(:@server_session).last_use).to be_within(1).of(Time.now)
       end
 
       context 'when options are provided' do
-
         let(:options) do
           { causal_consistency: true }
         end
@@ -810,14 +942,12 @@ describe Mongo::Client do
       end
 
       context 'when options are not provided' do
-
         it 'does not set options on the session' do
           expect(session.options).to eq({ implicit: false })
         end
       end
 
       context 'when a session is checked out and checked back in' do
-
         let!(:session_a) do
           authorized_client.start_session
         end
@@ -855,7 +985,6 @@ describe Mongo::Client do
       end
 
       context 'when an implicit session is used' do
-
         before do
           authorized_client.database.command(ping: 1)
         end
@@ -873,6 +1002,247 @@ describe Mongo::Client do
           expect(before_last_use).to be < (pool.instance_variable_get(:@queue)[0].last_use)
         end
       end
+
+      context 'when an implicit session is used without enough connections' do
+        require_no_multi_mongos
+        require_wired_tiger
+
+        let(:client) do
+          authorized_client.with(options).tap do |cl|
+            cl.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+          end
+        end
+
+        let(:options) do
+          { max_pool_size: 1, retry_writes: true }
+        end
+
+        shared_examples 'a single connection' do
+          # JRuby, due to being concurrent, does not like rspec setting mocks
+          # in threads while other threads are calling the methods being mocked.
+          # My theory is that rspec removes & redefines methods as part of
+          # the mocking process, but while a method is undefined JRuby is
+          # running another thread that calls it leading to this exception:
+          # NoMethodError: undefined method `with_connection' for #<Mongo::Server:0x5386 address=localhost:27017 PRIMARY>
+          fails_on_jruby
+
+          before do
+            sessions_checked_out = 0
+
+            allow_any_instance_of(Mongo::Server).to receive(:with_connection).and_wrap_original do |m, *args, **kwargs, &block|
+              m.call(*args, **kwargs) do |connection|
+                sessions_checked_out = 0
+                res = block.call(connection)
+                expect(sessions_checked_out).to be < 2
+                res
+              end
+            end
+          end
+
+          it "doesn't have any live sessions" do
+            threads.each do |thread|
+              thread.join
+            end
+          end
+        end
+
+        context 'when doing three inserts' do
+          let(:threads) do
+            (1..3).map do |i|
+              Thread.new do
+                client['test'].insert_one({ test: "test#{i}" })
+              end
+            end
+          end
+
+          include_examples 'a single connection'
+        end
+
+        context 'when doing an insert and two updates' do
+          let(:threads) do
+            threads = []
+            threads << Thread.new do
+              client['test'].insert_one({ test: 'test' })
+            end
+            threads << Thread.new do
+              client['test'].update_one({ test: 'test' }, { '$set' => { test: 'test2' } })
+            end
+            threads << Thread.new do
+              client['test'].update_one({ test: 'test' }, { '$set' => { test: 'test2' } })
+            end
+            threads
+          end
+
+          include_examples 'a single connection'
+        end
+
+        context 'when doing an insert, update and delete' do
+          let(:threads) do
+            threads = []
+            threads << Thread.new do
+              client['test'].insert_one({ test: 'test' })
+            end
+            threads << Thread.new do
+              client['test'].update_one({ test: 'test' }, { '$set' => { test: 'test2' } })
+            end
+            threads << Thread.new do
+              client['test'].delete_one({ test: 'test' })
+            end
+            threads
+          end
+
+          include_examples 'a single connection'
+        end
+
+        context 'when doing an insert, update and find' do
+          let(:threads) do
+            threads = []
+            threads << Thread.new do
+              client['test'].insert_one({ test: 'test' })
+            end
+            threads << Thread.new do
+              client['test'].update_one({ test: 'test' }, { '$set' => { test: 'test2' } })
+            end
+            threads << Thread.new do
+              client['test'].find({ test: 'test' }).to_a
+            end
+            threads
+          end
+
+          include_examples 'a single connection'
+        end
+
+        context 'when doing an insert, update and bulk write' do
+          let(:threads) do
+            threads = []
+            threads << Thread.new do
+              client['test'].insert_one({ test: 'test' })
+            end
+            threads << Thread.new do
+              client['test'].update_one({ test: 'test' }, { '$set' => { test: 'test2' } })
+            end
+            threads << Thread.new do
+              client['test'].bulk_write([ { insert_one: { test: 'test1' } },
+                                          { update_one: { filter: { test: 'test1' }, update: { '$set' => { test: 'test2' } } } } ])
+            end
+            threads
+          end
+
+          include_examples 'a single connection'
+        end
+
+        context 'when doing an insert, update and find_one_and_delete' do
+          let(:threads) do
+            threads = []
+            threads << Thread.new do
+              client['test'].insert_one({ test: 'test' })
+            end
+            threads << Thread.new do
+              client['test'].update_one({ test: 'test' }, { '$set' => { test: 'test2' } })
+            end
+            threads << Thread.new do
+              client['test'].find_one_and_delete({ test: 'test' })
+            end
+            threads
+          end
+
+          include_examples 'a single connection'
+        end
+
+        context 'when doing an insert, update and find_one_and_update' do
+          let(:threads) do
+            threads = []
+            threads << Thread.new do
+              client['test'].insert_one({ test: 'test' })
+            end
+            threads << Thread.new do
+              client['test'].update_one({ test: 'test' }, { '$set' => { test: 'test2' } })
+            end
+            threads << Thread.new do
+              client['test'].find_one_and_update({ test: 'test' }, { test: 'test2' })
+            end
+            threads
+          end
+
+          include_examples 'a single connection'
+        end
+
+        context 'when doing an insert, update and find_one_and_replace' do
+          let(:threads) do
+            threads = []
+            threads << Thread.new do
+              client['test'].insert_one({ test: 'test' })
+            end
+            threads << Thread.new do
+              client['test'].update_one({ test: 'test' }, { '$set' => { test: 'test2' } })
+            end
+            threads << Thread.new do
+              client['test'].find_one_and_replace({ test: 'test' }, { test: 'test2' })
+            end
+            threads
+          end
+
+          include_examples 'a single connection'
+        end
+
+        context 'when doing an insert, update and a replace' do
+          let(:threads) do
+            threads = []
+            threads << Thread.new do
+              client['test'].insert_one({ test: 'test' })
+            end
+            threads << Thread.new do
+              client['test'].update_one({ test: 'test' }, { '$set' => { test: 'test2' } })
+            end
+            threads << Thread.new do
+              client['test'].replace_one({ test: 'test' }, { test: 'test2' })
+            end
+            threads
+          end
+
+          include_examples 'a single connection'
+        end
+
+        context 'when doing all of the operations' do
+          let(:threads) do
+            threads = []
+            threads << Thread.new do
+              client['test'].insert_one({ test: 'test' })
+            end
+            threads << Thread.new do
+              client['test'].update_one({ test: 'test' }, { '$set' => { test: 1 } })
+            end
+            threads << Thread.new do
+              client['test'].find_one_and_replace({ test: 'test' }, { test: 'test2' })
+            end
+            threads << Thread.new do
+              client['test'].delete_one({ test: 'test' })
+            end
+            threads << Thread.new do
+              client['test'].find({ test: 'test' }).to_a
+            end
+            threads << Thread.new do
+              client['test'].bulk_write([ { insert_one: { test: 'test1' } },
+                                          { update_one: { filter: { test: 'test1' }, update: { '$set' => { test: 'test2' } } } } ])
+            end
+            threads << Thread.new do
+              client['test'].find_one_and_delete({ test: 'test' })
+            end
+            threads << Thread.new do
+              client['test'].find_one_and_update({ test: 'test' }, { test: 'test2' })
+            end
+            threads << Thread.new do
+              client['test'].find_one_and_replace({ test: 'test' }, { test: 'test2' })
+            end
+            threads << Thread.new do
+              client['test'].replace_one({ test: 'test' }, { test: 'test2' })
+            end
+            threads
+          end
+
+          include_examples 'a single connection'
+        end
+      end
     end
 
     context 'when two clients have the same cluster' do
@@ -920,21 +1290,40 @@ describe Mongo::Client do
         }.to raise_exception(Mongo::Error::InvalidSession)
       end
     end
+
+    context 'when CSOT is set on the client' do
+      require_topology :replica_set
+
+      let(:timeout_ms) { 10 }
+
+      let(:timeout_sec) { timeout_ms / 1_000.0 }
+
+      let(:client) do
+        authorized_client.with(timeout_ms: timeout_ms)
+      end
+
+      it 'uses CSOT timeout set on the client' do
+        expect_any_instance_of(Mongo::ServerSelector::PrimaryPreferred).to(
+          receive(:select_server).with(anything, {timeout: timeout_sec}).and_call_original
+        )
+
+        client.start_session
+      end
+    end
   end
 
   describe '#summary' do
-
     context 'monitoring omitted' do
       let(:client) do
         new_local_client_nmio(
-          ['127.0.0.1:27017'],
-          :read => { :mode => :primary },
-          :database => SpecConfig.instance.test_db
+          [ DEFAULT_LOCAL_HOST ],
+          read: { mode: :primary },
+          database: SpecConfig.instance.test_db
         )
       end
 
       it 'indicates lack of monitoring' do
-        client.summary.should =~ /servers=.*UNKNOWN.*NO-MONITORING/
+        expect(client.summary).to match /servers=.*UNKNOWN.*NO-MONITORING/
       end
     end
 
@@ -946,20 +1335,22 @@ describe Mongo::Client do
       end
 
       it 'does not indicate lack of monitoring' do
-        client.summary.should =~ /servers=.*(?:STANDALONE|PRIMARY|MONGOS)/
-        client.summary.should_not =~ /servers=.*(?:STANDALONE|PRIMARY|MONGOS).*NO-MONITORING/
+        expect(client.summary).to match /servers=.*(?:STANDALONE|PRIMARY|MONGOS)/
+        expect(client.summary).not_to match /servers=.*(?:STANDALONE|PRIMARY|MONGOS).*NO-MONITORING/
       end
     end
 
     context 'background threads killed' do
       let(:client) do
         authorized_client.tap do |client|
-          client.cluster.servers.map(&:disconnect!)
+          client.cluster.servers.map do |server|
+            server.monitor&.stop!
+          end
         end
       end
 
       it 'does not indicate lack of monitoring' do
-        client.summary.should =~ /servers=.*(STANDALONE|PRIMARY|MONGOS|\bLB\b).*NO-MONITORING/
+        expect(client.summary).to match /servers=.*(STANDALONE|PRIMARY|MONGOS|\bLB\b).*NO-MONITORING/
       end
     end
   end