RUBY-2484 Update unified test runner for integration with drivers-atlas-testing (#2157)

* RUBY-2484 amend driver to be usable by astrolabe workload executor

* RUBY-2484 accept mongo client options override

Co-authored-by: Oleg Pudeyev <oleg@bsdpower.com>

Author: p-mongo

spec/runners/unified.rb

@@ -1,3 +1,4 @@
+require 'runners/unified/error'
 require 'runners/unified/entity_map'
 require 'runners/unified/event_subscriber'
 require 'runners/unified/test'

spec/runners/unified/assertions.rb

@@ -36,11 +36,11 @@ def assert_result_matches(actual, expected)
           if expected_v
             if expected_v.empty?
               if actual_v && !actual_v.empty?
-                raise "Actual not empty"
+                raise Error::ResultMismatch, "Actual not empty"
               end
             else
               if actual_v != expected_v
-                raise "Mismatch: actual #{actual_v}, expected #{expected_v}"
+                raise Error::ResultMismatch, "Mismatch: actual #{actual_v}, expected #{expected_v}"
               end
             end
           end
@@ -62,14 +62,14 @@ def assert_outcome
         actual_docs = collection.find({}, order: :_id).to_a
         assert_documents_match(actual_docs, expected_docs)
         unless spec.empty?
-          raise "Unhandled keys: #{spec}"
+          raise NotImplementedError, "Unhandled keys: #{spec}"
         end
       end
     end
 
     def assert_documents_match(actual, expected)
       unless actual.length == expected.length
-        raise "Unexpected number of documents: expected #{expected.length}, actual #{actual.length}"
+        raise Error::ResultMismatch, "Unexpected number of documents: expected #{expected.length}, actual #{actual.length}"
       end
 
       actual.each_with_index do |document, index|
@@ -81,7 +81,7 @@ def assert_document_matches(actual, expected, msg)
       unless actual == expected
     p actual
     p expected
-        raise "#{msg} does not match"
+        raise Error::ResultMismatch, "#{msg} does not match"
       end
     end
 
@@ -95,7 +95,7 @@ def assert_events
         expected_events = spec.use!('events')
         actual_events = subscriber.wanted_events
         unless actual_events.length == expected_events.length
-          raise "Event count mismatch: expected #{expected_events.length}, actual #{actual_events.length}\nExpected: #{expected_events}\nActual: #{actual_events}"
+          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)
@@ -122,22 +122,22 @@ def assert_event_matches(actual, expected)
 
     def assert_eq(actual, expected, msg)
       unless expected == actual
-        raise "#{msg}: expected #{expected}, actual #{actual}"
+        raise Error::ResultMismatch, "#{msg}: expected #{expected}, actual #{actual}"
       end
     end
 
     def assert_matches(actual, expected, msg)
       if actual.nil? && !expected.nil?
-        raise "#{msg}: expected #{expected} but got nil"
+        raise Error::ResultMismatch, "#{msg}: expected #{expected} but got nil"
       end
 
       case expected
       when Array
         unless Array === actual
-          raise "Expected an array, found #{actual}"
+          raise Error::ResultMismatch, "Expected an array, found #{actual}"
         end
         unless actual.length == expected.length
-          raise "Expected array of length #{expected.length}, found array of length #{actual.length}: #{actual}"
+          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}")
@@ -166,7 +166,7 @@ def assert_matches(actual, expected, msg)
           actual = actual.value
         end
         unless actual == expected
-          raise "#{msg}: expected #{expected}, actual #{actual}"
+          raise Error::ResultMismatch, "#{msg}: expected #{expected}, actual #{actual}"
         end
       end
     end
@@ -182,10 +182,10 @@ def assert_type(object, type)
       when 'date'
         Time === object
       else
-        raise "Unhandled type #{type}"
+        raise NotImplementedError, "Unhandled type #{type}"
       end
       unless ok
