mongo 2.11.4 → 2.18.1

data/spec/support/spec_config.rb

@@ -1,4 +1,8 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require 'singleton'
+require 'pathname'
 
 class SpecConfig
   include Singleton
@@ -7,13 +11,17 @@ class SpecConfig
   # only loading the lite spec helper. Do I/O eagerly in accessor methods.
   def initialize
     @uri_options = {}
+    @ruby_options = {}
     if ENV['MONGODB_URI']
-      @mongodb_uri = Mongo::URI.new(ENV['MONGODB_URI'])
+      @mongodb_uri = Mongo::URI.get(ENV['MONGODB_URI'])
       @uri_options = Mongo::Options::Mapper.transform_keys_to_symbols(@mongodb_uri.uri_options)
-      if @uri_options[:replica_set]
+      if ENV['TOPOLOGY'] == 'load-balanced'
+        @addresses = @mongodb_uri.servers
+        @connect_options = { connect: :load_balanced }
+      elsif @uri_options[:replica_set]
         @addresses = @mongodb_uri.servers
         @connect_options = { connect: :replica_set, replica_set: @uri_options[:replica_set] }
-      elsif @uri_options[:connect] == :sharded || ENV['TOPOLOGY'] == 'sharded_cluster'
+      elsif @uri_options[:connect] == :sharded || ENV['TOPOLOGY'] == 'sharded-cluster'
         @addresses = @mongodb_uri.servers
         @connect_options = { connect: :sharded }
       elsif @uri_options[:connect] == :direct
@@ -25,15 +33,6 @@ class SpecConfig
       else
         @ssl = @uri_options[:ssl]
       end
-    elsif ENV['MONGODB_ADDRESSES']
-      @addresses = ENV['MONGODB_ADDRESSES'] ? ENV['MONGODB_ADDRESSES'].split(',').freeze : [ '127.0.0.1:27017' ].freeze
-      if ENV['RS_ENABLED']
-        @connect_options = { connect: :replica_set, replica_set: ENV['RS_NAME'] }
-      elsif ENV['SHARDED_ENABLED']
-        @connect_options = { connect: :sharded }
-      else
-        @connect_options = { connect: :direct }
-      end
     end
 
     @uri_tls_options = {}
@@ -45,9 +44,19 @@ class SpecConfig
     end
 
     @ssl ||= false
+
+    if (server_api = ENV['SERVER_API']) && !server_api.empty?
+      @ruby_options[:server_api] = BSON::Document.new(YAML.load(server_api))
+      # Since the tests pass options provided by SpecConfig directly to
+      # internal driver objects (e.g. connections), transform server api
+      # parameters here as they would be transformed by Client constructor.
+      if (v = @ruby_options[:server_api][:version]).is_a?(Integer)
+        @ruby_options[:server_api][:version] = v.to_s
+      end
+    end
   end
 
-  attr_reader :uri_options, :connect_options
+  attr_reader :uri_options, :ruby_options, :connect_options
 
   def addresses
     @addresses ||= begin
@@ -73,8 +82,8 @@ class SpecConfig
       # TLS options need to be merged for evergreen due to
       # https://github.com/10gen/mongo-orchestration/issues/268
       client = Mongo::Client.new(addresses, Mongo::Options::Redacted.new(
-        server_selection_timeout: 5,
-      ).merge(ssl_options))
+        server_selection_timeout: 5.03,
+      ).merge(ssl_options).merge(ruby_options))
 
       begin
         case client.cluster.topology.class.name
@@ -98,7 +107,7 @@ class SpecConfig
   # Environment
 
   def ci?
-    !!ENV['CI']
+    %w(1 true yes).include?(ENV['CI']&.downcase)
   end
 
   def mri?
@@ -109,18 +118,62 @@ class SpecConfig
     !!(RUBY_PLATFORM =~ /\bjava\b/)
   end
 
+  def linux?
+    !!(RbConfig::CONFIG['host_os'].downcase =~ /\blinux/)
+  end
+
+  def macos?
+    !!(RbConfig::CONFIG['host_os'].downcase =~ /\bdarwin/)
+  end
+
+  def windows?
+    ENV['OS'] == 'Windows_NT' && !RUBY_PLATFORM.match?(/cygwin/)
+  end
+
   def platform
     RUBY_PLATFORM
   end
 
