mongo 2.14.0 → 2.15.0.alpha

data/spec/runners/unified/change_stream_operations.rb

@@ -0,0 +1,26 @@
+module Unified
+
+  module ChangeStreamOperations
+
+    def create_change_stream(op)
+      object_id = op.use!('object')
+      object = entities.get_any(object_id)
+      use_arguments(op) do |args|
+        pipeline = args.use!('pipeline')
+        opts = {}
+        if batch_size = args.use('batchSize')
+          opts[:batch_size] = batch_size
+        end
+        cs = object.watch(pipeline, **opts)
+        name = op.use!('saveResultAsEntity')
+        entities.set(:change_stream, name, cs)
+      end
+    end
+
+    def iterate_until_document_or_error(op)
+      object_id = op.use!('object')
+      object = entities.get(:change_stream, object_id)
+      object.to_enum.next
+    end
+  end
+end

data/spec/runners/unified/crud_operations.rb

@@ -0,0 +1,199 @@
+module Unified
+
+  module CrudOperations
+
+    def find(op)
+      collection = entities.get(:collection, op.use!('object'))
+      use_arguments(op) do |args|
+        req = collection.find(args.use!('filter'))
+        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
+        result = req.to_a
+      end
+    end
+
+    def count_documents(op)
+      collection = entities.get(:collection, op.use!('object'))
+      use_arguments(op) do |args|
+        collection.find(args.use!('filter')).count_documents
+      end
+    end
+
+    def estimated_document_count(op)
+      collection = entities.get(:collection, op.use!('object'))
+      use_arguments(op) do |args|
+        opts = {}
+        if max_time_ms = args.use('maxTimeMS')
+          opts[:max_time_ms] = max_time_ms
+        end
+        collection.estimated_document_count(**opts)
+      end
+    end
+
+    def distinct(op)
+      collection = entities.get(:collection, op.use!('object'))
+      use_arguments(op) do |args|
+        req = collection.find(args.use!('filter')).distinct(args.use!('fieldName'))
+        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 = {}
+        if return_document = args.use('returnDocument')
+          opts[:return_document] = return_document.downcase.to_sym
+        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')
+        collection.find_one_and_replace(filter, update)
+      end
+    end
+
+    def find_one_and_delete(op)
+      collection = entities.get(:collection, op.use!('object'))
+      use_arguments(op) do |args|
+        filter = args.use!('filter')
+        collection.find_one_and_delete(filter)
+      end
+    end
+
+    def insert_one(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
+        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|
+        options = {}
+        unless (ordered = args.use('ordered')).nil?
+          options[:ordered] = ordered
+        end
+        collection.insert_many(args.use!('documents'), **options)
+      end
+    end
+
+    def update_one(op)
+      collection = entities.get(:collection, op.use!('object'))
+      use_arguments(op) do |args|
+        collection.update_one(args.use!('filter'), args.use!('update'))
+      end
+    end
+
+    def update_many(op)
+      collection = entities.get(:collection, op.use!('object'))
+      use_arguments(op) do |args|
+        collection.update_many(args.use!('filter'), args.use!('update'))
+      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'),
+          upsert: args.use('upsert'),
+        )
+      end
+    end
+
+    def delete_one(op)
+      collection = entities.get(:collection, op.use!('object'))
+      use_arguments(op) do |args|
+        collection.delete_one(args.use!('filter'))
+      end
+    end
+
+    def delete_many(op)
+      collection = entities.get(:collection, op.use!('object'))
+      use_arguments(op) do |args|
+        collection.delete_many(args.use!('filter'))
+      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 ordered = args.use('ordered')
+          opts[:ordered] = true
+        end
+        collection.bulk_write(requests, **opts)
+      end
+    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'),
+        }
+      when 'replaceOne'
+        {
+          filter: spec.use('filter'),
+          replacement: spec.use('replacement'),
+          upsert: spec.use('upsert'),
+        }
+      when 'deleteOne', 'deleteMany'
+        {
+          filter: spec.use('filter'),
+        }
+      else
+        raise NotImplementedError, "Unknown operation #{op}"
+      end
+      unless spec.empty?
+        raise NotImplementedError, "Unhandled keys: #{spec}"
+      end
+      {Utils.underscore(op) =>out}
+    end
+
+    def aggregate(op)
+      obj = entities.get_any(op.use!('object'))
+      args = op.use!('arguments')
+      pipeline = args.use!('pipeline')
+      unless args.empty?
+        raise NotImplementedError, "Unhandled spec keys: #{test_spec}"
+      end
+      obj.aggregate(pipeline).to_a
+    end
+  end
+end

