mongo 2.12.4 → 2.14.0.rc1

data/spec/mongo/auth_spec.rb

@@ -11,7 +11,7 @@ describe Mongo::Auth do
       end
 
       let(:cr) do
-        described_class.get(user)
+        described_class.get(user, double('connection'))
       end
 
       it 'returns CR' do
@@ -26,7 +26,7 @@ describe Mongo::Auth do
       end
 
       let(:x509) do
-        described_class.get(user)
+        described_class.get(user, double('connection'))
       end
 
       it 'returns X509' do
@@ -41,7 +41,7 @@ describe Mongo::Auth do
       end
 
       let(:ldap) do
-        described_class.get(user)
+        described_class.get(user, double('connection'))
       end
 
       it 'returns LDAP' do
@@ -57,7 +57,7 @@ describe Mongo::Auth do
 
       it 'raises an error' do
         expect {
-          described_class.get(user)
+          described_class.get(user, double('connection'))
         }.to raise_error(Mongo::Auth::InvalidMechanism)
       end
     end

data/spec/mongo/bulk_write_spec.rb

@@ -235,6 +235,44 @@ describe Mongo::BulkWrite do
             expect(authorized_collection.find(_id: 0).count).to eq(0)
           end
 
+          context 'when the write has specified a hint option' do
+            let(:requests) do
+              [{
+                 delete_one: {
+                   filter: { _id: 1 },
+                   hint: '_id_',
+                 }
+               }]
+            end
+
+            context 'with unacknowledged write concern' do
+              let(:bulk_write) do
+                described_class.new(
+                  collection,
+                  requests,
+                  options.merge(write_concern: { w: 0 })
+                )
+              end
+
+              it 'raises a client-side error' do
+                expect do
+                  bulk_write.execute
+                end.to raise_error(Mongo::Error::UnsupportedOption, /The hint option cannot be specified on an unacknowledged write operation/)
+              end
+            end
+
+            # Functionality on more recent servers is sufficiently covered by spec tests.
+            context 'on server versions < 3.4' do
+              max_server_fcv '3.2'
+
+              it 'raises a client-side error' do
+                expect do
+                  bulk_write.execute
+                end.to raise_error(Mongo::Error::UnsupportedOption, /The MongoDB server handling this request does not support the hint option on this command./)
+              end
+            end
+          end
+
           context 'when a session is provided' do
 
             let(:operation) do
@@ -348,6 +386,44 @@ describe Mongo::BulkWrite do
           end
 
           context 'when bulk executing update_one' do
+            context 'when the write has specified a hint option' do
+              let(:requests) do
+                [{
+                   update_one: {
+                     filter: { _id: 1 },
+                     update: { '$set' => { 'x.$[i].y' => 5 } },
+                     hint: '_id_',
+                   }
+                 }]
+              end
+
+              # Functionality on more recent servers is sufficiently covered by spec tests.
+              context 'on server versions < 3.4' do
+                max_server_fcv '3.2'
+
+                it 'raises a client-side error' do
+                  expect do
+                    bulk_write.execute
+                  end.to raise_error(Mongo::Error::UnsupportedOption, /The MongoDB server handling this request does not support the hint option on this command./)
+                end
+              end
+
+              context 'with unacknowledged write concern' do
+                let(:bulk_write) do
+                  described_class.new(
+                    collection,
+                    requests,
+                    options.merge(write_concern: { w: 0 })
+                  )
+                end
+
+                it 'raises a client-side error' do
+                  expect do
+                    bulk_write.execute
+                  end.to raise_error(Mongo::Error::UnsupportedOption, /The hint option cannot be specified on an unacknowledged write operation/)
+                end
+              end
+            end
 
             context 'when the write has specified arrayFilters' do
 
@@ -392,6 +468,45 @@ describe Mongo::BulkWrite do
           end
 
           context 'when bulk executing update_many' do
