updated tests

delete extraneous files

Author: aditi-khare-mongoDB

heartbeat-failed-monitor-timer.cjs

@@ -1,12 +1,6 @@
 /* eslint-disable @typescript-eslint/no-empty-function */
-import { expect } from 'chai';
-import * as sinon from 'sinon';
-import { Connection, HostAddress, MongoClient } from '../../mongodb';
 import { type TestConfiguration } from '../../tools/runner/config';
 import { runScriptAndGetProcessInfo } from './resource_tracking_script_builder';
-import { sleep } from '../../tools/utils';
-import { ConnectionPool } from '../../mongodb';
-import { getActiveResourcesInfo } from 'process';
 
 describe.only('MongoClient.close() Integration', () => {
   // note: these tests are set-up in accordance of the resource ownership tree
@@ -342,33 +336,49 @@ describe.only('MongoClient.close() Integration', () => {
         describe('Node.js resource: checkOut Timer', () => {
           describe('after new connection pool is created', () => {
             it('the wait queue timer is cleaned up by client.close()', async function () {
-              // note: this test is not called in a separate process since it stubs internal class: ConnectionPool
               const run = async function ({ MongoClient, uri, expect, sinon, sleep, getTimerCount }) {
-                const waitQueueTimeoutMS = 999;
-                const client = new MongoClient(uri, { minPoolSize: 1, waitQueueTimeoutMS });
+                const waitQueueTimeoutMS = 1515;
+
+                // configure failPoint
+                const utilClient = new MongoClient(uri);
+                await utilClient.connect();
+                const failPoint = {
+                  configureFailPoint: 'failCommand',
+                  mode: { times: 1 },
+                  data: { blockConnection: true, blockTimeMS: waitQueueTimeoutMS * 3, failCommands: ['insert'] }
+                }
+                await utilClient.db('admin').command(failPoint);
+
                 const timers = require('timers');
                 const timeoutStartedSpy = sinon.spy(timers, 'setTimeout');
-                let checkoutTimeoutStarted = false;
-
-                // make waitQueue hang so check out timer isn't cleared and check that the timeout has started
-                sinon.stub(ConnectionPool.prototype, 'processWaitQueue').callsFake(async () => {
-                  checkoutTimeoutStarted = timeoutStartedSpy.getCalls().filter(r => r.args.includes(waitQueueTimeoutMS)).flat().length > 0;
-                });
 
+                const client = new MongoClient(uri, { minPoolSize: 1, maxPoolSize: 1, waitQueueTimeoutMS });
                 const insertPromise = client.db('db').collection('collection').insertOne({ x: 1 }).catch(e => e);
+                client.db('db').collection('collection').insertOne({ x: 1 }).catch(e => e);
 
                 // don't allow entire checkout timer to elapse to ensure close is called mid-timeout
                 await sleep(waitQueueTimeoutMS / 2);
+                const checkoutTimeoutStarted = timeoutStartedSpy.getCalls().filter(r => r.args.includes(waitQueueTimeoutMS)).flat().length > 0;
                 expect(checkoutTimeoutStarted).to.be.true;
 
                 await client.close();
                 expect(getTimerCount()).to.equal(0);
+                // un-configure fail{oint
+                await utilClient
+                  .db()
+                  .admin()
+                  .command({
+                    configureFailPoint: 'failCommand',
+                    mode: 'off'
+                  });
+
+                await utilClient.close();
 
                 const err = await insertPromise;
-                expect(err).to.not.be.instanceOf(Error);
+                expect(err).to.be.instanceOf(Error);
+                expect(err.message).to.contain('Timed out while checking out a connection from connection pool');
               };
-              const getTimerCount = () => process.getActiveResourcesInfo().filter(r => r === 'Timeout').length;
-              await run({ MongoClient, uri: config.uri, sleep, sinon, expect, getTimerCount});
+              await runScriptAndGetProcessInfo('timer-check-out', config, run);
             });
           });
         });
@@ -409,43 +419,22 @@ describe.only('MongoClient.close() Integration', () => {
 
     describe('SrvPoller', () => {
       describe('Node.js resource: Timer', () => {
-        // srv polling is not available for load-balanced mode
+        // requires an srv environment that can transition to sharded
         const metadata: MongoDBMetadataUI = {
           requires: {
-            topology: ['single', 'replicaset', 'sharded']
+            predicate: () => process.env.ATLAS_SRV_REPL ? 'Skipped: this test requires an SRV environment' : true
           }
         };
+
         describe('after SRVPoller is created', () => {
           it.only('timers are cleaned up by client.close()', metadata, async () => {
-            const run = async function ({ MongoClient, uri, expect, mongodb, sinon, getTimerCount }) {
-              const dns = require('dns');
-              sinon.stub(dns.promises, 'resolveTxt').callsFake(async () => {
-                throw { code: 'ENODATA' };
-              });
-              sinon.stub(dns.promises, 'resolveSrv').callsFake(async () => {
-                return [
-                  {
-                    name: 'domain.localhost',
-                    port: 27017,
-                    weight: 0,
-                    priority: 0,
-                    protocol: 'IPv6'
-                  }
-                ];
-              });
-
-              const client = new MongoClient('mongodb+srv://localhost');
-              client.connect();
-
-              const topology = client.topology;
-              const prevDesc = topology;
-              log({ topology });
-              const currDesc = prevDesc;
-              client.topology.emit(
-                'topologyDescriptionChanged',
-                mongodb.TopologyDescriptionChangedEvent(client.topology.s.id, prevDesc, currDesc)
-              );
-              
+            const run = async function ({ MongoClient, uri, expect, sinon, getTimerCount }) {
+              const client = new MongoClient(uri);
+              await client.connect();
+              const description = client.topology.s.description;
+              // simulate transition to sharded
+              client.topology.emit('topologyDescriptionChanged', description, { ... description, type: 'Sharded'}); 
+              expect(client.topology.s.srvPoller?._timeout).to.exist;
               await client.close();
               expect(getTimerCount()).to.equal(0);
             };