mongo 2.10.5 → 2.15.1

data/spec/support/connection_string.rb

@@ -1,326 +0,0 @@
-# Copyright (C) 2014-2019 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.
-
-RSpec::Matchers.define :have_hosts do |test|
-
-  match do |cl|
-
-    def find_server(client, host)
-      client.cluster.instance_variable_get(:@servers).detect do |s|
-        s.address.host == host.host
-      end
-    end
-
-    def match_host?(server, host)
-      server.address.host == host.host
-    end
-
-    def match_port?(server, host)
-      server.address.port == host.port || !host.port
-    end
-
-    def match_address_family?(server, host)
-      address_family(server) == host.address_family
-    end
-
-    def address_family(server)
-      server.address.socket(2)
-      server.address.instance_variable_get(:@resolver).class
-    end
-
-    test.hosts.all? do |host|
-      server = find_server(cl, host)
-      match_host?(server, host) &&
-          match_port?(server, host) if server #&&
-          #match_address_family?(server, host) if server
-    end
-
-    failure_message do |client|
-      "With URI: #{test.uri_string}\n" +
-          "Expected that test hosts: #{test.hosts} would match " +
-          "client hosts: #{cl.cluster.instance_variable_get(:@servers)}"
-    end
-  end
-end
-
-RSpec::Matchers.define :match_auth do |test|
-
-  def match_database?(client, auth)
-    client.options[:database] == auth.database || !auth.database
-  end
-
-  def match_password?(client, auth)
-    client.options[:password] == auth.password ||
-      client.options[:password].nil? && auth.password == ''
-  end
-
-  match do |client|
-    auth = test.auth
-    return true unless auth
-    client.options[:user] == auth.username &&
-      match_password?(client, auth) &&
-        match_database?(client, auth)
-  end
-
-  failure_message do |client|
-    "With URI: #{test.uri_string}\n" +
-        "Expected that test auth: #{test.auth} would match client auth: #{client.options}"
-  end
-end
-
-RSpec::Matchers.define :match_options do |test|
-
-  match do |client|
-    options = test.options
-    return true unless options
-    options.match?(client.options)
-  end
-
-  failure_message do |client|
-    "With URI: #{test.uri_string}\n" +
-      "Expected that test options: #{test.options.options} would match client options: #{client.options}"
-  end
-end
-
-module Mongo
-  module ConnectionString
-
-    class Spec
-
-      attr_reader :description
-
-      # Instantiate the new spec.
-      #
-      # @example Create the spec.
-      #   Spec.new(file)
-      #
-      # @param [ String ] file The name of the file.
-      #
-      # @since 2.0.0
-      def initialize(file)
-        file = File.new(file)
-        @spec = YAML.load(ERB.new(file.read).result)
-        file.close
-        @description = File.basename(file)
-      end
-
-      def tests
-        @tests ||= @spec['tests'].collect do |spec|
-          Test.new(spec)
-        end
-      end
-    end
-
-    class Test
-      include RSpec::Core::Pending
-
-      attr_reader :description
-      attr_reader :uri_string
-
-      def initialize(spec)
-        @spec = spec
-        @description = @spec['description']
-        @uri_string = @spec['uri']
-      end
-
-      def valid?
-        @spec['valid']
-      end
-
-      def warn?
-        @spec['warning']
-      end
-
-      def hosts
-        @hosts ||= (@spec['hosts'] || []).collect do |host|
-          Host.new(host)
-        end
-      end
-
-      def options
-        @options ||= Options.new(@spec['options']) if @spec['options']
-      end
-
-      def client
-        @client ||= ClientRegistry.instance.new_local_client(@spec['uri'], monitoring_io: false)
-      rescue Mongo::Error::LintError => e
-        if e.message =~ /arbitraryButStillValid/
-          skip 'Test uses a read concern that fails linter'
-        end
-      end
-
-      def uri
-        @uri ||= Mongo::URI.get(@spec['uri'])
-      end
-
-      def auth
-        @auth ||= Auth.new(@spec['auth']) if @spec['auth']
-      end
-
-      def raise_error?
-        @spec['error']
-      end
-    end
-
-    class Host
-
-      MAPPING = {
-          'ipv4' => Mongo::Address::IPv4,
-          'ipv6' => Mongo::Address::IPv6,
-          'unix' => Mongo::Address::Unix
-      }
-
-      attr_reader :host
-      attr_reader :port
-
-      def initialize(spec)
-        @spec = spec
-        @host = @spec['host']
-        @port = @spec['port']
-      end
-
-      def address_family
-        MAPPING[@spec['type']]
-      end
-    end
-
-    class Auth
-
-      attr_reader :username
-      attr_reader :password
-      attr_reader :database
-
-      def initialize(spec)
-        @spec = spec
-        @username = @spec['username']
-        @password = @spec['password']
-        @database = @spec['db']
-      end
-
-      def to_s
-        "username: #{username}, password: #{password}, database: #{database}"
-      end
-    end
-
-    class Options
-
-      MAPPINGS = {
-        # Replica Set Options
-        'replicaset' => :replica_set,
-
-        # Timeout Options
-        'connecttimeoutms' => :connect_timeout,
-        'sockettimeoutms' => :socket_timeout,
-        'serverselectiontimeoutms' => :server_selection_timeout,
-        'localthresholdms' => :local_threshold,
-        'heartbeatfrequencyms' => :heartbeat_frequency,
-        'maxidletimems' => :max_idle_time,
-
-         # Write  Options
-        'journal' => [:write_concern, 'j'],
-        'w' => [:write_concern, 'w'],
-        'wtimeoutms' => [:write_concern, 'wtimeout'],
-
-        # Read Options
-        'readpreference' => ['read', 'mode'],
-        'readpreferencetags' => ['read', 'tag_sets'],
-        'maxstalenessseconds' => ['read', 'max_staleness'],
-
-        # Pool Options
-        'minpoolsize' => :min_pool_size,
-        'maxpoolsize' => :max_pool_size,
-
-        # Security Options
-        'tls' => :ssl,
-        'tlsallowinvalidcertificates' => :ssl_verify_certificate,
-        'tlsallowinvalidhostnames' => :ssl_verify_hostname,
-        'tlscafile' => :ssl_ca_cert,
-        'tlscertificatekeyfile' => :ssl_cert,
-        'tlscertificatekeyfilepassword' => :ssl_key_pass_phrase,
-        'tlsinsecure' => :ssl_verify,
-
-        # Auth Options
-        'authsource' => :auth_source,
-        'authmechanism' => :auth_mech,
-        'authmechanismproperties' => :auth_mech_properties,
-
-        # Client Options
-        'appname' => :app_name,
-        'readconcernlevel' => [:read_concern, 'level'],
-        'retrywrites' => :retry_writes,
-        'zlibcompressionlevel' => :zlib_compression_level,
-      }
-
-      attr_reader :options
-
-      def initialize(options)
-        @options = options
-      end
-
-      def match?(opts)
-        @options.all? do |k, v|
-          k = k.downcase
-
-          expected =
-            case k
-            when 'authmechanism'
-              Mongo::URI::AUTH_MECH_MAP[v].downcase.to_s
-            when 'authsource'
-              v == '$external' ? 'external' : v.downcase
-            when 'authmechanismproperties'
-              v.reduce({}) do |new_v, prop|
-                prop_key = prop.first.downcase
-                prop_val = prop.last == 'true' ? true : prop.last
-                new_v[prop_key] = prop_val
-
-                new_v
-              end
-            when 'compressors'
-              v.dup.tap do |compressors|
-                # The Ruby driver doesn't support snappy
-                compressors.delete('snappy')
-              end
-            when 'readpreference'
-              Mongo::URI::READ_MODE_MAP[v.downcase].to_s
-            when 'tlsallowinvalidcertificates', 'tlsallowinvalidhostnames', 'tlsinsecure'
-              !v
-            else
-              if k.end_with?('ms') && k != 'wtimeoutms'
-                v / 1000.0
-              elsif v.is_a?(String)
-                v.downcase
-              else
-                v
-              end
-            end
-
-          actual =
-            case MAPPINGS[k]
-            when nil
-              opts[k]
-            when Array
-              opts[MAPPINGS[k].first][MAPPINGS[k].last]
-            else
-              opts[MAPPINGS[k]]
-            end
-
-          actual = actual.to_s if actual.is_a?(Symbol)
-          actual.downcase! if actual.is_a?(String)
-
-          expected == actual
-        end
-      end
-    end
-  end
-end

