mongo 2.13.1 → 2.19.1

data/spec/support/utils.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 autoload :Base64, 'base64'
 autoload :JSON, 'json'
 module Net
@@ -5,13 +7,26 @@ module Net
 end
 
 module Utils
+  extend self
+
+  # Used by #yamlify_command_events
+  MAP_REDUCE_COMMANDS = %w[ map reduce ].freeze
+
+  # Used by #yamlify_command_events
+  AUTHENTICATION_COMMANDS = %w[ saslStart saslContinue authenticate getnonce ].freeze
+
+  # The system command to invoke to represent a false result
+  BIN_FALSE = File.executable?('/bin/false') ? '/bin/false' : 'false'
+
+  # The system command to invoke to represent a true result
+  BIN_TRUE  = File.executable?('/bin/true') ? '/bin/true' : 'true'
+
   # Converts a 'camelCase' string or symbol to a :under_score symbol.
   def underscore(str)
     str = str.to_s
     str = str[0].downcase + str[1...str.length].gsub(/([A-Z]+)/) { |m| "_#{m.downcase}" }
     str.to_sym
   end
-  module_function :underscore
 
   # Creates a copy of a hash where all keys and string values are converted to
   # snake-case symbols.
@@ -27,24 +42,50 @@ module Utils
       end
     end
   end
-  module_function :underscore_hash
 
   # Creates a copy of a hash where all keys and string values are converted to
   # snake-case symbols.
   #
   # For example, { 'fooBar' => { 'baz' => 'bingBing', :x => 1 } } converts to
   # { :foo_bar => { :baz => :bing_bing, :x => 1 } }.
-  def snakeize_hash(value)
-    return underscore(value) if value.is_a?(String)
+  def shallow_underscore_hash(value)
     return value unless value.is_a?(Hash)
 
     value.reduce({}) do |hash, (k, v)|
       hash.tap do |h|
-        h[underscore(k)] = snakeize_hash(v)
+        h[underscore(k)] = v
+      end
+    end
+  end
+
+  # Creates a copy of a hash where all keys and string values are converted to
+  # snake-case symbols.
+  #
+  # For example, { 'fooBar' => { 'baz' => 'bingBing', :x => 1 } } converts to
+  # { :foo_bar => { :baz => :bing_bing, :x => 1 } }.
+  def snakeize_hash(value)
+    return underscore(value) if value.is_a?(String)
+
+    case value
+    when Array
+      value.map do |sub|
+        case sub
+        when Hash
+          snakeize_hash(sub)
+        else
+          sub
+        end
+      end
+    when Hash
+      value.reduce({}) do |hash, (k, v)|
+        hash.tap do |h|
+          h[underscore(k)] = snakeize_hash(v)
+        end
       end
+    else
+      value
     end
   end
-  module_function :snakeize_hash
 
   # Like snakeize_hash but does not recurse.
   def shallow_snakeize_hash(value)
@@ -57,7 +98,6 @@ module Utils
       end
     end
   end
-  module_function :shallow_snakeize_hash
 
   # Creates a copy of a hash where all keys and symbol values are converted to
   # camel-case strings.
@@ -74,18 +114,18 @@ module Utils
       end
     end
   end
-  module_function :camelize_hash
 
   def camelize(str, upcase_first = false)
-    str = str.gsub(%r,_(\w),) { |m| m[1].upcase }
-    if upcase_first
-      str = str[0].upcase + str[1...str.length]
-    end
+    str = str.gsub(/_(\w)/) { |m| m[1].upcase }
+    str = str[0].upcase + str[1...str.length] if upcase_first
     str
   end
-  module_function :camelize
 
