mongoid 7.2.0.rc1 → 7.3.0

data/spec/support/child_process_helper.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-gem 'childprocess'
-require 'childprocess'
-require '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 "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 "Failed to execute: #{args}"
-    end
-    output
-  end
-end

data/spec/support/cluster_config.rb

@@ -1,158 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-require 'singleton'
-
-class ClusterConfig
-  include Singleton
-
-  def single_server?
-    determine_cluster_config
-    @single_server
-  end
-
-  def replica_set_name
-    determine_cluster_config
-    @replica_set_name
-  end
-
-  def server_version
-    determine_cluster_config
-    @server_version
-  end
-
-  def short_server_version
-    server_version.split('.')[0..1].join('.')
-  end
-
-  def fcv
-    determine_cluster_config
-    @fcv
-  end
-
-  # Per https://jira.mongodb.org/browse/SERVER-39052, working with FCV
-  # in sharded topologies is annoying. Also, FCV doesn't exist in servers
-  # less than 3.4. This method returns FCV on 3.4+ servers when in single
-  # or RS topologies, and otherwise returns the major.minor server version.
-  def fcv_ish
-    if server_version >= '3.4' && topology != :sharded
-      fcv
-    else
-      if short_server_version == '4.1'
-        '4.2'
-      else
-        short_server_version
-      end
-    end
-  end
-
-  def primary_address
-    determine_cluster_config
-    @primary_address
-  end
-
-  def primary_address_str
-    determine_cluster_config
-    @primary_address.seed
-  end
-
-  def primary_address_host
-    both = primary_address_str
-    both.split(':').first
-  end
-
-  def primary_address_port
-    both = primary_address_str
-    both.split(':')[1] || 27017
-  end
-
-  def primary_description
-    determine_cluster_config
-    @primary_description
-  end
-
-  # Try running a command on the admin database to see if the mongod was
-  # started with auth.
-  def auth_enabled?
-    if @auth_enabled.nil?
-      @auth_enabled = begin
-        basic_client.use(:admin).command(getCmdLineOpts: 1).first["argv"].include?("--auth")
-      rescue => e
-        e.message =~ /(not authorized)|(unauthorized)|(no users authenticated)|(requires authentication)/
-      end
-    end
-    @auth_enabled
-  end
-
-  def topology
-    determine_cluster_config
-    @topology
-  end
-
-  def storage_engine
-    @storage_engine ||= begin
-      # 2.6 does not have wired tiger
-      if short_server_version == '2.6'
-        :mmapv1
-      else
-        client = ClientRegistry.instance.global_client('root_authorized')
-        if topology == :sharded
-          shards = client.use(:admin).command(listShards: 1).first
-          shard = shards['shards'].first
-          address_str = shard['host'].sub(/\A.*\//, '').sub(/,.*/, '')
-          client = ClusterTools.instance.direct_client(address_str,
-            SpecConfig.instance.test_options.merge(SpecConfig.instance.auth_options).merge(connect: :direct))
-        end
-        rv = client.use(:admin).command(serverStatus: 1).first
-        rv = rv['storageEngine']['name']
-        rv_map = {
-          'wiredTiger' => :wired_tiger,
-          'mmapv1' => :mmapv1,
-        }
-        rv_map[rv] || rv
-      end
-    end
-  end
-
-  private
-
-  def determine_cluster_config
-    return if @primary_address
-
-    # Run all commands to figure out the cluster configuration from the same
-    # client. This is somewhat wasteful when running a single test, but reduces
-    # test runtime for the suite overall because all commands are sent on the
-    # same connection rather than each command connecting to the cluster by
-    # itself.
-    client = Mongoid::Clients.default
-
-    primary = client.cluster.next_primary
-    @primary_address = primary.address
-    @primary_description = primary.description
-    @replica_set_name = client.cluster.topology.replica_set_name
-
-    @topology ||= begin
-      topology = client.cluster.topology.class.name.sub(/.*::/, '')
-      topology = topology.gsub(/([A-Z])/) { |match| '_' + match.downcase }.sub(/\A_/, '')
-      if topology =~ /\Areplica_set/
-        topology = 'replica_set'
-      end
-      topology.to_sym
-    end
-
-    @single_server = client.cluster.send(:servers_list).length == 1
-
-    @server_version = client.database.command(buildInfo: 1).first['version']
-
-    if @topology != :sharded && short_server_version >= '3.4'
-      rv = client.use(:admin).command(getParameter: 1, featureCompatibilityVersion: 1).first['featureCompatibilityVersion']
-      @fcv = rv['version'] || rv
-    end
-  end
-
-  def basic_client
-    # Do not cache the result here so that if the client gets closed,
-    # client registry reconnects it in subsequent tests
-    ClientRegistry.instance.global_client('basic')
-  end
-end

data/spec/support/lite_constraints.rb

@@ -1,22 +0,0 @@
-module LiteConstraints
-  # Constrain tests that use TimeoutInterrupt to MRI (and Unix)
-  def only_mri
-    before do
-      unless SpecConfig.instance.mri?
-        skip "MRI 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
-    before do
-      unless SpecConfig.instance.mri?
-        skip "Fails on jruby"
-      end
-    end
-  end
-end

data/spec/support/spec_organizer.rb

@@ -1,130 +0,0 @@
-require 'support/child_process_helper'
-require 'json'
-
-autoload :FileUtils, 'fileutils'
-autoload :Find, 'find'
-
-# 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,^mongoid/attribute,, :attributes],
-    [%r,^mongoid/association/[or],, :associations_referenced],
-    [%r,^mongoid/association,, :associations],
-    [%r,^mongoid,, :unit],
-    [%r,^integration,, :integration],
-    [%r,^rails,, :rails],
-  ]
-
-  RUN_PRIORITY = %i(
-    unit attributes associations_referenced associations
-    integration rails
-  )
-
-  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