mongo 2.13.0.beta1 → 2.14.0

data/spec/integration/zlib_compression_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe 'Zlib compression' do
+  require_compression
+
+  before do
+    authorized_client['test'].drop
+  end
+
+  context 'when client has zlib compressor option enabled' do
+    it 'compresses the message to the server' do
+      # Double check that the client has zlib compression enabled
+      expect(authorized_client.options[:compressors]).to include('zlib')
+
+      expect(Mongo::Protocol::Compressed).to receive(:new).twice.and_call_original
+      expect(Zlib::Deflate).to receive(:deflate).twice.and_call_original
+      expect(Zlib::Inflate).to receive(:inflate).twice.and_call_original
+
+      authorized_client['test'].insert_one(_id: 1, text: 'hello world')
+      document = authorized_client['test'].find(_id: 1).first
+
+      expect(document['text']).to eq('hello world')
+    end
+  end
+end

data/spec/lite_spec_helper.rb

@@ -1,11 +1,11 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "shared", "lib"))
+
 COVERAGE_MIN = 90
 CURRENT_PATH = File.expand_path(File.dirname(__FILE__))
 
 SERVER_DISCOVERY_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/sdam/**/*.yml").sort
 SDAM_MONITORING_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/sdam_monitoring/*.yml").sort
 SERVER_SELECTION_RTT_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/server_selection_rtt/*.yml").sort
-SERVER_SELECTION_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/server_selection/**/*.yml").sort
-MAX_STALENESS_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/max_staleness/**/*.yml").sort
 CRUD_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/crud/**/*.yml").sort
 CRUD2_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/crud_v2/**/*.yml").sort
 RETRYABLE_WRITES_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/retryable_writes/**/*.yml").sort