-  module_function def disable_retries_client_options
+  def downcase_keys(hash)
+    hash.transform_keys(&:downcase)
+  end
+
+  def disable_retries_client_options
     {
       retry_reads: false,
       retry_writes: false,
@@ -97,75 +137,33 @@ module Utils
   # Converts camel case clientOptions, as used in spec tests,
   # to Ruby driver underscore options.
   def convert_client_options(spec_test_options)
-    uri = Mongo::URI.new('mongodb://localhost')
-    spec_test_options.reduce({}) do |opts, (name, value)|
+    mapper = Mongo::URI::OptionsMapper.new
+    spec_test_options.each_with_object({}) do |(name, value), opts|
       if name == 'autoEncryptOpts'
-        opts.merge!(
-          auto_encryption_options: convert_auto_encryption_client_options(value)
-            .merge(
-              # Spawn mongocryptd on non-default port for sharded cluster tests
-              extra_options: {
-                mongocryptd_spawn_args: ["--port=#{SpecConfig.instance.mongocryptd_port}"],
-                mongocryptd_uri: "mongodb://localhost:#{SpecConfig.instance.mongocryptd_port}",
-              }
-            )
-        )
+        auto_encryption_options = convert_auto_encryption_client_options(value)
+        opts[:auto_encryption_options] = auto_encryption_options
       else
-        uri.send(:add_uri_option, name, value.to_s, opts)
+        mapper.add_uri_option(name, value.to_s, opts)
       end
 
       opts
     end
   end
-  module_function :convert_client_options
-
-  private def convert_auto_encryption_client_options(opts)
-    auto_encrypt_opts = Utils.snakeize_hash(opts)
-
-    if opts['kmsProviders']['aws']
-      # The tests require that AWS credentials be filled in by the driver.
-      auto_encrypt_opts[:kms_providers][:aws] = {
-        access_key_id: SpecConfig.instance.fle_aws_key,
-        secret_access_key: SpecConfig.instance.fle_aws_secret,
-      }
-    end
-
-    if opts['kmsProviders']['local']
-      auto_encrypt_opts[:kms_providers][:local] = {
-        key: BSON::ExtJSON.parse_obj(opts['kmsProviders']['local']['key']).data
-      }
-    end
-
-    if opts['keyVaultNamespace']
-      auto_encrypt_opts[:key_vault_namespace] = opts['keyVaultNamespace']
-    else
-      auto_encrypt_opts[:key_vault_namespace] = 'admin.datakeys'
-    end
-
-    if opts['schemaMap']
-      auto_encrypt_opts[:schema_map] = BSON::ExtJSON.parse_obj(opts['schemaMap'])
-    end
-
-    auto_encrypt_opts
-  end
-  module_function :convert_auto_encryption_client_options
 
   def order_hash(hash)
-    Hash[hash.to_a.sort]
+    hash.to_a.sort.to_h
   end
-  module_function :order_hash
 
   # Transforms an array of CommandStarted events to an array of hashes
   # matching event specification in YAML spec files
+  # rubocop:disable Metrics, Style/IfUnlessModifier
   def yamlify_command_events(events)
     events = events.map do |e|
       command = e.command.dup
 
       # Fake BSON::Code for map/reduce commands
-      %w(map reduce).each do |key|
-        if command[key].is_a?(String)
-          command[key] = BSON::Code.new(command[key])
-        end
+      MAP_REDUCE_COMMANDS.each do |key|
+        command[key] = BSON::Code.new(command[key]) if command[key].is_a?(String)
       end
 
       if command['readConcern']
@@ -190,14 +188,13 @@ module Utils
       command['getMore'] = command['getMore'].class.new(42) if command['getMore']
 
       # Remove fields if empty
-      #command.delete('filter') if command['filter'] && command['filter'].empty?
       command.delete('query') if command['query'] && command['query'].empty?
 
       {
         'command_started_event' => order_hash(
           'command' => order_hash(command),
           'command_name' => e.command_name.to_s,
-          'database_name' => e.database_name,
+          'database_name' => e.database_name
         )
       }
     end
@@ -205,79 +202,74 @@ module Utils
     # Remove any events from authentication commands.
     events.reject! do |e|
       command_name = e['command_started_event']['command_name']
-      %w(saslStart saslContinue authenticate getnonce).include?(command_name)
+      AUTHENTICATION_COMMANDS.include?(command_name)
     end
 
     events
   end
-  module_function :yamlify_command_events
+  # rubocop:enable Metrics, Style/IfUnlessModifier
 
+  # rubocop:disable Metrics
   def convert_operation_options(options)
     if options
-      Hash[options.map do |k, v|
-        out_v = case k
-        when 'readPreference'
-          out_k = :read
-          out_v = {}
-          v.each do |sub_k, sub_v|
-            if sub_k == 'mode'
-              out_v[:mode] = Utils.underscore(v['mode'])
-            else
-              out_v[sub_k.to_sym] = sub_v
+      options.map do |k, v|
+        out_v =
+          case k
+          when 'readPreference'
+            out_k = :read
+            out_v = {}
+            v.each do |sub_k, sub_v|
+              if sub_k == 'mode'
+                out_v[:mode] = Utils.underscore(v['mode'])
+              else
+                out_v[sub_k.to_sym] = sub_v
+              end
             end
-          end
-          out_v
-        when 'defaultTransactionOptions'
-          out_k = Utils.underscore(k).to_sym
-          convert_operation_options(v)
-        when 'readConcern'
-          out_k = Utils.underscore(k).to_sym
-          Mongo::Options::Mapper.transform_keys_to_symbols(v).tap do |out|
-            if out[:level]
-              out[:level] = out[:level].to_sym
+            out_v
+          when 'defaultTransactionOptions'
+            out_k = Utils.underscore(k).to_sym
+            convert_operation_options(v)
+          when 'readConcern'
+            out_k = Utils.underscore(k).to_sym
+            Mongo::Options::Mapper.transform_keys_to_symbols(v).tap do |out|
+              out[:level] = out[:level].to_sym if out[:level]
             end
-          end
-        when 'causalConsistency'
-          out_k = Utils.underscore(k).to_sym
-          v
-        when 'writeConcern'
-          if v == {}
+          when 'causalConsistency'
+            out_k = Utils.underscore(k).to_sym
+            v
+          when 'writeConcern'
             # Tests added in SPEC-1352 specify {writeConcern: {}} but what
             # they mean is for the driver to use the default write concern,
             # which for Ruby means no write concern is specified at all.
             #
             # This nil return requires the compact call below to get rid of
             # the nils before outgoing options are constructed.
-            next nil
-          else
+            next nil if v == {}
+
             # Write concern option is called :write on the client, but
             # :write_concern on all levels below the client.
             out_k = :write_concern
             # The client expects write concern value to only have symbol keys.
-            Hash[v.map do |sub_k, sub_v|
-              [sub_k.to_sym, sub_v]
-            end]
+            v.transform_keys(&:to_sym)
+          else
+            raise "Unhandled operation option #{k}"
           end
-        else
-          raise "Unhandled operation option #{k}"
-        end
-        [out_k, out_v]
-      end.compact]
+        [ out_k, out_v ]
+      end.compact.to_h
     else
       {}
     end
   end
-  module_function :convert_operation_options
+  # rubocop:enable Metrics
 
   def int64_value(value)
     if value.respond_to?(:value)
       # bson-ruby >= 4.6.0
       value.value
     else
-      value.instance_variable_get('@integer')
+      value.instance_variable_get(:@integer)
     end
   end
-  module_function :int64_value
 
   URI_OPTION_MAP = {
     app_name: 'appName',
@@ -289,17 +281,14 @@ module Utils
     ssl_key: 'tlsCertificateKeyFile',
   }.freeze
 
-  module_function def create_mongodb_uri(address_strs, **opts)
-    creds = if opts[:username]
-      "#{opts[:username]}:#{opts[:password]}@"
-    else
-      ''
-    end
-    uri = "mongodb://#{creds}#{address_strs.join(',')}/"
-    if opts[:database]
-      uri << opts[:database]
-    end
-    if uri_options = opts[:uri_options]
+  # rubocop:disable Metrics
+  def create_mongodb_uri(address_strs, **opts)
+    creds = opts[:username] ? "#{opts[:username]}:#{opts[:password]}@" : ''
+
+    uri = +"mongodb://#{creds}#{address_strs.join(',')}/"
+    uri << opts[:database] if opts[:database]
+
+    if (uri_options = opts[:uri_options])
       uri << '?'
 
       uri_options.each do |k, v|
@@ -307,17 +296,14 @@ module Utils
 
         write_k = URI_OPTION_MAP[k] || k
 
-        if k == :compressors
+        case k
+        when :compressors
           write_v = v.join(',')
-        elsif k == :auth_mech
-          if v
-            write_v = Mongo::URI::AUTH_MECH_MAP.key(v)
-            unless write_v
-              raise "Unhandled auth mech value: #{v}"
-            end
-          else
-            next
-          end
+        when :auth_mech
+          next unless v
+
+          write_v = Mongo::URI::AUTH_MECH_MAP.key(v)
+          raise "Unhandled auth mech value: #{v}" unless write_v
         else
           write_v = v
         end
@@ -328,11 +314,13 @@ module Utils
 
     uri
   end
+  # rubocop:enable Metrics
 
   # Client-Side encryption tests introduce the $$type syntax for determining
   # equality in command started events. The $$type key specifies which type of
   # BSON object is expected in the result. If the $$type key is present, only
   # check the class of the result.
+  # rubocop:disable Metrics
   def match_with_type?(expected, actual)
     if expected.is_a?(Hash) && expected.key?('$$type')
       case expected['$$type']
@@ -348,14 +336,13 @@ module Utils
 
       actual.is_a?(expected_class) || actual.key?(expected_key)
     elsif expected.is_a?(Hash) && actual.is_a?(Hash)
-      same_keys = (expected.keys - actual.keys).empty? &&
-        (actual.keys - expected.keys).empty?
+      has_all_keys = (expected.keys - actual.keys).empty?
 
       same_values = expected.keys.all? do |key|
         match_with_type?(expected[key], actual[key])
       end
 
-      same_keys && same_values
+      has_all_keys && same_values
     elsif expected.is_a?(Array) && actual.is_a?(Array)
       same_length = expected.length == actual.length
 
@@ -370,46 +357,72 @@ module Utils
       expected == actual
     end
   end
-  module_function :match_with_type?
+  # rubocop:enable Metrics
+
+  # Takes a timeout and a block. Waits up to the specified timeout until
+  # the value of the block is true. If timeout is reached, this method
+  # returns normally and does not raise an exception. The block is invoked
+  # every second or so.
+  def wait_for_condition(timeout)
+    deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
+    loop do
+      break if yield ||
+               Process.clock_gettime(Process::CLOCK_MONOTONIC) > deadline
+
+      sleep 1
+    end
+  end
 
-  module_function def get_ec2_metadata_token(ttl: 30, http: nil)
+  def ensure_port_free(port)
+    TCPServer.open(port) do
+      # Nothing
+    end
+  end
+
+  def wait_for_port_free(port, timeout)
+    wait_for_condition(timeout) do
+      ensure_port_free(port)
+      true
+    rescue Errno::EADDRINUSE
+      false
+    end
+  end
+
+  def get_ec2_metadata_token(ttl: 30, http: nil)
     http ||= Net::HTTP.new('169.254.169.254')
+    # The TTL is required in order to obtain the metadata token.
     req = Net::HTTP::Put.new('/latest/api/token',
-      # The TTL is required in order to obtain the metadata token.
-      {'x-aws-ec2-metadata-token-ttl-seconds' => ttl.to_s})
+                             { 'x-aws-ec2-metadata-token-ttl-seconds' => ttl.to_s })
     resp = http.request(req)