-  def stress_spec?
-    !!ENV['STRESS_SPEC']
+  def stress?
+    %w(1 true yes).include?(ENV['STRESS']&.downcase)
+  end
+
+  def fork?
+    %w(1 true yes).include?(ENV['FORK']&.downcase)
+  end
+
+  # OCSP tests require python and various dependencies.
+  # Assumes an OCSP responder is running on port 8100 (configured externally
+  # to the test suite).
+  def ocsp?
+    %w(1 true yes).include?(ENV['OCSP']&.downcase)
+  end
+
+  # OCSP tests require python and various dependencies.
+  # When testing OCSP verifier, there cannot be a responder running on
+  # port 8100 or the tests will fail.
+  def ocsp_verifier?
+    %w(1 true yes).include?(ENV['OCSP_VERIFIER']&.downcase)
+  end
+
+  def ocsp_connectivity?
+    ENV.key?('OCSP_CONNECTIVITY') && ENV['OCSP_CONNECTIVITY'] != ''
+  end
+
+  # Detect whether specs are running against Mongodb Atlas serverless instance.
+  # This method does not do any magic, it just checks whether environment
+  # variable SERVERLESS is set. This is a recommended way to inform spec runners
+  # that they are running against a serverless instance
+  #
+  # @return [ true | false ] Whether specs are running against a serverless instance.
+  def serverless?
+    !!ENV['SERVERLESS']
   end
 
   # Test suite configuration
 
   def client_debug?
-    %w(1 true yes).include?((ENV['CLIENT_DEBUG'] || '').downcase)
+    %w(1 true yes).include?(ENV['MONGO_RUBY_DRIVER_CLIENT_DEBUG']&.downcase)
   end
 
   def drivers_tools?
@@ -133,11 +186,7 @@ class SpecConfig
 
   # What compressor to use, if any.
   def compressors
-    if ENV['COMPRESSORS']
-      ENV['COMPRESSORS'].split(',')
-    else
-      nil
-    end
+    uri_options[:compressors]
   end
 
   def retry_reads
@@ -189,7 +238,7 @@ class SpecConfig
   end
 
   def auth_source
-    @uri_options && uri_options[:auth_source]
+    uri_options[:auth_source]
   end
 
   def connect_replica_set?
@@ -220,6 +269,10 @@ EOT
     Pathname.new("#{spec_root}/support/certificates")
   end
 
+  def ocsp_files_dir
+    Pathname.new("#{spec_root}/../.mod/drivers-evergreen-tools/.evergreen/ocsp")
+  end
+
   # TLS certificates & keys
 
   def local_client_key_path
@@ -247,7 +300,11 @@ EOT
   end
 
   def local_client_pem_path
-    "#{ssl_certs_dir}/client.pem"
+    if (algo = ENV['OCSP_ALGORITHM'])&.empty?
+      "#{ssl_certs_dir}/client.pem"
+    else
+      Pathname.new("#{spec_root}/support/ocsp/#{algo}/server.pem")
+    end
   end
 
   def client_pem_path
@@ -311,35 +368,161 @@ EOT
     'ruby-driver'.freeze
   end
 
