mongo 2.3.1 → 2.16.0

data/spec/mongo/client_spec.rb

@@ -1,30 +1,32 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require 'spec_helper'
 
+# NB: tests for .new, #initialize, #use, #with and #dup are in
+# client_construction_spec.rb.
+
 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
 
-    after do
-      client.close
-    end
-
     context 'when the other is a client' do
 
       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
 
@@ -33,17 +35,32 @@ describe Mongo::Client do
         end
       end
 
-      context 'when the options and cluster are not equal' 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
 
-        it 'returns true' do
+        it 'returns false' do
+          expect(client).not_to eq(other)
+        end
+      end
+
+      context 'when cluster is not equal' do
+
+        let(:other) do
+          new_local_client_nmio(
+            ['127.0.0.1:27010'],
+            :read => { :mode => :primary },
+            :database => SpecConfig.instance.test_db
+          )
+        end
+
+        it 'returns false' do
           expect(client).not_to eq(other)
         end
       end
@@ -60,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
@@ -96,10 +114,10 @@ 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
 
@@ -108,10 +126,10 @@ describe Mongo::Client do
       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
 
@@ -120,17 +138,32 @@ describe Mongo::Client do
         end
       end
 
-      context 'when the options and cluster are not equal' 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
 
-        it 'returns true' do
+        it 'returns false' do
+          expect(client).not_to eql(other)
+        end
+      end
+
+      context 'when the cluster is not equal' do
+
+        let(:other) do
+          new_local_client_nmio(
+            ['127.0.0.1:27010'],
+            :read => { :mode => :primary },
+            :database => SpecConfig.instance.test_db
+          )
+        end
+
+        it 'returns false' do
           expect(client).not_to eql(other)
         end
       end
@@ -139,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
 
@@ -155,24 +188,27 @@ 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 => 10,
+        :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 => 10,
+                                    :local_threshold => 0.010,
                                     :server_selection_timeout => 10000,
-                                    :database => TEST_DB)
+                                    :database => SpecConfig.instance.test_db)
     end
 
     let(:expected) do
-      [client.cluster, options].hash
+      [client.cluster, default_options.merge(options)].hash
     end
 
     it 'returns a hash of the cluster and options' do
@@ -183,26 +219,24 @@ describe Mongo::Client do
   describe '#inspect' 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
 
     it 'returns the cluster information' do
-      expect(client.inspect).to include(
-        "<Mongo::Client:0x#{client.object_id} cluster=127.0.0.1:27017"
-      )
+      expect(client.inspect).to match(/Cluster(.|\n)*topology=(.|\n)*servers=/)
     end
 
     context 'when there is sensitive data in the options' 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,
             :password => 'some_password',
             :user => 'emily'
         )
@@ -214,175 +248,117 @@ describe Mongo::Client do
     end
   end
 
-  describe '#initialize' do
+  describe '#server_selector' do
 
-    context 'when providing options' do
+    context 'when there is a read preference set' do
 
-      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
+      let(:client) do
+        new_local_client_nmio(['127.0.0.1:27017'],
+                            :database => SpecConfig.instance.test_db,
+                            :read => mode,
+                            :server_selection_timeout => 2)
       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
+      let(:server_selector) do
+        client.server_selector
       end
 
-      context 'when providing a custom logger' do
+      context 'when mode is primary' do
 
-        let(:logger) do
-          Logger.new($stdout).tap do |l|
-            l.level = Logger::FATAL
-          end
+        let(:mode) do
+          { :mode => :primary }
         end
 
-        let(:client) do
-          authorized_client.with(logger: logger)
+        it 'returns a primary server selector' do
+          expect(server_selector).to be_a(Mongo::ServerSelector::Primary)
         end
 
-        after do
-          client.close
-        end
-
-        it 'does not use the global logger' do
-          expect(client.cluster.logger).to_not eq(Mongo::Logger.logger)
+        it 'passes the options to the cluster' do
+          expect(client.cluster.options[:server_selection_timeout]).to eq(2)
         end
       end
-    end
 
