tests + utils

Author: baileympearson

test/integration/crud/explain.test.ts

@@ -8,9 +8,10 @@ import {
   type Document,
   type MongoClient,
   MongoOperationTimeoutError,
-  MongoServerError
+  MongoServerError,
+  now
 } from '../../mongodb';
-import { clearFailPoint, configureFailPoint } from '../../tools/utils';
+import { clearFailPoint, configureFailPoint, measureDuration } from '../../tools/utils';
 import { filterForCommands } from '../shared';
 
 const explain = [true, false, 'queryPlanner', 'allPlansExecution', 'executionStats', 'invalid'];
@@ -334,10 +335,14 @@ describe('CRUD API explain option', function () {
 
     describe('when a cursor api is being explained', function () {
       describe('when timeoutMS is provided', function () {
-        test('the explain command respects timeoutMS', async function () {
+        test('the explain command times out after timeoutMS', async function () {
           const cursor = client.db('foo').collection('bar').find({}, { timeoutMS: 1000 });
-          const timeout = await cursor.explain({ verbosity: 'queryPlanner' }).catch(e => e);
-          expect(timeout).to.be.instanceOf(MongoOperationTimeoutError);
+          const { duration, result } = await measureDuration(() =>
+            cursor.explain({ verbosity: 'queryPlanner' }).catch(e => e)
+          );
+
+          expect(result).to.be.instanceOf(MongoOperationTimeoutError);
+          expect(duration).to.be.within(1000, 1000 + 100);
         });
 
         test('the explain command has the calculated maxTimeMS value attached', async function () {
@@ -384,19 +389,23 @@ describe('CRUD API explain option', function () {
 
     describe('when a non-cursor api is being explained', function () {
       describe('when timeoutMS is provided', function () {
-        test('the explain command respects timeoutMS', async function () {
-          const timeout = await client
-            .db('foo')
-            .collection('bar')
-            .deleteMany(
-              {},
-              {
-                timeoutMS: 1000,
-                explain: { verbosity: 'queryPlanner' }
-              }
-            )
-            .catch(e => e);
-          expect(timeout).to.be.instanceOf(MongoOperationTimeoutError);
+        test('the explain command times out after timeoutMS', async function () {
+          const { duration, result } = await measureDuration(() =>
+            client
+              .db('foo')
+              .collection('bar')
+              .deleteMany(
+                {},
+                {
+                  timeoutMS: 1000,
+                  explain: { verbosity: 'queryPlanner' }
+                }
+              )
+              .catch(e => e)
+          );
+
+          expect(result).to.be.instanceOf(MongoOperationTimeoutError);
+          expect(duration).to.be.within(1000, 1000 + 100);
         });
 
         test('the explain command has the calculated maxTimeMS value attached', async function () {
@@ -512,56 +521,70 @@ describe('CRUD API explain option', function () {
       describe('find({}, { timeoutMS }).explain()', function () {
         test('respects the timeoutMS from the find options', async function () {
           const cursor = client.db('foo').collection('bar').find({}, { timeoutMS: 1000 });
-          const timeout = await cursor.explain({ verbosity: 'queryPlanner' }).catch(e => e);
-          expect(timeout).to.be.instanceOf(MongoOperationTimeoutError);
+
+          const { result, duration } = await measureDuration(() =>
+            cursor.explain({ verbosity: 'queryPlanner' }).catch(e => e)
+          );
+          expect(result).to.be.instanceOf(MongoOperationTimeoutError);
+          expect(duration).to.be.within(1000, 1000 + 100);
         });
       });
 
       describe('find().explain({}, { timeoutMS })', function () {
         test('respects the timeoutMS from the explain helper', async function () {
           const cursor = client.db('foo').collection('bar').find();
-          const timeout = await cursor
-            .explain({ verbosity: 'queryPlanner' }, { timeoutMS: 1000 })
-            .catch(e => e);
-          expect(timeout).to.be.instanceOf(MongoOperationTimeoutError);
+
+          const { result, duration } = await measureDuration(() =>
+            cursor.explain({ verbosity: 'queryPlanner' }, { timeoutMS: 1000 }).catch(e => e)
+          );
+          expect(result).to.be.instanceOf(MongoOperationTimeoutError);
+          expect(duration).to.be.within(1000, 1000 + 100);
         });
       });
 
       describe('find({}, { timeoutMS} ).explain({}, { timeoutMS })', function () {
         test('the timeoutMS from the explain helper has precedence', async function () {
           const cursor = client.db('foo').collection('bar').find({}, { timeoutMS: 2000 });
-          const timeout = await cursor
-            .explain({ verbosity: 'queryPlanner' }, { timeoutMS: 1000 })
-            .catch(e => e);
-          expect(timeout).to.be.instanceOf(MongoOperationTimeoutError);
+          const { result, duration } = await measureDuration(() =>
+            cursor.explain({ verbosity: 'queryPlanner' }, { timeoutMS: 1000 }).catch(e => e)
+          );
+          expect(result).to.be.instanceOf(MongoOperationTimeoutError);
+          expect(duration).to.be.within(1000, 1000 + 100);
         });
       });
 
       describe('aggregate([], { timeoutMS }).explain()', function () {
         test('respects the timeoutMS from the find options', async function () {
           const cursor = client.db('foo').collection('bar').aggregate([], { timeoutMS: 1000 });
-          const timeout = await cursor.explain({ verbosity: 'queryPlanner' }).catch(e => e);
-          expect(timeout).to.be.instanceOf(MongoOperationTimeoutError);
+          const { result, duration } = await measureDuration(() =>
+            cursor.explain({ verbosity: 'queryPlanner' }).catch(e => e)
+          );
+
+          expect(result).to.be.instanceOf(MongoOperationTimeoutError);
+          expect(duration).to.be.within(1000, 1000 + 100);
         });
       });
 
       describe('aggregate([], { timeoutMS })', function () {
         test('respects the timeoutMS from the explain helper', async function () {
           const cursor = client.db('foo').collection('bar').aggregate();
-          const timeout = await cursor
-            .explain({ verbosity: 'queryPlanner' }, { timeoutMS: 1000 })
-            .catch(e => e);
-          expect(timeout).to.be.instanceOf(MongoOperationTimeoutError);
+          const { result, duration } = await measureDuration(() =>
+            cursor.explain({ verbosity: 'queryPlanner' }, { timeoutMS: 1000 }).catch(e => e)
+          );
+
+          expect(result).to.be.instanceOf(MongoOperationTimeoutError);
+          expect(duration).to.be.within(1000, 1000 + 100);
         });
       });
 
       describe('aggregate([], { timeoutMS} ).explain({}, { timeoutMS })', function () {
         test('the timeoutMS from the explain helper has precedence', async function () {
           const cursor = client.db('foo').collection('bar').aggregate([], { timeoutMS: 2000 });
-          const timeout = await cursor
-            .explain({ verbosity: 'queryPlanner' }, { timeoutMS: 1000 })
-            .catch(e => e);
-          expect(timeout).to.be.instanceOf(MongoOperationTimeoutError);
+          const { duration, result } = await measureDuration(() =>
+            cursor.explain({ verbosity: 'queryPlanner' }, { timeoutMS: 1000 }).catch(e => e)
+          );
+          expect(duration).to.be.within(1000, 1000 + 100);
+          expect(result).to.be.instanceOf(MongoOperationTimeoutError);
         });
       });
     });

test/tools/utils.ts

@@ -14,6 +14,7 @@ import {
   type Document,
   type HostAddress,
   MongoClient,
+  now,
   OP_MSG,
   Topology,
   type TopologyOptions
@@ -624,3 +625,21 @@ export async function clearFailPoint(configuration: TestConfiguration) {
     await utilClient.close();
   }
 }
+
+/**
+ * A utility to measure the duration of an async function.  This is intended to be used for CSOT
+ * testing, where we expect to timeout within a certain threshold and want to measure the duration
+ * of that operation.
+ */
+export async function measureDuration<T>(f: () => Promise<T>): Promise<{
+  duration: number;
+  result: T | Error;
+}> {
+  const start = now();
+  const result = await f().catch(e => e);
+  const end = now();
+  return {
+    duration: end - start,
+    result
+  };
+}