mongo 2.14.0 → 2.18.1

data/spec/mongo/client_construction_spec.rb

@@ -1,9 +1,12 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Mongo::Client do
   clean_slate
 
-  let(:subscriber) { EventSubscriber.new }
+  let(:subscriber) { Mrss::EventSubscriber.new }
 
   describe '.new' do
     context 'with scan: false' do
@@ -21,26 +24,8 @@ describe Mongo::Client do
     end
 
     context 'with default scan: true' do
-      # TODO this test requires there being no outstanding background
-      # monitoring threads running, as otherwise the scan! expectation
-      # can be executed on a thread that belongs to one of the global
-      # clients for instance
-      it 'performs one round of sdam' do
-        # Does not work due to
-        # https://github.com/rspec/rspec-mocks/issues/1242.
-        #expect_any_instance_of(Mongo::Server::Monitor).to receive(:scan!).
-        #  exactly(SpecConfig.instance.addresses.length).times.and_call_original
-        c = new_local_client(
-          SpecConfig.instance.addresses, SpecConfig.instance.test_options)
-        expect(c.cluster.servers).not_to be_empty
-      end
-
-      # This checks the case of all initial seeds being removed from
-      # cluster during SDAM
-      context 'me mismatch on the only initial seed' do
-        let(:address) do
-          ClusterConfig.instance.alternate_address.to_s
-        end
+
+      shared_examples 'does not wait for server selection timeout' do
 
         let(:logger) do
           Logger.new(STDOUT, level: Logger::DEBUG)
@@ -91,13 +76,52 @@ describe Mongo::Client do
             Mongo::Cluster::Topology::ReplicaSetWithPrimary,
             Mongo::Cluster::Topology::Single,
             Mongo::Cluster::Topology::Sharded,
+            Mongo::Cluster::Topology::LoadBalanced,
           ]).to include(actual_class)
           expect(time_taken).to be < 5
 
           # run a command to ensure the client is a working one
-          client.database.command(ismaster: 1)
+          client.database.command(ping: 1)
+        end
+      end
+
+      context 'when cluster is monitored' do
+        require_topology :single, :replica_set, :sharded
+
+        # TODO this test requires there being no outstanding background
+        # monitoring threads running, as otherwise the scan! expectation
+        # can be executed on a thread that belongs to one of the global
+        # clients for instance
+        it 'performs one round of sdam' do
+          # Does not work due to
+          # https://github.com/rspec/rspec-mocks/issues/1242.
+          #expect_any_instance_of(Mongo::Server::Monitor).to receive(:scan!).
+          #  exactly(SpecConfig.instance.addresses.length).times.and_call_original
+          c = new_local_client(
+            SpecConfig.instance.addresses, SpecConfig.instance.test_options)
+          expect(c.cluster.servers).not_to be_empty
+        end
+
+        # This checks the case of all initial seeds being removed from
+        # cluster during SDAM
+        context 'me mismatch on the only initial seed' do
+          let(:address) do
+            ClusterConfig.instance.alternate_address.to_s
+          end
+
+          include_examples 'does not wait for server selection timeout'
         end
       end
+
+      context 'when cluster is not monitored' do
+        require_topology :load_balanced
+
+        let(:address) do
+          ClusterConfig.instance.alternate_address.to_s
+        end
+
+        include_examples 'does not wait for server selection timeout'
+      end
     end
 
     context 'with monitoring_io: false' do
@@ -187,7 +211,7 @@ describe Mongo::Client do
             let(:kms_providers) { nil }
 
             it 'raises an exception' do
-              expect { client }.to raise_error(ArgumentError, /kms_providers option must not be nil/)
+              expect { client }.to raise_error(ArgumentError, /KMS providers options must not be nil/)
             end
           end
 
@@ -195,7 +219,7 @@ describe Mongo::Client do
             let(:kms_providers) { { random_key: 'hello' } }
 
             it 'raises an exception' do
-              expect { client }.to raise_error(ArgumentError, /kms_providers option must have one of the following keys: :aws, :local/)
+              expect { client }.to raise_error(ArgumentError, /KMS providers options must have one of the following keys: :aws, :azure, :gcp, :kmip, :local/)
             end
           end
 
@@ -203,7 +227,7 @@ describe Mongo::Client do
             let(:kms_providers) { { local: { wrong_key: 'hello' } } }
 
             it 'raises an exception' do