-    context 'when providing a connection string' do
+      context 'when mode is primary_preferred' do
 
-      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)
+        let(:mode) do
+          { :mode => :primary_preferred }
         end
 
-        it 'sets the database' do
-          expect { client[:users] }.to_not raise_error
+        it 'returns a primary preferred server selector' do
+          expect(server_selector).to be_a(Mongo::ServerSelector::PrimaryPreferred)
         end
       end
 
-      context 'when a database is not provided' do
+      context 'when mode is secondary' do
 
-        let!(:uri) do
-          'mongodb://127.0.0.1:27017'
+        let(:mode) do
+          { :mode => :secondary }
         end
 
-        let(:client) do
-          described_class.new(uri)
-        end
-
-        it 'defaults the database to admin' do
-          expect(client.database.name).to eq('admin')
+        it 'uses a Secondary server selector' do
+          expect(server_selector).to be_a(Mongo::ServerSelector::Secondary)
         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
+      context 'when mode is secondary preferred' do
 
-        let(:expected_options) do
-          Mongo::Options::Redacted.new(:write => { :w => 3 }, :database => 'testdb')
+        let(:mode) do
+          { :mode => :secondary_preferred }
         end
 
-        it 'sets the options' do
-          expect(client.options).to eq(expected_options)
+        it 'uses a Secondary server selector' do
+          expect(server_selector).to be_a(Mongo::ServerSelector::SecondaryPreferred)
         end
       end
 
-      context 'when options are provided not in the string' do
-
-        let!(:uri) do
-          'mongodb://127.0.0.1:27017/testdb'
-        end
+      context 'when mode is nearest' do
 
-        let(:client) do
-          described_class.new(uri, :write => { :w => 3 })
+        let(:mode) do
+          { :mode => :nearest }
         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)
+        it 'uses a Secondary server selector' do
+          expect(server_selector).to be_a(Mongo::ServerSelector::Nearest)
         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
+      context 'when no mode provided' do
 
         let(:client) do
-          described_class.new(uri, :write => { :w => 4 })
-        end
-
-        let(:expected_options) do
-          Mongo::Options::Redacted.new(:write => { :w => 4 }, :database => 'testdb')
+          new_local_client_nmio(['127.0.0.1:27017'],
+                              :database => SpecConfig.instance.test_db,
+                              :server_selection_timeout => 2)
         end
 
-        it 'allows explicit options to take preference' do
-          expect(client.options).to eq(expected_options)
+        it 'returns a primary server selector' do
+          expect(server_selector).to be_a(Mongo::ServerSelector::Primary)
         end
       end
 
-      context 'when a replica set name is provided' do
-
-        let!(:uri) do
-          'mongodb://127.0.0.1:27017/testdb?replicaSet=testing'
-        end
+      context 'when the read preference is printed' do
 
         let(:client) do
-          described_class.new(uri)
+          new_local_client_nmio(SpecConfig.instance.addresses, options)
         end
 
-        it 'sets the correct cluster topology' do
-          expect(client.cluster.topology).to be_a(Mongo::Cluster::Topology::ReplicaSet)
+        let(:options) do
+          { user: 'Emily', password: 'sensitive_data', server_selection_timeout: 0.1 }
         end
-      end
 
-      context 'when an invalid option is provided' do
-
-        let(:client) do
-          described_class.new(['127.0.0.1:27017'], :ssl => false, :invalid => :test)
+        before do
+          allow(client.database.cluster).to receive(:single?).and_return(false)
         end
 
-        it 'does not set the option' do
-          expect(client.options.keys).not_to include('invalid')
-        end
-
-        it 'sets the valid options' do
-          expect(client.options.keys).to include('ssl')
+        let(:error) do
+          begin
+            client.database.command(ping: 1)
+          rescue => e
+            e
+          end
         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')
+        it 'redacts sensitive client options' do
+          expect(error.message).not_to match(options[:password])
         end
       end
     end
@@ -391,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
@@ -408,11 +384,7 @@ describe Mongo::Client do
       end
 
       it 'returns a primary read preference' do
