bson 5.0.0 → 5.0.2

data/spec/shared/lib/mrss/lite_constraints.rb

@@ -1,238 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-module Mrss
-  module LiteConstraints
-
-    # Constrain tests that use TimeoutInterrupt to MRI (and Unix).
-    def require_mri
-      before(:all) do
-        unless SpecConfig.instance.mri?
-          skip "MRI required, we have #{SpecConfig.instance.platform}"
-        end
-      end
-    end
-
-    def require_jruby
-      before(:all) do
-        unless BSON::Environment.jruby?
-          skip "JRuby required, we have #{SpecConfig.instance.platform}"
-        end
-      end
-    end
-
-    # This is for marking tests that fail on JRuby that should
-    # in principle work (as opposed to being fundamentally incompatible
-    # with JRuby).
-    # Often times these failures happen only in Evergreen.
-    def fails_on_jruby(version=nil)
-      before(:all) do
-        if BSON::Environment.jruby?
-          if version
-            min_parts = version.split('.').map(&:to_i)
-            actual_parts = JRUBY_VERSION.split('.').map(&:to_i)[0...min_parts.length]
-            actual = actual_parts.join('.')
-            if actual <= version
-              skip "Fails on jruby through #{version}"
-            end
-          else
-            skip "Fails on jruby"
-          end
-        end
-      end
-    end
-
-    # Indicates that the respective test uses the internet in some capacity,
-    # for example the test resolves SRV DNS records.
-    def require_external_connectivity
-      before(:all) do
-        if ENV['EXTERNAL_DISABLED']
-          skip "Test requires external connectivity"
-        end
-      end
-    end
-
-    def require_mongo_kerberos
-      before(:all) do
-        # TODO Use a more generic environment variable name if/when
-        # Mongoid tests get Kerberos configurations.
-        unless %w(1 yes true).include?(ENV['MONGO_RUBY_DRIVER_KERBEROS']&.downcase)
-          skip 'Set MONGO_RUBY_DRIVER_KERBEROS=1 in environment to run Kerberos unit tests'
-        end
-        require 'mongo_kerberos'
-      end
-    end
-
-    def require_linting
-      before(:all) do
-        unless Mongo::Lint.enabled?
-          skip "Linting is not enabled"
-        end
-      end
-    end
-
-    # Some tests will fail if linting is enabled:
-    # 1. Tests that pass invalid options to client, etc. which the linter
-    #    rejects.
-    # 2. Tests that set expectations on topologies, server descriptions, etc.
-    #    (since setting expectations requires mutating said objects, and when
-    #    linting is on those objects are frozen).
-    def require_no_linting
-      before(:all) do
-        if Mongo::Lint.enabled?
-          skip "Linting is enabled"
-        end
-      end
-    end
-
-    def require_libmongocrypt
-      before(:all) do
-        # If FLE is set in environment, the entire test run is supposed to
-        # include FLE therefore run the FLE tests.
-        if (ENV['LIBMONGOCRYPT_PATH'] || '').empty? && (ENV['FLE'] || '').empty?
-          skip 'Test requires path to libmongocrypt to be specified in LIBMONGOCRYPT_PATH env variable'
-        end
-      end
-    end
-
-    def min_libmongocrypt_version(version)
-      require_libmongocrypt
-      before(:all) do
-        actual_version = Utils.parse_version(Mongo::Crypt::Binding.mongocrypt_version(nil))
-        min_version = Utils.parse_version(version)
-        unless actual_version >= min_version
-          skip "libmongocrypt version #{min_version} required, but version #{actual_version} is available"
-        end
-      end
-    end
-
-    def require_no_libmongocrypt
-      before(:all) do
-        if ENV['LIBMONGOCRYPT_PATH']
-          skip 'Test requires libmongocrypt to not be configured'
-        end
-      end
-    end
-
-    def require_aws_auth
-      before(:all) do
-        unless (ENV['AUTH'] || '') =~ /^aws/
-          skip 'This test requires AUTH=aws* and an appropriately configured runtime environment'
-        end
-      end
-    end
-
-    def require_ec2_host
-      before(:all) do
-        if $have_aws.nil?
-          $have_aws = begin
-            require 'open-uri'
-            begin
-              Timeout.timeout(3.81) do
-                URI.parse('http://169.254.169.254/latest/meta-data/profile').open.read
-              end
-              true
-            # When trying to use the EC2 metadata endpoint on ECS:
-            # Errno::EINVAL: Failed to open TCP connection to 169.254.169.254:80 (Invalid argument - connect(2) for "169.254.169.254" port 80)
-            rescue Timeout::Error, Errno::ETIMEDOUT, Errno::EINVAL, OpenURI::HTTPError => $aws_error
-              false
-            end
-          end
-        end
-        unless $have_aws
-          skip "EC2 instance metadata is not available - assuming not running on an EC2 instance: #{$aws_error.class}: #{$aws_error}"
-        end
-      end
-    end
-
-    def require_stress
-      before(:all) do
-        if !SpecConfig.instance.stress?
-          skip 'Set STRESS=1 in environment to run stress tests'
-        end
-      end
-    end
-
-    def require_fork
-      before(:all) do
-        if !SpecConfig.instance.fork?
-          skip 'Set FORK=1 in environment to run fork tests'
-        end
-      end
-    end
-
-    def require_ocsp
-      before(:all) do
-        if !SpecConfig.instance.ocsp?
-          skip 'Set OCSP=1 in environment to run OCSP tests'
-        end
-      end
-    end
-
-    def require_ocsp_verifier
-      before(:all) do
-        if !SpecConfig.instance.ocsp_verifier?
-          skip 'Set OCSP_VERIFIER=1 in environment to run OCSP verifier tests'
-        end
-      end
-    end
-
-    def require_ocsp_connectivity
-      before(:all) do
-        if !SpecConfig.instance.ocsp_connectivity?
-          skip 'Set OCSP_CONNECTIVITY=pass or OCSP_CONNECTIVITY=fail in environment to run OCSP connectivity tests'
-        end
-      end
-    end
-
-    def require_active_support
-      before(:all) do
-        if !SpecConfig.instance.active_support?
-          skip 'This test requires ActiveSupport; set WITH_ACTIVE_SUPPORT=1 in environment'
-        end
-      end
-    end
-
-    def no_active_support
-      before(:all) do
-        if SpecConfig.instance.active_support?
-          skip 'This test requires no ActiveSupport; unset WITH_ACTIVE_SUPPORT in environment'
-        end
-      end
-    end
-
-    def require_fallbacks
-      before(:all) do
-        unless %w(yes true 1).include?((ENV['TEST_I18N_FALLBACKS'] || '').downcase)
-          skip 'Set TEST_I18N_FALLBACKS=1 environment variable to run these tests'
-        end
-      end
-    end
-
-    def require_no_fallbacks
-      before(:all) do
-        if %w(yes true 1).include?((ENV['TEST_I18N_FALLBACKS'] || '').downcase)
-          skip 'Set TEST_I18N_FALLBACKS=0 environment variable to run these tests'
-        end
-      end
-    end
-
-    # This is a macro for retrying flaky tests on CI that occasionally fail.
-    # Note that the tests will only be retried on CI.
-    #
-    # @param [ Integer ] :tries The number of times to retry.
-    # @param [ Integer ] :sleep The number of seconds to sleep in between retries.
-    #   If nothing, or nil, is passed, we won't wait in between retries.
-    def retry_test(tries: 3, sleep: nil)
-      if %w(1 yes true).include?(ENV['CI'])
-        around do |example|
-          if sleep
-            example.run_with_retry retry: tries, retry_wait: sleep
-          else
-            example.run_with_retry retry: tries
-          end
-        end
-      end
-    end
-  end
-end

