mongo 2.21.0 → 2.21.1

data/spec/runners/unified/crud_operations.rb

@@ -1,367 +0,0 @@
-# frozen_string_literal: true
-# rubocop:todo all
-
-module Unified
-
-  module CrudOperations
-
-    def crud_find(op)
-      get_find_view(op).to_a
-    end
-
-    def find_one(op)
-      get_find_view(op).first
-    end
-
-    def get_find_view(op)
-      collection = entities.get(:collection, op.use!('object'))
-      use_arguments(op) do |args|
-        filter = args.use!('filter')
-        session = args.use('session')
-
-        opts = extract_options(args, 'let', 'comment',
-          'allowDiskUse', 'returnKey', 'projection',
-          'skip', 'hint', 'maxTimeMS', 'timeoutMS',
-          'collation', 'noCursorTimeout', 'oplogReplay', 'allowPartialResults',
-          'timeoutMode', 'maxAwaitTimeMS', 'cursorType', 'timeoutMode',
-          { 'showRecordId' => :show_disk_loc, 'max' => :max_value, 'min' => :min_value },
-          allow_extra: true)
-        symbolize_options!(opts, :timeout_mode, :cursor_type)
-
-        opts[:session] = entities.get(:session, session) if session
-
-        req = collection.find(filter, **opts)
-        if batch_size = args.use('batchSize')
-          req = req.batch_size(batch_size)
-        end
-        if sort = args.use('sort')
-          req = req.sort(sort)
-        end
-        if limit = args.use('limit')
-          req = req.limit(limit)
-        end
-        if projection = args.use('projection')
-          req = req.projection(projection)
-        end
-        req
-      end
-    end
-
-    def count(op)
-      collection = entities.get(:collection, op.use!('object'))
-      use_arguments(op) do |args|
-        opts = extract_options(args, 'comment', 'timeoutMS', 'maxTimeMS', allow_extra: true)
-        if session = args.use('session')
-          opts[:session] = entities.get(:session, session)
-        end
-        collection.count(args.use!('filter'), **opts)
-      end
-    end
-
-    def count_documents(op)
-      collection = entities.get(:collection, op.use!('object'))
-      use_arguments(op) do |args|
-        opts = extract_options(args, 'comment', 'timeoutMS', 'maxTimeMS', allow_extra: true)
-        if session = args.use('session')
-          opts[:session] = entities.get(:session, session)
-        end
-        collection.find(args.use!('filter')).count_documents(**opts)
-      end
-    end
-
-    def estimated_document_count(op)
-      collection = entities.get(:collection, op.use!('object'))
-      use_arguments(op) do |args|
-        opts = extract_options(args, 'comment', 'timeoutMS', 'maxTimeMS', allow_extra: true)
-        if session = args.use('session')
-          opts[:session] = entities.get(:session, session)
-        end
-        collection.estimated_document_count(**opts)
-      end
-    end
-
-    def distinct(op)
-      collection = entities.get(:collection, op.use!('object'))
-      use_arguments(op) do |args|
-        opts = extract_options(args, 'comment', 'timeoutMS', 'maxTimeMS', allow_extra: true)
-        if session = args.use('session')
-          opts[:session] = entities.get(:session, session)
-        end
-        req = collection.find(args.use!('filter'), **opts).distinct(args.use!('fieldName'), **opts)
-        result = req.to_a
-      end
-    end
-
-    def find_one_and_update(op)
-      collection = entities.get(:collection, op.use!('object'))
-      use_arguments(op) do |args|
-        filter = args.use!('filter')
-        update = args.use!('update')
-        opts = {
-          let: args.use('let'),
-          comment: args.use('comment'),
-          hint: args.use('hint'),
-          upsert: args.use('upsert'),
-          timeout_ms: args.use('timeoutMS'),
-          max_time_ms: args.use('maxTimeMS')
-        }
-        if return_document = args.use('returnDocument')
-          opts[:return_document] = return_document.downcase.to_sym
-        end
-        if session = args.use('session')
-          opts[:session] = entities.get(:session, session)
-        end
-        collection.find_one_and_update(filter, update, **opts)
-      end
-    end
-
-    def find_one_and_replace(op)
-      collection = entities.get(:collection, op.use!('object'))
-      use_arguments(op) do |args|
-        filter = args.use!('filter')
-        update = args.use!('replacement')
-        opts = {
-          let: args.use('let'),
-          comment: args.use('comment'),
-          hint: args.use('hint'),
-          timeout_ms: args.use('timeoutMS'),
-          max_time_ms: args.use('maxTimeMS')
-        }
-        if session = args.use('session')
-          opts[:session] = entities.get(:session, session)
-        end
-        collection.find_one_and_replace(filter, update, **opts)
-      end
-    end
-
-    def find_one_and_delete(op)
-      collection = entities.get(:collection, op.use!('object'))
-      use_arguments(op) do |args|
-        filter = args.use!('filter')
-        opts = {
-          let: args.use('let'),
-          comment: args.use('comment'),
-          hint: args.use('hint'),
-          timeout_ms: args.use('timeoutMS'),
-          max_time_ms: args.use('maxTimeMS')
-        }
-        if session = args.use('session')
-          opts[:session] = entities.get(:session, session)
-        end
-        collection.find_one_and_delete(filter, **opts)
-      end
-    end
-
-    def insert_one(op)
-      collection = entities.get(:collection, op.use!('object'))
-      use_arguments(op) do |args|
-        opts = {
-          comment: args.use('comment'),
-          timeout_ms: args.use('timeoutMS'),
-          max_time_ms: args.use('maxTimeMS')
-        }
-        if session = args.use('session')
-          opts[:session] = entities.get(:session, session)
-        end
-        collection.insert_one(args.use!('document'), **opts)
-      end
-    end
-
-    def insert_many(op)
-      collection = entities.get(:collection, op.use!('object'))
-      use_arguments(op) do |args|
-        opts = {
-          comment: args.use('comment'),
-          timeout_ms: args.use('timeoutMS'),
-          max_time_ms: args.use('maxTimeMS')
-        }
-        unless (ordered = args.use('ordered')).nil?
-          opts[:ordered] = ordered
-        end
-        if session = args.use('session')
-          opts[:session] = entities.get(:session, session)
-        end
-        collection.insert_many(args.use!('documents'), **opts)
-      end
-    end
-
-    def update_one(op)
-      collection = entities.get(:collection, op.use!('object'))
-      use_arguments(op) do |args|
-        opts = {
-          let: args.use('let'),
-          comment: args.use('comment'),
-          hint: args.use('hint'),
-          upsert: args.use('upsert'),
-          timeout_ms: args.use('timeoutMS'),
-          max_time_ms: args.use('maxTimeMS')
-        }
-        if session = args.use('session')
-          opts[:session] = entities.get(:session, session)
-        end
-        collection.update_one(args.use!('filter'), args.use!('update'), **opts)
-      end
-    end
-
-    def update_many(op)
-      collection = entities.get(:collection, op.use!('object'))
-      use_arguments(op) do |args|
-        opts = {
-          let: args.use('let'),
-          comment: args.use('comment'),
-          hint: args.use('hint'),
-          timeout_ms: args.use('timeoutMS'),
-          max_time_ms: args.use('maxTimeMS')
-        }
-        collection.update_many(args.use!('filter'), args.use!('update'), **opts)
-      end
-    end
-
-    def replace_one(op)
-      collection = entities.get(:collection, op.use!('object'))
-      use_arguments(op) do |args|
-        collection.replace_one(
-          args.use!('filter'),
-          args.use!('replacement'),
-          comment: args.use('comment'),
-          upsert: args.use('upsert'),
-          let: args.use('let'),
-          hint: args.use('hint'),
-          timeout_ms: args.use('timeoutMS'),
-          max_time_ms: args.use('maxTimeMS')
-        )
-      end
-    end
-
-    def delete_one(op)
-      collection = entities.get(:collection, op.use!('object'))
-      use_arguments(op) do |args|
-        opts = {
-          let: args.use('let'),
-          comment: args.use('comment'),
-          hint: args.use('hint'),
-          timeout_ms: args.use('timeoutMS'),
-          max_time_ms: args.use('maxTimeMS')
-        }
-        if session = args.use('session')
-          opts[:session] = entities.get(:session, session)
-        end
-        collection.delete_one(args.use!('filter'), **opts)
-      end
-    end
-
-    def delete_many(op)
-      collection = entities.get(:collection, op.use!('object'))
-      use_arguments(op) do |args|
-        opts = {
-          let: args.use('let'),
-          comment: args.use('comment'),
-          hint: args.use('hint'),
-          timeout_ms: args.use('timeoutMS'),
-          max_time_ms: args.use('maxTimeMS')
-        }
-        collection.delete_many(args.use!('filter'), **opts)
-      end
-    end
-
-    def bulk_write(op)
-      collection = entities.get(:collection, op.use!('object'))
-      use_arguments(op) do |args|
-        requests = args.use!('requests').map do |req|
-          convert_bulk_write_spec(req)
-        end
-        opts = {}
-        if args.key?('ordered')
-          opts[:ordered] = args.use!('ordered')
-        end
-        if comment = args.use('comment')
-          opts[:comment] = comment
-        end
-        if let = args.use('let')
-          opts[:let] = let
-        end
-        if timeout_ms = args.use('timeoutMS')
-          opts[:timeout_ms] = timeout_ms
-        end
-        if max_time_ms = args.use('maxTimeMS')
-          opts[:max_time_ms] = max_time_ms
-        end
-        collection.bulk_write(requests, **opts)
-      end
-    end
-
-    def aggregate(op)
-      obj = entities.get_any(op.use!('object'))
-      args = op.use!('arguments')
-      pipeline = args.use!('pipeline')
-
-      opts = extract_options(args, 'let', 'comment', 'batchSize', 'maxTimeMS',
-        'allowDiskUse', 'timeoutMode', 'timeoutMS', 'maxTimeMS', allow_extra: true)
-      symbolize_options!(opts, :timeout_mode)
-
-      if session = args.use('session')
-        opts[:session] = entities.get(:session, session)
-      end
-
-      unless args.empty?
-        raise NotImplementedError, "Unhandled spec keys: #{args} in #{test_spec}"
-      end
-
-      obj.aggregate(pipeline, **opts).to_a
-    end
-
-    def create_find_cursor(op)
-      obj = entities.get_any(op.use!('object'))
-      args = op.use!('arguments')
-
-      filter = args.use('filter')
-      opts = extract_options(args, 'batchSize', 'timeoutMS', 'cursorType', 'maxAwaitTimeMS')
-      symbolize_options!(opts, :cursor_type)
-
-      view = obj.find(filter, opts)
-      view.each # to initialize the cursor
-
-      view.cursor
-    end
-
-    private
-
-    def convert_bulk_write_spec(spec)
-      unless spec.keys.length == 1
-        raise NotImplementedError, "Must have exactly one item"
-      end
-      op, spec = spec.first
-      spec = UsingHash[spec]
-      out = case op
-      when 'insertOne'
-        spec.use!('document')
-      when 'updateOne', 'updateMany'
-        {
-          filter: spec.use('filter'),
-          update: spec.use('update'),
-          upsert: spec.use('upsert'),
-          array_filters: spec.use('arrayFilters'),
-          hint: spec.use('hint'),
-        }
-      when 'replaceOne'
-        {
-          filter: spec.use('filter'),
-          replacement: spec.use('replacement'),
-          upsert: spec.use('upsert'),
-          hint: spec.use('hint'),
-        }
-      when 'deleteOne', 'deleteMany'
-        {
-          filter: spec.use('filter'),
-          hint: spec.use('hint'),
-        }
-      else
-        raise NotImplementedError, "Unknown operation #{op}"
-      end
-      unless spec.empty?
-        raise NotImplementedError, "Unhandled keys: #{spec}"
-      end
-      {Utils.underscore(op) =>out}
-    end
-  end
-end