-        expect(preference).to be_a(Mongo::ServerSelector::Primary)
-      end
-
-      it 'passes the options to the cluster' do
-        expect(client.cluster.options[:server_selection_timeout]).to eq(2)
+        expect(preference).to eq(BSON::Document.new(mode))
       end
     end
 
@@ -423,7 +395,7 @@ describe Mongo::Client do
       end
 
       it 'returns a primary preferred read preference' do
-        expect(preference).to be_a(Mongo::ServerSelector::PrimaryPreferred)
+        expect(preference).to eq(BSON::Document.new(mode))
       end
     end
 
@@ -434,7 +406,7 @@ describe Mongo::Client do
       end
 
       it 'returns a secondary read preference' do
-        expect(preference).to be_a(Mongo::ServerSelector::Secondary)
+        expect(preference).to eq(BSON::Document.new(mode))
       end
     end
 
@@ -445,7 +417,7 @@ describe Mongo::Client do
       end
 
       it 'returns a secondary preferred read preference' do
-        expect(preference).to be_a(Mongo::ServerSelector::SecondaryPreferred)
+        expect(preference).to eq(BSON::Document.new(mode))
       end
     end
 
@@ -456,344 +428,539 @@ describe Mongo::Client do
       end
 
       it 'returns a nearest read preference' do
-        expect(preference).to be_a(Mongo::ServerSelector::Nearest)
+        expect(preference).to eq(BSON::Document.new(mode))
       end
     end
 
     context 'when no mode provided' do
 
-      let(:mode) do
-        {}
+      let(:client) do
+        new_local_client_nmio(['127.0.0.1:27017'],
+                            :database => SpecConfig.instance.test_db,
+                            :server_selection_timeout => 2)
       end
 
-      it 'returns a primary read preference' do
-        expect(preference).to be_a(Mongo::ServerSelector::Primary)
+      it 'returns nil' do
+        expect(preference).to be_nil
       end
     end
+  end
 
-    context 'when the read preference is printed' do
+  describe '#write_concern' do
 
-      let(:client) do
-        described_class.new([ default_address.to_s ], options)
-      end
+    let(:concern) { client.write_concern }
 
-      let(:options) do
-        { user: 'Emily', password: 'sensitive_data', server_selection_timeout: 0.1 }
-      end
+    context 'when no option was provided to the client' do
 
-      before do
-        allow(client.database.cluster).to receive(:single?).and_return(false)
+      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
       end
+    end
+
+    context 'when an option is provided' do
+
+      context 'when the option is acknowledged' do
+
+        let(:client) do
+          new_local_client_nmio(['127.0.0.1:27017'], :write => { :j => true }, :database => SpecConfig.instance.test_db)
+        end
 
-      let(:error) do
-        begin
-          client.database.command(ping: 1)
-        rescue => e
-          e
+        it 'returns a acknowledged write concern' do
+          expect(concern.get_last_error).to eq(:getlasterror => 1, :j => true)
         end
       end
 
-      it 'redacts sensitive client options' do
-        expect(error.message).not_to match(options[:password])
+      context 'when the option is unacknowledged' do
+
+        context 'when the w is 0' do
+
+          let(:client) do
+            new_local_client_nmio(['127.0.0.1:27017'], :write => { :w => 0 }, :database => SpecConfig.instance.test_db)
+          end
+
+          it 'returns an unacknowledged write concern' do
+            expect(concern.get_last_error).to be_nil
+          end
+        end
+
+        context 'when the w is -1' do
+
+          let(:client) do
+            new_local_client_nmio(['127.0.0.1:27017'], :write => { :w => -1 }, :database => SpecConfig.instance.test_db)
+          end
+
+          it 'raises an error' do
+            expect {
+              concern
+            }.to raise_error(Mongo::Error::InvalidWriteConcern)
+          end
+        end
       end
     end
   end
 
