mongo 2.13.0 → 2.15.0.alpha

data/lib/mongo/operation/shared/collections_info_or_list_collections.rb

@@ -1,56 +0,0 @@
-# Copyright (C) 2020 MongoDB Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-module Mongo
-  module Operation
-    module CollectionsInfoOrListCollections
-      include PolymorphicLookup
-
-      # Execute the operation.
-      #
-      # @example
-      #   operation.execute(server, client: nil)
-      #
-      # @param [ Mongo::Server ] server The server to send the operation to.
-      # @param [ Mongo::Client ] client The client that will be used to
-      #   perform auto-encryption if it is necessary to encrypt the command
-      #   being executed (optional).
-      #
-      # @return [ Mongo::Operation::CollectionsInfo::Result,
-      #           Mongo::Operation::ListCollections::Result ] The operation result.
-      def execute(server, client:)
-        server.with_connection do |connection|
-          operation = final_operation(connection)
-          operation.execute(connection, client: client)
-        end
-      end
-
-      private
-
-      def final_operation(connection)
-         op_class = if connection.features.list_collections_enabled?
-          if connection.features.op_msg_enabled?
-            ListCollections::OpMsg
-          else
-            ListCollections::Command
-          end
-        else
-          CollectionsInfo::Command
-        end
-
-        op_class.new(spec)
-      end
-    end
-  end
-end

data/lib/mongo/operation/shared/op_msg_or_list_indexes_command.rb

@@ -1,47 +0,0 @@
-# Copyright (C) 2018-2020 MongoDB Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-module Mongo
-  module Operation
-
-    # Shared behavior of executing the operation as an OpMsg when supported,
-    # as a Command when list indxes command is supported by the server, and as
-    # Legacy otherwise.
-    #
-    # @api private
-    module OpMsgOrListIndexesCommand
-      include PolymorphicLookup
-
-      def execute(server, client:)
-        server.with_connection do |connection|
-          operation = final_operation(connection)
-          operation.execute(connection, client: client)
-        end
-      end
-
-      private
-
-      def final_operation(connection)
-        cls = if connection.features.op_msg_enabled?
-          polymorphic_class(self.class.name, :OpMsg)
-        elsif connection.features.list_indexes_enabled?
-          polymorphic_class(self.class.name, :Command)
-        else
-          polymorphic_class(self.class.name, :Legacy)
-        end
-        cls.new(spec)
-      end
-    end
-  end
-end

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/cluster_config.rb

@@ -1,207 +0,0 @@
-require 'singleton'
-
-class ClusterConfig
-  include Singleton
-  include RSpec::Core::Pending
-
-  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 enterprise?
-    determine_cluster_config
-    @enterprise
-  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.nil?
-      raise "Deployment server version not known - check that connection to deployment succeeded"
-    end
-
-    if server_version >= '3.4' && topology != :sharded
-      fcv
-    else
-      if short_server_version == '4.1'
-        '4.2'
-      else
-        short_server_version
-      end
-    end
-  end
-
-  # @return [ Mongo::Address ] The address of the primary in the deployment.
-  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
-          if shards['shards'].empty?
-            raise 'Shards are empty'
-          end
-          shard = shards['shards'].first
-          address_str = shard['host'].sub(/^.*\//, '').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
-
-  # This method returns an alternate address for connecting to the configured
-  # deployment. For example, if the replica set is configured with nodes at
-  # of localhost:27017 and so on, this method will return 127.0.0.:27017.
-  #
-  # Note that the "alternate" refers to replica set configuration, not the
-  # addresses specified in test suite configuration. If the deployment topology
-  # is not a replica set, "alternate" refers to test suite configuration as
-  # this is the only configuration available.
-  def alternate_address
-    @alternate_address ||= begin
-      address = primary_address_host
-      str = case address
-      when '127.0.0.1'
-        'localhost'
-      when /^(\d+\.){3}\d+$/
-        skip 'This test requires a hostname or 127.0.0.1 as address'
-      else
-        # We don't know if mongod is listening on ipv4 or ipv6, in principle.
-        # Our tests use ipv4, so hardcode that for now.
-        # To support both we need to try both addresses which will make this
-        # test more complicated.
-        #
-        # JRuby chokes on primary_address_port as the port (e.g. 27017).
-        # Since the port does not actually matter, use a common port like 80.
-        resolved_address = Addrinfo.getaddrinfo(address, 80, Socket::PF_INET).first.ip_address
-        if resolved_address.include?(':')
-          "[#{resolved_address}]"
-        else
-          resolved_address
-        end
-      end + ":#{primary_address_port}"
-      Mongo::Address.new(str)
-    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 = ClientRegistry.instance.global_client('root_authorized')
-
-    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(/^_/, '')
-      if topology =~ /^replica_set/
-        topology = 'replica_set'
-      end
-      topology.to_sym
-    end
-
-    @single_server = client.cluster.servers_list.length == 1
-
-    build_info = client.database.command(buildInfo: 1).first
-
-    @server_version = build_info['version']
-    @enterprise = build_info['modules'] && build_info['modules'].include?('enterprise')
-
-    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,141 +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
-end