mongo 2.18.1 → 2.19.1

data/spec/mongo/client_construction_spec.rb

@@ -1,8 +1,19 @@
 # frozen_string_literal: true
-# encoding: utf-8
 
 require 'spec_helper'
 
+SINGLE_CLIENT = [ '127.0.0.1:27017' ].freeze
+
+# let these existing styles stand, rather than going in for a deep refactoring
+# of these specs.
+#
+# possible future work: re-enable these one at a time and do the hard work of
+# making them right.
+#
+# rubocop:disable RSpec/ExpectInHook, RSpec/MessageSpies, RSpec/ExampleLength
+# rubocop:disable RSpec/ContextWording, RSpec/RepeatedExampleGroupDescription
+# rubocop:disable RSpec/ExampleWording, Style/BlockComments, RSpec/AnyInstance
+# rubocop:disable RSpec/VerifiedDoubles
 describe Mongo::Client do
   clean_slate
 
@@ -10,13 +21,15 @@ describe Mongo::Client do
 
   describe '.new' do
     context 'with scan: false' do
+      fails_on_jruby
+
       it 'does not perform i/o' do
         allow_any_instance_of(Mongo::Server::Monitor).to receive(:run!)
         expect_any_instance_of(Mongo::Server::Monitor).not_to receive(:scan!)
-        start_time = Time.now
+
         # return should be instant
         c = Timeout.timeout(1) do
-          ClientRegistry.instance.new_local_client(['1.1.1.1'], scan: false)
+          ClientRegistry.instance.new_local_client([ '1.1.1.1' ], scan: false)
         end
         expect(c.cluster.servers).to be_empty
         c.close
@@ -24,23 +37,21 @@ describe Mongo::Client do
     end
 
     context 'with default scan: true' do
-
       shared_examples 'does not wait for server selection timeout' do
-
         let(:logger) do
-          Logger.new(STDOUT, level: Logger::DEBUG)
+          Logger.new($stdout, level: Logger::DEBUG)
         end
 
         let(:subscriber) do
           Mongo::Monitoring::UnifiedSdamLogSubscriber.new(
             logger: logger,
-            log_prefix: 'CCS-SDAM',
+            log_prefix: 'CCS-SDAM'
           )
         end
 
         let(:client) do
           ClientRegistry.instance.new_local_client(
-            [address],
+            [ address ],
             # Specify server selection timeout here because test suite sets
             # one by default and it's fairly low
             SpecConfig.instance.test_options.merge(
@@ -49,10 +60,9 @@ describe Mongo::Client do
               server_selection_timeout: 8,
               logger: logger,
               log_prefix: 'CCS-CLIENT',
-              sdam_proc: lambda do |client|
-                subscriber.subscribe(client)
-              end
-            ))
+              sdam_proc: ->(client) { subscriber.subscribe(client) }
+            )
+          )
         end
 
         it 'does not wait for server selection timeout' do
@@ -73,11 +83,11 @@ describe Mongo::Client do
 
           actual_class = client.cluster.topology.class
           expect([
-            Mongo::Cluster::Topology::ReplicaSetWithPrimary,
-            Mongo::Cluster::Topology::Single,
-            Mongo::Cluster::Topology::Sharded,
-            Mongo::Cluster::Topology::LoadBalanced,
-          ]).to include(actual_class)
+                   Mongo::Cluster::Topology::ReplicaSetWithPrimary,
+                   Mongo::Cluster::Topology::Single,
+                   Mongo::Cluster::Topology::Sharded,
+                   Mongo::Cluster::Topology::LoadBalanced,
+                 ]).to include(actual_class)
           expect(time_taken).to be < 5
 
           # run a command to ensure the client is a working one
@@ -88,17 +98,17 @@ describe Mongo::Client do
       context 'when cluster is monitored' do
         require_topology :single, :replica_set, :sharded
 
-        # TODO this test requires there being no outstanding background
+        # TODO: this test requires there being no outstanding background
         # monitoring threads running, as otherwise the scan! expectation
         # can be executed on a thread that belongs to one of the global
         # clients for instance
         it 'performs one round of sdam' do
           # Does not work due to
           # https://github.com/rspec/rspec-mocks/issues/1242.
-          #expect_any_instance_of(Mongo::Server::Monitor).to receive(:scan!).
+          #
+          # expect_any_instance_of(Mongo::Server::Monitor).to receive(:scan!).
           #  exactly(SpecConfig.instance.addresses.length).times.and_call_original
-          c = new_local_client(
-            SpecConfig.instance.addresses, SpecConfig.instance.test_options)
+          c = new_local_client(SpecConfig.instance.addresses, SpecConfig.instance.test_options)
           expect(c.cluster.servers).not_to be_empty
         end
 
@@ -126,7 +136,7 @@ describe Mongo::Client do
 
     context 'with monitoring_io: false' do
       let(:client) do
-        new_local_client(['127.0.0.1:27017'], monitoring_io: false)
+        new_local_client(SINGLE_CLIENT, monitoring_io: false)
       end
 
       it 'passes monitoring_io: false to cluster' do
@@ -178,7 +188,7 @@ describe Mongo::Client do
         let(:mongocryptd_uri) { 'mongodb://localhost:27021' }
         let(:mongocryptd_bypass_spawn) { true }
         let(:mongocryptd_spawn_path) { '/spawn/path' }
-        let(:mongocryptd_spawn_args) { ['--idleShutdownTimeoutSecs=100'] }
+        let(:mongocryptd_spawn_args) { [ '--idleShutdownTimeoutSecs=100' ] }
 
         shared_examples 'a functioning auto encryption client' do
           let(:encryption_options) { client.encrypter.options }
@@ -203,7 +213,10 @@ describe Mongo::Client do
             let(:key_vault_namespace) { 'not.good.formatting' }
 
             it 'raises an exception' do
-              expect { client }.to raise_error(ArgumentError, /key_vault_namespace option must be in the format database.collection/)
+              expect { client }.to raise_error(
+                ArgumentError,
+                /key_vault_namespace option must be in the format database.collection/
+              )
             end
           end
 
@@ -219,7 +232,10 @@ describe Mongo::Client do
             let(:kms_providers) { { random_key: 'hello' } }
 
             it 'raises an exception' do
-              expect { client }.to raise_error(ArgumentError, /KMS providers options must have one of the following keys: :aws, :azure, :gcp, :kmip, :local/)
+              expect { client }.to raise_error(
+                ArgumentError,
+                /KMS providers options must have one of the following keys: :aws, :azure, :gcp, :kmip, :local/
+              )
             end
           end
 
@@ -227,15 +243,25 @@ describe Mongo::Client do
             let(:kms_providers) { { local: { wrong_key: 'hello' } } }
 
             it 'raises an exception' do
-              expect { client }.to raise_error(ArgumentError, /Local KMS provider options must be in the format: { key: 'MASTER-KEY' }/)
+              expect { client }.to raise_error(
+                ArgumentError,
+                /Local KMS provider options must be in the format: { key: 'MASTER-KEY' }/
+              )
             end
           end
 
           context 'when aws kms_provider is incorrectly formatted' do
             let(:kms_providers) { { aws: { wrong_key: 'hello' } } }
 
+            let(:expected_options_format) do
+              "{ access_key_id: 'YOUR-ACCESS-KEY-ID', secret_access_key: 'SECRET-ACCESS-KEY' }"
+            end
+
             it 'raises an exception' do
-              expect { client }.to raise_error(ArgumentError, / AWS KMS provider options must be in the format: { access_key_id: 'YOUR-ACCESS-KEY-ID', secret_access_key: 'SECRET-ACCESS-KEY' }/)
+              expect { client }.to raise_error(
+                ArgumentError,
+                / AWS KMS provider options must be in the format: #{expected_options_format}/
+              )
             end
           end
 
@@ -265,7 +291,7 @@ describe Mongo::Client do
               expect(encryption_options[:key_vault_namespace]).to eq(key_vault_namespace)
               # Don't explicitly expect kms_providers to avoid accidentally exposing
               # sensitive data in evergreen logs
-              expect(encryption_options[:kms_providers]).to be_a_kind_of(Hash)
+              expect(encryption_options[:kms_providers]).to be_a(Hash)
               expect(encryption_options[:schema_map]).to eq(schema_map)
               expect(encryption_options[:bypass_auto_encryption]).to eq(bypass_auto_encryption)
               expect(encryption_options[:extra_options][:mongocryptd_uri]).to eq(mongocryptd_uri)
@@ -298,20 +324,22 @@ describe Mongo::Client do
                 expect(encryption_options[:extra_options][:mongocryptd_uri]).to eq('mongodb://localhost:27020')
                 expect(encryption_options[:extra_options][:mongocryptd_bypass_spawn]).to be false
                 expect(encryption_options[:extra_options][:mongocryptd_spawn_path]).to eq('mongocryptd')
-                expect(encryption_options[:extra_options][:mongocryptd_spawn_args]).to eq(['--idleShutdownTimeoutSecs=60'])
+                expect(encryption_options[:extra_options][:mongocryptd_spawn_args])
+                  .to eq([ '--idleShutdownTimeoutSecs=60' ])
               end
             end
 
             context 'with mongocryptd_spawn_args that don\'t include idleShutdownTimeoutSecs' do
-              let(:mongocryptd_spawn_args) { ['--otherArgument=true'] }
+              let(:mongocryptd_spawn_args) { [ '--otherArgument=true' ] }
 
               it 'adds a default value to mongocryptd_spawn_args' do
-                expect(encryption_options[:extra_options][:mongocryptd_spawn_args]).to eq(mongocryptd_spawn_args + ['--idleShutdownTimeoutSecs=60'])
+                expect(encryption_options[:extra_options][:mongocryptd_spawn_args])
+                  .to eq(mongocryptd_spawn_args + [ '--idleShutdownTimeoutSecs=60' ])
               end
             end
 
             context 'with mongocryptd_spawn_args that has idleShutdownTimeoutSecs as two arguments' do
-              let(:mongocryptd_spawn_args) { ['--idleShutdownTimeoutSecs', 100] }
+              let(:mongocryptd_spawn_args) { [ '--idleShutdownTimeoutSecs', 100 ] }
 
               it 'does not modify mongocryptd_spawn_args' do
                 expect(encryption_options[:extra_options][:mongocryptd_spawn_args]).to eq(mongocryptd_spawn_args)
@@ -324,7 +352,7 @@ describe Mongo::Client do
               it 'creates a key_vault_client' do
                 key_vault_client = encryption_options[:key_vault_client]
 
-                expect(key_vault_client).to be_a_kind_of(Mongo::Client)
+                expect(key_vault_client).to be_a(described_class)
               end
             end
           end
@@ -345,54 +373,47 @@ describe Mongo::Client do
 
       context 'timeout options' do
         let(:client) do
-          new_local_client(SpecConfig.instance.addresses,
-            SpecConfig.instance.authorized_test_options.merge(options))
+          new_local_client(
+            SpecConfig.instance.addresses,
+            SpecConfig.instance.authorized_test_options.merge(options)
+          )
         end
 
         context 'when network timeouts are zero' do
-          let(:options) do
-            { socket_timeout: 0, connect_timeout: 0 }
-          end
+          let(:options) { { socket_timeout: 0, connect_timeout: 0 } }
 
           it 'sets options to zeros' do
-            client.options[:socket_timeout].should == 0
-            client.options[:connect_timeout].should == 0
+            expect(client.options[:socket_timeout]).to be == 0
+            expect(client.options[:connect_timeout]).to be == 0
           end
 
           it 'connects and performs operations successfully' do
-            lambda do
-              client.database.command(ping: 1)
-            end.should_not raise_error
+            expect { client.database.command(ping: 1) }
+              .not_to raise_error
           end
         end
 