-        raise "Object #{object} is not of type #{type}"
+        raise Error::ResultMismatch, "Object #{object} is not of type #{type}"
       end
     end
 
@@ -198,46 +198,46 @@ def assert_value_matches(actual, expected, msg)
         when '$$unsetOrMatches'
           if actual
             unless actual == expected_v
-              raise "Mismatch for #{msg}: expected #{expected}, have #{actual}"
+              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 "Hex bytes do not match"
+            raise Error::ResultMismatch, "Hex bytes do not match"
           end
         when '$$exists'
           case expected_v
           when true
             if actual.nil?
-              raise "#{msg}: wanted value to exist, but it did not"
+              raise Error::ResultMismatch, "#{msg}: wanted value to exist, but it did not"
             end
           when false
             if actual
-              raise "#{msg}: wanted value to not exist, but it did"
+              raise Error::ResultMismatch, "#{msg}: wanted value to not exist, but it did"
             end
           else
-            raise "Bogus value #{expected_v}"
+            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 "Session does not match: wanted #{expected_session}, have #{actual_v}"
+          #  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 "Actual value #{actual} does not match entity #{expected_v} with value #{result}"
+            raise Error::ResultMismatch, "Actual value #{actual} does not match entity #{expected_v} with value #{result}"
           end
         else
-          raise "Unknown operator #{operator}"
+          raise NotImplementedError, "Unknown operator #{operator}"
         end
       else
         if actual != expected
-          raise "Mismatch for #{msg}: expected #{expected}, have #{actual}"
+          raise Error::ResultMismatch, "Mismatch for #{msg}: expected #{expected}, have #{actual}"
         end
       end
     end

spec/runners/unified/crud_operations.rb

@@ -54,6 +54,13 @@ def insert_many(op)
       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 replace_one(op)
       collection = entities.get(:collection, op.use!('object'))
       use_arguments(op) do |args|
@@ -86,7 +93,7 @@ def bulk_write(op)
 
     def convert_bulk_write_spec(spec)
       unless spec.keys.length == 1
-        raise "Must have exactly one item"
+        raise NotImplementedError, "Must have exactly one item"
       end
       op, spec = spec.first
       spec = UsingHash[spec]
@@ -110,10 +117,10 @@ def convert_bulk_write_spec(spec)
           filter: spec.use('filter'),
         }
       else
-        raise "Unknown operation #{op}"
+        raise NotImplementedError, "Unknown operation #{op}"
       end
       unless spec.empty?
-        raise "Unhandled keys: #{spec}"
+        raise NotImplementedError, "Unhandled keys: #{spec}"
       end
       {Utils.underscore(op) =>out}
     end
@@ -123,7 +130,7 @@ def aggregate(op)
       args = op.use!('arguments')
       pipeline = args.use!('pipeline')
       unless args.empty?
-        raise "Unhandled spec keys: #{test_spec}"
+        raise NotImplementedError, "Unhandled spec keys: #{test_spec}"
       end
       obj.aggregate(pipeline).to_a
     end

spec/runners/unified/ddl_operations.rb

@@ -34,11 +34,11 @@ def assert_collection_exists(op, state = true)
         collection_name = args.use!('collectionName')
         if state
           unless database.collection_names.include?(collection_name)
-            raise "Expected collection #{collection_name} to exist, but it does not"
+            raise Error::ResultMismatch, "Expected collection #{collection_name} to exist, but it does not"
           end
         else
           if database.collection_names.include?(collection_name)
-            raise "Expected collection #{collection_name} to not exist, but it does"
+            raise Error::ResultMismatch, "Expected collection #{collection_name} to not exist, but it does"
           end
         end
       end
@@ -82,7 +82,7 @@ def assert_index_not_exists(op)
         collection = database[args.use!('collectionName')]
         begin
           index = collection.indexes.get(args.use!('indexName'))
-          raise "Index found"
+          raise Error::ResultMismatch, "Index found"
         rescue Mongo::Error::OperationFailure => e
           if e.code == 26
             # OK