+            context 'when the write has specified a hint option' do
+              let(:requests) do
+                [{
+                   update_many: {
+                     filter: { '$or' => [{ _id: 1 }, { _id: 2 }]},
+                     update: { '$set' => { 'x.$[i].y' => 5 } },
+                     hint: '_id_',
+                   }
+                 }]
+              end
+
+              # Functionality on more recent servers is sufficiently covered by spec tests.
+              context 'on server versions < 3.4' do
+                max_server_fcv '3.2'
+
+                it 'raises a client-side error' do
+                  expect do
+                    bulk_write.execute
+                  end.to raise_error(Mongo::Error::UnsupportedOption, /The MongoDB server handling this request does not support the hint option on this command./)
+                end
+              end
+
+              context 'with unacknowledged write concern' do
+                let(:bulk_write) do
+                  described_class.new(
+                    collection,
+                    requests,
+                    options.merge(write_concern: { w: 0 })
+                  )
+                end
+
+                it 'raises a client-side error' do
+                  expect do
+                    bulk_write.execute
+                  end.to raise_error(Mongo::Error::UnsupportedOption, /The hint option cannot be specified on an unacknowledged write operation/)
+                end
+              end
+            end
+
 
             context 'when the write has specified arrayFilters' do
 
@@ -639,6 +754,44 @@ describe Mongo::BulkWrite do
             expect(authorized_collection.find(_id: 0).count).to eq(0)
           end
 
+          context 'when the write has specified a hint option' do
+            let(:requests) do
+              [{
+                 delete_many: {
+                   filter: { _id: 1 },
+                   hint: '_id_',
+                 }
+               }]
+            end
+
+            # Functionality on more recent servers is sufficiently covered by spec tests.
+            context 'on server versions < 3.4' do
+              max_server_fcv '3.2'
+
+              it 'raises a client-side error' do
+                expect do
+                  bulk_write.execute
+                end.to raise_error(Mongo::Error::UnsupportedOption, /The MongoDB server handling this request does not support the hint option on this command./)
+              end
+            end
+
+            context 'with unacknowledged write concern' do
+              let(:bulk_write) do
+                described_class.new(
+                  collection,
+                  requests,
+                  options.merge(write_concern: { w: 0 })
+                )
+              end
+
+              it 'raises a client-side error' do
+                expect do
+                  bulk_write.execute
+                end.to raise_error(Mongo::Error::UnsupportedOption, /The hint option cannot be specified on an unacknowledged write operation/)
+              end
+            end
+          end
+
           context 'when a session is provided' do
 
             let(:operation) do
@@ -918,6 +1071,45 @@ describe Mongo::BulkWrite do
             expect(authorized_collection.find(_id: 0).first[:name]).to eq('test')
           end
 
+          context 'when a hint option is provided' do
+            let(:requests) do
+              [{
+                replace_one: {
+                  filter: { _id: 0 },
+                  replacements: { name: 'test' },
+                  hint: '_id_'
+                }
+              }]
+            end
+
+            # Functionality on more recent servers is sufficiently covered by spec tests.
+            context 'on server versions < 3.4' do
+              max_server_fcv '3.2'
+
+              it 'raises a client-side error' do
+                expect do
+                  bulk_write.execute
+                end.to raise_error(Mongo::Error::UnsupportedOption, /The MongoDB server handling this request does not support the hint option on this command./)
+              end
+            end
+
+            context 'with unacknowledged write concern' do
+              let(:bulk_write) do
+                described_class.new(
+                  collection,
+                  requests,
+                  options.merge(write_concern: { w: 0 })
+                )
+              end
+
+              it 'raises a client-side error' do
+                expect do
+                  bulk_write.execute
+                end.to raise_error(Mongo::Error::UnsupportedOption, /The hint option cannot be specified on an unacknowledged write operation/)
+              end
+            end
+          end
+
           context 'when a session is provided' do
 
             let(:operation) do
@@ -1141,13 +1333,17 @@ describe Mongo::BulkWrite do
             end
 
             context 'when the number of updates exceeds the max batch size' do
+              # Test uses doubles for server descriptions, doubles are
+              # incompatible with freezing which linting does for descriptions
+              skip_if_linting
 
               let(:batch_size) do
                 11
               end
 
               before do
-                allow(client.cluster.next_primary).to receive(:max_write_batch_size).and_return(batch_size - 1)
+                allow_any_instance_of(Mongo::Server::Description).to \
+                  receive(:max_write_batch_size).and_return(batch_size - 1)
               end
 
               let(:requests) do