@@ -22,7 +22,11 @@ CMAP_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/cmap/*.yml").sort
 AUTH_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/auth/*.yml").sort
 CLIENT_SIDE_ENCRYPTION_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/client_side_encryption/*.yml").sort
 
-if ENV['CI']
+# Disable output buffering: https://www.rubyguides.com/2019/02/ruby-io/
+STDOUT.sync = true
+STDERR.sync = true
+
+if %w(1 true yes).include?(ENV['CI']&.downcase)
   autoload :Byebug, 'byebug'
 else
   # Load debuggers before loading the driver code, so that breakpoints
@@ -47,6 +51,7 @@ end
 autoload :Benchmark, 'benchmark'
 autoload :IceNine, 'ice_nine'
 autoload :Timecop, 'timecop'
+autoload :ChildProcess, 'childprocess'
 
 if BSON::Environment.jruby?
   require 'concurrent-ruby'
@@ -58,14 +63,14 @@ end
 require 'support/utils'
 require 'support/spec_config'
 
-Mongo::Logger.logger = Logger.new($stdout)
+Mongo::Logger.logger = Logger.new(STDOUT)
 unless SpecConfig.instance.client_debug?
   Mongo::Logger.logger.level = Logger::INFO
 end
 Encoding.default_external = Encoding::UTF_8
 
+require 'mrss/lite_constraints'
 require 'support/matchers'
-require 'support/lite_constraints'
 require 'support/event_subscriber'
 require 'support/common_shortcuts'
 require 'support/client_registry'
@@ -74,6 +79,7 @@ require 'support/crypt'
 require 'support/json_ext_formatter'
 require 'support/sdam_formatter_integration'
 require 'support/background_thread_registry'
+require 'support/session_registry'
 
 if SpecConfig.instance.mri?
   require 'timeout_interrupt'
@@ -85,7 +91,7 @@ end
 RSpec.configure do |config|
   config.extend(CommonShortcuts::ClassMethods)
   config.include(CommonShortcuts::InstanceMethods)
-  config.extend(LiteConstraints)
+  config.extend(Mrss::LiteConstraints)
   config.include(ClientRegistryMacros)
 
   if SpecConfig.instance.ci?
@@ -102,19 +108,24 @@ RSpec.configure do |config|
     end
   end
 
-  if SpecConfig.instance.ci?
+  if SpecConfig.instance.ci? && !%w(1 true yes).include?(ENV['INTERACTIVE']&.downcase)
     # Allow a max of 30 seconds per test.
     # Tests should take under 10 seconds ideally but it seems
     # we have some that run for more than 10 seconds in CI.
     config.around(:each) do |example|
-      TimeoutInterrupt.timeout(45) do
+      timeout = if %w(1 true yes).include?(ENV['STRESS']&.downcase)
+        210
+      else
+        45
+      end
+      TimeoutInterrupt.timeout(timeout) do
         example.run
       end
     end
   end
 
   if SpecConfig.instance.ci?
-    if defined?(Rfc)
+    if defined?(Rfc::Rif)
       unless BSON::Environment.jruby?
         Rfc::Rif.output_object_space_stats = true
       end

data/spec/mongo/address_spec.rb

@@ -234,7 +234,7 @@ describe Mongo::Address do
       end
 
       let(:address) do
-        Mongo::Address.new(custom_hostname)
+        Mongo::Address.new("#{custom_hostname}:#{SpecConfig.instance.any_port}")
       end
 
       before do

data/spec/mongo/auth/aws/request_region_spec.rb

@@ -0,0 +1,42 @@
+require 'lite_spec_helper'
+
+AWS_REGION_TEST_CASES = {
+  'sts.amazonaws.com' => 'us-east-1',
+  'sts.us-west-2.amazonaws.com' => 'us-west-2',
+  'sts.us-west-2.amazonaws.com.ch' => 'us-west-2',
+  'example.com' => 'com',
+  'localhost' => 'us-east-1',
+  'sts..com' => Mongo::Error::InvalidServerAuthHost,
+  '.amazonaws.com' => Mongo::Error::InvalidServerAuthHost,
+  'sts.amazonaws.' => Mongo::Error::InvalidServerAuthHost,
+  '' => Mongo::Error::InvalidServerAuthResponse,
+  'x' * 256 => Mongo::Error::InvalidServerAuthHost,
+}
+
+describe 'AWS auth region tests' do
+
+  AWS_REGION_TEST_CASES.each do |host, expected_region|
+    context "host '#{host}'" do
+      let(:request) do
+        Mongo::Auth::Aws::Request.new(access_key_id: 'access_key_id',
+          secret_access_key: 'secret_access_key',
+          session_token: 'session_token',
+          host: host,
+          server_nonce: 'server_nonce',
+        )
+      end
+
+      if expected_region.is_a?(String)
+        it 'derives expected region' do
+          request.region.should == expected_region
+        end
+      else
+        it 'fails with an error' do
+          lambda do
+            request.region
+          end.should raise_error(expected_region)
+        end
+      end
+    end
+  end
+end

data/spec/mongo/auth/aws/request_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe Mongo::Auth::Aws::Request do
+
+  describe "#formatted_time" do
+    context "when time is provided and frozen" do
+      let(:original_time) { Time.at(1592399523).freeze }
+      let(:request) do
+        described_class.new(access_key_id: 'access_key_id',
+          secret_access_key: 'secret_access_key',
+          session_token: 'session_token',
+          host: 'host',
+          server_nonce: 'server_nonce',
+          time: original_time
+        )
+      end
+
+      it 'doesn\'t modify the time instance variable' do
+        expect { request.formatted_time }.to_not raise_error
+      end
+
+      it 'returns the correct formatted time' do
+        expect(request.formatted_time).to eq('20200617T131203Z')
+      end
+    end
+
+    context "when time is not provided" do
+      let(:request) do
+        described_class.new(access_key_id: 'access_key_id',
+          secret_access_key: 'secret_access_key',
+          session_token: 'session_token',
+          host: 'host',
+          server_nonce: 'server_nonce'
+        )
+      end
+
+      it 'doesn\'t raise an error on formatted_time' do
+        expect { request.formatted_time }.to_not raise_error
+      end
+    end
+  end
+
+  describe "#signature" do
+    context "when time is provided and frozen" do
+      let(:original_time) { Time.at(1592399523).freeze }
+      let(:request) do
+        described_class.new(access_key_id: 'access_key_id',
+          secret_access_key: 'secret_access_key',
+          session_token: 'session_token',
+          host: 'host',
+          server_nonce: 'server_nonce',
+          time: original_time
+        )
+      end
+
+      it 'doesn\'t raise error on signature' do
+        expect { request.signature }.to_not raise_error
+      end
+    end
+
+    context "when time is not provided" do
+      let(:request) do
+        described_class.new(access_key_id: 'access_key_id',
+          secret_access_key: 'secret_access_key',
+          session_token: 'session_token',
+          host: 'host',
+          server_nonce: 'server_nonce'
+        )
+      end
+
+      it 'doesn\'t raise error on signature' do
+        expect { request.signature }.to_not raise_error
+      end
+    end
+  end
+end

data/spec/mongo/auth/scram_spec.rb

@@ -65,7 +65,7 @@ describe Mongo::Auth::Scram do
           it 'does not compress the message' do
             expect(Mongo::Protocol::Compressed).not_to receive(:new)
             expect {
-              authenticator.login(connection)
+              authenticator.login
             }.to raise_error(Mongo::Auth::Unauthorized)
           end
         end

data/spec/mongo/auth/user_spec.rb

@@ -55,7 +55,7 @@ describe Mongo::Auth::User do
       let(:options) { {auth_mech: 'scram'} }
 
       context 'not linting' do
-        skip_if_linting
+        require_no_linting
 
         it 'warns' do
           expect(Mongo::Logger.logger).to receive(:warn)

data/spec/mongo/bulk_write_spec.rb

@@ -1335,7 +1335,7 @@ describe Mongo::BulkWrite do
             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
+              require_no_linting
 
               let(:batch_size) do
                 11
@@ -2012,7 +2012,7 @@ describe Mongo::BulkWrite do
       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
+        require_no_linting
 
         let(:batch_size) do
           11

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

@@ -319,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)
@@ -398,6 +496,7 @@ describe Mongo::Client do
         end
 
         context 'when the compressor is not supported by the driver' do
+          require_warning_clean
 
           let(:options) do
             { compressors: ['snoopy'] }
@@ -576,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
@@ -746,7 +845,7 @@ describe Mongo::Client do
         end
 
         context 'mri' do
-          only_mri
+          require_mri
 
           let(:platform_string) do
             [
@@ -1138,6 +1237,48 @@ describe Mongo::Client do
         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
@@ -1171,7 +1312,7 @@ describe Mongo::Client do
         end
 
         context 'when not linting' do
-          skip_if_linting
+          require_no_linting
 
           it 'rejects bogus read preference as symbol' do
             expect do
@@ -1203,6 +1344,46 @@ describe Mongo::Client do
         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
+          require_no_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(:options) do
@@ -1242,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
 
@@ -1773,6 +2145,7 @@ describe Mongo::Client do
             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
 
@@ -1793,6 +2166,10 @@ describe Mongo::Client do
       end
 
       it 'does not notify subscribers set up by sdam_proc' do
+        # 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
 
@@ -1800,6 +2177,12 @@ describe Mongo::Client do
         # subscriber may receive events from the original 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