-              expect { client }.to raise_error(ArgumentError, /kms_providers with :local key must be in the format: { local: { key: 'MASTER-KEY' } }/)
+              expect { client }.to raise_error(ArgumentError, /Local KMS provider options must be in the format: { key: 'MASTER-KEY' }/)
             end
           end
 
@@ -211,7 +235,7 @@ describe Mongo::Client do
             let(:kms_providers) { { aws: { wrong_key: 'hello' } } }
 
             it 'raises an exception' do
-              expect { client }.to raise_error(ArgumentError, /kms_providers with :aws key must be in the format: { aws: { access_key_id: 'YOUR-ACCESS-KEY-ID', secret_access_key: 'SECRET-ACCESS-KEY' } }/)
+              expect { client }.to raise_error(ArgumentError, / AWS KMS provider options must be in the format: { access_key_id: 'YOUR-ACCESS-KEY-ID', secret_access_key: 'SECRET-ACCESS-KEY' }/)
             end
           end
 
@@ -261,9 +285,9 @@ describe Mongo::Client do
                 }
               end
 
-              it 'sets key_vault_client as a clone of self with no encryption options' do
+              it 'sets key_vault_client with no encryption options' do
                 key_vault_client = client.encrypter.key_vault_client
-                expect(key_vault_client).to eq(client)
+                expect(key_vault_client.options['auto_encryption_options']).to be_nil
               end
 
               it 'sets bypass_auto_encryption to false' do
@@ -385,10 +409,24 @@ describe Mongo::Client do
             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)
+          context 'non-lb' do
+            require_topology :single, :replica_set, :sharded
+
+            it 'fails server selection due to very small timeout' do
+              lambda do
+                client.database.command(ping: 1)
+              end.should raise_error(Mongo::Error::NoServerAvailable)
+            end
+          end
+
+          context 'lb' do
+            require_topology :load_balanced
+
+            it 'fails the operation after successful server selection' do
+              lambda do
+                client.database.command(ping: 1)
+              end.should raise_error(Mongo::Error::SocketTimeoutError, /socket took over.*to connect/)
+            end
           end
         end
 
@@ -409,6 +447,7 @@ describe Mongo::Client do
             end.should_not raise_error
           end
 
+          retry_test
           it 'fails operations due to very small timeout' do
             lambda do
               client.database.command(ping: 1)
@@ -463,7 +502,56 @@ describe Mongo::Client do
             SpecConfig.instance.all_test_options.merge(options))
         end
 
-        context 'when the compressor is supported' do
+        context 'when the compressor is not supported by the driver' do
+          require_warning_clean
+
+          let(:options) do
+            { compressors: ['snoopy'] }
+          end
+
+          it 'does not set the compressor and warns' do
+            expect(Mongo::Logger.logger).to receive(:warn).with(/Unsupported compressor/)
+            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' do
+            require_compression
+            min_server_fcv '3.6'
+
+            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' do
+          max_server_version '3.4'
+
+          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
+
+        context 'when zlib compression is requested' do
+          require_zlib_compression
 
           let(:options) do
             { compressors: ['zlib'] }
@@ -478,7 +566,6 @@ describe Mongo::Client do
           end
 
           context 'when server supports compression' do
-            require_compression
             min_server_fcv '3.6'
 
             it 'uses compression for messages' do
@@ -495,51 +582,55 @@ describe Mongo::Client do
           end
         end
 
-        context 'when the compressor is not supported by the driver' do
-          require_warning_clean
+        context 'when snappy compression is requested and supported by the server' do
+          min_server_version '3.6'
 
           let(:options) do
-            { compressors: ['snoopy'] }
+            { compressors: ['snappy'] }
           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
+          context 'when snappy gem is installed' do
+            require_snappy_compression
 
-          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' do
-            require_compression
-            min_server_fcv '3.6'
-
-            let(:options) do
-              { compressors: ['zlib', 'snoopy'] }
+            it 'creates the client' do
+              expect(client.options['compressors']).to eq(['snappy'])
             end
+          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
+          context 'when snappy gem is not installed' do
+            require_no_snappy_compression
 
-            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'])
+            it 'raises an exception' do
+              expect do
+                client
+              end.to raise_error(Mongo::Error::UnmetDependency, /Cannot enable snappy compression/)
             end
           end
         end
 