@@ -1814,13 +2010,21 @@ describe Mongo::BulkWrite do
       end
 
       context 'when the operations need to be split' do
+        # Test uses doubles for server descriptions, doubles are
+        # incompatible with freezing which linting does for descriptions
+        skip_if_linting
 
         let(:batch_size) do
           11
         end
 
+        let(:connection) do
+          server = client.cluster.next_primary
+        end
+
         before do
-          allow(client.cluster.next_primary).to receive(:max_write_batch_size).and_return(batch_size - 1)
+          allow_any_instance_of(Mongo::Server::Description).to \
+            receive(:max_write_batch_size).and_return(batch_size - 1)
         end
 
         context 'when a write error occurs' do

data/spec/mongo/caching_cursor_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe Mongo::CachingCursor do
+
+  around do |spec|
+    Mongo::QueryCache.clear
+    Mongo::QueryCache.cache { spec.run }
+  end
+
+  let(:authorized_collection) do
+    authorized_client['caching_cursor']
+  end
+
+  before do
+    authorized_collection.drop
+  end
+
+  let(:server) do
+    view.send(:server_selector).select_server(authorized_client.cluster)
+  end
+
+  let(:reply) do
+    view.send(:send_initial_query, server)
+  end
+
+  let(:cursor) do
+    described_class.new(view, reply, server)
+  end
+
+  let(:view) do
+    Mongo::Collection::View.new(authorized_collection)
+  end
+
+  before do
+    authorized_collection.delete_many
+    3.times { |i| authorized_collection.insert_one(_id: i) }
+  end
+
+  describe '#cached_docs' do
+    context 'when no query has been performed' do
+      it 'returns nil' do
+        expect(cursor.cached_docs).to be_nil
+      end
+    end
+
+    context 'when a query has been performed' do
+      it 'returns the number of documents' do
+        cursor.to_a
+        expect(cursor.cached_docs.length).to eq(3)
+        expect(cursor.cached_docs).to eq([{ '_id' => 0 }, { '_id' => 1 }, { '_id' => 2 }])
+      end
+    end
+  end
+
+  describe '#try_next' do
+    it 'fetches the next document' do
+      expect(cursor.try_next).to eq('_id' => 0)
+      expect(cursor.try_next).to eq('_id' => 1)
+      expect(cursor.try_next).to eq('_id' => 2)
+    end
+  end
+
+  describe '#each' do
+    it 'iterates the cursor' do
+      result = cursor.each.to_a
+      expect(result.length).to eq(3)
+      expect(result).to eq([{ '_id' => 0 }, { '_id' => 1 }, { '_id' => 2 }])
+    end
+  end
+end

data/spec/mongo/client_construction_spec.rb

@@ -3,64 +3,9 @@ require 'spec_helper'
 describe Mongo::Client do
   clean_slate
 