data/spec/support/crud/requirement.rb

@@ -1,69 +0,0 @@
-module Mongo
-  module CRUD
-    class Requirement
-      YAML_KEYS = %w(minServerVersion maxServerVersion topology).freeze
-
-      def initialize(spec)
-        @min_server_version = spec['minServerVersion']
-        @max_server_version = spec['maxServerVersion']
-        @topologies = if topologies = spec['topology']
-          topologies.map do |topology|
-            {'replicaset' => :replica_set, 'single' => :single, 'sharded' => :sharded}[topology]
-          end
-        else
-          nil
-        end
-      end
-
-      attr_reader :min_server_version
-      attr_reader :max_server_version
-      attr_reader :topologies
-
-      def short_min_server_version
-        if min_server_version
-          min_server_version.split('.')[0..1].join('.')
-        else
-          nil
-        end
-      end
-
-      def short_max_server_version
-        if max_server_version
-          max_server_version.split('.')[0..1].join('.')
-        else
-          nil
-        end
-      end
-
-      def satisfied?
-        cc = ClusterConfig.instance
-        ok = true
-        if short_min_server_version
-          ok &&= cc.fcv_ish >= short_min_server_version
-        end
-        if max_server_version
-          ok &&= cc.server_version <= max_server_version
-        end
-        if topologies
-          ok &&= topologies.include?(cc.topology)
-        end
-        ok
-      end
-
-      def description
-        versions = [min_server_version, max_server_version].compact
-        if versions.any?
-          versions = versions.join('-')
-        else
-          versions = nil
-        end
-        topologies = if self.topologies
-          self.topologies.map(&:to_s).join(',')
-        else
-          nil
-        end
-        [versions, topologies].compact.join('/')
-      end
-    end
-  end
-end

