mongoid 7.5.4 → 8.1.7

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

@@ -1,210 +0,0 @@
-# frozen_string_literal: true
-
-module Mrss
-  # Test event subscriber.
-  class EventSubscriber
-
-    # The mappings of event names to types.
-    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
-
-    attr_reader :all_events
-
-    attr_reader :started_events
-
-    attr_reader :succeeded_events
-
-    attr_reader :failed_events
-
-    attr_reader :published_events
-
-    # @param [ String ] name Optional name for the event subscriber.
-    def initialize(name: nil)
-      @mutex = Mutex.new
-      clear_events!
-      @name = name
-    end
-
-    def to_s
-      %Q`#<EventSubscriber:#{@name ? "\"#{@name}\"" : '%x' % object_id} \
-  started=#{started_events.length} \
-  succeeded=#{succeeded_events.length} \
-  failed=#{failed_events.length} \
-  published=#{published_events.length}>`
-    end
-
-    alias :inspect :to_s
-
-    # Event retrieval
-
-    def select_started_events(cls)
-      started_events.select do |event|
-        event.is_a?(cls)
-      end
-    end
-
-    def select_succeeded_events(cls)
-      succeeded_events.select do |event|
-        event.is_a?(cls)
-      end
-    end
-
-    def select_completed_events(*classes)
-      (succeeded_events + failed_events).select do |event|
-        classes.any? { |c| c === event }
-      end
-    end
-
-    def select_published_events(cls)
-      published_events.select do |event|
-        event.is_a?(cls)
-      end
-    end
-
-    # Filters command started events for the specified command name.
-    def command_started_events(command_name)
-      started_events.select do |event|
-        event.command[command_name]
-      end
-    end
-
-    def non_auth_command_started_events
-      started_events.reject do |event|
-        %w(authenticate getnonce saslSstart saslContinue).any? do |cmd|
-          event.command[cmd]
-        end
-      end
-    end
-
-    # Locates command stated events for the specified command name,
-    # asserts that there is exactly one such event, and returns it.
-    def single_command_started_event(command_name, include_auth: false, database_name: nil)
-      events = if include_auth
-                 started_events
-               else
-                 non_auth_command_started_events
-               end
-      get_one_event(events, command_name, 'started', database_name: database_name)
-    end
-
-    # Locates command succeeded events for the specified command name,
-    # asserts that there is exactly one such event, and returns it.
-    def single_command_succeeded_event(command_name, database_name: nil)
-      get_one_event(succeeded_events, command_name, 'succeeded', database_name: database_name)
-    end
-
-    def get_one_event(events, command_name, kind, database_name: nil)
-      events = events.select do |event|
-        event.command_name == command_name and
-        database_name.nil? || database_name == event.database_name
-      end
-      if events.length != 1
-        raise "Expected a single '#{command_name}' #{kind} event#{database_name ? " for '#{database_name}'" : ''} but we have #{events.length}"
-      end
-      events.first
-    end
-
-    # Get the first succeeded event published 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 = succeeded_events.find do |event|
-        cls === event
-      end
-      succeeded_events.delete(matching)
-      matching
-    end
-
-    # Event recording
-
-    # Cache the started event.
-    #
-    # @param [ Event ] event The event.
-    def started(event)
-      @mutex.synchronize do
-        started_events << event
-        all_events << event
-      end
-    end
-
-    # Cache the succeeded event.
-    #
-    # @param [ Event ] event The event.
-    def succeeded(event)
-      @mutex.synchronize do
-        succeeded_events << event
-        all_events << event
-      end
-    end
-
-    # Cache the failed event.
-    #
-    # @param [ Event ] event The event.
-    def failed(event)
-      @mutex.synchronize do
-        failed_events << event
-        all_events << event
-      end
-    end
-
-    def published(event)
-      @mutex.synchronize do
-        published_events << event
-        all_events << event
-      end
-    end
-
-    # Clear all cached events.
-    def clear_events!
-      @all_events = []
-      @started_events = []
-      @succeeded_events = []
-      @failed_events = []
-      @published_events = []
-      self
-    end
-  end
-  # Only handles succeeded events correctly.
-  class PhasedEventSubscriber < EventSubscriber
-    def initialize
-      super
-      @phase_events = {}
-    end
-
-    def phase_finished(phase_index)
-      @phase_events[phase_index] = succeeded_events
-      @succeeded_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
-
-  class VerboseEventSubscriber < EventSubscriber
-    %w(started succeeded failed published).each do |meth|
-      define_method(meth) do |event|
-        puts event.summary
-        super(event)
-      end
-    end
-  end
-end

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 = Gem::Version.new(Mongo::Crypt::Binding.mongocrypt_version(nil))
-        min_version = Gem::Version.new(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,120 +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 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'] == 'x86_64'
-        end
-        unless dl
-          raise MissingDownloadUrl, "No download for #{arch} for #{version['version']}"
-        end
-        url = dl['archive']['url']
-      end
-    rescue MissingDownloadUrl
-      if %w(2.6 3.0).include?(desired_version) && arch == 'ubuntu1604'
-        # 2.6 and 3.0 are only available for ubuntu1204 and ubuntu1404.
-        # Those ubuntus have ancient Pythons that don't work due to not
-        # implementing recent TLS protocols.
-        # Because of this we test on ubuntu1604 which has a newer Python.
-        # But we still need to retrieve ubuntu1404-targeting builds.
-        url = self.class.new('3.2', arch).download_url
-        unless url.include?('3.2.')
-          raise 'URL not in expected format'
-        end
-        url = case desired_version
-        when '2.6'
-          url.sub(/\b3\.2\.\d+/, '2.6.12')
-        when '3.0'
-          url.sub(/\b3\.2\.\d+/, '3.0.15')
-        else
-          raise NotImplementedError
-        end.sub('ubuntu1604', 'ubuntu1404')
-      else
-        raise
-      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