data/spec/runners/unified/ddl_operations.rb

@@ -0,0 +1,96 @@
+module Unified
+
+  module DdlOperations
+
+    def list_databases(op)
+      client = entities.get(:client, op.use!('object'))
+      client.list_databases
+    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
+        database[args.use!('collection')].create(**opts)
+      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 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 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
+
+        collection.indexes.create_one(
+          args.use!('keys'),
+          name: 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 => e
+          if e.code == 26
+            # OK
+          else
+            raise
+          end
+        end
+      end
+    end
+  end
+end

data/spec/runners/unified/entity_map.rb

@@ -0,0 +1,39 @@
+module Unified
+  class EntityMap
+    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 [](type)
+      @map[type]
+    end
+  end
+end

data/spec/runners/unified/error.rb

@@ -0,0 +1,25 @@
+module Unified
+
+  class Error < StandardError
+
+    class ResultMismatch < Error
+    end
+
+    class ErrorMismatch < Error
+    end
+
+    class UnhandledField < Error
+    end
+
+    class EntityMapOverwriteAttempt < Error
+    end
+
+    class EntityMissing < Error
+    end
+
+    class InvalidTest < Error
+    end
+
+  end
+
+end

data/spec/runners/unified/event_subscriber.rb

@@ -0,0 +1,91 @@
+require 'support/event_subscriber'
+
+module Unified
+
+  class EventSubscriber < ::EventSubscriber
+    def ignore_commands(command_names)
+      @ignore_commands = command_names
+    end
+
+    def wanted_events
+      all_events.select do |event|
+        kind = event.class.name.sub(/.*::/, '').sub('Command', '').downcase.to_sym
+        @wanted_events[kind]
+      end.select do |event|
+        event.command_name != 'configureFailPoint' &&
+          if @ignore_commands
+            !@ignore_commands.include?(event.command_name)
+          else
+            true
+          end
+      end.reject do |event|
+        %w(authenticate getnonce saslStart saslContinue).include?(event.command_name)
+      end
+    end
+
+    def add_wanted_events(kind)
+      @wanted_events ||= {}
+      @wanted_events[kind] = true
+    end
+  end
+
+  class StoringEventSubscriber
+    def initialize(&block)
+      @handler = block
+    end
+
+    def started(event)
+      @handler.call(
+        'name' => event.class.name.sub(/.*::/, '') + 'Event',
+        'commandName' => event.command_name,
+        'databaseName' => event.database_name,
+        'observedAt' => Time.now.to_f,
+        'address' => event.address.seed,
+        'requestId' => event.request_id,
+        'operationId' => event.operation_id,
+        'connectionId' => event.connection_id,
+      )
+    end
+
+    def succeeded(event)
+      @handler.call(
+        'name' => event.class.name.sub(/.*::/, '') + 'Event',
+        'commandName' => event.command_name,
+        'duration' => event.duration,
+        'observedAt' => Time.now.to_f,
+        'address' => event.address.seed,
+        'requestId' => event.request_id,
+        'operationId' => event.operation_id,
+      )
+    end
+
+    def failed(event)
+      @handler.call(
+        'name' => event.class.name.sub(/.*::/, '') + 'Event',
+        'commandName' => event.command_name,
+        'duration' => event.duration,
+        'failure' => event.failure,
+        'observedAt' => Time.now.to_f,
+        'address' => event.address.seed,
+        'requestId' => event.request_id,
+        'operationId' => event.operation_id,
+      )
+    end
+
+    def published(event)
+      payload = {
+        'name' => event.class.name.sub(/.*::/, '') + 'Event',
+        'observedAt' => Time.now.to_f,
+        'address' => event.address.seed,
+      }.tap do |entry|
+        if event.respond_to?(:connection_id)
+          entry['connectionId'] = event.connection_id
+        end
+        if event.respond_to?(:reason)
+          entry['reason'] = event.reason
+        end
+      end
+      @handler.call(payload)
+    end
+  end
+end