-        context 'when the compressor is not supported by the server' do
-          max_server_version '3.4'
+        context 'when zstd compression is requested and supported by the server' do
+          min_server_version '4.2'
 
           let(:options) do
-            { compressors: ['zlib'] }
+            { compressors: ['zstd'] }
           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
+          context 'when zstd gem is installed' do
+            require_zstd_compression
+
+            it 'creates the client' do
+              expect(client.options['compressors']).to eq(['zstd'])
+            end
+          end
+
+          context 'when zstd gem is not installed' do
+            require_no_zstd_compression
+
+            it 'raises an exception' do
+              expect do
+                client
+              end.to raise_error(Mongo::Error::UnmetDependency, /Cannot enable zstd compression/)
+            end
           end
         end
       end
@@ -753,6 +844,20 @@ describe Mongo::Client do
               expect(client.options[:max_pool_size]).to eq(options[:max_pool_size])
             end
           end
+
+          context 'when max_pool_size is zero (unlimited)' do
+            let(:options) do
+              {
+                  :min_pool_size => 10,
+                  :max_pool_size => 0
+              }
+            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
@@ -761,7 +866,7 @@ describe Mongo::Client do
 
             let(:options) do
               {
-                  :min_pool_size => 10
+                  :min_pool_size => 30
               }
             end
 
@@ -800,6 +905,24 @@ describe Mongo::Client do
         end
       end
 
+      context 'when max_pool_size is provided' do
+        let(:client) do
+          new_local_client_nmio(['127.0.0.1:27017'], options)
+        end
+
+        context 'when max_pool_size is 0 (unlimited)' do
+          let(:options) do
+            {
+                :max_pool_size => 0
+            }
+          end
+
+          it 'sets the option' do
+            expect(client.options[:max_pool_size]).to eq(options[:max_pool_size])
+          end
+        end
+      end
+
       context 'when max_pool_size and min_pool_size are both nil' do
 
         let(:client) do
@@ -851,7 +974,8 @@ describe Mongo::Client do
             [
               "Ruby #{RUBY_VERSION}",
               RUBY_PLATFORM,
-              RbConfig::CONFIG['build']
+              RbConfig::CONFIG['build'],
+              'A',
             ].join(', ')
           end
 
@@ -869,7 +993,8 @@ describe Mongo::Client do
               "like Ruby #{RUBY_VERSION}",
               RUBY_PLATFORM,
               "JVM #{java.lang.System.get_property('java.version')}",
-              RbConfig::CONFIG['build']
+              RbConfig::CONFIG['build'],
+              'A',
             ].join(', ')
           end
 
@@ -988,6 +1113,17 @@ describe Mongo::Client do
                 expect(client.options[:max_pool_size]).to eq(10)
               end
             end
+
+            context 'when max_pool_size is 0 (unlimited)' do
+              let(:uri) do
+                'mongodb://127.0.0.1:27017/?minPoolSize=10&maxPoolSize=0'
+              end
+
+              it 'sets the option' do
+                expect(client.options[:min_pool_size]).to eq(10)
+                expect(client.options[:max_pool_size]).to eq(0)
+              end
+            end
           end
 
           context 'when max_pool_size is not provided' do
@@ -995,7 +1131,7 @@ describe Mongo::Client 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'
+                'mongodb://127.0.0.1:27017/?minPoolSize=30'
               end
 
               it 'raises an Exception' do
@@ -1235,6 +1371,325 @@ describe Mongo::Client do
             client.options[:connect].should be :sharded
           end
         end
