chore: fix tests and remove changes

Author: nbbeeken

src/mongo_client.ts

@@ -47,7 +47,6 @@ 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,
@@ -528,19 +527,13 @@ export class MongoClient extends TypedEventEmitter<MongoClientEvents> implements
       return await this.connectionLock;
     }
 
-    const timeoutMS = this[kOptions].timeoutMS;
-
-    this.connectionLock = this._connect().finally(() => {
-      // Clear the lock only when this promise finishes:
+    try {
+      this.connectionLock = this._connect();
+      await this.connectionLock;
+    } finally {
+      // release
       this.connectionLock = undefined;
-    });
-
-    await (timeoutMS == null
-      ? this.connectionLock
-      : Promise.race([
-          this.connectionLock,
-          Timeout.expires(timeoutMS).catch(Timeout.convertError)
-        ]));
+    }
 
     return this;
   }

src/timeout.ts

@@ -126,12 +126,6 @@ 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

@@ -1,5 +1,6 @@
 import { expect } from 'chai';
 import { once } from 'events';
+import * as sinon from 'sinon';
 
 import {
   BSONType,
@@ -8,12 +9,11 @@ import {
   type Collection,
   type MongoClient,
   MongoNotConnectedError,
-  MongoOperationTimeoutError,
   ProfilingLevel,
   Topology,
   TopologyType
 } from '../../mongodb';
-import { type FailPoint } from '../../tools/utils';
+import { type FailPoint, sleep } from '../../tools/utils';
 
 describe('When executing an operation for the first time', () => {
   let client: MongoClient;
@@ -824,7 +824,7 @@ describe('When executing an operation for the first time', () => {
     });
   });
 
-  describe.only('and CSOT is enabled', function () {
+  describe('and CSOT is enabled', function () {
     let client: MongoClient;
 
     beforeEach(async function () {
@@ -836,7 +836,7 @@ describe('When executing an operation for the first time', () => {
     });
 
     describe('and nothing is wrong', function () {
-      it('should connect the client', async function () {
+      it('connects the client', async function () {
         await client.connect();
         expect(client).to.have.property('topology').that.is.instanceOf(Topology);
       });
@@ -856,24 +856,45 @@ describe('When executing an operation for the first time', () => {
       });
 
       it(
-        'should throw an MongoOperationTimeoutError error from connect',
+        'takes as long as ping is delayed for and does not throw a timeout error',
         { requires: { auth: 'enabled' } },
         async function () {
           const start = performance.now();
-          const error = await client.connect().catch(error => error);
+          const returnedClient = await client.connect();
           const end = performance.now();
-          expect(error).to.be.instanceOf(MongoOperationTimeoutError);
-          expect(end - start).to.be.within(1000, 1500);
+          expect(returnedClient).to.equal(client);
+          expect(end - start).to.be.within(2000, 2500); // timeoutMS is 1000, did not apply.
         }
       );
+    });
+
+    describe('when server selection takes longer than the timeout', function () {
+      beforeEach(async function () {
+        const selectServerStub = sinon
+          .stub(Topology.prototype, 'selectServer')
+          .callsFake(async function (selector, options) {
+            await sleep(2000);
+            const result = selectServerStub.wrappedMethod.call(this, selector, options);
+            sinon.restore(); // restore after connect selection
+            return result;
+          });
+      });
+
+      // restore sinon stub after test
+      afterEach(() => {
+        sinon.restore();
+      });
 
       it(
-        'still have a pending connect promise',
+        'takes as long as selectServer is delayed for and does not throw a timeout error',
         { 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);
+          const start = performance.now();
+          expect(client.topology).to.not.exist; // make sure not connected.
+          const res = await client.db().collection('test').insertOne({ a: 1 }, { timeoutMS: 1000 }); // auto-connect
+          const end = performance.now();
+          expect(res).to.have.property('acknowledged', true);
+          expect(end - start).to.be.within(2000, 2500); // timeoutMS is 1000, did not apply.
         }
       );
     });