-  describe '#use' do
-
-    let(:client) do
-      described_class.new(['127.0.0.1:27017'], :database => TEST_DB)
-    end
+  [
+    [:max_read_retries, 1],
+    [:read_retry_interval, 5],
+    [:max_write_retries, 1],
+  ].each do |opt, default|
+    describe "##{opt}" do
+      let(:client_options) { {} }
 
-    shared_examples_for 'a database switching object' do
+      let(:client) do
+        new_local_client_nmio(['127.0.0.1:27017'], client_options)
+      end
 
-      it 'returns the new client' do
-        expect(client.send(:database).name).to eq('ruby-driver')
+      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
 
-      it 'keeps the same cluster' do
-        expect(database.cluster).to equal(client.cluster)
+      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
 
-    context 'when provided a string' do
+  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(:database) do
-        client.use('testdb')
+      let(:client) do
+        new_local_client_nmio(['localhost'], server_api: {version: '1'})
       end
 
-      it_behaves_like 'a database switching object'
+      it 'is not transfered to the collection' do
+        database.options[:server_api].should be nil
+      end
     end
 
-    context 'when provided a symbol' do
+  end
 
-      let(:database) do
-        client.use(:testdb)
-      end
+  describe '#database_names' do
 
-      it_behaves_like 'a database switching object'
+    it 'returns a list of database names' do
+      expect(root_authorized_client.database_names).to include(
+        'admin'
+      )
     end
 
-    context 'when providing nil' do
+    context 'when filter criteria is present' do
+      min_server_fcv '3.6'
 
-      it 'raises an exception' do
-        expect {
-          client.use(nil)
-        }.to raise_error(Mongo::Error::InvalidDatabaseName)
+      include_context 'ensure test db exists'
+
+      let(:result) do
+        root_authorized_client.database_names(filter)
+      end
+
+      let(:filter) do
+        { name: SpecConfig.instance.test_db }
+      end
+
+      it 'returns a filtered list of database names' do
+        expect(result.length).to eq(1)
+        expect(result.first).to eq(filter[:name])
       end
     end
   end
 
-  describe '#with' do
+  describe '#list_databases' do
 
-    let(:client) do
-      described_class.new(['127.0.0.1:27017'], :database => TEST_DB)
+    it 'returns a list of database info documents' do
+      expect(
+        root_authorized_client.list_databases.collect do |i|
+          i['name']
+        end).to include('admin')
     end
 
-    context 'when providing nil' do
+    context 'when filter criteria is present' do
+      min_server_fcv '3.6'
+
+      include_context 'ensure test db exists'
 
-      it 'returns the cloned client' do
-        expect(client.with(nil)).to eq(client)
+      let(:result) do
+        root_authorized_client.list_databases(filter)
       end
-    end
 
-    context 'when the write concern is not changed' do
+      let(:filter) do
+        { name: SpecConfig.instance.test_db }
+      end
 
-      let(:client) do
-        described_class.new(
-          ['127.0.0.1:27017'],
-          :read => { :mode => :secondary }, :write => { :w => 1 }, :database => TEST_DB
-        )
+      it 'returns a filtered list of database info documents' do
+        expect(result.length).to eq(1)
+        expect(result[0]['name']).to eq(filter[:name])
       end
+    end
+
+    context 'when name_only is true' do
+      min_server_fcv '3.6'
 
-      let!(:new_client) do
-        client.with(:read => { :mode => :primary })
+      let(:command) do
+        Utils.get_command_event(root_authorized_client, 'listDatabases') do |client|
+          client.list_databases({}, true)
+        end.command
       end
 
-      let(:new_options) do
-        Mongo::Options::Redacted.new(:read => { :mode => :primary },
-                                             :write => { :w => 1 },
-                                             :database => TEST_DB)
+      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(:original_options) do
-        Mongo::Options::Redacted.new(:read => { :mode => :secondary },
-                                             :write => { :w => 1 },
-                                             :database => TEST_DB)
+      let(:client_options) do
+        root_authorized_client.options.merge(heartbeat_frequency: 100, monitoring: true)
       end
 