-    if resp.code != '200'
-      raise "Metadata token request failed: #{e.class}: #{e}"
-    end
+    raise "Metadata token request failed: #{e.class}: #{e}" if resp.code != '200'
+
     resp.body
   end
 
-  module_function def ec2_instance_id
+  def ec2_instance_id
     http = Net::HTTP.new('169.254.169.254')
     metadata_token = get_ec2_metadata_token(http: http)
     req = Net::HTTP::Get.new('/latest/dynamic/instance-identity/document',
-      {'x-aws-ec2-metadata-token' => metadata_token})
+                             { 'x-aws-ec2-metadata-token' => metadata_token })
     resp = http.request(req)
     payload = JSON.parse(resp.body)
     payload.fetch('instanceId')
   end
 
-  module_function def ec2_instance_profile
+  def ec2_instance_profile
     http = Net::HTTP.new('169.254.169.254')
     metadata_token = get_ec2_metadata_token(http: http)
     req = Net::HTTP::Get.new('/latest/meta-data/iam/info',
-      {'x-aws-ec2-metadata-token' => metadata_token})
+                             { 'x-aws-ec2-metadata-token' => metadata_token })
     resp = http.request(req)
-    if resp.code == '404'
-      nil
-    else
-      payload = JSON.parse(resp.body)
-      payload['InstanceProfileArn']
-    end
+    return nil if resp.code == '404'
+
+    payload = JSON.parse(resp.body)
+    payload['InstanceProfileArn']
   end
 
