mongo 2.14.0.rc1 → 2.14.0

data/spec/support/child_process_helper.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-autoload :ChildProcess, 'childprocess'
-autoload :Tempfile, 'tempfile'
-
-module ChildProcessHelper
-  class SpawnError < StandardError; end
-
-  module_function def call(cmd, env: nil, cwd: nil)
-    process = ChildProcess.new(*cmd)
-    process.io.inherit!
-    if cwd
-      process.cwd = cwd
-    end
-    if env
-      env.each do |k, v|
-        process.environment[k.to_s] = v
-      end
-    end
-    process.start
-    process.wait
-    process
-  end
-
-  module_function def check_call(cmd, env: nil, cwd: nil)
-    process = call(cmd, env: env, cwd: cwd)
-    unless process.exit_code == 0
-      raise SpawnError, "Failed to execute: #{cmd}"
-    end
-  end
-
-  module_function def get_output(cmd, env: nil, cwd: nil)
-    process = ChildProcess.new(*cmd)
-    process.io.inherit!
-    if cwd
-      process.cwd = cwd
-    end
-    if env
-      env.each do |k, v|
-        process.environment[k.to_s] = v
-      end
-    end
-
-    output = ''
-    r, w = IO.pipe
-
-    begin
-      process.io.stdout = w
-      process.start
-      w.close
-
-      thread = Thread.new do
-        begin
-          loop do
-            output << r.readpartial(16384)
-          end
-        rescue EOFError
-        end
-      end
-
-      process.wait
-      thread.join
-    ensure
-      r.close
-    end
-
-    [process, output]
-  end
-
-  module_function def check_output(*args)
-    process, output = get_output(*args)
-    unless process.exit_code == 0
-      raise SpawnError,"Failed to execute: #{args}"
-    end
-    output
-  end
-end

data/spec/support/lite_constraints.rb

@@ -1,165 +0,0 @@
-module LiteConstraints
-  # Constrain tests that use TimeoutInterrupt to MRI (and Unix)
-  def only_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
-
-  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
-      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 do
-      unless Mongo::Lint.enabled?
-        skip "Linting is not enabled"
-      end
-    end
-  end
-
-  def require_libmongocrypt
-    before(:all) do
-      unless ENV['LIBMONGOCRYPT_PATH']
-        skip 'Test requires path to libmongocrypt to be specified in LIBMONGOCRYPT_PATH env variable'
-      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
-
-  # 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 skip_if_linting
-    before do
-      if Mongo::Lint.enabled?
-        skip "Linting is enabled"
-      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
-end

data/spec/support/spec_organizer.rb

@@ -1,129 +0,0 @@
-autoload :FileUtils, 'fileutils'
-autoload :Find, 'find'
-autoload :ChildProcessHelper, 'support/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
-  CLASSIFIERS = [
-    [%r,^mongo,, :unit],
-    [%r,^kerberos,, :unit],
-    [%r,^integration/sdam_error_handling,, :sdam_integration],
-    [%r,^integration/cursor_reaping,, :cursor_reaping],
-    [%r,^(atlas|integration),, :integration],
-    [%r,^spec_tests,, :spec],
-    [%r,^spec_tests/sdam_integration,, :spec_sdam_integration],
-  ]
-
-  RUN_PRIORITY = %i(unit
-    integration sdam_integration cursor_reaping
-    spec spec_sdam_integration
-  )
-
-  SPEC_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
-  ROOT = File.expand_path(File.join(SPEC_ROOT, '..'))
-  RSPEC_JSON_PATH = File.join(ROOT, 'tmp/rspec.json')
-  RSPEC_ALL_JSON_PATH = File.join(ROOT, 'tmp/rspec-all.json')
-
-  def run
-    FileUtils.rm_f(RSPEC_ALL_JSON_PATH)
-
-    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] << rel_path
-          found = true
-          break
-        end
-      end
-
-      unless found
-        buckets[nil] ||= []
-        buckets[nil] << rel_path
-      end
-    end
-
-    failed = []
-
-    RUN_PRIORITY.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)
-    paths = paths.map do |path|
-      File.join('spec', path)
-    end
-
-    puts "Running #{category.to_s.gsub('_', ' ')} tests"
-    FileUtils.rm_f(RSPEC_JSON_PATH)
-    cmd = %w(rspec) + paths
-
-    begin
-      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')
-    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