-      it 'returns a new client' do
-        expect(new_client).not_to equal(client)
+      let(:subscriber) { Mrss::EventSubscriber.new }
+
+      let(:client) do
+        ClientRegistry.instance.new_local_client(
+          SpecConfig.instance.addresses, client_options
+        ).tap do |cl|
+          cl.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+        end
       end
 
-      it 'replaces the existing options' do
-        expect(new_client.options).to eq(new_options)
+      let(:command) do
+        subscriber.started_events.find { |c| c.command_name == 'listDatabases' }.command
       end
 
-      it 'does not modify the original client' do
-        expect(client.options).to eq(original_options)
+      let(:authDb) do
+        { authorized_databases: true }
       end
 
-      it 'keeps the same cluster' do
-        expect(new_client.cluster).to equal(client.cluster)
+      let(:noAuthDb) do
+        { authorized_databases: false }
       end
-    end
 
-    context 'when the write concern is changed' do
+      before do
+        client.list_databases({}, true, authDb)
+        client.list_databases({}, true, noAuthDb)
+      end
 
-      let(:client) do
-        described_class.new(['127.0.0.1:27017'], :write => { :w => 1 }, :database => TEST_DB)
+      let(:events) do
+        subscriber.command_started_events('listDatabases')
       end
 
-      context 'when the write concern has not been accessed' do
+      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
 
-        let!(:new_client) do
-          client.with(:write => { :w => 0 })
-        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
 
-        let(:get_last_error) do
-          new_client.write_concern.get_last_error
-        end
+  describe '#list_mongo_databases' do
 
-        it 'returns the correct write concern' do
-          expect(get_last_error).to be_nil
-        end
-      end
+    let(:options) do
+      { read: { mode: :secondary } }
+    end
 
-      context 'when the write concern has been accessed' do
+    let(:client) do
+      root_authorized_client.with(options)
+    end
 
-        let!(:new_client) do
-          client.write_concern
-          client.with(:write => { :w => 0 })
-        end
+    let(:result) do
+      client.list_mongo_databases
+    end
 
-        let(:get_last_error) do
-          new_client.write_concern.get_last_error
-        end
+    it 'returns a list of Mongo::Database objects' do
+      expect(result).to all(be_a(Mongo::Database))
+    end
 
-        it 'returns the correct write concern' do
-          expect(get_last_error).to be_nil
-        end
-      end
+    it 'creates database with specified options' do
+      expect(result.first.options[:read]).to eq(BSON::Document.new(options)[:read])
     end
 
-    context 'when an invalid option is provided' do
+    context 'when filter criteria is present' do
+      min_server_fcv '3.6'
 
-      let(:new_client) do
-        client.with(invalid: :option, ssl: false)
+      include_context 'ensure test db exists'
+
+      let(:result) do
+        client.list_mongo_databases(filter)
       end
 
-      it 'does not set the invalid option' do
-        expect(new_client.options.keys).not_to include('invalid')
+      let(:filter) do
+        { name: SpecConfig.instance.test_db }
       end
 
-      it 'sets the valid options' do
-        expect(new_client.options.keys).to include('ssl')
+      it 'returns a filtered list of Mongo::Database objects' do
+        expect(result.length).to eq(1)
+        expect(result.first.name).to eq(filter[:name])
       end
+    end
+  end
+
+  describe '#close' do
+    let(:client) do
+      new_local_client_nmio(['127.0.0.1:27017'])
+    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')
+    it 'disconnects the cluster and returns true' do
+      RSpec::Mocks.with_temporary_scope do
+        expect(client.cluster).to receive(:disconnect!).and_call_original
+        expect(client.close).to be(true)
       end
     end
   end
 
-  describe '#write_concern' do
+  describe '#reconnect' do
 
-    let(:concern) { client.write_concern }
+    let(:client) do
+      new_local_client_nmio([ClusterConfig.instance.primary_address_str])
+    end
 
-    context 'when no option was provided to the client' do
+    it 'replaces the cluster' do
+      old_id = client.cluster.object_id
+      client.reconnect
+      new_id = client.cluster.object_id
+      expect(new_id).not_to eql(old_id)
+    end
 