spec/runners/unified/entity_map.rb

@@ -7,17 +7,18 @@ def initialize
     def set(type, id, value)
       @map[type] ||= {}
       if @map[type][id]
-        raise "Cannot set #{type} #{id} because it is already defined"
+        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 "There are no #{type} entities known"
+        raise Error::EntityMissing, "There are no #{type} entities known"
       end
       unless v = @map[type][id]
-        raise "There is no #{type} #{id} known"
+        raise Error::EntityMissing, "There is no #{type} #{id} known"
       end
       v
     end
@@ -28,7 +29,7 @@ def get_any(id)
           return sub[id]
         end
       end
-      raise "There is no #{id} known"
+      raise Error::EntityMissing, "There is no #{id} known"
     end
 
     def [](type)

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

spec/runners/unified/event_subscriber.rb

@@ -1,3 +1,5 @@
+require 'support/event_subscriber'
+
 module Unified
 
   class EventSubscriber < ::EventSubscriber

spec/runners/unified/exceptions.rb

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

spec/runners/unified/grid_fs_operations.rb

@@ -39,10 +39,10 @@ def upload(op)
     def transform_contents(contents)
       if Hash === contents
         if contents.length != 1
-          raise "Wanted hash with one element"
+          raise NotImplementedError, "Wanted hash with one element"
         end
         if contents.keys.first != '$$hexBytes'
-          raise "$$hexBytes is the only key supported"
+          raise NotImplementedError, "$$hexBytes is the only key supported"
         end
 
         decode_hex_bytes(contents.values.first)

spec/runners/unified/support_operations.rb

@@ -58,18 +58,18 @@ def assert_same_lsid_on_last_two_commands(op, expected: true)
         client = entities.get(:client, args.use!('client'))
         subscriber = @subscribers.fetch(client)
         unless subscriber.started_events.length >= 2
-          raise "Must have at least 2 events, have #{subscriber.started_events.length}"
+          raise Error::ResultMismatch, "Must have at least 2 events, have #{subscriber.started_events.length}"
         end
         lsids = subscriber.started_events[-2...-1].map do |cmd|
           cmd.command.fetch('lsid')
         end
         if expected
           unless lsids.first == lsids.last
-            raise "lsids differ but they were expected to be the same"
+            raise Error::ResultMismatch, "lsids differ but they were expected to be the same"
           end
         else
           if lsids.first == lsids.last
-            raise "lsids are the same but they were expected to be different"
+            raise Error::ResultMismatch, "lsids are the same but they were expected to be different"
           end
         end
       end
@@ -92,7 +92,7 @@ def assert_session_transaction_state(op)
         session = entities.get(:session, args.use!('session'))
         state = args.use!('state')
         unless session.send("#{state}_transaction?")
-          raise "Expected session to have state #{state}"
+          raise Error::ResultMismatch, "Expected session to have state #{state}"
         end
       end
     end
@@ -138,11 +138,11 @@ def assert_session_pinned(op, state = true)
 
         if state
           unless session.pinned_server
-            raise 'Expected session to be pinned but it is not'
+            raise Error::ResultMismatch, 'Expected session to be pinned but it is not'
           end
         else
           if session.pinned_server
-            raise 'Expected session to be not pinned but it is'
+            raise Error::ResultMismatch, 'Expected session to be not pinned but it is'
           end
         end
       end
@@ -156,14 +156,14 @@ def assert_session_unpinned(op)
 
     def assert_no_arguments(op)
       if op.key?('arguments')
-        raise "Arguments are not allowed"
+        raise NotimplementedError, "Arguments are not allowed"
       end
     end
 
     def consume_test_runner(op)
       v = op.use!('object')
       unless v == 'testRunner'
-        raise 'Expected object to be testRunner'
+        raise NotImplementedError, 'Expected object to be testRunner'
       end
     end