data/spec/support/crud/test_base.rb

@@ -1,22 +0,0 @@
-module Mongo
-  module CRUD
-
-    class CRUDTestBase
-
-      def resolve_target(client, operation)
-        case operation.object
-        when 'collection'
-          client[@spec.collection_name].with(operation.collection_options)
-        when 'database'
-          client.database
-        when 'client'
-          client
-        when 'gridfsbucket'
-          client.database.fs
-        else
-          raise "Unknown target #{operation.object}"
-        end
-      end
-    end
-  end
-end

data/spec/support/lite_constraints.rb

@@ -1,52 +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
-
-  def require_external_connectivity
-    before do
-      if ENV['EXTERNAL_DISABLED']
-        skip "Test requires external connectivity"
-      end
-    end
-  end
-
-  def require_linting
-    before 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 skip_if_linting
-    before do
-      if Mongo::Lint.enabled?
-        skip "Linting is enabled"
-      end
-    end
-  end
-end

data/spec/support/sdam_monitoring.rb

@@ -1,89 +0,0 @@
-# Copyright (C) 2014-2015 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 SDAMMonitoring
-
-    # Test subscriber for SDAM monitoring.
-    #
-    # @since 2.4.0
-    class TestSubscriber
-
-      # The mappings of event names to types.
-      #
-      # @since 2.4.0
-      MAPPINGS = {
-        'topology_opening_event' => Mongo::Monitoring::Event::TopologyOpening,
-        'topology_description_changed_event' => Mongo::Monitoring::Event::TopologyChanged,
-        'topology_closed_event' => Mongo::Monitoring::Event::TopologyClosed,
-        'server_opening_event' => Mongo::Monitoring::Event::ServerOpening,
-        'server_description_changed_event' => Mongo::Monitoring::Event::ServerDescriptionChanged,
-        'server_closed_event' => Mongo::Monitoring::Event::ServerClosed
-      }.freeze
-
-      # Implement the succeeded event.
-      #
-      # @param [ Event ] event The event.
-      #
-      # @since 2.4.0
-      def succeeded(event)
-        events.push(event)
-      end
-
-      # Get the first event fired for the name, and then delete it.
-      #
-      # @param [ String ] name The event name.
-      #
-      # @return [ Event ] The matching event.
-      def first_event(name)
-        cls = MAPPINGS[name]
-        if cls.nil?
-          raise ArgumentError, "Bogus event name #{name}"
-        end
-        matching = events.find do |event|
-          cls === event
-        end
-        events.delete(matching)
-        matching
-      end
-
-      def events
-        @events ||= []
-      end
-    end
-
-    class PhasedTestSubscriber < TestSubscriber
-      def initialize
-        super
-        @phase_events = {}
-      end
-
-      def phase_finished(phase_index)
-        @phase_events[phase_index] = events
-        @events = []
-      end
-
-      def phase_events(phase_index)
-        @phase_events[phase_index]
-      end
-
-      def event_count
-        @phase_events.inject(0) do |sum, event|
-          sum + event.length
-        end
-      end
-    end
-  end
-end

data/spec/support/server_selection.rb

