mongo 2.14.1 → 2.15.0.alpha

data/spec/runners/unified/assertions.rb

@@ -0,0 +1,249 @@
+module Unified
+
+  module Assertions
+
+    def assert_result_matches(actual, expected)
+      if Hash === expected
+        use_all(expected, 'expected result', expected) do |expected|
+          %w(deleted inserted matched modified upserted).each do |k|
+            if count = expected.use("#{k}Count")
+              if Hash === count || count > 0
+                actual_count = case actual
+                when Mongo::BulkWrite::Result, Mongo::Operation::Delete::Result
+                  actual.send("#{k}_count")
+                else
+                  actual["n_#{k}"]
+                end
+                assert_value_matches(actual_count, count, "#{k} count")
+              end
+            end
+          end
+          %w(inserted upserted).each do |k|
+            expected_v = expected.use("#{k}Ids")
+            next unless expected_v
+            actual_v = case actual
+            when Mongo::BulkWrite::Result, Mongo::Operation::Update::Result
+              # Ruby driver returns inserted ids as an array of ids.
+              # The yaml file specifies them as a map from operation.
+              if Hash === expected_v && expected_v.keys == %w($$unsetOrMatches)
+                expected_v = expected_v.values.first.values
+              elsif Hash === expected_v
+                expected_v = expected_v.values
+              end
+              actual.send("#{k}_ids")
+            else
+              actual["#{k}_ids"]
+            end
+            if expected_v
+              if expected_v.empty?
+                if actual_v && !actual_v.empty?
+                  raise Error::ResultMismatch, "Actual not empty"
+                end
+              else
+                if actual_v != expected_v
+                  raise Error::ResultMismatch, "Mismatch: actual #{actual_v}, expected #{expected_v}"
+                end
+              end
+            end
+          end
+
+          assert_matches(actual, expected, 'result')
+          expected.clear
+        end
+      else
+        assert_matches(actual, expected, 'result')
+      end
+    end
+
+    def assert_outcome
+      return unless outcome
+
+      client = ClientRegistry.instance.global_client('authorized')
+      outcome.each do |spec|
+        spec = UsingHash[spec]
+        collection = client.use(spec.use!('databaseName'))[spec.use!('collectionName')]
+        expected_docs = spec.use!('documents')
+        actual_docs = collection.find({}, order: :_id).to_a
+        assert_documents_match(actual_docs, expected_docs)
+        unless spec.empty?
+          raise NotImplementedError, "Unhandled keys: #{spec}"
+        end
+      end
+    end
+
+    def assert_documents_match(actual, expected)
+      unless actual.length == expected.length
+        raise Error::ResultMismatch, "Unexpected number of documents: expected #{expected.length}, actual #{actual.length}"
+      end
+
+      actual.each_with_index do |document, index|
+        assert_matches(document, expected[index], "document ##{index}")
+      end
+    end
+
+    def assert_document_matches(actual, expected, msg)
+      unless actual == expected
+    p actual
+    p expected
+        raise Error::ResultMismatch, "#{msg} does not match"
+      end
+    end
+
+    def assert_events
+      return unless @expected_events
+      @expected_events.each do |spec|
+        spec = UsingHash[spec]
+        client_id = spec.use!('client')
+        client = entities.get(:client, client_id)
+        subscriber = @subscribers.fetch(client)
+        expected_events = spec.use!('events')
+        actual_events = subscriber.wanted_events
+        unless actual_events.length == expected_events.length
+          raise Error::ResultMismatch, "Event count mismatch: expected #{expected_events.length}, actual #{actual_events.length}\nExpected: #{expected_events}\nActual: #{actual_events}"
+        end
+        expected_events.each_with_index do |event, i|
+          assert_event_matches(actual_events[i], event)
+        end
+      end
+    end
+
+    def assert_event_matches(actual, expected)
+      assert_eq(expected.keys.length, 1, "Expected event must have one key: #{expected}")
+      expected_name, spec = expected.first
+      spec = UsingHash[spec]
+      expected_name = expected_name.sub(/Event$/, '').sub(/^(.)/) { $1.upcase }
+      assert_eq(actual.class.name.sub(/.*::/, ''), expected_name, 'Event name does not match')
+      if db_name = spec.use('databaseName')
+        assert_eq(actual.database_name, db_name, 'Database names differ')
+      end
+      if command_name = spec.use('commandName')
+        assert_eq(actual.command_name, command_name, 'Command names differ')
+      end
+      if command = spec.use('command')
+        assert_matches(actual.command, command, 'Commands differ')
+      end
+    end
+
+    def assert_eq(actual, expected, msg)
+      unless expected == actual
+        raise Error::ResultMismatch, "#{msg}: expected #{expected}, actual #{actual}"
+      end
+    end
+
+    def assert_matches(actual, expected, msg)
+      if actual.nil? && !expected.nil?
+        raise Error::ResultMismatch, "#{msg}: expected #{expected} but got nil"
+      end
+
+      case expected
+      when Array
+        unless Array === actual
+          raise Error::ResultMismatch, "Expected an array, found #{actual}"
+        end
+        unless actual.length == expected.length
+          raise Error::ResultMismatch, "Expected array of length #{expected.length}, found array of length #{actual.length}: #{actual}"
+        end
+        expected.each_with_index do |v, i|
+          assert_matches(actual[i], v, "#{msg}: index #{i}")
+        end
+      when Hash
+        if expected.keys == %w($$unsetOrMatches) && expected.values.first.keys == %w(insertedId)
+          actual_v = actual.inserted_id
+          expected_v = expected.values.first.values.first
+          assert_value_matches(actual_v, expected_v, 'inserted_id')
+        else
+          expected.each do |k, expected_v|
+            if k.start_with?('$$')
+              assert_value_matches(actual, expected, k)
+            else
+              actual_v = actual[k]
+              if Hash === expected_v && expected_v.length == 1 && expected_v.keys.first.start_with?('$$')
+                assert_value_matches(actual_v, expected_v, k)
+              else
+                assert_matches(actual_v, expected_v, "#{msg}: key #{k}")
+              end
+            end
+          end
+        end
+      else
+        if Integer === expected && BSON::Int64 === actual
+          actual = actual.value
+        end
+        unless actual == expected
+          raise Error::ResultMismatch, "#{msg}: expected #{expected}, actual #{actual}"
+        end
+      end
+    end
+
+    def assert_type(object, type)
+      ok = case type
+      when 'object'
+        Hash === object
+      when %w(int long)
+        Integer === object || BSON::Int32 === object || BSON::Int64 === object
+      when 'objectId'
+        BSON::ObjectId === object
+      when 'date'
+        Time === object
+      else
+        raise NotImplementedError, "Unhandled type #{type}"
+      end
+      unless ok
+        raise Error::ResultMismatch, "Object #{object} is not of type #{type}"
+      end
+    end
+
+    def assert_value_matches(actual, expected, msg)
+      if Hash === expected && expected.keys.length == 1 &&
+        (operator = expected.keys.first).start_with?('$$')
+      then
+        expected_v = expected.values.first
+        case operator
+        when '$$unsetOrMatches'
+          if actual
+            unless actual == expected_v
+              raise Error::ResultMismatch, "Mismatch for #{msg}: expected #{expected}, have #{actual}"
+            end
+          end
+        when '$$matchesHexBytes'
+          expected_data = decode_hex_bytes(expected_v)
+          unless actual == expected_data
+            raise Error::ResultMismatch, "Hex bytes do not match"
+          end
+        when '$$exists'
+          case expected_v
+          when true
+            if actual.nil?
+              raise Error::ResultMismatch, "#{msg}: wanted value to exist, but it did not"
+            end
+          when false
+            if actual
+              raise Error::ResultMismatch, "#{msg}: wanted value to not exist, but it did"
+            end
+          else
+            raise NotImplementedError, "Bogus value #{expected_v}"
+          end
+        when '$$sessionLsid'
+          expected_session = entities.get(:session, expected_v)
+          # TODO - sessions do not expose server sessions after being ended
+          #unless actual_v == {'id' => expected_session.server_session.session_id.to_bson}
+          #  raise Error::ResultMismatch, "Session does not match: wanted #{expected_session}, have #{actual_v}"
+          #end
+        when '$$type'
+          assert_type(actual, expected_v)
+        when '$$matchesEntity'
+          result = entities.get(:result, expected_v)
+          unless actual == result
+            raise Error::ResultMismatch, "Actual value #{actual} does not match entity #{expected_v} with value #{result}"
+          end
+        else
+          raise NotImplementedError, "Unknown operator #{operator}"
+        end
+      else
+        if actual != expected
+          raise Error::ResultMismatch, "Mismatch for #{msg}: expected #{expected}, have #{actual}"
+        end
+      end
+    end
+  end
+end

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