data/spec/shared/lib/mrss/server_version_registry.rb

@@ -1,113 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-autoload :JSON, 'json'
-require 'open-uri'
-
-module Mrss
-  class ServerVersionRegistry
-    class Error < StandardError
-    end
-
-    class UnknownVersion < Error
-    end
-
-    class MissingDownloadUrl < Error
-    end
-
-    class BrokenDownloadUrl < Error
-    end
-
-    def initialize(desired_version, arch)
-      @desired_version, @arch = desired_version, arch
-    end
-
-    attr_reader :desired_version, :arch
-
-    def target_arch
-      # can't use RbConfig::CONFIG["arch"] because JRuby doesn't
-      # return anything meaningful there.
-      #
-      # also, need to use `uname -a` instead of (e.g.) `uname -p`
-      # because debian (at least) does not return anything meaningful
-      # for `uname -p`.
-      uname = `uname -a`.strip
-      @target_arch ||= case uname
-        when /aarch/ then "aarch64"
-        when /x86/   then "x86_64"
-        else raise "unsupported architecture #{uname.inspect}"
-        end
-    end
-
-    def download_url
-      @download_url ||= begin
-        version, version_ok = detect_version(current_catalog)
-        if version.nil?
-          version, full_version_ok = detect_version(full_catalog)
-          version_ok ||= full_version_ok
-        end
-        if version.nil?
-          if version_ok
-            raise MissingDownloadUrl, "No downloads for version #{desired_version}"
-          else
-            raise UnknownVersion, "No version #{desired_version}"
-          end
-        end
-        dl = version['downloads'].detect do |dl|
-          dl['archive']['url'].index("enterprise-#{arch}") &&
-          dl['arch'] == target_arch
-        end
-        unless dl
-          raise MissingDownloadUrl, "No download for #{arch} for #{version['version']}"
-        end
-        url = dl['archive']['url']
-      end
-    end
-
-    private
-
-    def uri_open(*args)
-      if RUBY_VERSION < '2.5'
-        open(*args)
-      else
-        URI.open(*args)
-      end
-    end
-
-    def detect_version(catalog)
-      candidate_versions = catalog['versions'].select do |version|
-        version['version'].start_with?(desired_version) &&
-        !version['version'].include?('-')
-      end
-      version_ok = !candidate_versions.empty?
-      # Sometimes the download situation is borked and there is a release
-      # with no downloads... skip those.
-      version = candidate_versions.detect do |version|
-        !version['downloads'].empty?
-      end
-      # Allow RC releases if there isn't a GA release.
-      if version.nil?
-        candidate_versions = catalog['versions'].select do |version|
-          version['version'].start_with?(desired_version)
-        end
-        version_ok ||= !candidate_versions.empty?
-        version = candidate_versions.detect do |version|
-          !version['downloads'].empty?
-        end
-      end
-      [version, version_ok]
-    end
-
-    def current_catalog
-      @current_catalog ||= begin
-        JSON.load(uri_open('http://downloads.mongodb.org/current.json').read)
-      end
-    end
-
-    def full_catalog
-      @full_catalog ||= begin
-        JSON.load(uri_open('http://downloads.mongodb.org/full.json').read)
-      end
-    end
-  end
-end

