wip

Author: nbbeeken

src/mongo_client.ts

@@ -47,6 +47,7 @@ import { readPreferenceServerSelector } from './sdam/server_selection';
 import type { SrvPoller } from './sdam/srv_polling';
 import { Topology, type TopologyEvents } from './sdam/topology';
 import { ClientSession, type ClientSessionOptions, ServerSessionPool } from './sessions';
+import { Timeout } from './timeout';
 import {
   COSMOS_DB_CHECK,
   COSMOS_DB_MSG,
@@ -520,13 +521,19 @@ export class MongoClient extends TypedEventEmitter<MongoClientEvents> implements
       return await this.connectionLock;
     }
 
-    try {
-      this.connectionLock = this._connect();
-      await this.connectionLock;
-    } finally {
-      // release
+    const timeoutMS = this[kOptions].timeoutMS;
+
+    this.connectionLock = this._connect().finally(() => {
+      // Clear the lock only when this promise finishes:
       this.connectionLock = undefined;
-    }
+    });
+
+    await (timeoutMS == null
+      ? this.connectionLock
+      : Promise.race([
+          this.connectionLock,
+          Timeout.expires(timeoutMS).catch(Timeout.convertError)
+        ]));
 
     return this;
   }

src/timeout.ts

@@ -126,6 +126,12 @@ export class Timeout extends Promise<never> {
   static override reject(rejection?: Error): Timeout {
     return new Timeout(undefined, { duration: 0, unref: true, rejection });
   }
+
+  static convertError(this: void, cause: unknown): never {
+    if (TimeoutError.is(cause)) throw new MongoOperationTimeoutError('Timed out');
+    if (cause instanceof Error) throw cause;
+    throw new MongoRuntimeError('Unknown error', { cause: cause as any });
+  }
 }
 
 /** @internal */

test/integration/node-specific/auto_connect.test.ts

@@ -8,10 +8,12 @@ import {
   type Collection,
   type MongoClient,
   MongoNotConnectedError,
+  MongoOperationTimeoutError,
   ProfilingLevel,
   Topology,
   TopologyType
 } from '../../mongodb';
+import { type FailPoint } from '../../tools/utils';
 
 describe('When executing an operation for the first time', () => {
   let client: MongoClient;
@@ -821,4 +823,59 @@ describe('When executing an operation for the first time', () => {
       });
     });
   });
+
+  describe.only('and CSOT is enabled', function () {
+    let client: MongoClient;
+
+    beforeEach(async function () {
+      client = this.configuration.newClient({ timeoutMS: 1000 });
+    });
+
+    afterEach(async function () {
+      await client.close();
+    });
+
+    describe('and nothing is wrong', function () {
+      it('should connect the client', async function () {
+        await client.connect();
+        expect(client).to.have.property('topology').that.is.instanceOf(Topology);
+      });
+    });
+
+    describe('and the server requires auth and ping is delayed', function () {
+      beforeEach(async function () {
+        // set failpoint to delay ping
+        // create new util client to avoid affecting the test client
+        const utilClient = this.configuration.newClient();
+        await utilClient.db('admin').command({
+          configureFailPoint: 'failCommand',
+          mode: { times: 1 },
+          data: { failCommands: ['ping'], blockConnection: true, blockTimeMS: 2000 }
+        } as FailPoint);
+        await utilClient.close();
+      });
+
+      it(
+        'should throw an MongoOperationTimeoutError error from connect',
+        { requires: { auth: 'enabled' } },
+        async function () {
+          const start = performance.now();
+          const error = await client.connect().catch(error => error);
+          const end = performance.now();
+          expect(error).to.be.instanceOf(MongoOperationTimeoutError);
+          expect(end - start).to.be.within(1000, 1500);
+        }
+      );
+
+      it(
+        'still have a pending connect promise',
+        { requires: { auth: 'enabled' } },
+        async function () {
+          const error = await client.connect().catch(error => error);
+          expect(client).to.have.property('connectionLock').that.is.instanceOf(Promise);
+          expect(error).to.be.instanceOf(MongoOperationTimeoutError);
+        }
+      );
+    });
+  });
 });