+  # Whether FLE tests should be enabled
+  def fle?
+    ENV['FLE']
+  end
+
+  # AWS IAM user access key id
+  def fle_aws_key
+    ENV['MONGO_RUBY_DRIVER_AWS_KEY']
+  end
+
+  # AWS IAM user secret access key
+  def fle_aws_secret
+    ENV['MONGO_RUBY_DRIVER_AWS_SECRET']
+  end
+
+  # Region of AWS customer master key
+  def fle_aws_region
+    ENV['MONGO_RUBY_DRIVER_AWS_REGION']
+  end
+
+  # Amazon resource name (ARN) of AWS customer master key
+  def fle_aws_arn
+    ENV['MONGO_RUBY_DRIVER_AWS_ARN']
+  end
+
+  def fle_azure_tenant_id
+    ENV['MONGO_RUBY_DRIVER_AZURE_TENANT_ID']
+  end
+
+  def fle_azure_client_id
+    ENV['MONGO_RUBY_DRIVER_AZURE_CLIENT_ID']
+  end
+
+  def fle_azure_client_secret
+    ENV['MONGO_RUBY_DRIVER_AZURE_CLIENT_SECRET']
+  end
+
+  def fle_azure_identity_platform_endpoint
+    ENV['MONGO_RUBY_DRIVER_AZURE_IDENTITY_PLATFORM_ENDPOINT']
+  end
+
+  def fle_azure_key_vault_endpoint
+    ENV['MONGO_RUBY_DRIVER_AZURE_KEY_VAULT_ENDPOINT']
+  end
+
+  def fle_azure_key_name
+    ENV['MONGO_RUBY_DRIVER_AZURE_KEY_NAME']
+  end
+
+  def fle_gcp_email
+    ENV['MONGO_RUBY_DRIVER_GCP_EMAIL']
+  end
+
+  def fle_gcp_private_key
+    ENV['MONGO_RUBY_DRIVER_GCP_PRIVATE_KEY']
+  end
+
+  def fle_gcp_endpoint
+    ENV['MONGO_RUBY_DRIVER_GCP_ENDPOINT']
+  end
+
+  def fle_gcp_project_id
+    ENV['MONGO_RUBY_DRIVER_GCP_PROJECT_ID']
+  end
+
+  def fle_gcp_location
+    ENV['MONGO_RUBY_DRIVER_GCP_LOCATION']
+  end
+
+  def fle_gcp_key_ring
+    ENV['MONGO_RUBY_DRIVER_GCP_KEY_RING']
+  end
+
+  def fle_gcp_key_name
+    ENV['MONGO_RUBY_DRIVER_GCP_KEY_NAME']
+  end
+
+  def fle_gcp_key_version
+    ENV['MONGO_RUBY_DRIVER_GCP_KEY_VERSION']
+  end
+
+  def fle_kmip_endpoint
+    "localhost:5698"
+  end
+
+  def fle_kmip_tls_ca_file
+    "#{spec_root}/../.evergreen/x509gen/ca.pem"
+  end
+
+  def fle_kmip_tls_certificate_key_file
+    "#{spec_root}/../.evergreen/x509gen/client.pem"
+  end
+
+  def mongocryptd_port
+    if ENV['MONGO_RUBY_DRIVER_MONGOCRYPTD_PORT'] &&
+      !ENV['MONGO_RUBY_DRIVER_MONGOCRYPTD_PORT'].empty?
+    then
+      ENV['MONGO_RUBY_DRIVER_MONGOCRYPTD_PORT'].to_i
+    else
+      27020
+    end
+  end
+
+  def crypt_shared_lib_path
+    ENV['MONGO_RUBY_DRIVER_CRYPT_SHARED_LIB_PATH']
+  end
+
+  def auth?
+    x509_auth? || user
+  end
+
   # Option hashes
 
   def auth_options
     if x509_auth?
       {
-        auth_mech: @uri_options[:auth_mech],
+        auth_mech: uri_options[:auth_mech],
         auth_source: '$external',
       }
     else
       {
         user: user,
         password: password,
-        auth_source: auth_source,
-      }
+      }.tap do |options|
+        if auth_source
+          options[:auth_source] = auth_source
+        end
+        %i(auth_mech auth_mech_properties).each do |key|
+          if uri_options[key]
+            options[key] = uri_options[key]
+          end
+        end
+      end
     end
   end
 
   def ssl_options
-    if ssl?
-      {
+    return {} unless ssl?
+    {
         ssl: true,
         ssl_verify: true,
-        ssl_cert:  client_cert_path,
-        ssl_key:  client_key_path,
-        ssl_ca_cert: ca_cert_path,
-      }.merge(Utils.underscore_hash(@uri_tls_options))
-    else
-      {}
-    end
+    }.tap do |options|
+      # We should use bundled cetificates for ssl except for testing against
+      # Atlas instances. Atlas instances have addresses in domains
+      # mongodb.net or mongodb-dev.net.
+      if @mongodb_uri.servers.grep(/mongodb.*\.net/).empty?
+        options.merge!(
+          {
+            ssl_cert: client_cert_path,
+            ssl_key: client_key_path,
+            ssl_ca_cert: ca_cert_path,
+          }
+        )
+      end
+    end.merge(Utils.underscore_hash(@uri_tls_options))
   end
 
   def compressor_options
@@ -354,23 +537,57 @@ EOT
     {retry_writes: retry_writes?}
   end
 