data/spec/shared/lib/mrss/session_registry.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-require 'singleton'
-
-module Mrss
-
-  def self.patch_mongo_for_session_registry
-
-    Mongo::Client.class_eval do
-      alias :get_session_without_tracking :get_session
-
-      def get_session(options = {})
-        get_session_without_tracking(options).tap do |session|
-          SessionRegistry.instance.register(session) if session&.materialized?
-        end
-      end
-    end
-
-    Mongo::Session.class_eval do
-      alias :end_session_without_tracking :end_session
-
-      def end_session
-        SessionRegistry.instance.unregister(self)
-        end_session_without_tracking
-      end
-
-      alias :materialize_if_needed_without_tracking :materialize_if_needed
-
-      def materialize_if_needed
-        materialize_if_needed_without_tracking.tap do
-          SessionRegistry.instance.register(self)
-        end
-      end
-    end
-  end
-end
-
-module Mrss
-  class SessionRegistry
-    include Singleton
-
-    def initialize
-      @registry = {}
-    end
-
-    def register(session)
-      @registry[session.session_id] = session if session
-    end
-
-    def unregister(session)
-      return if session.ended? || !session.materialized?
-      @registry.delete(session.session_id)
-    end
-
-    def verify_sessions_ended!
-      @registry.delete_if { |_, session| session.ended? }
-
-      unless @registry.empty?
-        sessions = @registry.map { |_, session| session }
-        raise "Session registry contains live sessions: #{sessions.join(', ')}"
-      end
-    end
-
-    def clear_registry
-      @registry = {}
-    end
-  end
-end