-  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 = new_local_client_nmio(['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 = new_local_client_nmio(['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
-
-        context 'when not linting' do
-          skip_if_linting
-
-          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')
-          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')
-          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')
-          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')
-          end
-        end
-      end
-    end
+  let(:subscriber) { EventSubscriber.new }
 
+  describe '.new' do
     context 'with scan: false' do
       it 'does not perform i/o' do
         allow_any_instance_of(Mongo::Server::Monitor).to receive(:run!)
@@ -374,6 +319,104 @@ describe Mongo::Client do
         end
       end
 
+      context 'timeout options' do
+        let(:client) do
+          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
+
+          it 'sets options to zeros' do
+            client.options[:socket_timeout].should == 0
+            client.options[:connect_timeout].should == 0
+          end
+
+          it 'connects and performs operations successfully' do
+            lambda do
+              client.database.command(ping: 1)
+            end.should_not raise_error
+          end
+        end
+
+        %i(socket_timeout connect_timeout).each do |option|
+          context "when #{option} is negative" do
+            let(:options) do
+              { option => -1 }
+            end
+
+            it 'fails client creation' do
+              lambda do
+                client
+              end.should 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
+
+            it 'fails client creation' do
+              lambda do
+                client
+              end.should raise_error(ArgumentError, /#{option} must be a non-negative number/)
+            end
+          end
+        end
+
+        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
+          # the network I/O take longer.
+          require_tls
+
+          let(:options) do
+            { connect_timeout: 1e-6, server_selection_timeout: 2 }
+          end
+
+          it 'allows client creation' do
+            lambda do
+              client
+            end.should_not raise_error
+          end
+
+          it 'fails server selection due to very small timeout' do
+            lambda do
+              client.database.command(ping: 1)
+            end.should raise_error(Mongo::Error::NoServerAvailable)
+          end
+        end
+
+        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
+          # the network I/O take longer.
+          require_tls
+
+          let(:options) do
+            { socket_timeout: 1e-6, server_selection_timeout: 2 }
+          end
+
+          it 'allows client creation' do
+            lambda do
+              client
+            end.should_not raise_error
+          end
+
+          it 'fails operations due to very small timeout' do
+            lambda do
+              client.database.command(ping: 1)
+            end.should raise_error(Mongo::Error::SocketTimeoutError)
+          end
+        end
+      end
+
       context 'retry_writes option' do
         let(:client) do
           new_local_client_nmio(SpecConfig.instance.addresses, options)
@@ -447,12 +490,13 @@ 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.send(:authenticate!, conn)
+              conn.connect!
             end
           end
         end
 
         context 'when the compressor is not supported by the driver' do
+          require_warning_clean
 
           let(:options) do
             { compressors: ['snoopy'] }
@@ -631,7 +675,7 @@ describe Mongo::Client do
       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
@@ -800,16 +844,38 @@ describe Mongo::Client do
           new_local_client_nmio(['127.0.0.1:27017'])
         end
 
-        let(:platform_string) do
-          [
-            RUBY_VERSION,
-            RUBY_PLATFORM,
-            RbConfig::CONFIG['build']
-          ].join(', ')
+        context 'mri' do
+          only_mri
+
+          let(:platform_string) do
+            [
+              "Ruby #{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
 
-        it 'does not include the platform info in the app metadata' do
-          expect(app_metadata.send(:full_client_document)[:platform]).to eq(platform_string)
+        context 'jruby' do
+          require_jruby
+
+          let(:platform_string) do
+            [
+              "JRuby #{JRUBY_VERSION}",
+              "like Ruby #{RUBY_VERSION}",
+              RUBY_PLATFORM,
+              "JVM #{java.lang.System.get_property('java.version')}",
+              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
     end
@@ -862,7 +928,7 @@ describe Mongo::Client do
         end
       end
 
-      context 'when options are provided' do
+      context 'when URI options are provided' do
 
         let!(:uri) do
           'mongodb://127.0.0.1:27017/testdb?w=3'
@@ -1080,11 +1146,248 @@ describe Mongo::Client do
           expect(client.cluster.topology).to be_a(Mongo::Cluster::Topology::ReplicaSetNoPrimary)
         end
       end
+    end
+
+    context 'when Ruby options are provided' do
+      let(:client) do
+        new_local_client_nmio(['127.0.0.1:27017'], 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)
+          end
+
+          it 'is rejected' do
+            lambda do
+              client
+            end.should 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}
+          end
+
+          it 'is accepted' do
+            client.options[:direct_connection].should be true
+            client.options[:connect].should be :direct
+          end
+        end
+
+        context 'direct_connection: true and connect: :replica_set' do
+          let(:options) do
+            {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/)
+          end
+        end
+
+        context 'direct_connection: true and connect: :sharded' do
+          let(:options) do
+            {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/)
+          end
+        end
+
+        context 'direct_connection: false and connect: :direct' do
+          let(:options) do
+            {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/)
+          end
+        end
+
+        context 'direct_connection: false and connect: :replica_set' do
+          let(:options) do
+            {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
+          end
+        end
+
+        context 'direct_connection: false and connect: :sharded' do
+          let(:options) do
+            {direct_connection: false, connect: :sharded}
+          end
+
+          it 'is accepted' do
+            client.options[:direct_connection].should be false
+            client.options[:connect].should be :sharded
+          end
+        end
+      end
+
+      context ':bg_error_backtrace option' do
+        [true, false, nil, 42].each do |valid_value|
+          context "valid value: #{valid_value.inspect}" do
+            let(:options) do
+              {bg_error_backtrace: valid_value}
+            end
+
+            it 'is accepted' do
+              client.options[:bg_error_backtrace].should == valid_value
+            end
+          end
+        end
+
+        context 'invalid value type' do
+          let(:options) do
+            {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/)
+          end
+        end
+
+        context 'invalid value' do
+          [0, -1, 42.0].each do |invalid_value|
+            context "invalid value: #{invalid_value.inspect}" do
+              let(:options) do
+                {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/)
+              end
+            end
+          end
+        end
+      end
+
+      describe ':read option' do
+        [
+          :primary, :primary_preferred, :secondary, :secondary_preferred,  :nearest
+        ].each do |sym|
+          describe "#{sym}" do
+            context 'when given as symbol' do
+              let(:options) do
+                {read: {mode: sym}}
+              end
+
+              it "is accepted" do
+                # the key got converted to a string here
+                expect(client.read_preference).to eq({'mode' => sym})
+              end
+            end
+
+            context 'when given as string' do
+              let(:options) do
+                {read: {mode: sym.to_s}}
+              end
+
+              # string keys are not documented as being allowed
+              # but the code accepts them
+              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})
+              end
+            end
+          end
+        end
+
+        context 'when not linting' do
+          skip_if_linting
+
+          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')
+          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')
+          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')
+          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')
+          end
+        end
+      end
+
+      context 'when setting read concern options' do
+        min_server_fcv '3.2'
+
+        context 'when read concern is valid' do
+          let(:options) do
+            { read_concern: { level: :local } }
+          end
+
+          it 'does not warn' do
+            expect(Mongo::Logger.logger).to_not receive(:warn)
+            new_local_client_nmio(SpecConfig.instance.addresses, options)
+          end
+        end
+
+        context 'when read concern has an invalid key' do
+          skip_if_linting
+
+          let(:options) do
+            { read_concern: { hello: :local } }
+          end
+
+          it 'logs a warning' do
+            expect(Mongo::Logger.logger).to receive(:warn).with(/Read concern has invalid keys: hello/)
+            new_local_client_nmio(SpecConfig.instance.addresses, options)
+          end
+        end
+
+        context 'when read concern has a non-user-settable key' do
+          let(:options) do
+            { read_concern: { after_cluster_time: 100 } }
+          end
+
+          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
+        end
+      end
 
       context 'when an invalid option is provided' do
 
-        let(:client) do
-          new_local_client_nmio(['127.0.0.1:27017'], :ssl => false, :invalid => :test)
+        let(:options) do
+          {ssl: false, invalid: :test}
         end
 
         it 'does not set the option' do
@@ -1104,8 +1407,8 @@ describe Mongo::Client do
 =begin WriteConcern object support
       context 'when write concern is provided via a WriteConcern object' do
 
-        let(:client) do
-          new_local_client_nmio(['127.0.0.1:27017'], write_concern: wc)
+        let(:options) do
+          {write_concern: wc}
         end
 
         let(:wc) { Mongo::WriteConcern.get(w: 2) }
@@ -1120,6 +1423,197 @@ describe Mongo::Client do
         end
       end
 =end
+
+      context ':wrapping_libraries option' do
+        let(:options) do
+          {wrapping_libraries: wrapping_libraries}
+        end
+
+        context 'valid input' do
+          context 'symbol keys' do
+            let(:wrapping_libraries) do
+              [name: 'Mongoid', version: '7.1.2'].freeze
+            end
+
+            it 'works' do
+              client.options[:wrapping_libraries].should == ['name' => 'Mongoid', 'version' => '7.1.2']
+            end
+          end
+
+          context 'string keys' do
+            let(:wrapping_libraries) do
+              ['name' => 'Mongoid', 'version' => '7.1.2'].freeze
+            end
+
+            it 'works' do
+              client.options[:wrapping_libraries].should == ['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
+            end
+
+            it 'works' do
+              client.options[:wrapping_libraries].should == ['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'},
+              ].freeze
+            end
+
+            it 'works' do
+              client.options[:wrapping_libraries].should == [
+                {'name' => 'Mongoid', 'version' => '7.1.2'},
+                {'name' => 'Rails', 'version' => '4.0', 'platform' => 'Foobar'},
+              ]
+            end
+          end
+
+          context 'empty array' do
+            let(:wrapping_libraries) do
+              []
+            end
+
+            it 'works' do
+              client.options[:wrapping_libraries].should == []
+            end
+          end
+
+          context 'empty array' do
+            let(:wrapping_libraries) do
+              nil
+            end
+
+            it 'works' do
+              client.options[:wrapping_libraries].should be nil
+            end
+          end
+        end
+
+        context 'valid input' do
+          context 'hash given instead of an array' do
+            let(:wrapping_libraries) do
+              {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/)
+            end
+          end
+
+          context 'invalid keys' do
+            let(:wrapping_libraries) do
+              [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/)
+            end
+          end
+
+          context 'value includes |' do
+            let(:wrapping_libraries) do
+              [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 '|'/)
+            end
+          end
+        end
+      end
+
+      context ':auth_mech_properties option' do
+        context 'is nil' do
+          let(:options) do
+            {auth_mech_properties: nil}
+          end
+
+          it 'creates the client without the option' do
+            client.options.should_not have_key(:auth_mech_properties)
+          end
+        end
+      end
+    end
+
+    context 'when making a block client' do
+      context 'when the block doesn\'t raise an error' do
+        let(:block_client) do
+          c = nil
+          Mongo::Client.new(
+            SpecConfig.instance.addresses,
+            SpecConfig.instance.test_options.merge(database: SpecConfig.instance.test_db),
+          ) do |client|
+            c = client
+          end
+          c
+        end
+
+        it 'is closed after block' do
+          expect(block_client.cluster.connected?).to eq(false)
+        end
+      end
+
+      context 'when the block raises an error' do
+        it 'it is closed after the block' do
+          block_client_raise = nil
+          expect do
+            Mongo::Client.new(
+              SpecConfig.instance.addresses,
+              SpecConfig.instance.test_options.merge(database: SpecConfig.instance.test_db),
+            ) do |client|
+              block_client_raise = client
+              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
+      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?")
+        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?")
+        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?")
+        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?")
+        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?")
+        end
+      end
     end
   end
 
@@ -1133,7 +1627,7 @@ describe Mongo::Client do
 
     it 'copies monitoring subscribers' do
       monitoring.subscribers.clear
-      client.subscribe(Mongo::Monitoring::SERVER_HEARTBEAT, EventSubscriber.new)
+      client.subscribe(Mongo::Monitoring::SERVER_HEARTBEAT, subscriber)
       expect(monitoring.present_subscribers.length).to eq(1)
       expect(monitoring.subscribers[Mongo::Monitoring::SERVER_HEARTBEAT].length).to eq(1)
 
@@ -1144,12 +1638,12 @@ describe Mongo::Client do
 
     it 'does not change subscribers on original client' do
       monitoring.subscribers.clear
-      client.subscribe(Mongo::Monitoring::SERVER_HEARTBEAT, EventSubscriber.new)
+      client.subscribe(Mongo::Monitoring::SERVER_HEARTBEAT, subscriber)
       expect(monitoring.present_subscribers.length).to eq(1)
       expect(monitoring.subscribers[Mongo::Monitoring::SERVER_HEARTBEAT].length).to eq(1)
 
-      new_client.subscribe(Mongo::Monitoring::SERVER_HEARTBEAT, EventSubscriber.new)
-      new_client.subscribe(Mongo::Monitoring::SERVER_HEARTBEAT, EventSubscriber.new)
+      new_client.subscribe(Mongo::Monitoring::SERVER_HEARTBEAT, subscriber)
+      new_client.subscribe(Mongo::Monitoring::SERVER_HEARTBEAT, subscriber)
       expect(new_monitoring.present_subscribers.length).to eq(1)
       expect(new_monitoring.subscribers[Mongo::Monitoring::SERVER_HEARTBEAT].length).to eq(3)
       # original client should not have gotten any of the new subscribers
@@ -1177,7 +1671,7 @@ describe Mongo::Client do
 
     it 'resets monitoring subscribers' do
       monitoring.subscribers.clear
-      client.subscribe(Mongo::Monitoring::SERVER_HEARTBEAT, EventSubscriber.new)
+      client.subscribe(Mongo::Monitoring::SERVER_HEARTBEAT, subscriber)
       expect(monitoring.present_subscribers.length).to eq(1)
       expect(monitoring.subscribers[Mongo::Monitoring::SERVER_HEARTBEAT].length).to eq(1)
 
@@ -1190,12 +1684,12 @@ describe Mongo::Client do
 
     it 'does not change subscribers on original client' do
       monitoring.subscribers.clear
-      client.subscribe(Mongo::Monitoring::SERVER_HEARTBEAT, EventSubscriber.new)
+      client.subscribe(Mongo::Monitoring::SERVER_HEARTBEAT, subscriber)
       expect(monitoring.present_subscribers.length).to eq(1)
       expect(monitoring.subscribers[Mongo::Monitoring::SERVER_HEARTBEAT].length).to eq(1)
 
-      new_client.subscribe(Mongo::Monitoring::SERVER_HEARTBEAT, EventSubscriber.new)
-      new_client.subscribe(Mongo::Monitoring::SERVER_HEARTBEAT, EventSubscriber.new)
+      new_client.subscribe(Mongo::Monitoring::SERVER_HEARTBEAT, subscriber)
+      new_client.subscribe(Mongo::Monitoring::SERVER_HEARTBEAT, subscriber)
       # 7 default subscribers + heartbeat
       expect(new_monitoring.present_subscribers.length).to eq(8)
       # the heartbeat subscriber on the original client is not inherited
@@ -1299,6 +1793,73 @@ describe Mongo::Client do
       end
     end
 
+    context 'when direct_connection option is given' do
+      let(:client) do
+        options = SpecConfig.instance.test_options
+        options.delete(:connect)
+        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
+
+        let(:new_options) do
+          { direct_connection: false }
+        end
+
+        it 'is accepted' do
+          new_client.options[:direct_connection].should be false
+        end
+      end
+
+      context 'direct_connection set to true' do
+
+        let(:new_options) do
+          { direct_connection: true }
+        end
+
+        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)
+          end
+        end
+
+        context 'in replica set or sharded cluster topology' 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/)
+          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/)
+            end
+          end
+        end
+      end
+    end
+
     context 'when the write concern is not changed' do
 
       let(:client) do