+  # The options needed for a successful socket connection to the server(s).
+  # These exclude options needed to handshake (e.g. server api parameters).
+  def connection_options
+    ssl_options
+  end
+
+  # The options needed for successful monitoring of the server(s).
+  # These exclude options needed to perform operations (e.g. credentials).
+  def monitoring_options
+    ssl_options.merge(
+      server_api: ruby_options[:server_api],
+    )
+  end
+
   # Base test options.
   def base_test_options
-    uri_options = @uri_options || {}
     {
-      max_pool_size: 1,
+      # Automatic encryption tests require a minimum of three connections:
+      # - The driver checks out a connection to build a command.
+      # - It may need to encrypt the command, which could require a query to
+      #   the key vault collection triggered by libmongocrypt.
+      # - If the key vault client has auto encryption options, it will also
+      #   attempt to encrypt this query, resulting in a third connection.
+      # In the worst case using FLE may end up tripling the number of
+      # connections that the driver uses at any one time.
+      max_pool_size: 3,
+
       heartbeat_frequency: 20,
+
       # The test suite seems to perform a number of operations
       # requiring server selection. Hence a timeout of 1 here,
       # together with e.g. a misconfigured replica set,
       # means the test suite hangs for about 4 seconds before
       # failing.
       # Server selection timeout of 1 is insufficient for evergreen.
-      server_selection_timeout: uri_options[:server_selection_timeout] || (ssl? ? 4.01 : 2.01),
-      wait_queue_timeout: 2,
-      connect_timeout: 3,
-      max_idle_time: 5
-   }
+      server_selection_timeout: uri_options[:server_selection_timeout] || (ssl? ? 8.01 : 7.01),
+
+      # Since connections are established under the wait queue timeout,
+      # the wait queue timeout should be at least as long as the
+      # connect timeout.
+      wait_queue_timeout: 6.04,
+      connect_timeout: 2.91,
+      socket_timeout: 5.09,
+      max_idle_time: 100.02,
+
+      # Uncomment to have exceptions in background threads log complete
+      # backtraces.
+      #bg_error_backtrace: true,
+    }.merge(ruby_options).merge(
+      server_api: ruby_options[:server_api] && ::Utils.underscore_hash(ruby_options[:server_api])
+    )
   end
 
   # Options for test suite clients.
@@ -384,6 +601,14 @@ EOT
     test_options.merge(auth_options)
   end
 
+  def authorized_test_options
+    test_options.merge(credentials_or_external_user(
+      user: test_user.name,
+      password: test_user.password,
+      auth_source: auth_options[:auth_source],
+    ))
+  end
+
   # User objects
 
   # Gets the root system administrator user.
@@ -403,9 +628,13 @@ EOT
 
   # Get the default test user for the suite on versions 2.6 and higher.
   def test_user