data/spec/shared/lib/mrss/session_registry_legacy.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-require 'singleton'
-
-module Mrss
-
-  def self.patch_mongo_for_session_registry
-
-    Mongo::Client.class_eval do
-      alias :get_session_without_tracking :get_session
-
-      def get_session(options = {})
-        get_session_without_tracking(options).tap do |session|
-          SessionRegistry.instance.register(session)
-        end
-      end
-    end
-
-    Mongo::Session.class_eval do
-      alias :end_session_without_tracking :end_session
-
-      def end_session
-        SessionRegistry.instance.unregister(self)
-        end_session_without_tracking
-      end
-    end
-  end
-end
-
-module Mrss
-  class SessionRegistry
-    include Singleton
-
-    def initialize
-      @registry = {}
-    end
-
-    def register(session)
-      @registry[session.session_id] = session if session
-    end
-
-    def unregister(session)
-      @registry.delete(session.session_id) unless session.ended?
-    end
-
-    def verify_sessions_ended!
-      @registry.delete_if { |_, session| session.ended? }
-
-      unless @registry.empty?
-        sessions = @registry.map { |_, session| session }
-        raise "Session registry contains live sessions: #{sessions.join(', ')}"
-      end
-    end
-
-    def clear_registry
-      @registry = {}
-    end
-  end
-end

data/spec/shared/lib/mrss/spec_organizer.rb