-  module_function def wait_for_instance_profile
-    deadline = Time.now + 15
+  def wait_for_instance_profile
+    deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + 15
     loop do
       begin
         ip = ec2_instance_profile
@@ -417,52 +430,54 @@ module Utils
           puts "Instance profile assigned: #{ip}"
           break
         end
-      rescue => e
+      rescue StandardError => e
         puts "Problem retrieving instance profile: #{e.class}: #{e}"
       end
-      if Time.now >= deadline
+
+      if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
         raise 'Instance profile did not get assigned in 15 seconds'
       end
+
       sleep 3
     end
   end
 
-  module_function def wait_for_no_instance_profile
-    deadline = Time.now + 15
+  def wait_for_no_instance_profile
+    deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + 15
     loop do
       begin
         ip = ec2_instance_profile
         if ip.nil?
-          puts "Instance profile cleared"
+          puts 'Instance profile cleared'
           break
         end
-      rescue => e
+      rescue StandardError => e
         puts "Problem retrieving instance profile: #{e.class}: #{e}"
       end
-      if Time.now >= deadline
+
+      if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
         raise 'Instance profile did not get cleared in 15 seconds'
       end
+
       sleep 3
     end
   end
 
-  module_function def wrap_forked_child
-    begin
-      yield
-    rescue => e
-      STDERR.puts "Failing process #{Process.pid} due to #{e.class}: #{e}"
-      exec('/bin/false')
-    else
-      # Exec so that we do not close any clients etc. in the child.
-      exec('/bin/true')
-    end
+  def wrap_forked_child
+    yield
+  rescue StandardError => e
+    warn "Failing process #{Process.pid} due to #{e.class}: #{e}"
+    exec(BIN_FALSE)
+  else
+    # Exec so that we do not close any clients etc. in the child.
+    exec(BIN_TRUE)
   end
 