@@ -1,153 +0,0 @@
-module Mongo
-  module ServerSelection
-    module Read
-
-      # Represents a Server Selection specification test.
-      #
-      # @since 2.0.0
-      class Spec
-
-        # Mapping of read preference modes.
-        #
-        # @since 2.0.0
-        READ_PREFERENCES = {
-          'Primary' => :primary,
-          'Secondary' => :secondary,
-          'PrimaryPreferred' => :primary_preferred,
-          'SecondaryPreferred' => :secondary_preferred,
-          'Nearest' => :nearest,
-        }
-
-        # @return [ String ] description The spec description.
-        #
-        # @since 2.0.0
-        attr_reader :description
-
-        # @return [ Hash ] read_preference The read preference to be used for selection.
-        #
-        # @since 2.0.0
-        attr_reader :read_preference
-
-        # @return [ Integer ] heartbeat_frequency The heartbeat frequency to be set on the client.
-        #
-        # @since 2.4.0
-        attr_reader :heartbeat_frequency
-
-        # @return [ Integer ] max_staleness The max_staleness.
-        #
-        # @since 2.4.0
-        attr_reader :max_staleness
-
-        # @return [ Array<Hash> ] eligible_servers The eligible servers before the latency
-        #   window is taken into account.
-        #
-        # @since 2.0.0
-        attr_reader :eligible_servers
-
-        # @return [ Array<Hash> ] suitable_servers The set of servers matching all server
-        #  selection logic. May be a subset of eligible_servers and/or candidate_servers.
-        #
-        # @since 2.0.0
-        attr_reader :suitable_servers
-
-        # @return [ Mongo::Cluster::Topology ] type The topology type.
-        #
-        # @since 2.0.0
-        attr_reader :type
-
-        # Instantiate the new spec.
-        #
-        # @example Create the spec.
-        #   Spec.new(file)
-        #
-        # @param [ String ] file The name of the file.
-        #
-        # @since 2.0.0
-        def initialize(file)
-          file = File.new(file)
-          @test = YAML.load(ERB.new(file.read).result)
-          file.close
-          @description = "#{@test['topology_description']['type']}: #{File.basename(file)}"
-          @heartbeat_frequency = @test['heartbeatFrequencyMS'] / 1000 if @test['heartbeatFrequencyMS']
-          @read_preference = @test['read_preference']
-          @read_preference['mode'] = READ_PREFERENCES[@read_preference['mode']]
-          @max_staleness = @read_preference['maxStalenessSeconds']
-          @candidate_servers = @test['topology_description']['servers']
-          @suitable_servers = @test['suitable_servers'] || []
-          @in_latency_window = @test['in_latency_window'] || []
-          @type = Mongo::Cluster::Topology.const_get(@test['topology_description']['type'])
-        end
-
-        # Whether this spec describes a replica set.
-        #
-        # @example Determine if the spec describes a replica set.
-        #   spec.replica_set?
-        #
-        # @return [true, false] If the spec describes a replica set.
-        #
-        # @since 2.0.0
-        def replica_set?
-          type == Mongo::Cluster::Topology::ReplicaSetNoPrimary ||
-          type == Mongo::Cluster::Topology::ReplicaSetWithPrimary
-        end
-
-        # Does this spec expect a server to be found.
-        #
-        # @example Will a server be found with this spec.
-        #   spec.server_available?
-        #
-        # @return [true, false] If a server will be found with this spec.
-        #
-        # @since 2.0.0
-        def server_available?
-          !in_latency_window.empty?
-        end
-
-        # Is the max staleness setting invalid.
-        #
-        # @example Will the max staleness setting be valid with other options.
-        #   spec.invalid_max_staleness?
-        #
-        # @return [ true, false ] If an error will be raised by the max staleness setting.
-        #
-        # @since 2.4.0
-        def invalid_max_staleness?
-          @test['error']
-        end
-
-        # The subset of suitable servers that falls within the allowable latency
-        #   window.
-        # We have to correct for our server selection algorithm that adds the primary
-        #  to the end of the list for SecondaryPreferred read preference mode.
-        #
-        # @example Get the list of suitable servers within the latency window.
-        #   spec.in_latency_window
-        #
-        # @return [ Array<Hash> ] The servers within the latency window.
-        #
-        # @since 2.0.0
-        def in_latency_window
-          if read_preference['mode'] == :secondary_preferred && primary
-            return @in_latency_window.push(primary).uniq
-          end
-          @in_latency_window
-        end
-
-        # The servers a topology would return as candidates for selection.
-        #
-        # @return [ Array<Hash> ] candidate_servers The candidate servers.
-        #
-        # @since 2.0.0
-        def candidate_servers
-          @candidate_servers.select { |s| !['Unknown', 'PossiblePrimary'].include?(s['type']) }
-        end
-
-        private
-
-        def primary
-          @candidate_servers.find { |s| s['type'] == 'RSPrimary' }
-        end
-      end
-    end
-  end
-end