-      let(:client) { described_class.new(['127.0.0.1:27017'], :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 'does not set the write concern' do
-        expect(concern).to be_nil
-      end
+    it 'returns true' do
+      expect(client.reconnect).to be(true)
     end
+  end
 
-    context 'when an option is provided' do
+  describe '#collections' do
 
-      context 'when the option is acknowledged' do
+    before do
+      authorized_client.database[:users].drop
+      authorized_client.database[:users].create
+    end
 
-        let(:client) do
-          described_class.new(['127.0.0.1:27017'], :write => { :j => true }, :database => TEST_DB)
+    let(:collection) do
+      Mongo::Collection.new(authorized_client.database, 'users')
+    end
+
+    it 'refers the current database collections' do
+      expect(authorized_client.collections).to include(collection)
+      expect(authorized_client.collections).to all(be_a(Mongo::Collection))
+    end
+  end
+
+  describe '#start_session' do
+
+    let(:session) do
+      authorized_client.start_session
+    end
+
+    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)
+      end
+
+      it 'sets the last use field to the current time', retry: 4 do
+        expect(session.instance_variable_get(:@server_session).last_use).to be_within(1).of(Time.now)
+      end
+
+      context 'when options are provided' do
+
+        let(:options) do
+          { causal_consistency: true }
         end
 
-        it 'returns a acknowledged write concern' do
-          expect(concern.get_last_error).to eq(:getlasterror => 1, :j => true)
+        let(:session) do
+          authorized_client.start_session(options)
+        end
+
+        it 'sets the options on the session' do
+          expect(session.options[:causal_consistency]).to eq(options[:causal_consistency])
         end
       end
 
-      context 'when the option is unacknowledged' do
+      context 'when options are not provided' do
 
-        context 'when the w is 0' do
+        it 'does not set options on the session' do
+          expect(session.options).to eq({ implicit: false })
+        end
+      end
 
-          let(:client) do
-            described_class.new(['127.0.0.1:27017'], :write => { :w => 0 }, :database => TEST_DB)
-          end
+      context 'when a session is checked out and checked back in' do
 
-          it 'returns an unacknowledged write concern' do
-            expect(concern.get_last_error).to be_nil
-          end
+        let!(:session_a) do
+          authorized_client.start_session
         end
 
-        context 'when the w is -1' do
+        let!(:session_b) do
+          authorized_client.start_session
+        end
 
-          let(:client) do
-            described_class.new(['127.0.0.1:27017'], :write => { :w => -1 }, :database => TEST_DB)
-          end
+        let!(:session_a_server_session) do
+          session_a.instance_variable_get(:@server_session)
+        end
 
-          it 'raises an error' do
-            expect {
-              concern
-            }.to raise_error(Mongo::Error::InvalidWriteConcern)
-          end
+        let!(:session_b_server_session) do
+          session_b.instance_variable_get(:@server_session)
+        end
+
+        before do
+          session_a_server_session.next_txn_num
+          session_a_server_session.next_txn_num
+          session_b_server_session.next_txn_num
+          session_b_server_session.next_txn_num
+          session_a.end_session
+          session_b.end_session
+        end
+
+        it 'is returned to the front of the queue' do
+          expect(authorized_client.start_session.instance_variable_get(:@server_session)).to be(session_b_server_session)
+          expect(authorized_client.start_session.instance_variable_get(:@server_session)).to be(session_a_server_session)
+        end
+
+        it 'preserves the transaction numbers on the server sessions' do
+          expect(authorized_client.start_session.next_txn_num).to be(3)
+          expect(authorized_client.start_session.next_txn_num).to be(3)
         end
       end
-    end
-  end
 
-  describe '#database_names' do
+      context 'when an implicit session is used' do
 
-    it 'returns a list of database names' do
-      expect(root_authorized_client.database_names).to include(
-        'admin'
-      )
-    end
-  end
+        before do
+          authorized_client.database.command(ping: 1)
+        end
 
-  describe '#list_databases' do
+        let(:pool) do
+          authorized_client.cluster.session_pool
+        end
 
-    it 'returns a list of database info documents' do
-      expect(
-        root_authorized_client.list_databases.collect do |i|
-          i['name']
-        end).to include('admin')
+        let!(:before_last_use) do
+          pool.instance_variable_get(:@queue)[0].last_use
+        end
+
+        it 'uses the session and updates the last use time' do
+          authorized_client.database.command(ping: 1)
+          expect(before_last_use).to be < (pool.instance_variable_get(:@queue)[0].last_use)
+        end
+      end
     end
-  end
 
-    describe '#close' do
+    context 'when two clients have the same cluster' do
+      min_server_fcv '3.6'
+      require_topology :replica_set, :sharded
 
-    let(:client) do
-      described_class.new(['127.0.0.1:27017'])
-    end
+      let(:client) do
+        authorized_client.with(read: { mode: :secondary })
+      end
 
-    before do
-      expect(client.cluster).to receive(:disconnect!).and_call_original
-    end
+      let(:session) do
+        authorized_client.start_session
+      end
 
-    it 'disconnects the cluster and returns true' do
-      expect(client.close).to be(true)
+      it 'allows the session to be used across the clients' do
+        client[TEST_COLL].insert_one({ a: 1 }, session: session)
+      end
     end
-  end
 
-  describe '#reconnect' do
+    context 'when two clients have different clusters' do
+      min_server_fcv '3.6'
+      require_topology :replica_set, :sharded
 
-    let(:client) do
-      described_class.new(['127.0.0.1:27017'])
-    end
+      let(:client) do
+        another_authorized_client
+      end
 
-    before do
-      expect(client.cluster).to receive(:reconnect!).and_call_original
+      let(:session) do
+        authorized_client.start_session
+      end
+
+      it 'raises an exception' do
+        expect {
+          client[TEST_COLL].insert_one({ a: 1 }, session: session)
+        }.to raise_exception(Mongo::Error::InvalidSession)
+      end
     end
 
-    it 'reconnects the cluster and returns true' do
-      expect(client.reconnect).to be(true)
+    context 'when sessions are not supported' do
+      max_server_version '3.4'
+
+      it 'raises an exception' do
+        expect {
+          session
+        }.to raise_exception(Mongo::Error::InvalidSession)
+      end
     end
   end
 
-  describe '#dup' do
+  describe '#summary' do
 
-    let(:client) do
-      described_class.new(
+    context 'monitoring omitted' do
+      let(:client) do
+        new_local_client_nmio(
           ['127.0.0.1:27017'],
           :read => { :mode => :primary },
-          :database => TEST_DB
-      )
-    end
+          :database => SpecConfig.instance.test_db
+        )
+      end
 
-    it 'creates a client with Redacted options' do
-      expect(client.dup.options).to be_a(Mongo::Options::Redacted)
+      it 'indicates lack of monitoring' do
+        client.summary.should =~ /servers=.*UNKNOWN.*NO-MONITORING/
+      end
     end
-  end
 
-  describe '#collections' do
+    context 'monitoring present' do
+      require_topology :single, :replica_set, :sharded
 
-    before do
-      authorized_client.database[:users].create
-    end
+      let(:client) do
+        authorized_client
+      end
 
-    after do
-      authorized_client.database[:users].drop
+      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
 
-    let(:collection) do
-      Mongo::Collection.new(authorized_client.database, 'users')
-    end
+    context 'background threads killed' do
+      let(:client) do
+        authorized_client.tap do |client|
+          client.cluster.servers.map(&:disconnect!)
+        end
+      end
 
-    it 'refers the current database collections' do
-      expect(authorized_client.collections).to include(collection)
-      expect(authorized_client.collections).to all(be_a(Mongo::Collection))
+      it 'does not indicate lack of monitoring' do
+        client.summary.should =~ /servers=.*(STANDALONE|PRIMARY|MONGOS|\bLB\b).*NO-MONITORING/
+      end
     end
   end
 end