@@ -1,179 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-autoload :JSON, 'json'
-autoload :FileUtils, 'fileutils'
-autoload :Find, 'find'
-
-module Mrss
-
-  autoload :ChildProcessHelper, 'mrss/child_process_helper'
-
-  # Organizes and runs all of the tests in the test suite in batches.
-  #
-  # Organizing the tests in batches serves two purposes:
-  #
-  # 1. This allows running unit tests before integration tests, therefore
-  #    in theory revealing failures quicker on average.
-  # 2. This allows running some tests that have high intermittent failure rate
-  #    in their own test process.
-  #
-  # This class aggregates RSpec results after the test runs.
-  class SpecOrganizer
-
-    class BucketsNotPrioritized < StandardError
-    end
-
-    def initialize(root: nil, classifiers:, priority_order:,
-      spec_root: nil, rspec_json_path: nil, rspec_all_json_path: nil,
-      randomize: false
-    )
-      @spec_root = spec_root || File.join(root, 'spec')
-      @classifiers = classifiers
-      @priority_order = priority_order
-      @rspec_json_path = rspec_json_path || File.join(root, 'tmp/rspec.json')
-      @rspec_all_json_path = rspec_all_json_path || File.join(root, 'tmp/rspec-all.json')
-      @randomize = !!randomize
-    end
-
-    attr_reader :spec_root, :classifiers, :priority_order
-    attr_reader :rspec_json_path, :rspec_all_json_path
-
-    def randomize?
-      @randomize
-    end
-
-    def seed
-      @seed ||= (rand * 100_000).to_i
-    end
-
-    def buckets
-      @buckets ||= {}.tap do |buckets|
-        Find.find(spec_root) do |path|
-          next unless File.file?(path)
-          next unless path =~ /_spec\.rb\z/
-          rel_path = path[(spec_root.length + 1)..path.length]
-
-          found = false
-          classifiers.each do |(regexp, category)|
-            if regexp =~ rel_path
-              buckets[category] ||= []
-              buckets[category] << File.join('spec', rel_path)
-              found = true
-              break
-            end
-          end
-
-          unless found
-            buckets[nil] ||= []
-            buckets[nil] << File.join('spec', rel_path)
-          end
-        end
-      end.freeze
-    end
-
-    def ordered_buckets
-      @ordered_buckets ||= {}.tap do |ordered_buckets|
-        buckets = self.buckets.dup
-        priority_order.each do |category|
-          files = buckets.delete(category)
-          ordered_buckets[category] = files
-        end
-
-        if files = buckets.delete(nil)
-          ordered_buckets[nil] = files
-        end
-
-        unless buckets.empty?
-          raise BucketsNotPrioritized, "Some buckets were not prioritized: #{buckets.keys.map(&:to_s).join(', ')}"
-        end
-      end.freeze
-    end
-
-    def run
-      run_buckets(*buckets.keys)
-    end
-
-    def run_buckets(*buckets)
-      FileUtils.rm_f(rspec_all_json_path)
-
-      buckets.each do |bucket|
-        if bucket && !self.buckets[bucket]
-          raise "Unknown bucket #{bucket}"
-        end
-      end
-      buckets = Hash[self.buckets.select { |k, v| buckets.include?(k) }]
-
-      failed = []
-
-      priority_order.each do |category|
-        if files = buckets.delete(category)
-          unless run_files(category, files)
-            failed << category
-          end
-        end
-      end
-      if files = buckets.delete(nil)
-        unless run_files('remaining', files)
-          failed << 'remaining'
-        end
-      end
-
-      unless buckets.empty?
-        raise "Some buckets were not executed: #{buckets.keys.map(&:to_s).join(', ')}"
-      end
-
-      if failed.any?
-        raise "The following buckets failed: #{failed.map(&:to_s).join(', ')}"
-      end
-    end
-
-    def run_files(category, paths)
-      puts "Running #{category.to_s.gsub('_', ' ')} tests"
-      FileUtils.rm_f(rspec_json_path)
-      cmd = %w(rspec) + paths
-      if randomize?
-        cmd += %W(--order rand:#{seed})
-      end
-
-      begin
-        puts "Running #{cmd.join(' ')}"
-        ChildProcessHelper.check_call(cmd)
-      ensure
-        if File.exist?(rspec_json_path)
-          if File.exist?(rspec_all_json_path)
-            merge_rspec_results
-          else
-            FileUtils.cp(rspec_json_path, rspec_all_json_path)
-          end
-        end
-      end
-
-      true
-    rescue ChildProcessHelper::SpawnError
-      false
-    end
-
-    def merge_rspec_results
-      all = JSON.parse(File.read(rspec_all_json_path))
-      new = JSON.parse(File.read(rspec_json_path))
-      all['examples'] += new.delete('examples')
-      new.delete('summary').each do |k, v|
-        all['summary'][k] += v
-      end
-      new.delete('version')
-      new.delete('summary_line')
-      # The spec organizer runs all buckets with the same seed, hence
-      # we can drop the seed from new results.
-      new.delete('seed')
-      unless new.empty?
-        raise "Unhandled rspec results keys: #{new.keys.join(', ')}"
-      end
-      # We do not merge summary lines, delete them from aggregated results
-      all.delete('summary_line')
-      File.open(rspec_all_json_path, 'w') do |f|
-        f << JSON.dump(all)
-      end
-    end
-  end
-end

data/spec/shared/lib/mrss/utils.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-module Mrss
-  module Utils
-    extend self
-
-    def print_backtrace(dest=STDERR)
-      raise
-    rescue => e
-      dest.puts e.backtrace.join("\n")
-    end
-
-    # Parses the given version string, accounting for suffix information that
-    # Gem::Version cannot successfully parse.
-    #
-    # @param [ String ] version the version to parse
-    #
-    # @return [ Gem::Version ] the parsed version
-    #
-    # @raise [ ArgumentError ] if the string cannot be parsed.
-    def parse_version(version)
-      Gem::Version.new(version)
-    rescue ArgumentError
-      match = version.match(/\A(?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+)?(-[A-Za-z\+\d]+)?\z/)
-      raise ArgumentError.new("Malformed version number string #{version}") if match.nil?
-
-      Gem::Version.new(
-        [
-          match[:major],
-          match[:minor],
-          match[:patch]
-        ].join('.')
-      )
-    end
-  end
-end