+    # When testing against a serverless instance, we are not allowed to create
+    # new users, we just have one user for everyhing.
+    return root_user if serverless?
+
     Mongo::Auth::User.new(
-      database: test_db,
-      user: 'test-user',
+      database: 'admin',
+      user: 'ruby-test-user',
       password: 'password',
       roles: [
         { role: Mongo::Auth::Roles::READ_WRITE, db: test_db },
@@ -419,25 +648,78 @@ EOT
         { role: Mongo::Auth::Roles::READ_WRITE, db: 'reporting' },
         { role: Mongo::Auth::Roles::DATABASE_ADMIN, db: 'reporting' },
 
-        # For transaction api spec tests
-        #{ role: Mongo::Auth::Roles::READ_WRITE, db: 'withTransaction-tests' },
-        #{ role: Mongo::Auth::Roles::DATABASE_ADMIN, db: 'withTransaction-tests' },
-
+        # For spec tests
+        { role: Mongo::Auth::Roles::READ_WRITE, db: 'crud-tests' },
+        { role: Mongo::Auth::Roles::DATABASE_ADMIN, db: 'crud-tests' },
+        { role: Mongo::Auth::Roles::READ_WRITE, db: 'crud-default' },
+        { role: Mongo::Auth::Roles::DATABASE_ADMIN, db: 'crud-default' },
+        { role: Mongo::Auth::Roles::READ_WRITE, db: 'default_write_concern_db' },
+        { role: Mongo::Auth::Roles::DATABASE_ADMIN, db: 'default_write_concern_db' },
+        { role: Mongo::Auth::Roles::READ_WRITE, db: 'retryable-reads-tests' },
+        { role: Mongo::Auth::Roles::DATABASE_ADMIN, db: 'retryable-reads-tests' },
+        { role: Mongo::Auth::Roles::READ_WRITE, db: 'sdam-tests' },
+        { role: Mongo::Auth::Roles::DATABASE_ADMIN, db: 'sdam-tests' },
+        { role: Mongo::Auth::Roles::READ_WRITE, db: 'transaction-tests' },
+        { role: Mongo::Auth::Roles::DATABASE_ADMIN, db: 'transaction-tests' },
+        { role: Mongo::Auth::Roles::READ_WRITE, db: 'withTransaction-tests' },
+        { role: Mongo::Auth::Roles::DATABASE_ADMIN, db: 'withTransaction-tests' },
+        { role: Mongo::Auth::Roles::READ_WRITE, db: 'admin' },
+        { role: Mongo::Auth::Roles::DATABASE_ADMIN, db: 'admin' },
+        { role: Mongo::Auth::Roles::READ_WRITE, db: 'command-monitoring-tests' },
+        { role: Mongo::Auth::Roles::DATABASE_ADMIN, db: 'command-monitoring-tests' },
+        { role: Mongo::Auth::Roles::READ_WRITE, db: 'session-tests' },
+        { role: Mongo::Auth::Roles::DATABASE_ADMIN, db: 'session-tests' },
+        { role: Mongo::Auth::Roles::READ_WRITE, db: 'gridfs-tests' },
+        { role: Mongo::Auth::Roles::DATABASE_ADMIN, db: 'gridfs-tests' },
+        { role: Mongo::Auth::Roles::READ_WRITE, db: 'change-stream-tests' },
+        { role: Mongo::Auth::Roles::DATABASE_ADMIN, db: 'change-stream-tests' },
+        { role: Mongo::Auth::Roles::READ_WRITE, db: 'change-stream-tests-2' },
+        { role: Mongo::Auth::Roles::DATABASE_ADMIN, db: 'change-stream-tests-2' },
+        { role: Mongo::Auth::Roles::READ_WRITE, db: 'retryable-writes-tests' },
+        { role: Mongo::Auth::Roles::DATABASE_ADMIN, db: 'retryable-writes-tests' },
+        { role: Mongo::Auth::Roles::READ_WRITE, db: 'ts-tests' },
+        { role: Mongo::Auth::Roles::DATABASE_ADMIN, db: 'ts-tests' },
+        { role: Mongo::Auth::Roles::READ_WRITE, db: 'ci-tests' },
+        { role: Mongo::Auth::Roles::DATABASE_ADMIN, db: 'ci-tests' },
+        { role: Mongo::Auth::Roles::READ_WRITE, db: 'papi-tests' },
+        { role: Mongo::Auth::Roles::DATABASE_ADMIN, db: 'papi-tests' },
       ]
     )
   end
 
   def x509_auth?
-    @uri_options[:auth_mech] == :mongodb_x509
+    uri_options[:auth_mech] == :mongodb_x509
   end
 
-  # When we use x.509 authentication, omit all of the users we normally create
-  # and authenticate with x.509.
-  def credentials_or_x509(creds)
-    if x509_auth?
-      {auth_mech: :mongodb_x509}
+  # When we authenticate with a username & password mechanism (scram, cr)
+  # we create a variety of users in the test suite for different purposes.
+  # When we authenticate with passwordless mechanisms (x509, aws) we use
+  # the globally specified user for all operations.
+  def external_user?
+    case uri_options[:auth_mech]
+    when :mongodb_x509, :aws
+      true
+    when nil, :scram, :scram256
+      false
+    else
+      raise "Unknown auth mechanism value: #{uri_options[:auth_mech]}"
+    end
+  end
+
+  # When we use external authentication, omit all of the users we normally
+  # create and authenticate with the external mechanism. This also ensures
+  # our various helpers work correctly when the only users available are
+  # the external ones.
+  def credentials_or_external_user(creds)
+    if external_user?
+      auth_options
     else
       creds
     end
   end
+
+  # Returns whether the test suite was configured with a single mongos.
+  def single_mongos?
+    %w(1 true yes).include?(ENV['SINGLE_MONGOS'])
+  end
 end

data/spec/support/spec_setup.rb

@@ -1,49 +1,64 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require_relative './spec_config'
 require_relative './client_registry'
 
 class SpecSetup
   def run