@@ -1571,7 +2132,6 @@ 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(:subscriber) { EventSubscriber.new }
 
       let(:sdam_proc) do
         Proc.new do |client|
@@ -1579,25 +2139,52 @@ describe Mongo::Client do
         end
       end
 
-      let(:new_client) { client.with(database: 'foo') }
+      let(:client) do
+        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))
+      end
+
+      let(:new_client) do
+        client.with(app_name: 'foo').tap do |new_client|
+          new_client.cluster.should_not == client.cluster
+        end
+      end
+
+      before do
+        client.cluster.next_primary
+        events = subscriber.select_started_events(Mongo::Monitoring::Event::ServerHeartbeatStarted)
+        events.length.should > 0
+      end
 
       it 'does not copy sdam_proc option to new client' do
-        client = new_local_client_nmio(['a'], sdam_proc: sdam_proc)
         expect(new_client.options[:sdam_proc]).to be nil
       end
 
       it 'does not notify subscribers set up by sdam_proc' do
-        client = new_local_client(['a'], sdam_proc: sdam_proc,
-          connect_timeout: 0.1, socket_timeout: 0.1,
-          server_selection_timeout: 0.1)
+        # On 4.4, the push monitor also is receiving heartbeats.
+        # Give those some time to be processed.
+        sleep 2
+
         expect(subscriber.started_events.length).to be > 0
         subscriber.started_events.clear
 
         # If this test takes longer than heartbeat interval,
         # subscriber may receive events from the original client.
 
-        new_client
+        new_client.cluster.next_primary
+
+        # Diagnostics
+        unless subscriber.started_events.empty?
+          p subscriber.started_events
+        end
+
         expect(subscriber.started_events.length).to eq 0
+        new_client.cluster.topology.class.should_not be Mongo::Cluster::Topology::Unknown
       end
     end
   end