chore: refactor test filters to typescript

test/mocha_mongodb.json

@@ -4,7 +4,7 @@
     "source-map-support/register",
     "ts-node/register",
     "test/tools/runner/chai-addons.js",
-    "test/tools/runner/hooks/configuration.js",
+    "test/tools/runner/hooks/configuration.ts",
     "test/tools/runner/hooks/unhandled_checker.ts",
     "test/tools/runner/hooks/leak_checker.ts",
     "test/tools/runner/hooks/legacy_crud_shims.ts"

test/tools/runner/config.ts

@@ -79,6 +79,7 @@ export class TestConfiguration {
   serverApi: ServerApi;
   activeResources: number;
   isSrv: boolean;
+  serverlessCredentials: { username: string | undefined; password: string | undefined };
 
   constructor(private uri: string, private context: Record<string, any>) {
     const url = new ConnectionString(uri);

test/tools/runner/filters/api_version_filter.js → test/tools/runner/filters/api_version_filter.ts

@@ -1,22 +1,26 @@
-'use strict';
+import { Filter } from './filter';
 
 /**
  * Filter for the MongoDB API Version required for the test
  *
- * example:
+ * @example
+ * ```js
  * metadata: {
  *    requires: {
  *      apiVersion: '1'
  *    }
  * }
+ * ```
  */
-class ApiVersionFilter {
+export class ApiVersionFilter extends Filter {
+  apiVersion: string | undefined;
   constructor() {
+    super();
     // Get environmental variables that are known
     this.apiVersion = process.env.MONGODB_API_VERSION;
   }
 
-  filter(test) {
+  filter(test: { metadata?: MongoDBMetadataUI }) {
     if (!test.metadata) return true;
     if (!test.metadata.requires) return true;
     const apiVersion = test.metadata.requires.apiVersion;
@@ -33,5 +37,3 @@ class ApiVersionFilter {
     return apiVersion === this.apiVersion;
   }
 }
-
-module.exports = ApiVersionFilter;

test/tools/runner/filters/auth_filter.js → test/tools/runner/filters/auth_filter.ts

@@ -1,21 +1,25 @@
-'use strict';
+import { Filter } from './filter';
 
 /**
  * Filter for authorization enabled or disabled on the server
  *
- * example:
+ * @example
+ * ```js
  * metadata: {
  *    requires: {
  *      auth: 'enabled' | 'disabled'
  *    }
  * }
+ * ```
  */
-class AuthFilter {
+export class AuthFilter extends Filter {
+  isAuthEnabled: boolean;
   constructor() {
+    super();
     this.isAuthEnabled = process.env.AUTH === 'auth';
   }
 
-  filter(test) {
+  filter(test: { metadata?: MongoDBMetadataUI }) {
     if (!test.metadata) return true;
     if (!test.metadata.requires) return true;
     if (!test.metadata.requires.auth) return true;
@@ -33,5 +37,3 @@ class AuthFilter {
     );
   }
 }
-
-module.exports = AuthFilter;

test/tools/runner/filters/client_encryption_filter.js → test/tools/runner/filters/client_encryption_filter.ts

@@ -1,22 +1,28 @@
-'use strict';
+import { readFile } from 'fs/promises';
+import { dirname, resolve } from 'path';
+import * as process from 'process';
 
-const { readFileSync } = require('fs');
-const { resolve } = require('path');
-const process = require('process');
+import { type MongoClient } from '../../../mongodb';
+import { Filter } from './filter';
 
 /**
  * Filter for whether or not a test needs / doesn't need Client Side Encryption
  *
- * example:
+ * @example
+ * ```js
  * metadata: {
  *    requires: {
  *      clientSideEncryption: true|false
  *    }
  * }
+ * ```
  */
 
-class ClientSideEncryptionFilter {
-  initializeFilter(client, context, callback) {
+export class ClientSideEncryptionFilter extends Filter {
+  enabled: boolean;
+  static version = null;
+
+  override async initializeFilter(client: MongoClient, context: Record<string, any>) {
     const CSFLE_KMS_PROVIDERS = process.env.CSFLE_KMS_PROVIDERS;
     let mongodbClientEncryption;
     try {
@@ -27,11 +33,12 @@ class ClientSideEncryptionFilter {
       }
     }
 
-    const { version } = JSON.parse(
-      readFileSync(
-        resolve(__dirname, '../../../../node_modules/mongodb-client-encryption', 'package.json')
+    ClientSideEncryptionFilter.version ??= JSON.parse(
+      await readFile(
+        resolve(dirname(require.resolve('mongodb-client-encryption')), '..', 'package.json'),
+        'utf8'
       )
-    );
+    ).version;
 
     this.enabled = !!(CSFLE_KMS_PROVIDERS && mongodbClientEncryption);
 
@@ -40,13 +47,11 @@ class ClientSideEncryptionFilter {
       enabled: this.enabled,
       mongodbClientEncryption,
       CSFLE_KMS_PROVIDERS,
-      version
+      version: ClientSideEncryptionFilter.version
     };
-
-    callback();
   }
 
-  filter(test) {
+  filter(test: { metadata?: MongoDBMetadataUI }) {
     const clientSideEncryption =
       test.metadata && test.metadata.requires && test.metadata.requires.clientSideEncryption;
 
@@ -66,5 +71,3 @@ class ClientSideEncryptionFilter {
     return this.enabled;
   }
 }
-
-module.exports = ClientSideEncryptionFilter;

test/tools/runner/filters/filter.ts

@@ -0,0 +1,11 @@
+import { type Test } from 'mocha';
+
+import { type MongoClient } from '../../../mongodb';
+
+export abstract class Filter {
+  async initializeFilter(_client: MongoClient, _context: Record<string, any>): Promise<void> {
+    return;
+  }
+
+  abstract filter(test: Test): string | boolean;
+}

test/tools/runner/filters/generic_predicate_filter.js → test/tools/runner/filters/generic_predicate_filter.ts

@@ -1,26 +1,26 @@
-'use strict';
-
 /**
  * Generic filter than can run predicates.
  *
  * Predicates cannot be async.  The test is skipped if the predicate returns
  * a string.  The string returned should be a skip reason.
  *
- * example:
+ * @example
+ * ```js
  * metadata: {
  *    requires: {
  *      predicate: (test: Mocha.Test) => true | string
  *    }
  * }
+ * ```
  */
 
-class GenericPredicateFilter {
-  filter(test) {
-    /** @type{ ((test?: Mocha.Test) => string | true) | undefined } */
-    const predicate = test?.metadata?.requires?.predicate;
+import { type Test } from 'mocha';
+
+import { Filter } from './filter';
 
+export class GenericPredicateFilter extends Filter {
+  filter(test: Test & { metadata?: MongoDBMetadataUI }) {
+    const predicate = test?.metadata?.requires?.predicate;
     return predicate?.(test) ?? true;
   }
 }
-
-module.exports = GenericPredicateFilter;

test/tools/runner/filters/idms_mock_server_filter.js → test/tools/runner/filters/idms_mock_server_filter.ts

@@ -1,6 +1,6 @@
-'use strict';
+import { get } from 'http';
 
-const { get } = require('http');
+import { Filter } from './filter';
 
 async function isMockServerSetup() {
   const url = (() => {
@@ -11,7 +11,7 @@ async function isMockServerSetup() {
     url.searchParams.append('resource', 'https://vault.azure.net');
     return url;
   })();
-  return new Promise((resolve, reject) => {
+  return new Promise<void>((resolve, reject) => {
     get(url, res => {
       if (res.statusCode === 200) {
         return resolve();
@@ -26,24 +26,28 @@ async function isMockServerSetup() {
 /**
  * Filter for tests that require the mock idms server to be running.
  *
- * example:
+ * @example
+ * ```js
  * metadata: {
  *    requires: {
  *      idmsMockServer: true
  *    }
  * }
+ * ```
  */
-class IDMSMockServerFilter {
-  initializeFilter(client, context, callback) {
-    isMockServerSetup()
-      .then(
-        () => (this.isRunning = true),
-        () => (this.isRunning = false)
-      )
-      .then(() => callback());
+export class IDMSMockServerFilter extends Filter {
+  isRunning: boolean;
+
+  override async initializeFilter() {
+    try {
+      await isMockServerSetup();
+      this.isRunning = true;
+    } catch (error) {
+      this.isRunning = false;
+    }
   }
 
-  filter(test) {
+  filter(test: { metadata?: MongoDBMetadataUI }) {
     if (!test.metadata) return true;
     if (!test.metadata.requires) return true;
     if (!test.metadata.requires.idmsMockServer) return true;
@@ -58,5 +62,3 @@ class IDMSMockServerFilter {
     return this.isRunning;
   }
 }
-
-module.exports = IDMSMockServerFilter;

test/tools/runner/filters/mongodb_topology_filter.js → test/tools/runner/filters/mongodb_topology_filter.ts

@@ -1,25 +1,29 @@
-'use strict';
-const { TopologyType } = require('../../../mongodb');
+import { type MongoClient, TopologyType } from '../../../mongodb';
+import { Filter } from './filter';
 
 /**
  * Filter for the MongoDB topology required for the test
  *
- * example:
+ * @example
+ * ```js
  * metadata: {
  *    requires: {
  *      topology: 'single' | 'replicaset' | 'sharded'
  *    }
  * }
+ * ```
  */
-class MongoDBTopologyFilter {
-  initializeFilter(client, context, callback) {
-    let type = client.topology.description.type;
+export class MongoDBTopologyFilter extends Filter {
+  runtimeTopology: string;
+
+  override async initializeFilter(client: MongoClient, context: Record<string, any>) {
+    const type = client.topology?.description.type;
+    if (type == null) throw new Error('unexpected nullish type' + client.topology?.description);
     context.topologyType = type;
     this.runtimeTopology = topologyTypeToString(type);
-    callback();
   }
 
-  filter(test) {
+  filter(test: { metadata?: MongoDBMetadataUI }) {
     if (!test.metadata) return true;
     if (!test.metadata.requires) return true;
     if (!test.metadata.requires.topology) return true;
@@ -72,5 +76,3 @@ function topologyTypeToString(topologyType) {
 
   return 'single';
 }
-
-module.exports = MongoDBTopologyFilter;