+
+        context 'load_balanced: true and multiple seeds' do
+          let(:client) do
+            new_local_client_nmio(['127.0.0.1:27017', '127.0.0.2:27017'],
+              load_balanced: true)
+          end
+
+          it 'is rejected' do
+            lambda do
+              client
+            end.should raise_error(ArgumentError, /load_balanced=true cannot be used with multiple seeds/)
+          end
+        end
+
+        context 'load_balanced: false and multiple seeds' do
+          let(:client) do
+            new_local_client_nmio(['127.0.0.1:27017', '127.0.0.2:27017'],
+              load_balanced: false)
+          end
+
+          it 'is accepted' do
+            lambda do
+              client
+            end.should_not raise_error
+            client.options[:load_balanced].should be false
+          end
+        end
+
+        context 'load_balanced: true and direct_connection: true' do
+          let(:client) do
+            new_local_client_nmio(['127.0.0.1:27017'],
+              load_balanced: true, direct_connection: true)
+          end
+
+          it 'is rejected' do
+            lambda do
+              client
+            end.should raise_error(ArgumentError, /direct_connection=true cannot be used with load_balanced=true/)
+          end
+        end
+
+        context 'load_balanced: true and direct_connection: false' do
+          let(:client) do
+            new_local_client_nmio(['127.0.0.1:27017'],
+              load_balanced: true, direct_connection: false)
+          end
+
+          it 'is accepted' do
+            lambda do
+              client
+            end.should_not raise_error
+            client.options[:load_balanced].should be true
+            client.options[:direct_connection].should be false
+          end
+        end
+
+        context 'load_balanced: false and direct_connection: true' do
+          let(:client) do
+            new_local_client_nmio(['127.0.0.1:27017'],
+              load_balanced: false, direct_connection: true)
+          end
+
+          it 'is accepted' do
+            lambda do
+              client
+            end.should_not raise_error
+            client.options[:load_balanced].should be false
+            client.options[:direct_connection].should be true
+          end
+        end
+
+        [:direct, 'direct', :sharded, 'sharded'].each do |v|
+          context "load_balanced: true and connect: #{v.inspect}" do
+            let(:client) do
+              new_local_client_nmio(['127.0.0.1:27017'],
+                load_balanced: true, connect: v)
+            end
+
+            it 'is rejected' do
+              lambda do
+                client
+              end.should raise_error(ArgumentError, /connect=#{v} cannot be used with load_balanced=true/)
+            end
+          end
+        end
+
+        [nil].each do |v|
+          context "load_balanced: true and connect: #{v.inspect}" do
+            let(:client) do
+              new_local_client_nmio(['127.0.0.1:27017'],
+                load_balanced: true, connect: v)
+            end
+
+            it 'is accepted' do
+              lambda do
+                client
+              end.should_not raise_error
+              client.options[:load_balanced].should be true
+              client.options[:connect].should eq v
+            end
+          end
+        end
+
+        [:load_balanced, 'load_balanced'].each do |v|
+          context "load_balanced: true and connect: #{v.inspect}" do
+            let(:client) do
+              new_local_client_nmio(['127.0.0.1:27017'],
+                load_balanced: true, connect: v)
+            end
+
+            it 'is accepted' do
+              lambda do
+                client
+              end.should_not raise_error
+              client.options[:load_balanced].should be true
+              client.options[:connect].should eq v
+            end
+          end
+
+          context "replica_set and connect: #{v.inspect}" do
+            let(:client) do
+              new_local_client_nmio(['127.0.0.1:27017'],
+                replica_set: 'foo', connect: v)
+            end
+
+            it 'is rejected' do
+              lambda do
+                client
+              end.should raise_error(ArgumentError, /connect=load_balanced cannot be used with replica_set option/)
+            end
+          end
+
+          context "direct_connection=true and connect: #{v.inspect}" do
+            let(:client) do
+              new_local_client_nmio(['127.0.0.1:27017'],
+                direct_connection: true, connect: v)
+            end
+
+            it 'is rejected' do
+              lambda do
+                client
+              end.should raise_error(ArgumentError, /Conflicting client options: direct_connection=true and connect=load_balanced/)
+            end
+          end
+
+          context "multiple seed addresses and connect: #{v.inspect}" do
+            let(:client) do
+              new_local_client_nmio(['127.0.0.1:27017', '127.0.0.1:1234'],
+                connect: v)
+            end
+
+            it 'is rejected' do
+              lambda do
+                client
+              end.should raise_error(ArgumentError, /connect=load_balanced cannot be used with multiple seeds/)
+            end
+          end
+        end
+
+        [:replica_set, 'replica_set'].each do |v|
+          context "load_balanced: true and connect: #{v.inspect}" do
+            let(:client) do
+              new_local_client_nmio(['127.0.0.1:27017'],
+                load_balanced: true, connect: v, replica_set: 'x')
+            end
+
+            it 'is rejected' do
+              lambda do
+                client
+              end.should raise_error(ArgumentError, /connect=replica_set cannot be used with load_balanced=true/)
+            end
+          end
+
+          context "load_balanced: true and #{v.inspect} option" do
+            let(:client) do
+              new_local_client_nmio(['127.0.0.1:27017'],
+                load_balanced: true, v => 'rs')
+            end
+
+            it 'is rejected' do
+              lambda do
+                client
+              end.should raise_error(ArgumentError, /load_balanced=true cannot be used with replica_set option/)
+            end
+          end
+        end
+
+        context 'srv_max_hosts > 0 and load_balanced: true' do
+          let(:client) do
+            new_local_client_nmio(['127.0.0.1:27017'],
+               srv_max_hosts: 1, load_balanced: true)
+          end
+
+          it 'it is rejected' do
+            expect do
+              client
+            end.to raise_error(ArgumentError, /:srv_max_hosts > 0 cannot be used with :load_balanced=true/)
+          end
+        end
+
+        context 'srv_max_hosts > 0 and replica_set' do
+          let(:client) do
+            new_local_client_nmio(['127.0.0.1:27017'],
+              srv_max_hosts: 1, replica_set: 'rs')
+          end
+
+          it 'it is rejected' do
+            expect do
+              client
+            end.to raise_error(ArgumentError, /:srv_max_hosts > 0 cannot be used with :replica_set option/)
+          end
+        end
+
+        context 'srv_max_hosts < 0' do
+          let(:client) do
+            new_local_client_nmio(['127.0.0.1:27017'],
+               srv_max_hosts: -1)
+          end
+
+          it 'is accepted and does not add the srv_max_hosts to uri_options' do
+            lambda do
+              client
+            end.should_not raise_error
+            expect(client.options).to_not have_key(:srv_max_hosts)
+          end
+        end
+
+        context 'srv_max_hosts invalid type' do
+          let(:client) do
+            new_local_client_nmio(['127.0.0.1:27017'],
+               srv_max_hosts: 'foo')
+          end
+
+          it 'is accepted and does not add the srv_max_hosts to uri_options' do
+            lambda do
+              client
+            end.should_not raise_error
+            expect(client.options).to_not have_key(:srv_max_hosts)
+          end
+        end
+
+        context 'srv_max_hosts with non-SRV URI' do
+          let(:client) do
+            new_local_client_nmio(['127.0.0.1:27017'],
+               srv_max_hosts: 1)
+          end
+
+          it 'is rejected' do
+            lambda do
+              client
+            end.should raise_error(ArgumentError, /:srv_max_hosts cannot be used on non-SRV URI/)
+          end
+        end
+
+        context 'srv_service_name with non-SRV URI' do
+          let(:client) do
+            new_local_client_nmio(['127.0.0.1:27017'],
+               srv_service_name: "customname")
+          end
+
+          it 'is rejected' do
+            lambda do
+              client
+            end.should raise_error(ArgumentError, /:srv_service_name cannot be used on non-SRV URI/)
+          end
+        end
+      end
+
+      context 'with SRV lookups mocked at Resolver' do
+        let(:srv_result) do
+          double('srv result').tap do |result|
+            allow(result).to receive(:empty?).and_return(false)
+            allow(result).to receive(:address_strs).and_return(
+              [ClusterConfig.instance.primary_address_str])
+          end
+        end
+
+        let(:client) do
+          allow_any_instance_of(Mongo::Srv::Resolver).to receive(:get_records).and_return(srv_result)
+          allow_any_instance_of(Mongo::Srv::Resolver).to receive(:get_txt_options_string)
+
+          new_local_client_nmio('mongodb+srv://foo.a.b', options)
+        end
+
+        context "when setting srv_max_hosts" do
+          let(:srv_max_hosts) { 1 }
+          let(:options) { { srv_max_hosts: srv_max_hosts } }
+
+          it 'is accepted and sets srv_max_hosts' do
+            lambda do
+              client
+            end.should_not raise_error
+            expect(client.options[:srv_max_hosts]).to eq(srv_max_hosts)
+          end
+        end
+
+        context "when setting srv_max_hosts to 0" do
+          let(:srv_max_hosts) { 0 }
+          let(:options) { { srv_max_hosts: srv_max_hosts } }
+
+          it 'is accepted sets srv_max_hosts' do
+            lambda do
+              client
+            end.should_not raise_error
+            expect(client.options[:srv_max_hosts]).to eq(srv_max_hosts)
+          end
+        end
+
+        context "when setting srv_service_name" do
+          let(:srv_service_name) { 'customname' }
+          let(:options) { { srv_service_name: srv_service_name } }
+
+          it 'is accepted and sets srv_service_name' do
+            lambda do
+              client
+            end.should_not raise_error
+            expect(client.options[:srv_service_name]).to eq(srv_service_name)
+          end
+        end
       end
 
       context ':bg_error_backtrace option' do
@@ -1547,6 +2002,97 @@ describe Mongo::Client do
           end
         end
       end
+
+      context ':server_api parameter' do
+        context 'is a hash with symbol keys' do
+          context 'using known keys' do
+            let(:options) do
+              {server_api: {
+                version: '1',
+                strict: true,
+                deprecation_errors: false,
+              }}
+            end
+
+            it 'is accepted' do
+              client.options[:server_api].should == {
+                'version' => '1',
+                'strict' => true,
+                'deprecation_errors' => false,
+              }
+            end
+          end
+
+          context 'using an unknown version' do
+            let(:options) do
+              {server_api: {
+                version: '42',
+              }}
+            end
+
+            it 'is rejected' do
+              lambda do
+                client
+              end.should raise_error(ArgumentError, 'Unknown server API version: 42')
+            end
+          end
+
+          context 'using an unknown option' do
+            let(:options) do
+              {server_api: {
+                vversion: '1',
+              }}
+            end
+
+            it 'is rejected' do
+              lambda do
+                client
+              end.should raise_error(ArgumentError, 'Unknown keys under :server_api: "vversion"')
+            end
+          end
+
+          context 'using a value which is not a hash' do
+            let(:options) do
+              {server_api: 42}
+            end
+
+            it 'is rejected' do
+              lambda do
+                client
+              end.should raise_error(ArgumentError, ':server_api value must be a hash: 42')
+            end
+          end
+        end
+
+        context 'when connected to a pre-OP_MSG server' do
+          max_server_version '3.4'
+
+          let(:options) do
+            {server_api: {version: 1}}
+          end
+
+          let(:client) do
+            new_local_client(SpecConfig.instance.addresses,
+              SpecConfig.instance.all_test_options.merge(options))
+          end
+
+          it 'constructs the client' do
+            client.should be_a(Mongo::Client)
+          end
+
+          it 'does not discover servers' do
+            client.cluster.servers_list.each do |s|
+              expect(s.status).to eq('UNKNOWN')
+            end
+          end
+
+          it 'fails operations' do
+            lambda do
+              client.command(ping: 1)
+            end.should raise_error(Mongo::Error::NoServerAvailable)
+          end
+        end
+      end
     end
 
     context 'when making a block client' do
@@ -2158,7 +2704,12 @@ describe Mongo::Client do
       before do
         client.cluster.next_primary
         events = subscriber.select_started_events(Mongo::Monitoring::Event::ServerHeartbeatStarted)
-        events.length.should > 0
+        if ClusterConfig.instance.topology == :load_balanced
+          # No server monitoring in LB topology
+          events.length.should == 0
+        else
+          events.length.should > 0
+        end
       end
 
       it 'does not copy sdam_proc option to new client' do
@@ -2170,7 +2721,12 @@ describe Mongo::Client do
         # Give those some time to be processed.
         sleep 2
 
-        expect(subscriber.started_events.length).to be > 0
+        if ClusterConfig.instance.topology == :load_balanced
+          # No server monitoring in LB topology
+          expect(subscriber.started_events.length).to eq 0
+        else
+          expect(subscriber.started_events.length).to be > 0
+        end
         subscriber.started_events.clear
 
         # If this test takes longer than heartbeat interval,
@@ -2187,6 +2743,37 @@ describe Mongo::Client do
         new_client.cluster.topology.class.should_not be Mongo::Cluster::Topology::Unknown
       end
     end
+
+    context 'when :server_api is changed' do
+
+      let(:client) do
+        new_local_client_nmio(['127.0.0.1:27017'])
+      end
+
+      let(:new_client) do
+        client.with(server_api: {version: '1'})
+      end
+
+      it 'changes :server_api' do
+        new_client.options[:server_api].should == {'version' => '1'}
+      end
+    end
+
+    context 'when :server_api is cleared' do
+
+      let(:client) do
+        new_local_client_nmio(['127.0.0.1:27017'], server_api: {version: '1'})
+      end
+
+      let(:new_client) do
+        client.with(server_api: nil)
+      end
+
+      it 'clears :server_api' do
+        new_client.options[:server_api].should be nil
+      end
+    end
+
   end
 
   describe '#dup' do