-        %i(socket_timeout connect_timeout).each do |option|
+        %i[ socket_timeout connect_timeout ].each do |option|
           context "when #{option} is negative" do
-            let(:options) do
-              { option => -1 }
-            end
+            let(:options) { { option => -1 } }
 
             it 'fails client creation' do
-              lambda do
-                client
-              end.should raise_error(ArgumentError, /#{option} must be a non-negative number/)
+              expect { client }
+                .to raise_error(ArgumentError, /#{option} must be a non-negative number/)
             end
           end
 
           context "when #{option} is of the wrong type" do
-            let(:options) do
-              { option => '42' }
-            end
+            let(:options) { { option => '42' } }
 
             it 'fails client creation' do
-              lambda do
-                client
-              end.should raise_error(ArgumentError, /#{option} must be a non-negative number/)
+              expect { client }
+                .to raise_error(ArgumentError, /#{option} must be a non-negative number/)
             end
           end
         end
 
-        context "when :connect_timeout is very small" do
+        context 'when :connect_timeout is very small' do
           # The driver reads first and checks the deadline second.
           # This means the read (in a monitor) can technically take more than
           # the connect timeout. Restrict to TLS configurations to make
@@ -404,18 +425,15 @@ describe Mongo::Client do
           end
 
           it 'allows client creation' do
-            lambda do
-              client
-            end.should_not raise_error
+            expect { client }.not_to raise_error
           end
 
           context 'non-lb' do
             require_topology :single, :replica_set, :sharded
 
             it 'fails server selection due to very small timeout' do
-              lambda do
-                client.database.command(ping: 1)
-              end.should raise_error(Mongo::Error::NoServerAvailable)
+              expect { client.database.command(ping: 1) }
+                .to raise_error(Mongo::Error::NoServerAvailable)
             end
           end
 
@@ -423,14 +441,13 @@ describe Mongo::Client do
             require_topology :load_balanced
 
             it 'fails the operation after successful server selection' do
-              lambda do
-                client.database.command(ping: 1)
-              end.should raise_error(Mongo::Error::SocketTimeoutError, /socket took over.*to connect/)
+              expect { client.database.command(ping: 1) }
+                .to raise_error(Mongo::Error::SocketTimeoutError, /socket took over.*to connect/)
             end
           end
         end
 
-        context "when :socket_timeout is very small" do
+        context 'when :socket_timeout is very small' do
           # The driver reads first and checks the deadline second.
           # This means the read (in a monitor) can technically take more than
           # the connect timeout. Restrict to TLS configurations to make
@@ -442,16 +459,13 @@ describe Mongo::Client do
           end
 
           it 'allows client creation' do
-            lambda do
-              client
-            end.should_not raise_error
+            expect { client }.not_to raise_error
           end
 
           retry_test
           it 'fails operations due to very small timeout' do
-            lambda do
-              client.database.command(ping: 1)
-            end.should raise_error(Mongo::Error::SocketTimeoutError)
+            expect { client.database.command(ping: 1) }
+              .to raise_error(Mongo::Error::SocketTimeoutError)
           end
         end
       end
@@ -462,7 +476,6 @@ describe Mongo::Client do
         end
 
         context 'when retry_writes is true' do
-
           let(:options) do
             { retry_writes: true }
           end
@@ -473,7 +486,6 @@ describe Mongo::Client do
         end
 
         context 'when retry_writes is false' do
-
           let(:options) do
             { retry_writes: false }
           end
@@ -484,10 +496,7 @@ describe Mongo::Client do
         end
 
         context 'when retry_writes is not given' do
-
-          let(:options) do
-            { }
-          end
+          let(:options) { {} }
 
           it 'sets retry_writes to true' do
             expect(client.options['retry_writes']).to be true
@@ -496,17 +505,18 @@ describe Mongo::Client do
       end
 
       context 'when compressors are provided' do
-
         let(:client) do
-          new_local_client(SpecConfig.instance.addresses,
-            SpecConfig.instance.all_test_options.merge(options))
+          new_local_client(
+            SpecConfig.instance.addresses,
+            SpecConfig.instance.all_test_options.merge(options)
+          )
         end
 
         context 'when the compressor is not supported by the driver' do
           require_warning_clean
 
           let(:options) do
-            { compressors: ['snoopy'] }
+            { compressors: %w[ snoopy ] }
           end
 
           it 'does not set the compressor and warns' do
@@ -523,16 +533,16 @@ describe Mongo::Client do
             min_server_fcv '3.6'
 
             let(:options) do
-              { compressors: ['zlib', 'snoopy'] }
+              { compressors: %w[ zlib snoopy ] }
             end
 
             it 'does not set the unsupported compressor and warns' do
               expect(Mongo::Logger.logger).to receive(:warn).at_least(:once)
-              expect(client.options['compressors']).to eq(['zlib'])
+              expect(client.options['compressors']).to eq(%w[ zlib ])
             end
 
             it 'sets the compression key of the handshake document to the list of supported compressors' do
-              expect(client.cluster.app_metadata.send(:document)[:compression]).to eq(['zlib'])
+              expect(client.cluster.app_metadata.send(:document)[:compression]).to eq(%w[ zlib ])
             end
           end
         end
@@ -541,7 +551,7 @@ describe Mongo::Client do
           max_server_version '3.4'
 
           let(:options) do
-            { compressors: ['zlib'] }
+            { compressors: %w[ zlib ] }
           end
 
           it 'does not set the compressor and warns' do
@@ -554,7 +564,7 @@ describe Mongo::Client do
           require_zlib_compression
 
           let(:options) do
-            { compressors: ['zlib'] }
+            { compressors: %w[ zlib ] }
           end
 
           it 'sets the compressor' do
@@ -576,9 +586,7 @@ describe Mongo::Client do
 
           it 'does not use compression for authentication messages' do
             expect(Mongo::Protocol::Compressed).not_to receive(:new)
-            client.cluster.next_primary.send(:with_connection) do |conn|
-              conn.connect!
-            end
+            client.cluster.next_primary.send(:with_connection, &:connect!)
           end
         end
 
@@ -586,14 +594,14 @@ describe Mongo::Client do
           min_server_version '3.6'
 
           let(:options) do
-            { compressors: ['snappy'] }
+            { compressors: %w[ snappy ] }
           end
 
           context 'when snappy gem is installed' do
             require_snappy_compression
 
             it 'creates the client' do
-              expect(client.options['compressors']).to eq(['snappy'])
+              expect(client.options['compressors']).to eq(%w[ snappy ])
             end
           end
 
@@ -612,14 +620,14 @@ describe Mongo::Client do
           min_server_version '4.2'
 
           let(:options) do
-            { compressors: ['zstd'] }
+            { compressors: %w[ zstd ] }
           end
 
           context 'when zstd gem is installed' do
             require_zstd_compression
 
             it 'creates the client' do
-              expect(client.options['compressors']).to eq(['zstd'])
+              expect(client.options['compressors']).to eq(%w[ zstd ])
             end
           end
 
@@ -661,7 +669,10 @@ describe Mongo::Client do
         min_server_fcv '3.6'
 
         let(:client) do
-          new_local_client_nmio(SpecConfig.instance.addresses, SpecConfig.instance.test_options.merge(zlib_compression_level: 1))
+          new_local_client_nmio(
+            SpecConfig.instance.addresses,
+            SpecConfig.instance.test_options.merge(zlib_compression_level: 1)
+          )
         end
 
         it 'sets the option on the client' do
@@ -670,26 +681,25 @@ describe Mongo::Client do
       end
 
       context 'when ssl options are provided' do
-
         let(:options) do
           {
-            :ssl => true,
-            :ssl_ca_cert => SpecConfig.instance.ca_cert_path,
-            :ssl_ca_cert_string => 'ca cert string',
-            :ssl_ca_cert_object => 'ca cert object',
-            :ssl_cert => SpecConfig.instance.client_cert_path,
-            :ssl_cert_string => 'cert string',
-            :ssl_cert_object => 'cert object',
-            :ssl_key => SpecConfig.instance.client_key_path,
-            :ssl_key_string => 'key string',
-            :ssl_key_object => 'key object',
-            :ssl_key_pass_phrase => 'passphrase',
-            :ssl_verify => true
+            ssl: true,
+            ssl_ca_cert: SpecConfig.instance.ca_cert_path,
+            ssl_ca_cert_string: 'ca cert string',
+            ssl_ca_cert_object: 'ca cert object',
+            ssl_cert: SpecConfig.instance.client_cert_path,
+            ssl_cert_string: 'cert string',
+            ssl_cert_object: 'cert object',
+            ssl_key: SpecConfig.instance.client_key_path,
+            ssl_key_string: 'key string',
+            ssl_key_object: 'key object',
+            ssl_key_pass_phrase: 'passphrase',
+            ssl_verify: true,
           }
         end
 
         let(:client) do
-          new_local_client_nmio(['127.0.0.1:27017'], options)
+          new_local_client_nmio(SINGLE_CLIENT, options)
         end
 
         it 'sets the ssl option' do
@@ -742,9 +752,8 @@ describe Mongo::Client do
       end
 
       context 'when no database is provided' do
-
         let(:client) do
-          new_local_client_nmio(['127.0.0.1:27017'], :read => { :mode => :secondary })
+          new_local_client_nmio(SINGLE_CLIENT, read: { mode: :secondary })
         end
 
         it 'defaults the database to admin' do
@@ -753,9 +762,8 @@ describe Mongo::Client do
       end
 
       context 'when a database is provided' do
-
         let(:client) do
-          new_local_client_nmio(['127.0.0.1:27017'], :database => :testdb)
+          new_local_client_nmio(SINGLE_CLIENT, database: :testdb)
         end
 
         it 'sets the current database' do
@@ -764,9 +772,8 @@ describe Mongo::Client do
       end
 
       context 'when providing a custom logger' do
-
         let(:logger) do
-          Logger.new(STDOUT).tap do |l|
+          Logger.new($stdout).tap do |l|
             l.level = Logger::FATAL
           end
         end
@@ -776,14 +783,13 @@ describe Mongo::Client do
         end
 
         it 'does not use the global logger' do
-          expect(client.cluster.logger).to_not eq(Mongo::Logger.logger)
+          expect(client.cluster.logger).not_to eq(Mongo::Logger.logger)
         end
       end
 
       context 'when providing a heartbeat_frequency' do
-
         let(:client) do
-          new_local_client_nmio(['127.0.0.1:27017'], :heartbeat_frequency => 2)
+          new_local_client_nmio(SINGLE_CLIENT, heartbeat_frequency: 2)
         end
 
         it 'sets the heartbeat frequency' do
@@ -791,38 +797,47 @@ describe Mongo::Client do
         end
       end
 
-      context 'when min_pool_size is provided' do
-
+      context 'when max_connecting is provided' do
         let(:client) do
-          new_local_client_nmio(['127.0.0.1:27017'], options)
+          new_local_client_nmio(SINGLE_CLIENT, options)
         end
 
-        context 'when max_pool_size is provided' do
+        context 'when max_connecting is a positive integer' do
+          let(:options) do
+            { max_connecting: 5 }
+          end
 
-          context 'when the min_pool_size is greater than the max_pool_size' do
+          it 'sets the max connecting' do
+            expect(client.options[:max_connecting]).to eq(options[:max_connecting])
+          end
+        end
 
-            let(:options) do
-              {
-                  :min_pool_size => 20,
-                  :max_pool_size => 10
-              }
-            end
+        context 'when max_connecting is a negative integer' do
+          let(:options) do
+            { max_connecting: -5 }
+          end
+
+          it 'raises an exception' do
+            expect { client }.to raise_error(Mongo::Error::InvalidMaxConnecting)
+          end
+        end
+      end
+
+      context 'when min_pool_size is provided' do
+        let(:client) { new_local_client_nmio(SINGLE_CLIENT, options) }
+
+        context 'when max_pool_size is provided' do
+          context 'when the min_pool_size is greater than the max_pool_size' do
+            let(:options) { { min_pool_size: 20, max_pool_size: 10 } }
 
             it 'raises an Exception' do
-              expect {
-                client
-              }.to raise_exception(Mongo::Error::InvalidMinPoolSize)
+              expect { client }
+                .to raise_exception(Mongo::Error::InvalidMinPoolSize)
             end
           end
 
           context 'when the min_pool_size is less than the max_pool_size' do
-
-            let(:options) do
-              {
-                  :min_pool_size => 10,
-                  :max_pool_size => 20
-              }
-            end
+            let(:options) { { min_pool_size: 10, max_pool_size: 20 } }
 
             it 'sets the option' do
               expect(client.options[:min_pool_size]).to eq(options[:min_pool_size])
@@ -831,13 +846,7 @@ describe Mongo::Client do
           end
 
           context 'when the min_pool_size is equal to the max_pool_size' do
-
-            let(:options) do
-              {
-                  :min_pool_size => 10,
-                  :max_pool_size => 10
-              }
-            end
+            let(:options) { { min_pool_size: 10, max_pool_size: 10 } }
 
             it 'sets the option' do
               expect(client.options[:min_pool_size]).to eq(options[:min_pool_size])
@@ -846,12 +855,7 @@ describe Mongo::Client do
           end
 
           context 'when max_pool_size is zero (unlimited)' do
-            let(:options) do
-              {
-                  :min_pool_size => 10,
-                  :max_pool_size => 0
-              }
-            end
+            let(:options) { { min_pool_size: 10, max_pool_size: 0 } }
 
             it 'sets the option' do
               expect(client.options[:min_pool_size]).to eq(options[:min_pool_size])
@@ -861,29 +865,17 @@ describe Mongo::Client do
         end
 
         context 'when max_pool_size is not provided' do
-
           context 'when the min_pool_size is greater than the default max_pool_size' do
-
-            let(:options) do
-              {
-                  :min_pool_size => 30
-              }
-            end
+            let(:options) { { min_pool_size: 30 } }
 
             it 'raises an Exception' do
-              expect {
-                client
-              }.to raise_exception(Mongo::Error::InvalidMinPoolSize)
+              expect { client }
+                .to raise_exception(Mongo::Error::InvalidMinPoolSize)
             end
           end
 
           context 'when the min_pool_size is less than the default max_pool_size' do
-
-            let(:options) do
-              {
-                  :min_pool_size => 3
-              }
-            end
+            let(:options) { { min_pool_size: 3 } }
 
             it 'sets the option' do
               expect(client.options[:min_pool_size]).to eq(options[:min_pool_size])
@@ -891,10 +883,9 @@ describe Mongo::Client do
           end
 
           context 'when the min_pool_size is equal to the max_pool_size' do
-
             let(:options) do
               {
-                :min_pool_size => Mongo::Server::ConnectionPool::DEFAULT_MAX_SIZE
+                min_pool_size: Mongo::Server::ConnectionPool::DEFAULT_MAX_SIZE
               }
             end
 
@@ -905,36 +896,18 @@ describe Mongo::Client do
         end
       end
 
-      context 'when max_pool_size is provided' do
-        let(:client) do
-          new_local_client_nmio(['127.0.0.1:27017'], options)
-        end
-
-        context 'when max_pool_size is 0 (unlimited)' do
-          let(:options) do
-            {
-                :max_pool_size => 0
-            }
-          end
+      context 'when max_pool_size is 0 (unlimited)' do
+        let(:client) { new_local_client_nmio(SINGLE_CLIENT, options) }
+        let(:options) { { max_pool_size: 0 } }
 
-          it 'sets the option' do
-            expect(client.options[:max_pool_size]).to eq(options[:max_pool_size])
-          end
+        it 'sets the option' do
+          expect(client.options[:max_pool_size]).to eq(options[:max_pool_size])
         end
       end
 
       context 'when max_pool_size and min_pool_size are both nil' do
-
-        let(:client) do
-          new_local_client_nmio(['127.0.0.1:27017'], options)
-        end
-
-        let(:options) do
-          {
-              :min_pool_size => nil,
-              :max_pool_size => nil
-          }
-        end
+        let(:options) { { min_pool_size: nil, max_pool_size: nil } }
+        let(:client) { new_local_client_nmio(SINGLE_CLIENT, options) }
 
         it 'does not set either option' do
           expect(client.options[:max_pool_size]).to be_nil
@@ -943,28 +916,26 @@ describe Mongo::Client do
       end
 
       context 'when platform details are specified' do
-
         let(:app_metadata) do
           client.cluster.app_metadata
         end
 
         let(:client) do
-          new_local_client_nmio(['127.0.0.1:27017'], :platform => 'mongoid-6.0.2')
+          new_local_client_nmio(SINGLE_CLIENT, platform: 'mongoid-6.0.2')
         end
 
         it 'includes the platform info in the app metadata' do
-          expect(app_metadata.send(:full_client_document)[:platform]).to match(/mongoid-6\.0\.2/)
+          expect(app_metadata.client_document[:platform]).to match(/mongoid-6\.0\.2/)
         end
       end
 
       context 'when platform details are not specified' do
-
         let(:app_metadata) do
           client.cluster.app_metadata
         end
 
         let(:client) do
-          new_local_client_nmio(['127.0.0.1:27017'])
+          new_local_client_nmio(SINGLE_CLIENT)
         end
 
         context 'mri' do
@@ -980,7 +951,7 @@ describe Mongo::Client do
           end
 
           it 'does not include the platform info in the app metadata' do
-            expect(app_metadata.send(:full_client_document)[:platform]).to eq(platform_string)
+            expect(app_metadata.client_document[:platform]).to eq(platform_string)
           end
         end
 
@@ -999,24 +970,18 @@ describe Mongo::Client do
           end
 
           it 'does not include the platform info in the app metadata' do
-            expect(app_metadata.send(:full_client_document)[:platform]).to eq(platform_string)
+            expect(app_metadata.client_document[:platform]).to eq(platform_string)
           end
         end
       end
     end
 
     context 'when providing a connection string' do
-
       context 'when the string uses the SRV Protocol' do
         require_external_connectivity
 
-        let!(:uri) do
-          'mongodb+srv://test5.test.build.10gen.cc/testdb'
-        end
-
-        let(:client) do
-          new_local_client_nmio(uri)
-        end
+        let(:uri) { 'mongodb+srv://test5.test.build.10gen.cc/testdb' }
+        let(:client) { new_local_client_nmio(uri) }
 
         it 'sets the database' do
           expect(client.options[:database]).to eq('testdb')
@@ -1024,29 +989,17 @@ describe Mongo::Client do
       end
 
       context 'when a database is provided' do
-
-        let!(:uri) do
-          'mongodb://127.0.0.1:27017/testdb'
-        end
-
-        let(:client) do
-          new_local_client_nmio(uri)
-        end
+        let(:uri) { 'mongodb://127.0.0.1:27017/testdb' }
+        let(:client) { new_local_client_nmio(uri) }
 
         it 'sets the database' do
-          expect { client[:users] }.to_not raise_error
+          expect { client[:users] }.not_to raise_error
         end
       end
 
       context 'when a database is not provided' do
-
-        let!(:uri) do
-          'mongodb://127.0.0.1:27017'
-        end
-
-        let(:client) do
-          new_local_client_nmio(uri)
-        end
+        let(:uri) { 'mongodb://127.0.0.1:27017' }
+        let(:client) { new_local_client_nmio(uri) }
 
         it 'defaults the database to admin' do
           expect(client.database.name).to eq('admin')
@@ -1054,44 +1007,59 @@ describe Mongo::Client do
       end
 
       context 'when URI options are provided' do
-
-        let!(:uri) do
-          'mongodb://127.0.0.1:27017/testdb?w=3'
-        end
-
-        let(:client) do
-          new_local_client_nmio(uri)
-        end
+        let(:uri) { 'mongodb://127.0.0.1:27017/testdb?w=3' }
+        let(:client) { new_local_client_nmio(uri) }
 
         let(:expected_options) do
-          Mongo::Options::Redacted.new(write_concern: { :w => 3 },
-            monitoring_io: false, :database => 'testdb', retry_writes: true,
-            retry_reads: true)
+          Mongo::Options::Redacted.new(
+            write_concern: { w: 3 },
+            monitoring_io: false,
+            database: 'testdb',
+            retry_writes: true,
+            retry_reads: true
+          )
         end
 
         it 'sets the options' do
           expect(client.options).to eq(expected_options)
         end
 
-        context 'when min_pool_size is provided' do
+        context 'when max_connecting is provided' do
+          context 'when max_connecting is a positive integer' do
+            let(:uri) do
+              'mongodb://127.0.0.1:27017/?maxConnecting=10'
+            end
 
-          context 'when max_pool_size is provided' do
+            it 'sets the max connecting' do
+              expect(client.options[:max_connecting]).to eq(10)
+            end
+          end
 
-            context 'when the min_pool_size is greater than the max_pool_size' do
+          context 'when max_connecting is a negative integer' do
+            let(:uri) do
+              'mongodb://127.0.0.1:27017/?maxConnecting=0'
+            end
 
+            it 'raises an exception' do
+              expect { client }.to raise_error(Mongo::Error::InvalidMaxConnecting)
+            end
+          end
+        end
+
+        context 'when min_pool_size is provided' do
+          context 'when max_pool_size is provided' do
+            context 'when the min_pool_size is greater than the max_pool_size' do
               let(:uri) do
                 'mongodb://127.0.0.1:27017/?minPoolSize=20&maxPoolSize=10'
               end
 
               it 'raises an Exception' do
-                expect {
-                  client
-                }.to raise_exception(Mongo::Error::InvalidMinPoolSize)
+                expect { client }
+                  .to raise_exception(Mongo::Error::InvalidMinPoolSize)
               end
             end
 
             context 'when the min_pool_size is less than the max_pool_size' do
-
               let(:uri) do
                 'mongodb://127.0.0.1:27017/?minPoolSize=10&maxPoolSize=20'
               end
@@ -1103,7 +1071,6 @@ describe Mongo::Client do
             end
 
             context 'when the min_pool_size is equal to the max_pool_size' do
-
               let(:uri) do
                 'mongodb://127.0.0.1:27017/?minPoolSize=10&maxPoolSize=10'
               end
@@ -1127,25 +1094,17 @@ describe Mongo::Client do
           end
 
           context 'when max_pool_size is not provided' do
-
             context 'when the min_pool_size is greater than the default max_pool_size' do
-
-              let(:uri) do
-                'mongodb://127.0.0.1:27017/?minPoolSize=30'
-              end
+              let(:uri) { 'mongodb://127.0.0.1:27017/?minPoolSize=30' }
 
               it 'raises an Exception' do
-                expect {
-                  client
-                }.to raise_exception(Mongo::Error::InvalidMinPoolSize)
+                expect { client }
+                  .to raise_exception(Mongo::Error::InvalidMinPoolSize)
               end
             end
 
             context 'when the min_pool_size is less than the default max_pool_size' do
-
-              let(:uri) do
-                'mongodb://127.0.0.1:27017/?minPoolSize=3'
-              end
+              let(:uri) { 'mongodb://127.0.0.1:27017/?minPoolSize=3' }
 
               it 'sets the option' do
                 expect(client.options[:min_pool_size]).to eq(3)
@@ -1153,10 +1112,7 @@ describe Mongo::Client do
             end
 
             context 'when the min_pool_size is equal to the max_pool_size' do
-
-              let(:uri) do
-                'mongodb://127.0.0.1:27017/?minPoolSize=5'
-              end
+              let(:uri) { 'mongodb://127.0.0.1:27017/?minPoolSize=5' }
 
               it 'sets the option' do
                 expect(client.options[:min_pool_size]).to eq(5)
@@ -1166,11 +1122,8 @@ describe Mongo::Client do
         end
 
         context 'when retryReads URI option is given' do
-
           context 'it is false' do
-            let!(:uri) do
-              'mongodb://127.0.0.1:27017/testdb?retryReads=false'
-            end
+            let(:uri) { 'mongodb://127.0.0.1:27017/testdb?retryReads=false' }
 
             it 'sets the option on the client' do
               expect(client.options[:retry_reads]).to be false
@@ -1178,9 +1131,7 @@ describe Mongo::Client do
           end
 
           context 'it is true' do
-            let!(:uri) do
-              'mongodb://127.0.0.1:27017/testdb?retryReads=true'
-            end
+            let(:uri) { 'mongodb://127.0.0.1:27017/testdb?retryReads=true' }
 
             it 'sets the option on the client' do
               expect(client.options[:retry_reads]).to be true
@@ -1189,11 +1140,8 @@ describe Mongo::Client do
         end
 
         context 'when retryWrites URI option is given' do
-
           context 'it is false' do
-            let!(:uri) do
-              'mongodb://127.0.0.1:27017/testdb?retryWrites=false'
-            end
+            let(:uri) { 'mongodb://127.0.0.1:27017/testdb?retryWrites=false' }
 
             it 'sets the option on the client' do
               expect(client.options[:retry_writes]).to be false
@@ -1201,9 +1149,7 @@ describe Mongo::Client do
           end
 
           context 'it is true' do
-            let!(:uri) do
-              'mongodb://127.0.0.1:27017/testdb?retryWrites=true'
-            end
+            let(:uri) { 'mongodb://127.0.0.1:27017/testdb?retryWrites=true' }
 
             it 'sets the option on the client' do
               expect(client.options[:retry_writes]).to be true
@@ -1213,19 +1159,20 @@ describe Mongo::Client do
       end
 
       context 'when options are provided not in the string' do
-
-        let!(:uri) do
-          'mongodb://127.0.0.1:27017/testdb'
-        end
+        let(:uri) { 'mongodb://127.0.0.1:27017/testdb' }
 
         let(:client) do
-          new_local_client_nmio(uri, :write => { :w => 3 })
+          new_local_client_nmio(uri, write: { w: 3 })
         end
 
         let(:expected_options) do
-          Mongo::Options::Redacted.new(:write => { :w => 3 },
-            monitoring_io: false, :database => 'testdb', retry_writes: true,
-            retry_reads: true)
+          Mongo::Options::Redacted.new(
+            write: { w: 3 },
+            monitoring_io: false,
+            database: 'testdb',
+            retry_writes: true,
+            retry_reads: true
+          )
         end
 
         it 'sets the options' do
@@ -1234,19 +1181,20 @@ describe Mongo::Client do
       end
 
       context 'when options are provided in the URI and as Ruby options' do
-
-        let!(:uri) do
-          'mongodb://127.0.0.1:27017/testdb?w=3'
-        end
+        let(:uri) { 'mongodb://127.0.0.1:27017/testdb?w=3' }
 
         let(:client) do
-          new_local_client_nmio(uri, option_name => { :w => 4 })
+          new_local_client_nmio(uri, option_name => { w: 4 })
         end
 
         let(:expected_options) do
-          Mongo::Options::Redacted.new(option_name => { :w => 4 },
-            monitoring_io: false, :database => 'testdb', retry_writes: true,
-            retry_reads: true)
+          Mongo::Options::Redacted.new(
+            option_name => { w: 4 },
+            monitoring_io: false,
+            database: 'testdb',
+            retry_writes: true,
+            retry_reads: true
+          )
         end
 
         shared_examples_for 'allows explicit options to take preference' do
@@ -1269,14 +1217,8 @@ describe Mongo::Client do
       end
 
       context 'when a replica set name is provided' do
-
-        let!(:uri) do
-          'mongodb://127.0.0.1:27017/testdb?replicaSet=testing'
-        end
-
-        let(:client) do
-          new_local_client_nmio(uri)
-        end
+        let(:uri) { 'mongodb://127.0.0.1:27017/testdb?replicaSet=testing' }
+        let(:client) { new_local_client_nmio(uri) }
 
         it 'sets the correct cluster topology' do
           expect(client.cluster.topology).to be_a(Mongo::Cluster::Topology::ReplicaSetNoPrimary)
@@ -1286,295 +1228,262 @@ describe Mongo::Client do
 
     context 'when Ruby options are provided' do
       let(:client) do
-        new_local_client_nmio(['127.0.0.1:27017'], options)
+        new_local_client_nmio(SINGLE_CLIENT, options)
       end
 
       describe 'connection option conflicts' do
         context 'direct_connection: true and multiple seeds' do
           let(:client) do
-            new_local_client_nmio(['127.0.0.1:27017', '127.0.0.2:27017'],
-              direct_connection: true)
+            new_local_client_nmio([ '127.0.0.1:27017', '127.0.0.2:27017' ], direct_connection: true)
           end
 
           it 'is rejected' do
-            lambda do
-              client
-            end.should raise_error(ArgumentError, /direct_connection=true cannot be used with multiple seeds/)
+            expect { client }
+              .to raise_error(ArgumentError, /direct_connection=true cannot be used with multiple seeds/)
           end
         end
 
         context 'direct_connection: true and connect: :direct' do
           let(:options) do
-            {direct_connection: true, connect: :direct}
+            { direct_connection: true, connect: :direct }
           end
 
           it 'is accepted' do
-            client.options[:direct_connection].should be true
-            client.options[:connect].should be :direct
+            expect(client.options[:direct_connection]).to be true
+            expect(client.options[:connect]).to be :direct
           end
         end
 
         context 'direct_connection: true and connect: :replica_set' do
           let(:options) do
-            {direct_connection: true, connect: :replica_set}
+            { direct_connection: true, connect: :replica_set }
           end
 
           it 'is rejected' do
-            lambda do
-              client
-            end.should raise_error(ArgumentError, /Conflicting client options: direct_connection=true and connect=replica_set/)
+            expect { client }
+              .to raise_error(
+                ArgumentError,
+                /Conflicting client options: direct_connection=true and connect=replica_set/
+              )
           end
         end
 
         context 'direct_connection: true and connect: :sharded' do
           let(:options) do
-            {direct_connection: true, connect: :sharded}
+            { direct_connection: true, connect: :sharded }
           end
 
           it 'is rejected' do
-            lambda do
-              client
-            end.should raise_error(ArgumentError, /Conflicting client options: direct_connection=true and connect=sharded/)
+            expect { client }
+              .to raise_error(ArgumentError, /Conflicting client options: direct_connection=true and connect=sharded/)
           end
         end
 
         context 'direct_connection: false and connect: :direct' do
           let(:options) do
-            {direct_connection: false, connect: :direct}
+            { direct_connection: false, connect: :direct }
           end
 
           it 'is rejected' do
-            lambda do
-              client
-            end.should raise_error(ArgumentError, /Conflicting client options: direct_connection=false and connect=direct/)
+            expect { client }
+              .to raise_error(ArgumentError, /Conflicting client options: direct_connection=false and connect=direct/)
           end
         end
 
         context 'direct_connection: false and connect: :replica_set' do
           let(:options) do
-            {direct_connection: false, connect: :replica_set, replica_set: 'foo'}
+            { direct_connection: false, connect: :replica_set, replica_set: 'foo' }
           end
 
           it 'is accepted' do
-            client.options[:direct_connection].should be false
-            client.options[:connect].should be :replica_set
+            expect(client.options[:direct_connection]).to be false
+            expect(client.options[:connect]).to be :replica_set
           end
         end
 
         context 'direct_connection: false and connect: :sharded' do
           let(:options) do
-            {direct_connection: false, connect: :sharded}
+            { direct_connection: false, connect: :sharded }
           end
 
           it 'is accepted' do
-            client.options[:direct_connection].should be false
-            client.options[:connect].should be :sharded
+            expect(client.options[:direct_connection]).to be false
+            expect(client.options[:connect]).to be :sharded
           end
         end
 
         context 'load_balanced: true and multiple seeds' do
           let(:client) do
-            new_local_client_nmio(['127.0.0.1:27017', '127.0.0.2:27017'],
-              load_balanced: true)
+            new_local_client_nmio([ '127.0.0.1:27017', '127.0.0.2:27017' ], load_balanced: true)
           end
 
           it 'is rejected' do
-            lambda do
-              client
-            end.should raise_error(ArgumentError, /load_balanced=true cannot be used with multiple seeds/)
+            expect { client }
+              .to raise_error(ArgumentError, /load_balanced=true cannot be used with multiple seeds/)
           end
         end
 
         context 'load_balanced: false and multiple seeds' do
           let(:client) do
-            new_local_client_nmio(['127.0.0.1:27017', '127.0.0.2:27017'],
-              load_balanced: false)
+            new_local_client_nmio([ '127.0.0.1:27017', '127.0.0.2:27017' ], load_balanced: false)
           end
 
           it 'is accepted' do
-            lambda do
-              client
-            end.should_not raise_error
-            client.options[:load_balanced].should be false
+            expect { client }.not_to raise_error
+            expect(client.options[:load_balanced]).to be false
           end
         end
 
         context 'load_balanced: true and direct_connection: true' do
           let(:client) do
-            new_local_client_nmio(['127.0.0.1:27017'],
-              load_balanced: true, direct_connection: true)
+            new_local_client_nmio(SINGLE_CLIENT, load_balanced: true, direct_connection: true)
           end
 
           it 'is rejected' do
-            lambda do
-              client
-            end.should raise_error(ArgumentError, /direct_connection=true cannot be used with load_balanced=true/)
+            expect { client }
+              .to raise_error(ArgumentError, /direct_connection=true cannot be used with load_balanced=true/)
           end
         end
 
         context 'load_balanced: true and direct_connection: false' do
           let(:client) do
-            new_local_client_nmio(['127.0.0.1:27017'],
-              load_balanced: true, direct_connection: false)
+            new_local_client_nmio(SINGLE_CLIENT, load_balanced: true, direct_connection: false)
           end
 
           it 'is accepted' do
-            lambda do
-              client
-            end.should_not raise_error
-            client.options[:load_balanced].should be true
-            client.options[:direct_connection].should be false
+            expect { client }.not_to raise_error
+            expect(client.options[:load_balanced]).to be true
+            expect(client.options[:direct_connection]).to be false
           end
         end
 
         context 'load_balanced: false and direct_connection: true' do
           let(:client) do
-            new_local_client_nmio(['127.0.0.1:27017'],
-              load_balanced: false, direct_connection: true)
+            new_local_client_nmio(SINGLE_CLIENT, load_balanced: false, direct_connection: true)
           end
 
           it 'is accepted' do
-            lambda do
-              client
-            end.should_not raise_error
-            client.options[:load_balanced].should be false
-            client.options[:direct_connection].should be true
+            expect { client }.not_to raise_error
+            expect(client.options[:load_balanced]).to be false
+            expect(client.options[:direct_connection]).to be true
           end
         end
 
-        [:direct, 'direct', :sharded, 'sharded'].each do |v|
+        [ :direct, 'direct', :sharded, 'sharded' ].each do |v|
           context "load_balanced: true and connect: #{v.inspect}" do
             let(:client) do
-              new_local_client_nmio(['127.0.0.1:27017'],
-                load_balanced: true, connect: v)
+              new_local_client_nmio(SINGLE_CLIENT, load_balanced: true, connect: v)
             end
 
             it 'is rejected' do
-              lambda do
-                client
-              end.should raise_error(ArgumentError, /connect=#{v} cannot be used with load_balanced=true/)
+              expect { client }
+                .to raise_error(ArgumentError, /connect=#{v} cannot be used with load_balanced=true/)
             end
           end
         end
 
-        [nil].each do |v|
+        [ nil ].each do |v|
           context "load_balanced: true and connect: #{v.inspect}" do
             let(:client) do
-              new_local_client_nmio(['127.0.0.1:27017'],
-                load_balanced: true, connect: v)
+              new_local_client_nmio(SINGLE_CLIENT, load_balanced: true, connect: v)
             end
 
             it 'is accepted' do
-              lambda do
-                client
-              end.should_not raise_error
-              client.options[:load_balanced].should be true
-              client.options[:connect].should eq v
+              expect { client }.not_to raise_error
+              expect(client.options[:load_balanced]).to be true
+              expect(client.options[:connect]).to eq v
             end
           end
         end
 
-        [:load_balanced, 'load_balanced'].each do |v|
+        [ :load_balanced, 'load_balanced' ].each do |v|
           context "load_balanced: true and connect: #{v.inspect}" do
             let(:client) do
-              new_local_client_nmio(['127.0.0.1:27017'],
-                load_balanced: true, connect: v)
+              new_local_client_nmio(SINGLE_CLIENT, load_balanced: true, connect: v)
             end
 
             it 'is accepted' do
-              lambda do
-                client
-              end.should_not raise_error
-              client.options[:load_balanced].should be true
-              client.options[:connect].should eq v
+              expect { client }.not_to raise_error
+              expect(client.options[:load_balanced]).to be true
+              expect(client.options[:connect]).to eq v
             end
           end
 
           context "replica_set and connect: #{v.inspect}" do
             let(:client) do
-              new_local_client_nmio(['127.0.0.1:27017'],
-                replica_set: 'foo', connect: v)
+              new_local_client_nmio(SINGLE_CLIENT, replica_set: 'foo', connect: v)
             end
 
             it 'is rejected' do
-              lambda do
-                client
-              end.should raise_error(ArgumentError, /connect=load_balanced cannot be used with replica_set option/)
+              expect { client }
+                .to raise_error(ArgumentError, /connect=load_balanced cannot be used with replica_set option/)
             end
           end
 
           context "direct_connection=true and connect: #{v.inspect}" do
             let(:client) do
-              new_local_client_nmio(['127.0.0.1:27017'],
-                direct_connection: true, connect: v)
+              new_local_client_nmio(SINGLE_CLIENT, direct_connection: true, connect: v)
             end
 
             it 'is rejected' do
-              lambda do
-                client
-              end.should raise_error(ArgumentError, /Conflicting client options: direct_connection=true and connect=load_balanced/)
+              expect { client }
+                .to raise_error(
+                  ArgumentError,
+                  /Conflicting client options: direct_connection=true and connect=load_balanced/
+                )
             end
           end
 
           context "multiple seed addresses and connect: #{v.inspect}" do
             let(:client) do
-              new_local_client_nmio(['127.0.0.1:27017', '127.0.0.1:1234'],
-                connect: v)
+              new_local_client_nmio([ '127.0.0.1:27017', '127.0.0.1:1234' ], connect: v)
             end
 
             it 'is rejected' do
-              lambda do
-                client
-              end.should raise_error(ArgumentError, /connect=load_balanced cannot be used with multiple seeds/)
+              expect { client }
+                .to raise_error(ArgumentError, /connect=load_balanced cannot be used with multiple seeds/)
             end
           end
         end
 
-        [:replica_set, 'replica_set'].each do |v|
+        [ :replica_set, 'replica_set' ].each do |v|
           context "load_balanced: true and connect: #{v.inspect}" do
             let(:client) do
-              new_local_client_nmio(['127.0.0.1:27017'],
-                load_balanced: true, connect: v, replica_set: 'x')
+              new_local_client_nmio(SINGLE_CLIENT, load_balanced: true, connect: v, replica_set: 'x')
             end
 
             it 'is rejected' do
-              lambda do
-                client
-              end.should raise_error(ArgumentError, /connect=replica_set cannot be used with load_balanced=true/)
+              expect { client }
+                .to raise_error(ArgumentError, /connect=replica_set cannot be used with load_balanced=true/)
             end
           end
 
           context "load_balanced: true and #{v.inspect} option" do
             let(:client) do
-              new_local_client_nmio(['127.0.0.1:27017'],
-                load_balanced: true, v => 'rs')
+              new_local_client_nmio(SINGLE_CLIENT, load_balanced: true, v => 'rs')
             end
 
             it 'is rejected' do
-              lambda do
-                client
-              end.should raise_error(ArgumentError, /load_balanced=true cannot be used with replica_set option/)
+              expect { client }
+                .to raise_error(ArgumentError, /load_balanced=true cannot be used with replica_set option/)
             end
           end
         end
 
         context 'srv_max_hosts > 0 and load_balanced: true' do
           let(:client) do
-            new_local_client_nmio(['127.0.0.1:27017'],
-               srv_max_hosts: 1, load_balanced: true)
+            new_local_client_nmio(SINGLE_CLIENT, srv_max_hosts: 1, load_balanced: true)
           end
 
           it 'it is rejected' do
-            expect do
-              client
-            end.to raise_error(ArgumentError, /:srv_max_hosts > 0 cannot be used with :load_balanced=true/)
+            expect { client }
+              .to raise_error(ArgumentError, /:srv_max_hosts > 0 cannot be used with :load_balanced=true/)
           end
         end
 
         context 'srv_max_hosts > 0 and replica_set' do
           let(:client) do
-            new_local_client_nmio(['127.0.0.1:27017'],
-              srv_max_hosts: 1, replica_set: 'rs')
+            new_local_client_nmio(SINGLE_CLIENT, srv_max_hosts: 1, replica_set: 'rs')
           end
 
           it 'it is rejected' do
@@ -1586,55 +1495,45 @@ describe Mongo::Client do
 
         context 'srv_max_hosts < 0' do
           let(:client) do
-            new_local_client_nmio(['127.0.0.1:27017'],
-               srv_max_hosts: -1)
+            new_local_client_nmio(SINGLE_CLIENT, srv_max_hosts: -1)
           end
 
           it 'is accepted and does not add the srv_max_hosts to uri_options' do
-            lambda do
-              client
-            end.should_not raise_error
-            expect(client.options).to_not have_key(:srv_max_hosts)
+            expect { client }.not_to raise_error
+            expect(client.options).not_to have_key(:srv_max_hosts)
           end
         end
 
         context 'srv_max_hosts invalid type' do
           let(:client) do
-            new_local_client_nmio(['127.0.0.1:27017'],
-               srv_max_hosts: 'foo')
+            new_local_client_nmio(SINGLE_CLIENT, srv_max_hosts: 'foo')
           end
 
           it 'is accepted and does not add the srv_max_hosts to uri_options' do
-            lambda do
-              client
-            end.should_not raise_error
-            expect(client.options).to_not have_key(:srv_max_hosts)
+            expect { client }.not_to raise_error
+            expect(client.options).not_to have_key(:srv_max_hosts)
           end
         end
 
         context 'srv_max_hosts with non-SRV URI' do
           let(:client) do
-            new_local_client_nmio(['127.0.0.1:27017'],
-               srv_max_hosts: 1)
+            new_local_client_nmio(SINGLE_CLIENT, srv_max_hosts: 1)
           end
 
           it 'is rejected' do
-            lambda do
-              client
-            end.should raise_error(ArgumentError, /:srv_max_hosts cannot be used on non-SRV URI/)
+            expect { client }
+              .to raise_error(ArgumentError, /:srv_max_hosts cannot be used on non-SRV URI/)
           end
         end
 
         context 'srv_service_name with non-SRV URI' do
           let(:client) do
-            new_local_client_nmio(['127.0.0.1:27017'],
-               srv_service_name: "customname")
+            new_local_client_nmio(SINGLE_CLIENT, srv_service_name: 'customname')
           end
 
           it 'is rejected' do
-            lambda do
-              client
-            end.should raise_error(ArgumentError, /:srv_service_name cannot be used on non-SRV URI/)
+            expect { client }
+              .to raise_error(ArgumentError, /:srv_service_name cannot be used on non-SRV URI/)
           end
         end
       end
@@ -1644,7 +1543,8 @@ describe Mongo::Client do
           double('srv result').tap do |result|
             allow(result).to receive(:empty?).and_return(false)
             allow(result).to receive(:address_strs).and_return(
-              [ClusterConfig.instance.primary_address_str])
+              [ ClusterConfig.instance.primary_address_str ]
+            )
           end
         end
 
@@ -1655,79 +1555,77 @@ describe Mongo::Client do
           new_local_client_nmio('mongodb+srv://foo.a.b', options)
         end
 
-        context "when setting srv_max_hosts" do
+        context 'when setting srv_max_hosts' do
           let(:srv_max_hosts) { 1 }
           let(:options) { { srv_max_hosts: srv_max_hosts } }
 
           it 'is accepted and sets srv_max_hosts' do
-            lambda do
-              client
-            end.should_not raise_error
+            expect { client }.not_to raise_error
             expect(client.options[:srv_max_hosts]).to eq(srv_max_hosts)
           end
         end
 
-        context "when setting srv_max_hosts to 0" do
+        context 'when setting srv_max_hosts to 0' do
           let(:srv_max_hosts) { 0 }
           let(:options) { { srv_max_hosts: srv_max_hosts } }
 
           it 'is accepted sets srv_max_hosts' do
-            lambda do
-              client
-            end.should_not raise_error
+            expect { client }.not_to raise_error
             expect(client.options[:srv_max_hosts]).to eq(srv_max_hosts)
           end
         end
 
-        context "when setting srv_service_name" do
+        context 'when setting srv_service_name' do
           let(:srv_service_name) { 'customname' }
           let(:options) { { srv_service_name: srv_service_name } }
 
           it 'is accepted and sets srv_service_name' do
-            lambda do
-              client
-            end.should_not raise_error
+            expect { client }.not_to raise_error
             expect(client.options[:srv_service_name]).to eq(srv_service_name)
           end
         end
       end
 
       context ':bg_error_backtrace option' do
-        [true, false, nil, 42].each do |valid_value|
+        [ true, false, nil, 42 ].each do |valid_value|
           context "valid value: #{valid_value.inspect}" do
             let(:options) do
-              {bg_error_backtrace: valid_value}
+              { bg_error_backtrace: valid_value }
             end
 
             it 'is accepted' do
-              client.options[:bg_error_backtrace].should == valid_value
+              expect(client.options[:bg_error_backtrace]).to be == valid_value
             end
           end
         end
 
         context 'invalid value type' do
           let(:options) do
-            {bg_error_backtrace: 'yes'}
+            { bg_error_backtrace: 'yes' }
           end
 
           it 'is rejected' do
-            lambda do
-              client
-            end.should raise_error(ArgumentError, /:bg_error_backtrace option value must be true, false, nil or a positive integer/)
+            expect { client }
+              .to raise_error(
+                ArgumentError,
+                /:bg_error_backtrace option value must be true, false, nil or a positive integer/
+              )
           end
         end
 
         context 'invalid value' do
-          [0, -1, 42.0].each do |invalid_value|
+          [ 0, -1, 42.0 ].each do |invalid_value|
             context "invalid value: #{invalid_value.inspect}" do
               let(:options) do
-                {bg_error_backtrace: invalid_value}
+                { bg_error_backtrace: invalid_value }
               end
 
               it 'is rejected' do
-                lambda do
-                  client
-                end.should raise_error(ArgumentError, /:bg_error_backtrace option value must be true, false, nil or a positive integer/)
+                expect { client }
+                  .to raise_error(
+                    ArgumentError,
+                    /:bg_error_backtrace option value must be true, false, nil or a positive integer/
+                  )
               end
             end
           end
@@ -1735,32 +1633,30 @@ describe Mongo::Client do
       end
 
       describe ':read option' do
-        [
-          :primary, :primary_preferred, :secondary, :secondary_preferred,  :nearest
-        ].each do |sym|
-          describe "#{sym}" do
+        %i[ primary primary_preferred secondary secondary_preferred nearest ].each do |sym|
+          describe sym.to_s do
             context 'when given as symbol' do
               let(:options) do
-                {read: {mode: sym}}
+                { read: { mode: sym } }
               end
 
-              it "is accepted" do
+              it 'is accepted' do
                 # the key got converted to a string here
-                expect(client.read_preference).to eq({'mode' => sym})
+                expect(client.read_preference).to eq({ 'mode' => sym })
               end
             end
 
             context 'when given as string' do
               let(:options) do
-                {read: {mode: sym.to_s}}
+                { read: { mode: sym.to_s } }
               end
 
               # string keys are not documented as being allowed
               # but the code accepts them
-              it "is accepted" do
+              it 'is accepted' do
                 # the key got converted to a string here
                 # the value remains a string
-                expect(client.read_preference).to eq({'mode' => sym.to_s})
+                expect(client.read_preference).to eq({ 'mode' => sym.to_s })
               end
             end
           end
@@ -1771,30 +1667,41 @@ describe Mongo::Client do
 
           it 'rejects bogus read preference as symbol' do
             expect do
-              client = new_local_client_nmio(['127.0.0.1:27017'],
-                :read => {:mode => :bogus})
-            end.to raise_error(Mongo::Error::InvalidReadOption, 'Invalid read option: {"mode"=>:bogus}: mode bogus is not one of recognized modes')
+              new_local_client_nmio(SINGLE_CLIENT, read: { mode: :bogus })
+            end.to raise_error(
+              Mongo::Error::InvalidReadOption,
+              'Invalid read preference value: {"mode"=>:bogus}: ' \
+              'mode bogus is not one of recognized modes'
+            )
           end
 
           it 'rejects bogus read preference as string' do
             expect do
-              client = new_local_client_nmio(['127.0.0.1:27017'],
-                :read => {:mode => 'bogus'})
-            end.to raise_error(Mongo::Error::InvalidReadOption, 'Invalid read option: {"mode"=>"bogus"}: mode bogus is not one of recognized modes')
+              new_local_client_nmio(SINGLE_CLIENT, read: { mode: 'bogus' })
+            end.to raise_error(
+              Mongo::Error::InvalidReadOption,
+              'Invalid read preference value: {"mode"=>"bogus"}: mode bogus is not one of recognized modes'
+            )
           end
 
           it 'rejects read option specified as a string' do
             expect do
-              client = new_local_client_nmio(['127.0.0.1:27017'],
-                :read => 'primary')
-            end.to raise_error(Mongo::Error::InvalidReadOption, 'Invalid read option: primary: must be a hash')
+              new_local_client_nmio(SINGLE_CLIENT, read: 'primary')
+            end.to raise_error(
+              Mongo::Error::InvalidReadOption,
+              'Invalid read preference value: "primary": ' \
+              'the read preference must be specified as a hash: { mode: "primary" }'
+            )
           end
 
           it 'rejects read option specified as a symbol' do
             expect do
-              client = new_local_client_nmio(['127.0.0.1:27017'],
-                :read => :primary)
-            end.to raise_error(Mongo::Error::InvalidReadOption, 'Invalid read option: primary: must be a hash')
+              new_local_client_nmio(SINGLE_CLIENT, read: :primary)
+            end.to raise_error(
+              Mongo::Error::InvalidReadOption,
+              'Invalid read preference value: :primary: ' \
+              'the read preference must be specified as a hash: { mode: :primary }'
+            )
           end
         end
       end
@@ -1808,7 +1715,7 @@ describe Mongo::Client do
           end
 
           it 'does not warn' do
-            expect(Mongo::Logger.logger).to_not receive(:warn)
+            expect(Mongo::Logger.logger).not_to receive(:warn)
             new_local_client_nmio(SpecConfig.instance.addresses, options)
           end
         end
@@ -1834,15 +1741,17 @@ describe Mongo::Client do
           it 'raises an exception' do
             expect do
               new_local_client_nmio(SpecConfig.instance.addresses, options)
-            end.to raise_error(Mongo::Error::InvalidReadConcern, 'The after_cluster_time read_concern option cannot be specified by the user')
+            end.to raise_error(
+              Mongo::Error::InvalidReadConcern,
+              'The after_cluster_time read_concern option cannot be specified by the user'
+            )
           end
         end
       end
 
       context 'when an invalid option is provided' do
-
         let(:options) do
-          {ssl: false, invalid: :test}
+          { ssl: false, invalid: :test }
         end
 
         it 'does not set the option' do
@@ -1861,9 +1770,8 @@ describe Mongo::Client do
 
 =begin WriteConcern object support
       context 'when write concern is provided via a WriteConcern object' do
-
         let(:options) do
-          {write_concern: wc}
+          { write_concern: wc }
         end
 
         let(:wc) { Mongo::WriteConcern.get(w: 2) }
@@ -1881,52 +1789,52 @@ describe Mongo::Client do
 
       context ':wrapping_libraries option' do
         let(:options) do
-          {wrapping_libraries: wrapping_libraries}
+          { wrapping_libraries: wrapping_libraries }
         end
 
         context 'valid input' do
           context 'symbol keys' do
             let(:wrapping_libraries) do
-              [name: 'Mongoid', version: '7.1.2'].freeze
+              [ { name: 'Mongoid', version: '7.1.2' } ].freeze
             end
 
             it 'works' do
-              client.options[:wrapping_libraries].should == ['name' => 'Mongoid', 'version' => '7.1.2']
+              expect(client.options[:wrapping_libraries]).to be == [ { 'name' => 'Mongoid', 'version' => '7.1.2' } ]
             end
           end
 
           context 'string keys' do
             let(:wrapping_libraries) do
-              ['name' => 'Mongoid', 'version' => '7.1.2'].freeze
+              [ { 'name' => 'Mongoid', 'version' => '7.1.2' } ].freeze
             end
 
             it 'works' do
-              client.options[:wrapping_libraries].should == ['name' => 'Mongoid', 'version' => '7.1.2']
+              expect(client.options[:wrapping_libraries]).to be == [ { 'name' => 'Mongoid', 'version' => '7.1.2' } ]
             end
           end
 
           context 'Redacted keys' do
             let(:wrapping_libraries) do
-              [Mongo::Options::Redacted.new(name: 'Mongoid', version: '7.1.2')].freeze
+              [ Mongo::Options::Redacted.new(name: 'Mongoid', version: '7.1.2') ].freeze
             end
 
             it 'works' do
-              client.options[:wrapping_libraries].should == ['name' => 'Mongoid', 'version' => '7.1.2']
+              expect(client.options[:wrapping_libraries]).to be == [ { 'name' => 'Mongoid', 'version' => '7.1.2' } ]
             end
           end
 
           context 'two libraries' do
             let(:wrapping_libraries) do
               [
-                {name: 'Mongoid', version: '7.1.2'},
-                {name: 'Rails', version: '4.0', platform: 'Foobar'},
+                { name: 'Mongoid', version: '7.1.2' },
+                { name: 'Rails', version: '4.0', platform: 'Foobar' },
               ].freeze
             end
 
             it 'works' do
-              client.options[:wrapping_libraries].should == [
-                {'name' => 'Mongoid', 'version' => '7.1.2'},
-                {'name' => 'Rails', 'version' => '4.0', 'platform' => 'Foobar'},
+              expect(client.options[:wrapping_libraries]).to be == [
+                { 'name' => 'Mongoid', 'version' => '7.1.2' },
+                { 'name' => 'Rails', 'version' => '4.0', 'platform' => 'Foobar' },
               ]
             end
           end
@@ -1937,7 +1845,7 @@ describe Mongo::Client do
             end
 
             it 'works' do
-              client.options[:wrapping_libraries].should == []
+              expect(client.options[:wrapping_libraries]).to be == []
             end
           end
 
@@ -1947,7 +1855,7 @@ describe Mongo::Client do
             end
 
             it 'works' do
-              client.options[:wrapping_libraries].should be nil
+              expect(client.options[:wrapping_libraries]).to be_nil
             end
           end
         end
@@ -1955,37 +1863,34 @@ describe Mongo::Client do
         context 'valid input' do
           context 'hash given instead of an array' do
             let(:wrapping_libraries) do
-              {name: 'Mongoid', version: '7.1.2'}.freeze
+              { name: 'Mongoid', version: '7.1.2' }.freeze
             end
 
             it 'is rejected' do
-              lambda do
-                client
-              end.should raise_error(ArgumentError, /:wrapping_libraries must be an array of hashes/)
+              expect { client }
+                .to raise_error(ArgumentError, /:wrapping_libraries must be an array of hashes/)
             end
           end
 
           context 'invalid keys' do
             let(:wrapping_libraries) do
-              [name: 'Mongoid', invalid: '7.1.2'].freeze
+              [ { name: 'Mongoid', invalid: '7.1.2' } ].freeze
             end
 
             it 'is rejected' do
-              lambda do
-                client
-              end.should raise_error(ArgumentError, /:wrapping_libraries element has invalid keys/)
+              expect { client }
+                .to raise_error(ArgumentError, /:wrapping_libraries element has invalid keys/)
             end
           end
 
           context 'value includes |' do
             let(:wrapping_libraries) do
-              [name: 'Mongoid|on|Rails', version: '7.1.2'].freeze
+              [ { name: 'Mongoid|on|Rails', version: '7.1.2' } ].freeze
             end
 
             it 'is rejected' do
-              lambda do
-                client
-              end.should raise_error(ArgumentError, /:wrapping_libraries element value cannot include '|'/)
+              expect { client }
+                .to raise_error(ArgumentError, /:wrapping_libraries element value cannot include '|'/)
             end
           end
         end
@@ -1993,12 +1898,10 @@ describe Mongo::Client do
 
       context ':auth_mech_properties option' do
         context 'is nil' do
-          let(:options) do
-            {auth_mech_properties: nil}
-          end
+          let(:options) { { auth_mech_properties: nil } }
 
           it 'creates the client without the option' do
-            client.options.should_not have_key(:auth_mech_properties)
+            expect(client.options).not_to have_key(:auth_mech_properties)
           end
         end
       end
@@ -2007,15 +1910,17 @@ describe Mongo::Client do
         context 'is a hash with symbol keys' do
           context 'using known keys' do
             let(:options) do
-              {server_api: {
-                version: '1',
-                strict: true,
-                deprecation_errors: false,
-              }}
+              {
+                server_api: {
+                  version: '1',
+                  strict: true,
+                  deprecation_errors: false,
+                }
+              }
             end
 
             it 'is accepted' do
-              client.options[:server_api].should == {
+              expect(client.options[:server_api]).to be == {
                 'version' => '1',
                 'strict' => true,
                 'deprecation_errors' => false,
@@ -2025,41 +1930,34 @@ describe Mongo::Client do
 
           context 'using an unknown version' do
             let(:options) do
-              {server_api: {
-                version: '42',
-              }}
+              { server_api: { version: '42' } }
             end
 
             it 'is rejected' do
-              lambda do
-                client
-              end.should raise_error(ArgumentError, 'Unknown server API version: 42')
+              expect { client }
+                .to raise_error(ArgumentError, 'Unknown server API version: 42')
             end
           end
 
           context 'using an unknown option' do
             let(:options) do
-              {server_api: {
-                vversion: '1',
-              }}
+              { server_api: { vversion: '1' } }
             end
 
             it 'is rejected' do
-              lambda do
-                client
-              end.should raise_error(ArgumentError, 'Unknown keys under :server_api: "vversion"')
+              expect { client }
+                .to raise_error(ArgumentError, 'Unknown keys under :server_api: "vversion"')
             end
           end
 
           context 'using a value which is not a hash' do
             let(:options) do
-              {server_api: 42}
+              { server_api: 42 }
             end
 
             it 'is rejected' do
-              lambda do
-                client
-              end.should raise_error(ArgumentError, ':server_api value must be a hash: 42')
+              expect { client }
+                .to raise_error(ArgumentError, ':server_api value must be a hash: 42')
             end
           end
         end
@@ -2068,16 +1966,18 @@ describe Mongo::Client do
           max_server_version '3.4'
 
           let(:options) do
-            {server_api: {version: 1}}
+            { server_api: { version: 1 } }
           end
 
           let(:client) do
-            new_local_client(SpecConfig.instance.addresses,
-              SpecConfig.instance.all_test_options.merge(options))
+            new_local_client(
+              SpecConfig.instance.addresses,
+              SpecConfig.instance.all_test_options.merge(options)
+            )
           end
 
           it 'constructs the client' do
-            client.should be_a(Mongo::Client)
+            expect(client).to be_a(described_class)
           end
 
           it 'does not discover servers' do
@@ -2087,9 +1987,8 @@ describe Mongo::Client do
           end
 
           it 'fails operations' do
-            lambda do
-              client.command(ping: 1)
-            end.should raise_error(Mongo::Error::NoServerAvailable)
+            expect { client.command(ping: 1) }
+              .to raise_error(Mongo::Error::NoServerAvailable)
           end
         end
       end
@@ -2099,9 +1998,9 @@ describe Mongo::Client do
       context 'when the block doesn\'t raise an error' do
         let(:block_client) do
           c = nil
-          Mongo::Client.new(
+          described_class.new(
             SpecConfig.instance.addresses,
-            SpecConfig.instance.test_options.merge(database: SpecConfig.instance.test_db),
+            SpecConfig.instance.test_options.merge(database: SpecConfig.instance.test_db)
           ) do |client|
             c = client
           end
@@ -2109,55 +2008,112 @@ describe Mongo::Client do
         end
 
         it 'is closed after block' do
-          expect(block_client.cluster.connected?).to eq(false)
+          expect(block_client.cluster.connected?).to be false
+        end
+
+        context 'with auto encryption options' do
+          require_libmongocrypt
+          min_server_fcv '4.2'
+          require_enterprise
+          clean_slate
+
+          include_context 'define shared FLE helpers'
+          include_context 'with local kms_providers'
+
+          let(:auto_encryption_options) do
+            {
+              key_vault_client: key_vault_client,
+              key_vault_namespace: key_vault_namespace,
+              kms_providers: kms_providers,
+              schema_map: schema_map,
+              extra_options: extra_options,
+            }
+          end
+
+          let(:key_vault_client) { new_local_client_nmio(SpecConfig.instance.addresses) }
+
+          let(:block_client) do
+            c = nil
+            described_class.new(
+              SpecConfig.instance.addresses,
+              SpecConfig.instance.test_options.merge(
+                auto_encryption_options: auto_encryption_options,
+                database: SpecConfig.instance.test_db
+              )
+            ) do |client|
+              c = client
+            end
+            c
+          end
+
+          it 'closes all clients after block' do
+            expect(block_client.cluster.connected?).to be false
+            [
+              block_client.encrypter.mongocryptd_client,
+              block_client.encrypter.key_vault_client,
+              block_client.encrypter.metadata_client
+            ].each do |crypt_client|
+              expect(crypt_client.cluster.connected?).to be false
+            end
+          end
         end
       end
 
       context 'when the block raises an error' do
-        it 'it is closed after the block' do
+        it 'is closed after the block' do
           block_client_raise = nil
           expect do
-            Mongo::Client.new(
+            described_class.new(
               SpecConfig.instance.addresses,
-              SpecConfig.instance.test_options.merge(database: SpecConfig.instance.test_db),
+              SpecConfig.instance.test_options.merge(database: SpecConfig.instance.test_db)
             ) do |client|
               block_client_raise = client
-              raise "This is an error!"
+              raise 'This is an error!'
             end
-          end.to raise_error(StandardError, "This is an error!")
-          expect(block_client_raise.cluster.connected?).to eq(false)
+          end.to raise_error(StandardError, 'This is an error!')
+          expect(block_client_raise.cluster.connected?).to be false
         end
       end
 
       context 'when the hosts given include the protocol' do
         it 'raises an error on mongodb://' do
           expect do
-            Mongo::Client.new(['mongodb://127.0.0.1:27017/test'])
-          end.to raise_error(ArgumentError, "Host 'mongodb://127.0.0.1:27017/test' should not contain protocol. Did you mean to not use an array?")
+            described_class.new([ 'mongodb://127.0.0.1:27017/test' ])
+          end.to raise_error(ArgumentError,
+                             "Host 'mongodb://127.0.0.1:27017/test' should not contain protocol. " \
+                             'Did you mean to not use an array?')
         end
 
         it 'raises an error on mongodb+srv://' do
           expect do
-            Mongo::Client.new(['mongodb+srv://127.0.0.1:27017/test'])
-          end.to raise_error(ArgumentError, "Host 'mongodb+srv://127.0.0.1:27017/test' should not contain protocol. Did you mean to not use an array?")
+            described_class.new([ 'mongodb+srv://127.0.0.1:27017/test' ])
+          end.to raise_error(ArgumentError,
+                             "Host 'mongodb+srv://127.0.0.1:27017/test' should not contain protocol. " \
+                             'Did you mean to not use an array?')
         end
 
         it 'raises an error on multiple items' do
           expect do
-            Mongo::Client.new(['127.0.0.1:27017', 'mongodb+srv://127.0.0.1:27017/test'])
-          end.to raise_error(ArgumentError, "Host 'mongodb+srv://127.0.0.1:27017/test' should not contain protocol. Did you mean to not use an array?")
+            described_class.new([ '127.0.0.1:27017', 'mongodb+srv://127.0.0.1:27017/test' ])
+          end.to raise_error(ArgumentError,
+                             "Host 'mongodb+srv://127.0.0.1:27017/test' should not contain protocol. " \
+                             'Did you mean to not use an array?')
         end
 
         it 'raises an error only at beginning of string' do
           expect do
-            Mongo::Client.new(['somethingmongodb://127.0.0.1:27017/test', 'mongodb+srv://127.0.0.1:27017/test'])
-          end.to raise_error(ArgumentError, "Host 'mongodb+srv://127.0.0.1:27017/test' should not contain protocol. Did you mean to not use an array?")
+            described_class
+              .new([ 'somethingmongodb://127.0.0.1:27017/test', 'mongodb+srv://127.0.0.1:27017/test' ])
+          end.to raise_error(ArgumentError,
+                             "Host 'mongodb+srv://127.0.0.1:27017/test' should not contain protocol. " \
+                             'Did you mean to not use an array?')
         end
 
         it 'raises an error with different case' do
-          expect do
-            Mongo::Client.new(['MongOdB://127.0.0.1:27017/test'])
-          end.to raise_error(ArgumentError, "Host 'MongOdB://127.0.0.1:27017/test' should not contain protocol. Did you mean to not use an array?")
+          expect { described_class.new([ 'MongOdB://127.0.0.1:27017/test' ]) }
+            .to raise_error(ArgumentError,
+                            "Host 'MongOdB://127.0.0.1:27017/test' should not contain protocol. " \
+                            'Did you mean to not use an array?')
         end
       end
     end
@@ -2247,13 +2203,11 @@ describe Mongo::Client do
   end
 
   describe '#use' do
-
     let(:client) do
-      new_local_client_nmio(['127.0.0.1:27017'], :database => SpecConfig.instance.test_db)
+      new_local_client_nmio(SINGLE_CLIENT, database: SpecConfig.instance.test_db)
     end
 
     shared_examples_for 'a database switching object' do
-
       it 'returns the new client' do
         expect(client.send(:database).name).to eq('ruby-driver')
       end
@@ -2264,7 +2218,6 @@ describe Mongo::Client do
     end
 
     context 'when provided a string' do
-
       let(:database) do
         client.use('testdb')
       end
@@ -2273,7 +2226,6 @@ describe Mongo::Client do
     end
 
     context 'when provided a symbol' do
-
       let(:database) do
         client.use(:testdb)
       end
@@ -2282,45 +2234,29 @@ describe Mongo::Client do
     end
 
     context 'when providing nil' do
-
       it 'raises an exception' do
-        expect {
-          client.use(nil)
-        }.to raise_error(Mongo::Error::InvalidDatabaseName)
+        expect { client.use(nil) }
+          .to raise_error(Mongo::Error::InvalidDatabaseName)
       end
     end
   end
 
   describe '#with' do
-
     let(:client) do
-      new_local_client_nmio(['127.0.0.1:27017'], :database => SpecConfig.instance.test_db)
+      new_local_client_nmio(SINGLE_CLIENT, database: SpecConfig.instance.test_db)
     end
 
     context 'when providing nil' do
-
       it 'returns the cloned client' do
         expect(client.with(nil)).to eq(client)
       end
     end
 
     context 'when the app_name is changed' do
-
-      let(:client) do
-        authorized_client
-      end
-
-      let!(:original_options) do
-        client.options
-      end
-
-      let(:new_options) do
-        { app_name: 'client_test' }
-      end
-
-      let!(:new_client) do
-        authorized_client.with(new_options)
-      end
+      let(:client) { authorized_client }
+      let(:original_options) { client.options }
+      let(:new_options) { { app_name: 'client_test' } }
+      let(:new_client) { authorized_client.with(new_options) }
 
       it 'returns a new client' do
         expect(new_client).not_to equal(client)
@@ -2346,27 +2282,25 @@ describe Mongo::Client do
         new_local_client(SpecConfig.instance.addresses, options)
       end
 
-      before do
-        client.options[:direct_connection].should be nil
-      end
-
       let(:new_client) do
         client.with(new_options)
       end
 
-      context 'direct_connection set to false' do
+      before do
+        expect(client.options[:direct_connection]).to be_nil
+      end
 
+      context 'direct_connection set to false' do
         let(:new_options) do
           { direct_connection: false }
         end
 
         it 'is accepted' do
-          new_client.options[:direct_connection].should be false
+          expect(new_client.options[:direct_connection]).to be false
         end
       end
 
       context 'direct_connection set to true' do
-
         let(:new_options) do
           { direct_connection: true }
         end
@@ -2374,10 +2308,9 @@ describe Mongo::Client do
         context 'in single topology' do
           require_topology :single
 
-
           it 'is accepted' do
-            new_client.options[:direct_connection].should be true
-            new_client.cluster.topology.should be_a(Mongo::Cluster::Topology::Single)
+            expect(new_client.options[:direct_connection]).to be true
+            expect(new_client.cluster.topology).to be_a(Mongo::Cluster::Topology::Single)
           end
         end
 
@@ -2385,21 +2318,19 @@ describe Mongo::Client do
           require_topology :replica_set, :sharded
 
           it 'is rejected' do
-            lambda do
-              new_client
-            end.should raise_error(ArgumentError, /direct_connection=true cannot be used with topologies other than Single/)
+            expect { new_client }
+              .to raise_error(ArgumentError, /direct_connection=true cannot be used with topologies other than Single/)
           end
 
           context 'when a new cluster is created' do
-
             let(:new_options) do
               { direct_connection: true, app_name: 'new-client' }
             end
 
             it 'is rejected' do
-              lambda do
-                new_client
-              end.should raise_error(ArgumentError, /direct_connection=true cannot be used with topologies other than Single/)
+              expect { new_client }
+                .to raise_error(ArgumentError,
+                                /direct_connection=true cannot be used with topologies other than Single/)
             end
           end
         end
@@ -2407,28 +2338,37 @@ describe Mongo::Client do
     end
 
     context 'when the write concern is not changed' do
-
       let(:client) do
         new_local_client_nmio(
-          ['127.0.0.1:27017'],
-          :read => { :mode => :secondary }, :write => { :w => 1 }, :database => SpecConfig.instance.test_db
+          SINGLE_CLIENT,
+          read: { mode: :secondary },
+          write: { w: 1 },
+          database: SpecConfig.instance.test_db
         )
       end
 
-      let!(:new_client) do
-        client.with(:read => { :mode => :primary })
-      end
+      let(:new_client) { client.with(read: { mode: :primary }) }
 
       let(:new_options) do
-        Mongo::Options::Redacted.new(:read => { :mode => :primary },
-          :write => { :w => 1 }, monitoring_io: false,
-          :database => SpecConfig.instance.test_db, retry_writes: true, retry_reads: true)
+        Mongo::Options::Redacted.new(
+          read: { mode: :primary },
+          write: { w: 1 },
+          monitoring_io: false,
+          database: SpecConfig.instance.test_db,
+          retry_writes: true,
+          retry_reads: true
+        )
       end
 
       let(:original_options) do
-        Mongo::Options::Redacted.new(:read => { :mode => :secondary },
-          :write => { :w => 1 }, monitoring_io: false,
-          :database => SpecConfig.instance.test_db, retry_writes: true, retry_reads: true)
+        Mongo::Options::Redacted.new(
+          read: { mode: :secondary },
+          write: { w: 1 },
+          monitoring_io: false,
+          database: SpecConfig.instance.test_db,
+          retry_writes: true,
+          retry_reads: true
+        )
       end
 
       it 'returns a new client' do
@@ -2449,21 +2389,19 @@ describe Mongo::Client do
     end
 
     context 'when the write concern is changed' do
-
       let(:client) do
-        new_local_client(['127.0.0.1:27017'],
-          {monitoring_io: false}.merge(client_options))
+        new_local_client(
+          SINGLE_CLIENT,
+          { monitoring_io: false }.merge(client_options)
+        )
       end
 
       let(:client_options) do
-        { :write => { :w => 1 } }
+        { write: { w: 1 } }
       end
 
       context 'when the write concern has not been accessed' do
-
-        let!(:new_client) do
-          client.with(:write => { :w => 0 })
-        end
+        let(:new_client) { client.with(write: { w: 0 }) }
 
         let(:get_last_error) do
           new_client.write_concern.get_last_error
@@ -2475,10 +2413,9 @@ describe Mongo::Client do
       end
 
       context 'when the write concern has been accessed' do
-
-        let!(:new_client) do
+        let(:new_client) do
           client.write_concern
-          client.with(:write => { :w => 0 })
+          client.with(write: { w: 0 })
         end
 
         let(:get_last_error) do
@@ -2491,9 +2428,8 @@ describe Mongo::Client do
       end
 
       context 'when write concern is given as :write' do
-
         let(:client_options) do
-          { :write => { :w => 1 } }
+          { write: { w: 1 } }
         end
 
         it 'sets :write option' do
@@ -2501,7 +2437,7 @@ describe Mongo::Client do
         end
 
         it 'does not set :write_concern option' do
-          expect(client.options[:write_concern]).to be nil
+          expect(client.options[:write_concern]).to be_nil
         end
 
         it 'returns correct write concern' do
@@ -2511,9 +2447,8 @@ describe Mongo::Client do
       end
 
       context 'when write concern is given as :write_concern' do
-
         let(:client_options) do
-          { :write_concern => { :w => 1 } }
+          { write_concern: { w: 1 } }
         end
 
         it 'sets :write_concern option' do
@@ -2521,20 +2456,19 @@ describe Mongo::Client do
         end
 
         it 'does not set :write option' do
-          expect(client.options[:write]).to be nil
+          expect(client.options[:write]).to be_nil
         end
 
         it 'returns correct write concern' do
-            expect(client.write_concern).to be_a(Mongo::WriteConcern::Acknowledged)
-            expect(client.write_concern.options).to eq(w: 1)
+          expect(client.write_concern).to be_a(Mongo::WriteConcern::Acknowledged)
+          expect(client.write_concern.options).to eq(w: 1)
         end
       end
 
       context 'when write concern is given as both :write and :write_concern' do
         context 'with identical values' do
-
           let(:client_options) do
-            { write: {w: 1}, write_concern: { w: 1 } }
+            { write: { w: 1 }, write_concern: { w: 1 } }
           end
 
           it 'sets :write_concern option' do
@@ -2552,9 +2486,8 @@ describe Mongo::Client do
         end
 
         context 'with different values' do
-
           let(:client_options) do
-            { write: {w: 1}, write_concern: { w: 2 } }
+            { write: { w: 1 }, write_concern: { w: 2 } }
           end
 
           it 'raises an exception' do
@@ -2566,43 +2499,35 @@ describe Mongo::Client do
       end
 
       context 'when #with uses a different write concern option name' do
-
         context 'from :write_concern to :write' do
-
           let(:client_options) do
-            { :write_concern => { :w => 1 } }
+            { write_concern: { w: 1 } }
           end
 
-          let!(:new_client) do
-            client.with(:write => { :w => 2 })
-          end
+          let(:new_client) { client.with(write: { w: 2 }) }
 
           it 'uses the new option' do
             expect(new_client.options[:write]).to eq(Mongo::Options::Redacted.new(w: 2))
-            expect(new_client.options[:write_concern]).to be nil
+            expect(new_client.options[:write_concern]).to be_nil
           end
         end
 
         context 'from :write to :write_concern' do
-
           let(:client_options) do
-            { :write => { :w => 1 } }
+            { write: { w: 1 } }
           end
 
-          let!(:new_client) do
-            client.with(:write_concern => { :w => 2 })
-          end
+          let(:new_client) { client.with(write_concern: { w: 2 }) }
 
           it 'uses the new option' do
             expect(new_client.options[:write_concern]).to eq(Mongo::Options::Redacted.new(w: 2))
-            expect(new_client.options[:write]).to be nil
+            expect(new_client.options[:write]).to be_nil
           end
         end
       end
     end
 
     context 'when an invalid option is provided' do
-
       let(:new_client) do
         client.with(invalid: :option, ssl: false)
       end
@@ -2623,24 +2548,18 @@ describe Mongo::Client do
 
     context 'when client is created with ipv6 address' do
       let(:client) do
-        new_local_client_nmio(['[::1]:27017'], :database => SpecConfig.instance.test_db)
+        new_local_client_nmio([ '[::1]:27017' ], database: SpecConfig.instance.test_db)
       end
 
       context 'when providing nil' do
-
         it 'returns the cloned client' do
           expect(client.with(nil)).to eq(client)
         end
       end
 
       context 'when changing options' do
-        let(:new_options) do
-          { app_name: 'client_test' }
-        end
-
-        let!(:new_client) do
-          client.with(new_options)
-        end
+        let(:new_options) { { app_name: 'client_test' } }
+        let(:new_client) { client.with(new_options) }
 
         it 'returns a new client' do
           expect(new_client).not_to equal(client)
@@ -2650,11 +2569,14 @@ describe Mongo::Client do
 
     context 'when new client has a new cluster' do
       let(:client) do
-        new_local_client(['127.0.0.1:27017'],
+        new_local_client(
+          SINGLE_CLIENT,
           database: SpecConfig.instance.test_db,
           server_selection_timeout: 0.5,
-          socket_timeout: 0.1, connect_timeout: 0.1)
+          socket_timeout: 0.1, connect_timeout: 0.1, populator_io: false
+        )
       end
+
       let(:new_client) do
         client.with(app_name: 'client_construction_spec').tap do |new_client|
           expect(new_client.cluster).not_to eql(client.cluster)
@@ -2678,26 +2600,28 @@ describe Mongo::Client do
     # in #with, the consistent behavior is to never transfer sdam_proc to
     # the new client.
     context 'when sdam_proc is given on original client' do
-
       let(:sdam_proc) do
-        Proc.new do |client|
+        proc do |client|
           client.subscribe(Mongo::Monitoring::SERVER_HEARTBEAT, subscriber)
         end
       end
 
       let(:client) do
-        new_local_client(SpecConfig.instance.addresses,
+        new_local_client(
+          SpecConfig.instance.addresses,
           SpecConfig.instance.test_options.merge(
             sdam_proc: sdam_proc,
             connect_timeout: 3.08, socket_timeout: 3.09,
             server_selection_timeout: 2.92,
             heartbeat_frequency: 100,
-            database: SpecConfig.instance.test_db))
+            database: SpecConfig.instance.test_db
+          )
+        )
       end
 
       let(:new_client) do
         client.with(app_name: 'foo').tap do |new_client|
-          new_client.cluster.should_not == client.cluster
+          expect(new_client.cluster).not_to be == client.cluster
         end
       end
 
@@ -2706,14 +2630,14 @@ describe Mongo::Client do
         events = subscriber.select_started_events(Mongo::Monitoring::Event::ServerHeartbeatStarted)
         if ClusterConfig.instance.topology == :load_balanced
           # No server monitoring in LB topology
-          events.length.should == 0
+          expect(events.length).to be == 0
         else
-          events.length.should > 0
+          expect(events.length).to be > 0
         end
       end
 
       it 'does not copy sdam_proc option to new client' do
-        expect(new_client.options[:sdam_proc]).to be nil
+        expect(new_client.options[:sdam_proc]).to be_nil
       end
 
       it 'does not notify subscribers set up by sdam_proc' do
@@ -2735,34 +2659,34 @@ describe Mongo::Client do
         new_client.cluster.next_primary
 
         # Diagnostics
+        # rubocop:disable Style/IfUnlessModifier, Lint/Debugger
         unless subscriber.started_events.empty?
           p subscriber.started_events
         end
+        # rubocop:enable Style/IfUnlessModifier, Lint/Debugger
 
         expect(subscriber.started_events.length).to eq 0
-        new_client.cluster.topology.class.should_not be Mongo::Cluster::Topology::Unknown
+        expect(new_client.cluster.topology.class).not_to be Mongo::Cluster::Topology::Unknown
       end
     end
 
     context 'when :server_api is changed' do
-
       let(:client) do
-        new_local_client_nmio(['127.0.0.1:27017'])
+        new_local_client_nmio(SINGLE_CLIENT)
       end
 
       let(:new_client) do
-        client.with(server_api: {version: '1'})
+        client.with(server_api: { version: '1' })
       end
 
       it 'changes :server_api' do
-        new_client.options[:server_api].should == {'version' => '1'}
+        expect(new_client.options[:server_api]).to be == { 'version' => '1' }
       end
     end
 
     context 'when :server_api is cleared' do
-
       let(:client) do
-        new_local_client_nmio(['127.0.0.1:27017'], server_api: {version: '1'})
+        new_local_client_nmio(SINGLE_CLIENT, server_api: { version: '1' })
       end
 
       let(:new_client) do
@@ -2770,19 +2694,17 @@ describe Mongo::Client do
       end
 
       it 'clears :server_api' do
-        new_client.options[:server_api].should be nil
+        expect(new_client.options[:server_api]).to be_nil
       end
     end
-
   end
 
   describe '#dup' do
-
     let(:client) do
       new_local_client_nmio(
-          ['127.0.0.1:27017'],
-          :read => { :mode => :primary },
-          :database => SpecConfig.instance.test_db
+        SINGLE_CLIENT,
+        read: { mode: :primary },
+        database: SpecConfig.instance.test_db
       )
     end
 
@@ -2795,3 +2717,7 @@ describe Mongo::Client do
     it_behaves_like 'duplicated client with reused monitoring'
   end
 end
+# rubocop:enable RSpec/ExpectInHook, RSpec/MessageSpies, RSpec/ExampleLength
+# rubocop:enable RSpec/ContextWording, RSpec/RepeatedExampleGroupDescription
+# rubocop:enable RSpec/ExampleWording, Style/BlockComments, RSpec/AnyInstance
+# rubocop:enable RSpec/VerifiedDoubles