mongo 2.6.2 → 2.16.0

data/spec/mongo/client_spec.rb

@@ -1,89 +1,32 @@
-require 'spec_helper'
-
-describe Mongo::Client do
-
-  after do
-    begin; client.close; rescue; end
-  end
-
-  describe '.new' do
-    describe 'options' do
-      describe 'read' do
-        [
-          :primary, :primary_preferred, :secondary, :secondary_preferred,  :nearest
-        ].each do |sym|
-          it "accepts #{sym} as symbol" do
-            client = described_class.new(['127.0.0.1:27017'],
-              :read => {:mode => sym})
-            # the key got converted to a string here
-            expect(client.read_preference).to eq({'mode' => sym})
-          end
-
-          # string keys are not documented as being allowed
-          # but the code accepts them
-          it "accepts #{sym} as string" do
-            client = described_class.new(['127.0.0.1:27017'],
-              :read => {:mode => sym.to_s})
-            # the key got converted to a string here
-            # the value remains a string
-            expect(client.read_preference).to eq({'mode' => sym.to_s})
-          end
-        end
-
-        it 'rejects bogus read preference as symbol' do
-          expect do
-            client = described_class.new(['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')
-        end
+# frozen_string_literal: true
+# encoding: utf-8
 
-        it 'rejects bogus read preference as string' do
-          expect do
-            client = described_class.new(['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')
-        end
+require 'spec_helper'
 
-        it 'rejects read option specified as a string' do
-          expect do
-            client = described_class.new(['127.0.0.1:27017'],
-              :read => 'primary')
-          end.to raise_error(Mongo::Error::InvalidReadOption, 'Invalid read option: primary: must be a hash')
-        end
+# NB: tests for .new, #initialize, #use, #with and #dup are in
+# client_construction_spec.rb.
 
-        it 'rejects read option specified as a symbol' do
-          expect do
-            client = described_class.new(['127.0.0.1:27017'],
-              :read => :primary)
-          end.to raise_error(Mongo::Error::InvalidReadOption, 'Invalid read option: primary: must be a hash')
-        end
-      end
-    end
-  end
+describe Mongo::Client do
 
   describe '#==' do
 
     let(:client) do
-      described_class.new(
+      new_local_client_nmio(
         ['127.0.0.1:27017'],
         :read => { :mode => :primary },
-        :database => TEST_DB
+        :database => SpecConfig.instance.test_db
       )
     end
 
     context 'when the other is a client' do
 
-      after do
-        other.close
-      end
-
       context 'when the options and cluster are equal' do
 
         let(:other) do
-          described_class.new(
+          new_local_client_nmio(
             ['127.0.0.1:27017'],
             :read => { :mode => :primary },
-            :database => TEST_DB
+            :database => SpecConfig.instance.test_db
           )
         end
 
@@ -95,10 +38,10 @@ describe Mongo::Client do
       context 'when the options are not equal' do
 
         let(:other) do
-          described_class.new(
+          new_local_client_nmio(
             ['127.0.0.1:27017'],
             :read => { :mode => :secondary },
-            :database => TEST_DB
+            :database => SpecConfig.instance.test_db
           )
         end
 
@@ -110,10 +53,10 @@ describe Mongo::Client do
       context 'when cluster is not equal' do
 
         let(:other) do
-          described_class.new(
+          new_local_client_nmio(
             ['127.0.0.1:27010'],
             :read => { :mode => :primary },
-            :database => TEST_DB
+            :database => SpecConfig.instance.test_db
           )
         end
 
@@ -134,7 +77,8 @@ describe Mongo::Client do
   describe '#[]' do
 
     let(:client) do
-      described_class.new(['127.0.0.1:27017'], :database => TEST_DB)
+      new_local_client_nmio(['127.0.0.1:27017'],
+        :database => SpecConfig.instance.test_db)
     end
 
     shared_examples_for 'a collection switching object' do
@@ -170,26 +114,22 @@ describe Mongo::Client do
   describe '#eql' do
 
     let(:client) do
-      described_class.new(
+      new_local_client_nmio(
         ['127.0.0.1:27017'],
         :read => { :mode => :primary },
-        :database => TEST_DB
+        :database => SpecConfig.instance.test_db
       )
     end
 
     context 'when the other is a client' do
 
-      after do
-        other.close
-      end
-
       context 'when the options and cluster are equal' do
 
         let(:other) do
-          described_class.new(
+          new_local_client_nmio(
             ['127.0.0.1:27017'],
             :read => { :mode => :primary },
-            :database => TEST_DB
+            :database => SpecConfig.instance.test_db
           )
         end
 
@@ -201,10 +141,10 @@ describe Mongo::Client do
       context 'when the options are not equal' do
 
         let(:other) do
-          described_class.new(
+          new_local_client_nmio(
             ['127.0.0.1:27017'],
             :read => { :mode => :secondary },
-            :database => TEST_DB
+            :database => SpecConfig.instance.test_db
           )
         end
 
@@ -216,10 +156,10 @@ describe Mongo::Client do
       context 'when the cluster is not equal' do
 
         let(:other) do
-          described_class.new(
+          new_local_client_nmio(
             ['127.0.0.1:27010'],
             :read => { :mode => :primary },
-            :database => TEST_DB
+            :database => SpecConfig.instance.test_db
           )
         end
 
@@ -232,10 +172,10 @@ describe Mongo::Client do
     context 'when the other is not a client' do
 
       let(:client) do
-        described_class.new(
+        new_local_client_nmio(
           ['127.0.0.1:27017'],
           :read => { :mode => :primary },
-          :database => TEST_DB
+          :database => SpecConfig.instance.test_db
         )
       end
 
@@ -248,692 +188,62 @@ describe Mongo::Client do
   describe '#hash' do
 
     let(:client) do
-      described_class.new(
+      new_local_client_nmio(
         ['127.0.0.1:27017'],
         :read => { :mode => :primary },
         :local_threshold => 0.010,
         :server_selection_timeout => 10000,
-        :database => TEST_DB
+        :database => SpecConfig.instance.test_db
       )
     end
 
+    let(:default_options) { Mongo::Options::Redacted.new(
+      retry_writes: true, retry_reads: true, monitoring_io: false) }
+
     let(:options) do
       Mongo::Options::Redacted.new(:read => { :mode => :primary },
                                     :local_threshold => 0.010,
                                     :server_selection_timeout => 10000,
-                                    :database => TEST_DB)
-    end
-
-    let(:expected) do
-      [client.cluster, options].hash
-    end
-
-    it 'returns a hash of the cluster and options' do
-      expect(client.hash).to eq(expected)
-    end
-  end
-
-  describe '#inspect' do
-
-    let(:client) do
-      described_class.new(
-        ['127.0.0.1:27017'],
-        :read => { :mode => :primary },
-        :database => TEST_DB
-      )
-    end
-
-    it 'returns the cluster information' do
-      expect(client.inspect).to include(
-        "<Mongo::Client:0x#{client.object_id} cluster=127.0.0.1:27017"
-      )
-    end
-
-    context 'when there is sensitive data in the options' do
-
-      let(:client) do
-        described_class.new(
-            ['127.0.0.1:27017'],
-            :read => { :mode => :primary },
-            :database => TEST_DB,
-            :password => 'some_password',
-            :user => 'emily'
-        )
-      end
-
-      it 'does not print out sensitive data' do
-        expect(client.inspect).not_to match('some_password')
-      end
-    end
-  end
-
-  describe '#initialize' do
-
-    context 'when providing options' do
-
-      context 'when retry_writes is defined' do
-
-        let(:options) do
-          { retry_writes: true }
-        end
-
-        let(:client) do
-          described_class.new([default_address.seed], authorized_client.options.merge(options))
-        end
-
-        it 'sets the option' do
-          expect(client.options['retry_writes']).to eq(options[:retry_writes])
-        end
-      end
-
-      context 'when compressors are provided' do
-
-        let(:client) do
-          described_class.new([default_address.seed], authorized_client.options.merge(options))
-        end
-
-        context 'when the compressor is supported' do
-
-          let(:options) do
-            { compressors: ['zlib'] }
-          end
-
-          it 'sets the compressor' do
-            expect(client.options['compressors']).to eq(options[:compressors])
-          end
-
-          it 'sends the compressor in the compression key of the handshake document' do
-            expect(client.cluster.app_metadata.send(:document)[:compression]).to eq(options[:compressors])
-          end
-
-          it 'uses compression for messages', if: testing_compression? do
-            expect(Mongo::Protocol::Compressed).to receive(:new).and_call_original
-            client[TEST_COLL].find({}, limit: 1).first
-          end
-
-          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.send(:authenticate!)
-            end
-          end
-        end
-
-        context 'when the compressor is not supported by the driver' do
-
-          let(:options) do
-            { compressors: ['snoopy'] }
-          end
-
-          it 'does not set the compressor and warns' do
-            expect(Mongo::Logger.logger).to receive(:warn)
-            expect(client.options['compressors']).to be_nil
-          end
-
-          it 'sets the compression key of the handshake document to an empty array' do
-            expect(client.cluster.app_metadata.send(:document)[:compression]).to eq([])
-          end
-
-          context 'when one supported compressor and one unsupported compressor are provided', if: compression_enabled? do
-
-            let(:options) do
-              { compressors: ['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'])
-            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'])
-            end
-          end
-        end
-
-        context 'when the compressor is not supported by the server', unless: collation_enabled? do
-
-          let(:options) do
-            { compressors: ['zlib'] }
-          end
-
-          it 'does not set the compressor and warns' do
-            expect(Mongo::Logger.logger).to receive(:warn).at_least(:once)
-            expect(client.cluster.next_primary.monitor.compressor).to be_nil
-          end
-        end
-      end
-
-      context 'when compressors are not provided', unless: compression_enabled? do
-
-        let(:client) do
-          authorized_client
-        end
-
-        it 'does not set the compressor' do
-          expect(client.options['compressors']).to be_nil
-        end
-
-        it 'sets the compression key of the handshake document to an empty array' do
-          expect(client.cluster.app_metadata.send(:document)[:compression]).to eq([])
-        end
-
-        it 'does not use compression for messages' do
-          client[TEST_COLL].find({}, limit: 1).first
-          expect(Mongo::Protocol::Compressed).not_to receive(:new)
-        end
-      end
-
-      context 'when a zlib_compression_level option is provided', if: testing_compression? do
-
-        let(:client) do
-          described_class.new([default_address.seed], TEST_OPTIONS.merge(zlib_compression_level: 1))
-        end
-
-        it 'sets the option on the client' do
-          expect(client.options[:zlib_compression_level]).to eq(1)
-        end
-      end
-
-      context 'when ssl options are provided' do
-
-        let(:options) do
-          {
-              :ssl => true,
-              :ssl_ca_cert => CA_PEM,
-              :ssl_ca_cert_string => 'ca cert string',
-              :ssl_ca_cert_object => 'ca cert object',
-              :ssl_cert => CLIENT_CERT_PEM,
-              :ssl_cert_string => 'cert string',
-              :ssl_cert_object => 'cert object',
-              :ssl_key => CLIENT_KEY_PEM,
-              :ssl_key_string => 'key string',
-              :ssl_key_object => 'key object',
-              :ssl_key_pass_phrase => 'passphrase',
-              :ssl_verify => true
-          }
-        end
-
-        let(:client) do
-          described_class.new(['127.0.0.1:27017'], TEST_OPTIONS.merge(options))
-        end
-
-        it 'sets the ssl option' do
-          expect(client.options[:ssl]).to eq(options[:ssl])
-        end
-
-        it 'sets the ssl_ca_cert option' do
-          expect(client.options[:ssl_ca_cert]).to eq(options[:ssl_ca_cert])
-        end
-
-        it 'sets the ssl_ca_cert_string option' do
-          expect(client.options[:ssl_ca_cert_string]).to eq(options[:ssl_ca_cert_string])
-        end
-
-        it 'sets the ssl_ca_cert_object option' do
-          expect(client.options[:ssl_ca_cert_object]).to eq(options[:ssl_ca_cert_object])
-        end
-
-        it 'sets the ssl_cert option' do
-          expect(client.options[:ssl_cert]).to eq(options[:ssl_cert])
-        end
-
-        it 'sets the ssl_cert_string option' do
-          expect(client.options[:ssl_cert_string]).to eq(options[:ssl_cert_string])
-        end
-
-        it 'sets the ssl_cert_object option' do
-          expect(client.options[:ssl_cert_object]).to eq(options[:ssl_cert_object])
-        end
-
-        it 'sets the ssl_key option' do
-          expect(client.options[:ssl_key]).to eq(options[:ssl_key])
-        end
-
-        it 'sets the ssl_key_string option' do
-          expect(client.options[:ssl_key_string]).to eq(options[:ssl_key_string])
-        end
-
-        it 'sets the ssl_key_object option' do
-          expect(client.options[:ssl_key_object]).to eq(options[:ssl_key_object])
-        end
-
-        it 'sets the ssl_key_pass_phrase option' do
-          expect(client.options[:ssl_key_pass_phrase]).to eq(options[:ssl_key_pass_phrase])
-        end
-
-        it 'sets the ssl_verify option' do
-          expect(client.options[:ssl_verify]).to eq(options[:ssl_verify])
-        end
-      end
-
-      context 'when no database is provided' do
-
-        let(:client) do
-          described_class.new(['127.0.0.1:27017'], :read => { :mode => :secondary })
-        end
-
-        it 'defaults the database to admin' do
-          expect(client.database.name).to eq('admin')
-        end
-      end
-
-      context 'when a database is provided' do
-
-        let(:client) do
-          described_class.new(['127.0.0.1:27017'], :database => :testdb)
-        end
-
-        it 'sets the current database' do
-          expect(client[:users].name).to eq('users')
-        end
-      end
-
-      context 'when providing a custom logger' do
-
-        let(:logger) do
-          Logger.new($stdout).tap do |l|
-            l.level = Logger::FATAL
-          end
-        end
-
-        let(:client) do
-          authorized_client.with(logger: logger)
-        end
-
-        it 'does not use the global logger' do
-          expect(client.cluster.logger).to_not eq(Mongo::Logger.logger)
-        end
-      end
-
-      context 'when providing a heartbeat_frequency' do
-
-        let(:client) do
-          described_class.new(['127.0.0.1:27017'], :heartbeat_frequency => 2)
-        end
-
-        it 'sets the heartbeat frequency' do
-          expect(client.cluster.options[:heartbeat_frequency]).to eq(client.options[:heartbeat_frequency])
-        end
-      end
-
-      context 'when min_pool_size is provided' do
-
-        let(:client) do
-          described_class.new(['127.0.0.1:27017'], options)
-        end
-
-        context 'when max_pool_size is provided' do
-
-          context 'when the min_pool_size is greater than the max_pool_size' do
-
-            let(:options) do
-              {
-                  :min_pool_size => 20,
-                  :max_pool_size => 10
-              }
-            end
-
-            it 'raises an Exception' do
-              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
-
-            it 'sets the option' do
-              expect(client.options[:min_pool_size]).to eq(options[:min_pool_size])
-              expect(client.options[:max_pool_size]).to eq(options[:max_pool_size])
-            end
-          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
-
-            it 'sets the option' do
-              expect(client.options[:min_pool_size]).to eq(options[:min_pool_size])
-              expect(client.options[:max_pool_size]).to eq(options[:max_pool_size])
-            end
-          end
-        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 => 10
-              }
-            end
-
-            it 'raises an Exception' do
-              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
-
-            it 'sets the option' do
-              expect(client.options[:min_pool_size]).to eq(options[:min_pool_size])
-            end
-          end
-
-          context 'when the min_pool_size is equal to the max_pool_size' do
-
-            let(:options) do
-              {
-                :min_pool_size => Mongo::Server::ConnectionPool::Queue::MAX_SIZE
-              }
-            end
-
-            it 'sets the option' do
-              expect(client.options[:min_pool_size]).to eq(options[:min_pool_size])
-            end
-          end
-        end
-      end
-
-      context 'when max_pool_size and min_pool_size are both nil' do
-
-        let(:client) do
-          described_class.new(['127.0.0.1:27017'], options)
-        end
-
-        let(:options) do
-          {
-              :min_pool_size => nil,
-              :max_pool_size => nil
-          }
-        end
-
-        it 'does not set either option' do
-          expect(client.options[:max_pool_size]).to be_nil
-          expect(client.options[:min_pool_size]).to be_nil
-        end
-      end
-
-      context 'when platform details are specified' do
-
-        let(:app_metadata) do
-          client.cluster.app_metadata
-        end
-
-        let(:client) do
-          described_class.new(['127.0.0.1:27017'], :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/)
-        end
-      end
-
-      context 'when platform details are not specified' do
-
-        let(:app_metadata) do
-          client.cluster.app_metadata
-        end
-
-        let(:client) do
-          described_class.new(['127.0.0.1:27017'])
-        end
-
-        let(:platform_string) do
-          [
-            RUBY_VERSION,
-            RUBY_PLATFORM,
-            RbConfig::CONFIG['build']
-          ].join(', ')
-        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)
-        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
-          described_class.new(uri)
-        end
-
-        it 'sets the database' do
-          expect(client.options[:database]).to eq('testdb')
-        end
-      end
-
-      context 'when a database is provided' do
-
-        let!(:uri) do
-          'mongodb://127.0.0.1:27017/testdb'
-        end
-
-        let(:client) do
-          described_class.new(uri)
-        end
-
-        it 'sets the database' do
-          expect { client[:users] }.to_not 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
-          described_class.new(uri)
-        end
-
-        it 'defaults the database to admin' do
-          expect(client.database.name).to eq('admin')
-        end
-      end
-
-      context 'when options are provided' do
-
-        let!(:uri) do
-          'mongodb://127.0.0.1:27017/testdb?w=3'
-        end
-
-        let(:client) do
-          described_class.new(uri)
-        end
-
-        let(:expected_options) do
-          Mongo::Options::Redacted.new(:write => { :w => 3 }, :database => 'testdb')
-        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_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)
-              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
-
-              it 'sets the option' do
-                expect(client.options[:min_pool_size]).to eq(10)
-                expect(client.options[:max_pool_size]).to eq(20)
-              end
-            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
-
-              it 'sets the option' do
-                expect(client.options[:min_pool_size]).to eq(10)
-                expect(client.options[:max_pool_size]).to eq(10)
-              end
-            end
-          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=10'
-              end
-
-              it 'raises an Exception' do
-                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
-
-              it 'sets the option' do
-                expect(client.options[:min_pool_size]).to eq(3)
-              end
-            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
-
-              it 'sets the option' do
-                expect(client.options[:min_pool_size]).to eq(5)
-              end
-            end
-          end
-        end
-      end
-
-      context 'when options are provided not in the string' do
-
-        let!(:uri) do
-          'mongodb://127.0.0.1:27017/testdb'
-        end
-
-        let(:client) do
-          described_class.new(uri, :write => { :w => 3 })
-        end
-
-        let(:expected_options) do
-          Mongo::Options::Redacted.new(:write => { :w => 3 }, :database => 'testdb')
-        end
-
-        it 'sets the options' do
-          expect(client.options).to eq(expected_options)
-        end
-      end
-
-      context 'when options are provided in the string and explicitly' do
-
-        let!(:uri) do
-          'mongodb://127.0.0.1:27017/testdb?w=3'
-        end
-
-        let(:client) do
-          described_class.new(uri, :write => { :w => 4 })
-        end
-
-        let(:expected_options) do
-          Mongo::Options::Redacted.new(:write => { :w => 4 }, :database => 'testdb')
-        end
-
-        it 'allows explicit options to take preference' do
-          expect(client.options).to eq(expected_options)
-        end
-      end
-
-      context 'when a replica set name is provided' do
+                                    :database => SpecConfig.instance.test_db)
+    end
 
-        let!(:uri) do
-          'mongodb://127.0.0.1:27017/testdb?replicaSet=testing'
-        end
+    let(:expected) do
+      [client.cluster, default_options.merge(options)].hash
+    end
 
-        let(:client) do
-          described_class.new(uri)
-        end
+    it 'returns a hash of the cluster and options' do
+      expect(client.hash).to eq(expected)
+    end
+  end
 
-        it 'sets the correct cluster topology' do
-          expect(client.cluster.topology).to be_a(Mongo::Cluster::Topology::ReplicaSet)
-        end
-      end
+  describe '#inspect' do
 
-      context 'when an invalid option is provided' do
+    let(:client) do
+      new_local_client_nmio(
+        ['127.0.0.1:27017'],
+        :read => { :mode => :primary },
+        :database => SpecConfig.instance.test_db
+      )
+    end
 
-        let(:client) do
-          described_class.new(['127.0.0.1:27017'], :ssl => false, :invalid => :test)
-        end
+    it 'returns the cluster information' do
+      expect(client.inspect).to match(/Cluster(.|\n)*topology=(.|\n)*servers=/)
+    end
 
-        it 'does not set the option' do
-          expect(client.options.keys).not_to include('invalid')
-        end
+    context 'when there is sensitive data in the options' do
 
-        it 'sets the valid options' do
-          expect(client.options.keys).to include('ssl')
-        end
+      let(:client) do
+        new_local_client_nmio(
+            ['127.0.0.1:27017'],
+            :read => { :mode => :primary },
+            :database => SpecConfig.instance.test_db,
+            :password => 'some_password',
+            :user => 'emily'
+        )
+      end
 
-        it 'warns that an invalid option has been specified' do
-          expect(Mongo::Logger.logger).to receive(:warn)
-          expect(client.options.keys).not_to include('invalid')
-        end
+      it 'does not print out sensitive data' do
+        expect(client.inspect).not_to match('some_password')
       end
     end
   end
@@ -943,8 +253,8 @@ describe Mongo::Client do
     context 'when there is a read preference set' do
 
       let(:client) do
-        described_class.new(['127.0.0.1:27017'],
-                            :database => TEST_DB,
+        new_local_client_nmio(['127.0.0.1:27017'],
+                            :database => SpecConfig.instance.test_db,
                             :read => mode,
                             :server_selection_timeout => 2)
       end
@@ -1015,8 +325,8 @@ describe Mongo::Client do
       context 'when no mode provided' do
 
         let(:client) do
-          described_class.new(['127.0.0.1:27017'],
-                              :database => TEST_DB,
+          new_local_client_nmio(['127.0.0.1:27017'],
+                              :database => SpecConfig.instance.test_db,
                               :server_selection_timeout => 2)
         end
 
@@ -1028,7 +338,7 @@ describe Mongo::Client do
       context 'when the read preference is printed' do
 
         let(:client) do
-          described_class.new([ default_address.to_s ], options)
+          new_local_client_nmio(SpecConfig.instance.addresses, options)
         end
 
         let(:options) do
@@ -1057,8 +367,8 @@ describe Mongo::Client do
   describe '#read_preference' do
 
     let(:client) do
-      described_class.new(['127.0.0.1:27017'],
-                          :database => TEST_DB,
+      new_local_client_nmio(['127.0.0.1:27017'],
+                          :database => SpecConfig.instance.test_db,
                           :read => mode,
                           :server_selection_timeout => 2)
     end
@@ -1125,8 +435,8 @@ describe Mongo::Client do
     context 'when no mode provided' do
 
       let(:client) do
-        described_class.new(['127.0.0.1:27017'],
-                            :database => TEST_DB,
+        new_local_client_nmio(['127.0.0.1:27017'],
+                            :database => SpecConfig.instance.test_db,
                             :server_selection_timeout => 2)
       end
 
@@ -1136,234 +446,13 @@ describe Mongo::Client do
     end
   end
 
-  describe '#use' do
-
-    let(:client) do
-      described_class.new(['127.0.0.1:27017'], :database => 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
-
-      it 'keeps the same cluster' do
-        expect(database.cluster).to equal(client.cluster)
-      end
-    end
-
-    context 'when provided a string' do
-
-      let(:database) do
-        client.use('testdb')
-      end
-
-      it_behaves_like 'a database switching object'
-    end
-
-    context 'when provided a symbol' do
-
-      let(:database) do
-        client.use(:testdb)
-      end
-
-      it_behaves_like 'a database switching object'
-    end
-
-    context 'when providing nil' do
-
-      it 'raises an exception' do
-        expect {
-          client.use(nil)
-        }.to raise_error(Mongo::Error::InvalidDatabaseName)
-      end
-    end
-  end
-
-  describe '#with' do
-
-    let(:client) do
-      described_class.new(['127.0.0.1:27017'], :database => 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
-
-      it 'returns a new client' do
-        expect(new_client).not_to equal(client)
-      end
-
-      it 'replaces the existing options' do
-        expect(new_client.options).to eq(client.options.merge(new_options))
-      end
-
-      it 'does not modify the original client' do
-        expect(client.options).to eq(original_options)
-      end
-
-      it 'does not keep the same cluster' do
-        expect(new_client.cluster).not_to be(client.cluster)
-      end
-    end
-
-    context 'when the write concern is not changed' do
-
-      let(:client) do
-        described_class.new(
-          ['127.0.0.1:27017'],
-          :read => { :mode => :secondary }, :write => { :w => 1 }, :database => TEST_DB
-        )
-      end
-
-      let!(:new_client) do
-        client.with(:read => { :mode => :primary })
-      end
-
-      let(:new_options) do
-        Mongo::Options::Redacted.new(:read => { :mode => :primary },
-                                             :write => { :w => 1 },
-                                             :database => TEST_DB)
-      end
-
-      let(:original_options) do
-        Mongo::Options::Redacted.new(:read => { :mode => :secondary },
-                                             :write => { :w => 1 },
-                                             :database => TEST_DB)
-      end
-
-      it 'returns a new client' do
-        expect(new_client).not_to equal(client)
-      end
-
-      it 'replaces the existing options' do
-        expect(new_client.options).to eq(new_options)
-      end
-
-      it 'does not modify the original client' do
-        expect(client.options).to eq(original_options)
-      end
-
-      it 'keeps the same cluster' do
-        expect(new_client.cluster).to be(client.cluster)
-      end
-    end
-
-    context 'when the write concern is changed' do
-
-      let(:client) do
-        described_class.new(['127.0.0.1:27017'], :write => { :w => 1 }, :database => TEST_DB)
-      end
-
-      context 'when the write concern has not been accessed' do
-
-        let!(:new_client) do
-          client.with(:write => { :w => 0 })
-        end
-
-        let(:get_last_error) do
-          new_client.write_concern.get_last_error
-        end
-
-        it 'returns the correct write concern' do
-          expect(get_last_error).to be_nil
-        end
-      end
-
-      context 'when the write concern has been accessed' do
-
-        let!(:new_client) do
-          client.write_concern
-          client.with(:write => { :w => 0 })
-        end
-
-        let(:get_last_error) do
-          new_client.write_concern.get_last_error
-        end
-
-        it 'returns the correct write concern' do
-          expect(get_last_error).to be_nil
-        end
-      end
-    end
-
-    context 'when an invalid option is provided' do
-
-      let(:new_client) do
-        client.with(invalid: :option, ssl: false)
-      end
-
-      it 'does not set the invalid option' do
-        expect(new_client.options.keys).not_to include('invalid')
-      end
-
-      it 'sets the valid options' do
-        expect(new_client.options.keys).to include('ssl')
-      end
-
-      it 'warns that an invalid option has been specified' do
-        expect(Mongo::Logger.logger).to receive(:warn)
-        expect(new_client.options.keys).not_to include('invalid')
-      end
-    end
-
-    context 'when client is created with ipv6 address' do
-      let(:client) do
-        described_class.new(['[::1]:27017'], :database => 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
-
-        it 'returns a new client' do
-          expect(new_client).not_to equal(client)
-        end
-      end
-    end
-  end
-
   describe '#write_concern' do
 
     let(:concern) { client.write_concern }
 
     context 'when no option was provided to the client' do
 
-      let(:client) { described_class.new(['127.0.0.1:27017'], :database => TEST_DB) }
+      let(:client) { new_local_client_nmio(['127.0.0.1:27017'], :database => SpecConfig.instance.test_db) }
 
       it 'does not set the write concern' do
         expect(concern).to be_nil
@@ -1375,7 +464,7 @@ describe Mongo::Client do
       context 'when the option is acknowledged' do
 
         let(:client) do
-          described_class.new(['127.0.0.1:27017'], :write => { :j => true }, :database => TEST_DB)
+          new_local_client_nmio(['127.0.0.1:27017'], :write => { :j => true }, :database => SpecConfig.instance.test_db)
         end
 
         it 'returns a acknowledged write concern' do
@@ -1388,7 +477,7 @@ describe Mongo::Client do
         context 'when the w is 0' do
 
           let(:client) do
-            described_class.new(['127.0.0.1:27017'], :write => { :w => 0 }, :database => TEST_DB)
+            new_local_client_nmio(['127.0.0.1:27017'], :write => { :w => 0 }, :database => SpecConfig.instance.test_db)
           end
 
           it 'returns an unacknowledged write concern' do
@@ -1399,7 +488,7 @@ describe Mongo::Client do
         context 'when the w is -1' do
 
           let(:client) do
-            described_class.new(['127.0.0.1:27017'], :write => { :w => -1 }, :database => TEST_DB)
+            new_local_client_nmio(['127.0.0.1:27017'], :write => { :w => -1 }, :database => SpecConfig.instance.test_db)
           end
 
           it 'raises an error' do
@@ -1412,6 +501,63 @@ describe Mongo::Client do
     end
   end
 
+  [
+    [:max_read_retries, 1],
+    [:read_retry_interval, 5],
+    [:max_write_retries, 1],
+  ].each do |opt, default|
+    describe "##{opt}" do
+      let(:client_options) { {} }
+
+      let(:client) do
+        new_local_client_nmio(['127.0.0.1:27017'], client_options)
+      end
+
+      it "defaults to #{default}" do
+        expect(default).not_to be nil
+        expect(client.options[opt]).to be nil
+        expect(client.send(opt)).to eq(default)
+      end
+
+      context 'specified on client' do
+        let(:client_options) { {opt => 2} }
+
+        it 'inherits from client' do
+          expect(client.options[opt]).to eq(2)
+          expect(client.send(opt)).to eq(2)
+        end
+      end
+    end
+  end
+
+  shared_context 'ensure test db exists' do
+    before(:all) do
+      # Ensure the database we are querying exists.
+      # When the entire test suite is run, it will generally have been
+      # created by a previous test, but if this test is run on a fresh
+      # deployment the database won't exist.
+      client = ClientRegistry.instance.global_client('authorized')
+      client['any-collection-name'].insert_one(any: :value)
+    end
+  end
+
+  describe '#database' do
+
+    let(:database) { client.database }
+
+    context 'when client has :server_api option' do
+
+      let(:client) do
+        new_local_client_nmio(['localhost'], server_api: {version: '1'})
+      end
+
+      it 'is not transfered to the collection' do
+        database.options[:server_api].should be nil
+      end
+    end
+
+  end
+
   describe '#database_names' do
 
     it 'returns a list of database names' do
@@ -1420,14 +566,17 @@ describe Mongo::Client do
       )
     end
 
-    context 'when filter criteria is present', if: sessions_enabled? do
+    context 'when filter criteria is present' do
+      min_server_fcv '3.6'
+
+      include_context 'ensure test db exists'
 
       let(:result) do
         root_authorized_client.database_names(filter)
       end
 
       let(:filter) do
-        { name: TEST_DB }
+        { name: SpecConfig.instance.test_db }
       end
 
       it 'returns a filtered list of database names' do
@@ -1446,14 +595,17 @@ describe Mongo::Client do
         end).to include('admin')
     end
 
-    context 'when filter criteria is present', if: sessions_enabled? do
+    context 'when filter criteria is present' do
+      min_server_fcv '3.6'
+
+      include_context 'ensure test db exists'
 
       let(:result) do
         root_authorized_client.list_databases(filter)
       end
 
       let(:filter) do
-        { name: TEST_DB }
+        { name: SpecConfig.instance.test_db }
       end
 
       it 'returns a filtered list of database info documents' do
@@ -1463,31 +615,66 @@ describe Mongo::Client do
     end
 
     context 'when name_only is true' do
+      min_server_fcv '3.6'
+
+      let(:command) do
+        Utils.get_command_event(root_authorized_client, 'listDatabases') do |client|
+          client.list_databases({}, true)
+        end.command
+      end
+
+      it 'sends the command with the nameOnly flag set to true' do
+        expect(command[:nameOnly]).to be(true)
+      end
+    end
+
+    context 'when authorized_databases is provided' do
+      min_server_fcv '4.0'
 
       let(:client_options) do
         root_authorized_client.options.merge(heartbeat_frequency: 100, monitoring: true)
       end
 
+      let(:subscriber) { Mrss::EventSubscriber.new }
+
       let(:client) do
-        Mongo::Client.new(SpecConfig.instance.addresses, client_options).tap do |cl|
-          cl.subscribe(Mongo::Monitoring::COMMAND, EventSubscriber.clear_events!)
+        ClientRegistry.instance.new_local_client(
+          SpecConfig.instance.addresses, client_options
+        ).tap do |cl|
+          cl.subscribe(Mongo::Monitoring::COMMAND, subscriber)
         end
       end
 
       let(:command) do
-        EventSubscriber.started_events.find { |c| c.command_name == 'listDatabases' }.command
+        subscriber.started_events.find { |c| c.command_name == 'listDatabases' }.command
+      end
+
+      let(:authDb) do
+        { authorized_databases: true }
+      end
+
+      let(:noAuthDb) do
+        { authorized_databases: false }
       end
 
       before do
-        client.list_databases({}, true)
+        client.list_databases({}, true, authDb)
+        client.list_databases({}, true, noAuthDb)
       end
 
-      after do
-        client.close
+      let(:events) do
+        subscriber.command_started_events('listDatabases')
       end
 
-      it 'sends the command with the nameOnly flag set to true' do
-        expect(command[:nameOnly]).to be(true)
+      it 'sends the command with the authorizedDatabases flag set to true' do
+        expect(events.length).to eq(2)
+        command = events.first.command
+        expect(command[:authorizedDatabases]).to be(true)
+      end
+
+      it 'sends the command with the authorizedDatabases flag set to nil' do
+        command = events.last.command
+        expect(command[:authorizedDatabases]).to be_nil
       end
     end
   end
@@ -1514,14 +701,17 @@ describe Mongo::Client do
       expect(result.first.options[:read]).to eq(BSON::Document.new(options)[:read])
     end
 
-    context 'when filter criteria is present', if: sessions_enabled? do
+    context 'when filter criteria is present' do
+      min_server_fcv '3.6'
+
+      include_context 'ensure test db exists'
 
       let(:result) do
         client.list_mongo_databases(filter)
       end
 
       let(:filter) do
-        { name: TEST_DB }
+        { name: SpecConfig.instance.test_db }
       end
 
       it 'returns a filtered list of Mongo::Database objects' do
@@ -1532,25 +722,22 @@ describe Mongo::Client do
   end
 
   describe '#close' do
-
     let(:client) do
-      described_class.new(['127.0.0.1:27017'])
-    end
-
-    before do
-      # note that disconnect! is called also in the after block
-      expect(client.cluster).to receive(:disconnect!).twice.and_call_original
+      new_local_client_nmio(['127.0.0.1:27017'])
     end
 
     it 'disconnects the cluster and returns true' do
-      expect(client.close).to be(true)
+      RSpec::Mocks.with_temporary_scope do
+        expect(client.cluster).to receive(:disconnect!).and_call_original
+        expect(client.close).to be(true)
+      end
     end
   end
 
   describe '#reconnect' do
 
     let(:client) do
-      described_class.new(['127.0.0.1:27017'])
+      new_local_client_nmio([ClusterConfig.instance.primary_address_str])
     end
 
     it 'replaces the cluster' do
@@ -1560,34 +747,23 @@ describe Mongo::Client do
       expect(new_id).not_to eql(old_id)
     end
 
-    it 'returns true' do
-      expect(client.reconnect).to be(true)
-    end
-  end
-
-  describe '#dup' do
-
-    let(:client) do
-      described_class.new(
-          ['127.0.0.1:27017'],
-          :read => { :mode => :primary },
-          :database => TEST_DB
-      )
+    it 'replaces the session pool' do
+      old_id = client.cluster.session_pool.object_id
+      client.reconnect
+      new_id = client.cluster.session_pool.object_id
+      expect(new_id).not_to eql(old_id)
     end
 
-    it 'creates a client with Redacted options' do
-      expect(client.dup.options).to be_a(Mongo::Options::Redacted)
+    it 'returns true' do
+      expect(client.reconnect).to be(true)
     end
   end
 
   describe '#collections' do
 
     before do
-      authorized_client.database[:users].create
-    end
-
-    after do
       authorized_client.database[:users].drop
+      authorized_client.database[:users].create
     end
 
     let(:collection) do
@@ -1606,7 +782,9 @@ describe Mongo::Client do
       authorized_client.start_session
     end
 
-    context 'when sessions are supported', if: test_sessions? do
+    context 'when sessions are supported' do
+      min_server_fcv '3.6'
+      require_topology :replica_set, :sharded
 
       it 'creates a session' do
         expect(session).to be_a(Mongo::Session)
@@ -1697,7 +875,9 @@ describe Mongo::Client do
       end
     end
 
-    context 'when two clients have the same cluster', if: test_sessions? do
+    context 'when two clients have the same cluster' do
+      min_server_fcv '3.6'
+      require_topology :replica_set, :sharded
 
       let(:client) do
         authorized_client.with(read: { mode: :secondary })
@@ -1712,10 +892,12 @@ describe Mongo::Client do
       end
     end
 
-    context 'when two clients have different clusters', if: test_sessions? do
+    context 'when two clients have different clusters' do
+      min_server_fcv '3.6'
+      require_topology :replica_set, :sharded
 
       let(:client) do
-        authorized_client_with_retry_writes
+        another_authorized_client
       end
 
       let(:session) do
@@ -1729,7 +911,8 @@ describe Mongo::Client do
       end
     end
 
-    context 'when sessions are not supported', unless: sessions_enabled? do
+    context 'when sessions are not supported' do
+      max_server_version '3.4'
 
       it 'raises an exception' do
         expect {
@@ -1738,4 +921,46 @@ describe Mongo::Client do
       end
     end
   end
+
+  describe '#summary' do
+
+    context 'monitoring omitted' do
+      let(:client) do
+        new_local_client_nmio(
+          ['127.0.0.1:27017'],
+          :read => { :mode => :primary },
+          :database => SpecConfig.instance.test_db
+        )
+      end
+
+      it 'indicates lack of monitoring' do
+        client.summary.should =~ /servers=.*UNKNOWN.*NO-MONITORING/
+      end
+    end
+
+    context 'monitoring present' do
+      require_topology :single, :replica_set, :sharded
+
+      let(:client) do
+        authorized_client
+      end
+
+      it 'does not indicate lack of monitoring' do
+        client.summary.should =~ /servers=.*(?:STANDALONE|PRIMARY|MONGOS)/
+        client.summary.should_not =~ /servers=.*(?:STANDALONE|PRIMARY|MONGOS).*NO-MONITORING/
+      end
+    end
+
+    context 'background threads killed' do
+      let(:client) do
+        authorized_client.tap do |client|
+          client.cluster.servers.map(&:disconnect!)
+        end
+      end
+
+      it 'does not indicate lack of monitoring' do
+        client.summary.should =~ /servers=.*(STANDALONE|PRIMARY|MONGOS|\bLB\b).*NO-MONITORING/
+      end
+    end
+  end
 end