data/spec/runners/unified/ddl_operations.rb

@@ -1,286 +0,0 @@
-# frozen_string_literal: true
-# rubocop:todo all
-
-module Unified
-
-  module DdlOperations
-
-    def list_databases(op)
-      list_dbs(op, name_only: false)
-    end
-
-    def list_database_names(op)
-      list_dbs(op, name_only: false)
-    end
-
-    def list_dbs(op, name_only: false)
-      client = entities.get(:client, op.use!('object'))
-      use_arguments(op) do |args|
-        opts = {}
-        if session = args.use('session')
-          opts[:session] = entities.get(:session, session)
-        end
-        if timeout_ms = args.use('timeoutMS')
-          opts[:timeout_ms] = timeout_ms
-        end
-        client.list_databases(args.use('filter') || {}, name_only, **opts)
-      end
-    end
-
-    def create_collection(op)
-      database = entities.get(:database, op.use!('object'))
-      use_arguments(op) do |args|
-        opts = {}
-        if session = args.use('session')
-          opts[:session] = entities.get(:session, session)
-        end
-        collection_opts = {}
-        if timeseries = args.use('timeseries')
-          collection_opts[:time_series] = timeseries
-        end
-        if expire_after_seconds = args.use('expireAfterSeconds')
-          collection_opts[:expire_after] = expire_after_seconds
-        end
-        if clustered_index = args.use('clusteredIndex')
-          collection_opts[:clustered_index] = clustered_index
-        end
-        if change_stream_pre_and_post_images = args.use('changeStreamPreAndPostImages')
-          collection_opts[:change_stream_pre_and_post_images] = change_stream_pre_and_post_images
-        end
-        if view_on = args.use('viewOn')
-          collection_opts[:view_on] = view_on
-        end
-        if pipeline = args.use('pipeline')
-          collection_opts[:pipeline] = pipeline
-        end
-        if capped = args.use('capped')
-          collection_opts[:capped] = capped
-        end
-        if size = args.use('size')
-          collection_opts[:size] = size
-        end
-        if max = args.use('max')
-          collection_opts[:max] = max
-        end
-        database[args.use!('collection'), collection_opts].create(**opts)
-      end
-    end
-
-    def list_collections(op)
-      list_colls(op, name_only: false)
-    end
-
-    def list_collection_names(op)
-      list_colls(op, name_only: true)
-    end
-
-    def list_colls(op, name_only: false)
-      database = entities.get(:database, op.use!('object'))
-      use_arguments(op) do |args|
-        opts = extract_options(args, 'filter', 'timeoutMode', allow_extra: true)
-        symbolize_options!(opts, :timeout_mode)
-
-        if session = args.use('session')
-          opts[:session] = entities.get(:session, session)
-        end
-        if timeout_ms = args.use('timeoutMS')
-          opts[:timeout_ms] = timeout_ms
-        end
-
-        database.list_collections(**opts.merge(name_only: name_only))
-      end
-    end
-
-    def drop_collection(op)
-      database = entities.get(:database, op.use!('object'))
-      use_arguments(op) do |args|
-        collection = database[args.use!('collection')]
-        collection.drop
-      end
-    end
-
-    def rename(op)
-      collection = entities.get(:collection, op.use!('object'))
-      use_arguments(op) do |args|
-        to = args.use!('to')
-        cmd = {
-          renameCollection: "#{collection.database.name}.#{collection.name}",
-          to: "#{collection.database.name}.#{to}"
-        }
-
-        if args.key?("dropTarget")
-          cmd[:dropTarget] = args.use("dropTarget")
-        end
-
-        collection.client.use(:admin).command(**cmd)
-      end
-    end
-
-    def assert_collection_exists(op, state = true)
-      consume_test_runner(op)
-      use_arguments(op) do |args|
-        client = ClientRegistry.instance.global_client('authorized')
-        database = client.use(args.use!('databaseName')).database
-        collection_name = args.use!('collectionName')
-        if state
-          unless database.collection_names.include?(collection_name)
-            raise Error::ResultMismatch, "Expected collection #{collection_name} to exist, but it does not"
-          end
-        else
-          if database.collection_names.include?(collection_name)
-            raise Error::ResultMismatch, "Expected collection #{collection_name} to not exist, but it does"
-          end
-        end
-      end
-    end
-
-    def assert_collection_not_exists(op)
-      assert_collection_exists(op, false)
-    end
-
-    def list_indexes(op)
-      collection = entities.get(:collection, op.use!('object'))
-      use_arguments(op) do |args|
-        opts = extract_options(args, 'timeoutMode', allow_extra: true)
-        if session = args.use('session')
-          opts[:session] = entities.get(:session, session)
-        end
-        if timeout_ms = args.use('timeoutMS')
-          opts[:timeout_ms] = timeout_ms
-        end
-        collection.indexes(**opts).to_a
-      end
-    end
-
-    def drop_indexes(op)
-      collection = entities.get(:collection, op.use!('object'))
-      use_arguments(op) do |args|
-        opts = extract_options(args, 'maxTimeMS', 'timeoutMS', allow_extra: true)
-        collection.indexes.drop_all(**opts)
-      end
-    end
-
-    def create_index(op)
-      collection = entities.get(:collection, op.use!('object'))
-      use_arguments(op) do |args|
-        opts = {}
-        if session = args.use('session')
-          opts[:session] = entities.get(:session, session)
-        end
-        if args.key?('unique')
-          opts[:unique] = args.use('unique')
-        end
-        if timeout_ms = args.use('timeoutMS')
-          opts[:timeout_ms] = timeout_ms
-        end
-        if max_time_ms = args.use('maxTimeMS')
-          opts[:max_time_ms] = max_time_ms
-        end
-        collection.indexes.create_one(
-          args.use!('keys'),
-          name: args.use('name'),
-          **opts,
-        )
-      end
-    end
-
-    def drop_index(op)
-      collection = entities.get(:collection, op.use!('object'))
-      use_arguments(op) do |args|
-        opts = extract_options(args, 'maxTimeMS', 'timeoutMS', allow_extra: true)
-        if session = args.use('session')
-          opts[:session] = entities.get(:session, session)
-        end
-
-        collection.indexes.drop_one(
-          args.use!('name'),
-          **opts,
-        )
-      end
-    end
-
-
-    def assert_index_exists(op)
-      consume_test_runner(op)
-      use_arguments(op) do |args|
-        client = ClientRegistry.instance.global_client('authorized')
-        database = client.use(args.use!('databaseName'))
-        collection = database[args.use!('collectionName')]
-        index = collection.indexes.get(args.use!('indexName'))
-      end
-    end
-
-    def assert_index_not_exists(op)
-      consume_test_runner(op)
-      use_arguments(op) do |args|
-        client = ClientRegistry.instance.global_client('authorized')
-        database = client.use(args.use!('databaseName'))
-        collection = database[args.use!('collectionName')]
-        begin
-          index = collection.indexes.get(args.use!('indexName'))
-          raise Error::ResultMismatch, "Index found"
-        rescue Mongo::Error::OperationFailure::Family => e
-          if e.code == 26
-            # OK
-          else
-            raise
-          end
-        end
-      end
-    end
-
-    def create_entities(op)
-      consume_test_runner(op)
-      use_arguments(op) do |args|
-        generate_entities(args.use!('entities'))
-      end
-    end
-
-    def record_topology_description(op)
-      consume_test_runner(op)
-      use_arguments(op) do |args|
-        client = entities.get(:client, args.use!('client'))
-        entities.set(:topology, args.use!('id'), client.cluster.topology)
-      end
-    end
-
-    def assert_topology_type(op)
-      consume_test_runner(op)
-      use_arguments(op) do |args|
-        topology = entities.get(:topology, args.use!('topologyDescription'))
-        type = args.use!('topologyType')
-        unless topology.display_name == type
-          raise Error::ResultMismatch, "Expected topology type to be #{type}, but got #{topology.class}"
-        end
-      end
-    end
-
-    def retrieve_primary(topology)
-      topology.server_descriptions.detect { |k, desc| desc.primary? }&.first
-    end
-
-    def wait_for_primary_change(op)
-      consume_test_runner(op)
-      use_arguments(op) do |args|
-        client = entities.get(:client, args.use!('client'))
-        topology = entities.get(:topology, args.use!('priorTopologyDescription'))
-        timeout_ms = args.use('timeoutMS') || 10000
-        old_primary = retrieve_primary(topology)
-
-        deadline = Mongo::Utils.monotonic_time + timeout_ms / 1000.0
-        loop do
-          client.cluster.scan!
-          new_primary = client.cluster.next_primary.address
-          if new_primary && old_primary != new_primary
-            break
-          end
-          if Mongo::Utils.monotonic_time >= deadline
-            raise "Did not receive a change in primary from #{old_primary} in 10 seconds"
-          else
-            sleep 0.1
-          end
-        end
-      end
-    end
-  end
-end

data/spec/runners/unified/entity_map.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-# rubocop:todo all
-
-module Unified
-  class EntityMap
-    extend Forwardable
-
-    def initialize
-      @map = {}
-    end
-
-    def set(type, id, value)
-      @map[type] ||= {}
-      if @map[type][id]
-        raise Error::EntityMapOverwriteAttempt,
-          "Cannot set #{type} #{id} because it is already defined"
-      end
-      @map[type][id] = value
-    end
-
-    def get(type, id)
-      unless @map[type]
-        raise Error::EntityMissing, "There are no #{type} entities known"
-      end
-      unless v = @map[type][id]
-        raise Error::EntityMissing, "There is no #{type} #{id} known"
-      end
-      v
-    end
-
-    def get_any(id)
-      @map.each do |type, sub|
-        if sub[id]
-          return sub[id]
-        end
-      end
-      raise Error::EntityMissing, "There is no #{id} known"
-    end
-
-    def_delegators :@map, :[], :fetch
-  end
-end