-    if SpecConfig.instance.x509_auth?
-      warn 'Skipping user creation because X.509 auth appears to be enabled'
+    if SpecConfig.instance.external_user?
+      warn 'Skipping user creation because the set of users is fixed'
       return
     end
 
-    # Create the root user administrator as the first user to be added to the
-    # database. This user will need to be authenticated in order to add any
-    # more users to any other databases.
-    begin
-      create_user(admin_unauthorized_client, SpecConfig.instance.root_user)
-    rescue Mongo::Error::OperationFailure => e
-      # When testing a cluster that requires auth, root user is already set up
-      # and it is not creatable without auth.
-      # Seems like every mongodb version has its own error message
-      # for trying to make a user when not authenticated,
-      # and prior to 4.0 or so the codes are supposedly not reliable either.
-      # In order: 4.0, 3.6, 3.4 through 2.6
-      if e.message =~ /command createUser requires authentication|there are no users authenticated|not authorized on admin to execute command.*createUser/
-        # However, if the cluster is configured to require auth but
-        # test suite has wrong credentials, then admin_authorized_test_client
-        # won't be authenticated and the following line will raise an
-        # exception
-        if admin_authorized_test_client.with(database: 'admin').database.users.info(SpecConfig.instance.root_user.name).any?
-          warn "Skipping root user creation, likely auth is enabled on cluster"
-        else
-          raise
+    with_client do |client|
+      # For historical reasons, the test suite always uses
+      # password-authenticated users, even when authentication is not
+      # requested in the configuration. When authentication is requested
+      # and password authentication is used (i.e., not x509 and not kerberos),
+      # a suitable user already exists (it's the one specified in the URI)
+      # and no additional users are needed. In other cases, including x509
+      # auth and kerberos, create the "root user".
+      # TODO redo the test suite so that this password-authenticated root user
+      # is not required and the test suite uses whichever user is specified
+      # in the URI, which could be none.
+      if !SpecConfig.instance.auth? || SpecConfig.instance.x509_auth?
+        # Create the root user administrator as the first user to be added to the
+        # database. This user will need to be authenticated in order to add any
+        # more users to any other databases.
+        begin
+          create_user(client, SpecConfig.instance.root_user)
+        rescue Mongo::Error::OperationFailure => e
+          # When testing a cluster that requires auth, root user is already set up
+          # and it is not creatable without auth.
+          # Seems like every mongodb version has its own error message
+          # for trying to make a user when not authenticated,
+          # and prior to 4.0 or so the codes are supposedly not reliable either.
+          # In order: 4.0, 3.6, 3.4 through 2.6
+          if e.message =~ /command createUser requires authentication|there are no users authenticated|not authorized on admin to execute command.*createUser/
+            # However, if the cluster is configured to require auth but
+            # test suite has wrong credentials, then admin_authorized_test_client
+            # won't be authenticated and the following line will raise an
+            # exception
+            if client.use('admin').database.users.info(SpecConfig.instance.root_user.name).any?
+              warn "Skipping root user creation, likely auth is enabled on cluster"
+            else
+              raise
+            end
+          else
+            raise
+          end
         end
-      else
-        raise
       end
-    end
-    admin_unauthorized_client.close
 
-    # Adds the test user to the test database with permissions on all
-    # databases that will be used in the test suite.
-    create_user(admin_authorized_test_client, SpecConfig.instance.test_user)
-    admin_authorized_test_client.close
+      # Adds the test user to the test database with permissions on all
+      # databases that will be used in the test suite.
+      create_user(client, SpecConfig.instance.test_user)
+    end
   end
 
   def create_user(client, user)
-    users = client.database.users
+    users = client.use('admin').database.users
     begin
       users.create(user)
     rescue Mongo::Error::OperationFailure => e
@@ -56,11 +71,13 @@ class SpecSetup
     end
   end
 
-  def admin_unauthorized_client
-    ClientRegistry.instance.global_client('admin_unauthorized')
-  end
-
-  def admin_authorized_test_client
-    ClientRegistry.instance.global_client('root_authorized')
+  def with_client(&block)
+    Mongo::Client.new(
+      SpecConfig.instance.addresses,
+      SpecConfig.instance.all_test_options.merge(
+        socket_timeout: 5, connect_timeout: 5,
+      ),
+      &block
+    )
   end
 end