wip run csot spec tests

Author: W-A-James

test/integration/client-side-operations-timeout/client_side_operations_timeout.spec.test.ts

@@ -4,6 +4,6 @@ import { loadSpecTests } from '../../spec';
 import { runUnifiedSuite } from '../../tools/unified-spec-runner/runner';
 
 // TODO(NODE-5823): Implement unified runner operations and options support for CSOT
-describe.skip('CSOT spec tests', function () {
+describe('CSOT spec tests', function () {
   runUnifiedSuite(loadSpecTests(join('client-side-operations-timeout')));
 });

test/mongodb.ts

@@ -201,6 +201,7 @@ export * from '../src/sdam/topology';
 export * from '../src/sdam/topology_description';
 export * from '../src/sessions';
 export * from '../src/sort';
+export * from '../src/timeout';
 export * from '../src/transactions';
 export * from '../src/utils';
 export * from '../src/write_concern';

test/tools/unified-spec-runner/match.ts

@@ -20,6 +20,7 @@ import {
   ConnectionPoolCreatedEvent,
   ConnectionPoolReadyEvent,
   ConnectionReadyEvent,
+  CSOTError,
   type Document,
   Long,
   MongoError,
@@ -134,7 +135,19 @@ export function isSpecialOperator(value: unknown): value is SpecialOperator {
 
 const TYPE_MAP = new Map();
 
-TYPE_MAP.set('double', actual => typeof actual === 'number' || actual._bsontype === 'Double');
+function hasBSONType(value: unknown): value is { _bsontype: string } & Record<string, any> {
+  return (
+    typeof value === 'object' &&
+    value != null &&
+    '_bsontype' in value &&
+    typeof value._bsontype === 'string'
+  );
+}
+
+TYPE_MAP.set(
+  'double',
+  actual => typeof actual === 'number' || (hasBSONType(actual) && actual._bsontype === 'Double')
+);
 TYPE_MAP.set('string', actual => typeof actual === 'string');
 TYPE_MAP.set('object', actual => typeof actual === 'object' && actual !== null);
 TYPE_MAP.set('array', actual => Array.isArray(actual));
@@ -144,18 +157,26 @@ TYPE_MAP.set('objectId', actual => actual instanceof ObjectId);
 TYPE_MAP.set('bool', actual => typeof actual === 'boolean');
 TYPE_MAP.set('date', actual => actual instanceof Date);
 TYPE_MAP.set('null', actual => actual === null);
-TYPE_MAP.set('regex', actual => actual instanceof RegExp || actual._bsontype === 'BSONRegExp');
-TYPE_MAP.set('dbPointer', actual => actual._bsontype === 'DBRef');
-TYPE_MAP.set('javascript', actual => actual._bsontype === 'Code');
-TYPE_MAP.set('symbol', actual => actual._bsontype === 'Symbol');
-TYPE_MAP.set('javascriptWithScope', actual => actual._bsontype === 'Code' && actual.scope);
-TYPE_MAP.set('timestamp', actual => actual._bsontype === 'Timestamp');
-TYPE_MAP.set('decimal', actual => actual._bsontype === 'Decimal128');
-TYPE_MAP.set('minKey', actual => actual._bsontype === 'MinKey');
-TYPE_MAP.set('maxKey', actual => actual._bsontype === 'MaxKey');
+TYPE_MAP.set(
+  'regex',
+  actual => actual instanceof RegExp || (hasBSONType(actual) && actual._bsontype === 'BSONRegExp')
+);
+TYPE_MAP.set('dbPointer', actual => hasBSONType(actual) && actual._bsontype === 'DBRef');
+TYPE_MAP.set('javascript', actual => hasBSONType(actual) && actual._bsontype === 'Code');
+TYPE_MAP.set('symbol', actual => hasBSONType(actual) && actual._bsontype === 'Symbol');
+TYPE_MAP.set(
+  'javascriptWithScope',
+  actual => hasBSONType(actual) && actual._bsontype === 'Code' && actual.scope
+);
+TYPE_MAP.set('timestamp', actual => hasBSONType(actual) && actual._bsontype === 'Timestamp');
+TYPE_MAP.set('decimal', actual => hasBSONType(actual) && actual._bsontype === 'Decimal128');
+TYPE_MAP.set('minKey', actual => hasBSONType(actual) && actual._bsontype === 'MinKey');
+TYPE_MAP.set('maxKey', actual => hasBSONType(actual) && actual._bsontype === 'MaxKey');
 TYPE_MAP.set(
   'int',
-  actual => (typeof actual === 'number' && Number.isInteger(actual)) || actual._bsontype === 'Int32'
+  actual =>
+    (typeof actual === 'number' && Number.isInteger(actual)) ||
+    (hasBSONType(actual) && actual._bsontype === 'Int32')
 );
 TYPE_MAP.set(
   'long',
@@ -342,7 +363,7 @@ export function specialCheck(
     for (const type of types) {
       ok ||= TYPE_MAP.get(type)(actual);
     }
-    expect(ok, `Expected [${actual}] to be one of [${types}]`).to.be.true;
+    expect(ok, `Expected [${actual}] to be one of [${types}] at ${path.join('')}`).to.be.true;
   } else if (isExistsOperator(expected)) {
     // $$exists
     const actualExists = actual !== undefined && actual !== null;
@@ -728,6 +749,10 @@ export function expectErrorCheck(
     expect(error, expectMessage).to.be.instanceOf(MongoError);
   }
 
+  if (expected.isTimeoutError === true) {
+    expect(CSOTError.is(error), error.stack).to.be.true;
+  }
+
   if (expected.isClientError === false) {
     expect(error).to.be.instanceOf(MongoServerError);
   } else if (expected.isClientError === true) {
@@ -741,19 +766,19 @@ export function expectErrorCheck(
   }
 
   if (expected.errorCode != null) {
-    expect(error, expectMessage).to.have.property('code', expected.errorCode);
+    expect(error).to.have.property('code', expected.errorCode);
   }
 
   if (expected.errorCodeName != null) {
-    expect(error, expectMessage).to.have.property('codeName', expected.errorCodeName);
+    expect(error).to.have.property('codeName', expected.errorCodeName);
   }
 
   if (expected.errorLabelsContain != null) {
     const mongoError = error as MongoError;
     for (const errorLabel of expected.errorLabelsContain) {
       expect(
         mongoError.hasErrorLabel(errorLabel),
-        `Error was supposed to have label ${errorLabel}, has [${mongoError.errorLabels}] -- ${expectMessage}`
+        `Error was supposed to have label ${errorLabel}, has [${mongoError.errorLabels}]`
       ).to.be.true;
     }
   }
@@ -763,7 +788,7 @@ export function expectErrorCheck(
     for (const errorLabel of expected.errorLabelsOmit) {
       expect(
         mongoError.hasErrorLabel(errorLabel),
-        `Error was not supposed to have label ${errorLabel}, has [${mongoError.errorLabels}] -- ${expectMessage}`
+        `Error was not supposed to have label ${errorLabel}, has [${mongoError.errorLabels}]`
       ).to.be.false;
     }
   }

test/tools/unified-spec-runner/operations.ts

@@ -198,7 +198,12 @@ operations.set('assertNumberConnectionsCheckedOut', async ({ entities, operation
 operations.set('bulkWrite', async ({ entities, operation }) => {
   const collection = entities.getEntity('collection', operation.object);
   const { requests, ...opts } = operation.arguments!;
-  return collection.bulkWrite(requests, opts);
+  const start = Math.trunc(performance.now());
+  const res = await collection.bulkWrite(requests, opts);
+  const end = Math.trunc(performance.now());
+
+  console.log(`bulkWrite took: ${end - start} ms`);
+  return res;
 });
 
 // The entity exists for the name but can potentially have the wrong

test/tools/unified-spec-runner/schema.ts

@@ -362,6 +362,7 @@ export interface StoreEventsAsEntity {
 export interface ExpectedError {
   isError?: true;
   isClientError?: boolean;
+  isTimeoutError?: boolean;
   errorContains?: string;
   errorCode?: number;
   errorCodeName?: string;