-  module_function def subscribe_all(client, subscriber)
+  def subscribe_all(client, subscriber)
     subscribe_all_sdam_proc(subscriber).call(client)
   end
 
-  module_function def subscribe_all_sdam_proc(subscriber)
+  def subscribe_all_sdam_proc(subscriber)
     lambda do |client|
       client.subscribe(Mongo::Monitoring::TOPOLOGY_OPENING, subscriber)
       client.subscribe(Mongo::Monitoring::SERVER_OPENING, subscriber)
@@ -483,8 +498,8 @@ module Utils
   # specified client, invokes the passed block, asserts there is exactly one
   # command event published, asserts the command event published has the
   # specified command name, and returns the published event.
-  module_function def get_command_event(client, command_name, include_auth: false)
-    subscriber = EventSubscriber.new
+  def get_command_event(client, command_name, include_auth: false)
+    subscriber = Mrss::EventSubscriber.new
     client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
     begin
       yield client
@@ -494,4 +509,170 @@ module Utils
 
     subscriber.single_command_started_event(command_name, include_auth: include_auth)
   end
+
+  # Drops and creates a collection for the purpose of starting the test from
+  # a clean slate.
+  #
+  # @param [ Mongo::Client ] client
+  # @param [ String ] collection_name
+  def create_collection(client, collection_name)
+    client[collection_name].drop
+    client[collection_name].create
+  end
+
+  # If the deployment is a sharded cluster, creates a direct client
+  # to each of the mongos nodes and yields each in turn to the
+  # provided block. Does nothing in other topologies.
+  # rubocop:disable Metrics
+  def mongos_each_direct_client
+    return unless ClusterConfig.instance.topology == :sharded
+
+    client = ClientRegistry.instance.global_client('basic')
+    client.cluster.next_primary
+    client.cluster.servers.each do |server|
+      direct_client = ClientRegistry.instance.new_local_client(
+        [ server.address.to_s ],
+        SpecConfig.instance.test_options.merge(
+          connect: :sharded
+        ).merge(SpecConfig.instance.auth_options)
+      )
+      yield direct_client
+      direct_client.close
+    end
+  end
+  # rubocop:enable Metrics
+
+  # rubocop:disable Metrics
+  def permitted_yaml_classes
+    @permitted_yaml_classes ||= [
+      BigDecimal,
+      Date,
+      Time,
+      Range,
+      Regexp,
+      Symbol,
+      BSON::Binary,
+      BSON::Code,
+      BSON::CodeWithScope,
+      BSON::DbPointer,
+      BSON::Decimal128,
+      BSON::Int32,
+      BSON::Int64,
+      BSON::MaxKey,
+      BSON::MinKey,
+      BSON::ObjectId,
+      BSON::Regexp::Raw,
+      BSON::Symbol::Raw,
+      BSON::Timestamp,
+      BSON::Undefined,
+    ].freeze
+  end
+  # rubocop:enable Metrics
+
+  def load_spec_yaml_file(path)
+    if RUBY_VERSION < '2.6'
+      YAML.safe_load(File.read(path), permitted_yaml_classes, [], true)
+    else
+      # Here we have Ruby 2.6+ that supports the new syntax of `safe_load``.
+      YAML.safe_load(File.read(path), permitted_classes: permitted_yaml_classes, aliases: true)
+    end
+  end
+
+  private
+
+  def convert_auto_encryption_client_options(opts)
+    auto_encrypt_opts = Utils.snakeize_hash(opts)
+
+    _apply_kms_providers(opts, auto_encrypt_opts)
+
+    _apply_key_vault_namespace(opts, auto_encrypt_opts)
+    _apply_schema_map(opts, auto_encrypt_opts)
+    _apply_encrypted_fields_map(opts, auto_encrypt_opts)
+
+    auto_encrypt_opts.merge!(extra_options: convert_auto_encryption_extra_options(auto_encrypt_opts))
+  end
+
+  def _apply_kms_provider_aws(opts, auto_encrypt_opts)
+    return unless opts['kmsProviders']['aws']
+
+    # The tests require that AWS credentials be filled in by the driver.
+    auto_encrypt_opts[:kms_providers][:aws] = {
+      access_key_id: SpecConfig.instance.fle_aws_key,
+      secret_access_key: SpecConfig.instance.fle_aws_secret,
+    }
+  end
+
+  def _apply_kms_providers(opts, auto_encrypt_opts)
+    _apply_kms_provider_aws(opts, auto_encrypt_opts)
+    _apply_kms_provider_azure(opts, auto_encrypt_opts)
+    _apply_kms_provider_gcp(opts, auto_encrypt_opts)
+    _apply_kms_provider_local(opts, auto_encrypt_opts)
+  end
+
+  def _apply_kms_provider_azure(opts, auto_encrypt_opts)
+    return unless opts['kmsProviders']['azure']
+
+    # The tests require that Azure credentials be filled in by the driver.
+    auto_encrypt_opts[:kms_providers][:azure] = {
+      tenant_id: SpecConfig.instance.fle_azure_tenant_id,
+      client_id: SpecConfig.instance.fle_azure_client_id,
+      client_secret: SpecConfig.instance.fle_azure_client_secret,
+    }
+  end
+
+  def _apply_kms_provider_gcp(opts, auto_encrypt_opts)
+    return unless opts['kmsProviders']['gcp']
+
+    # The tests require that GCP credentials be filled in by the driver.
+    auto_encrypt_opts[:kms_providers][:gcp] = {
+      email: SpecConfig.instance.fle_gcp_email,
+      private_key: SpecConfig.instance.fle_gcp_private_key,
+    }
+  end
+
+  def _apply_kms_provider_local(opts, auto_encrypt_opts)
+    return unless opts['kmsProviders']['local']
+
+    auto_encrypt_opts[:kms_providers][:local] = {
+      key: BSON::ExtJSON.parse_obj(opts['kmsProviders']['local']['key']).data
+    }
+  end
+
+  def _apply_key_vault_namespace(opts, auto_encrypt_opts)
+    auto_encrypt_opts[:key_vault_namespace] =
+      opts['keyVaultNamespace'] || 'keyvault.datakeys'
+  end
+
+  def _apply_schema_map(opts, auto_encrypt_opts)
+    return unless opts['schemaMap']
+
+    auto_encrypt_opts[:schema_map] = BSON::ExtJSON.parse_obj(opts['schemaMap'])
+  end
+
+  def _apply_encrypted_fields_map(opts, auto_encrypt_opts)
+    return unless opts['encryptedFieldsMap']
+
+    auto_encrypt_opts[:encrypted_fields_map] = BSON::ExtJSON.parse_obj(opts['encryptedFieldsMap'])
+  end
+
+  # rubocop:disable Metrics
+  def convert_auto_encryption_extra_options(opts)
+    # Spawn mongocryptd on non-default port for sharded cluster tests
+    extra_options = {
+      mongocryptd_spawn_args: [ "--port=#{SpecConfig.instance.mongocryptd_port}" ],
+      mongocryptd_uri: "mongodb://localhost:#{SpecConfig.instance.mongocryptd_port}"
+    }.merge(opts[:extra_options] || {})
+
+    # if bypass_query_analysis has been explicitly specified, then we ignore
+    # any requirement to use the shared library, as the two are not
+    # compatible.
+    if SpecConfig.instance.crypt_shared_lib_required && !opts[:bypass_query_analysis]
+      extra_options[:crypt_shared_lib_required] = SpecConfig.instance.crypt_shared_lib_required
+      extra_options[:crypt_shared_lib_path] = SpecConfig.instance.crypt_shared_lib_path
+      extra_options[:mongocryptd_uri] = 'mongodb://localhost:27777'
+    end
+
+    extra_options
+  end
+  # rubocop:enable Metrics
 end