review

Author: aditi-khare-mongoDB

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

@@ -4,7 +4,7 @@ import { expect } from 'chai';
 import { type TestConfiguration } from '../../tools/runner/config';
 import { runScriptAndGetProcessInfo } from './resource_tracking_script_builder';
 
-describe.skip('MongoClient.close() Integration', () => {
+describe.only('MongoClient.close() Integration', () => {
   // note: these tests are set-up in accordance of the resource ownership tree
 
   let config: TestConfiguration;
@@ -15,7 +15,7 @@ describe.skip('MongoClient.close() Integration', () => {
 
   describe('Node.js resource: TLS File read', () => {
     describe('when client is connecting and reads an infinite TLS file', () => {
-      it('the file read is interrupted by client.close()', async function () {
+      it.skip('the file read is interrupted by client.close()', async function () {
         await runScriptAndGetProcessInfo(
           'tls-file-read',
           config,
@@ -51,7 +51,7 @@ describe.skip('MongoClient.close() Integration', () => {
       });
 
       describe('when MongoClientAuthProviders is instantiated and token file read hangs', () => {
-        it('the file read is interrupted by client.close()', async () => {
+        it.skip('the file read is interrupted by client.close()', async () => {
           await runScriptAndGetProcessInfo(
             'token-file-read',
             config,
@@ -77,7 +77,7 @@ describe.skip('MongoClient.close() Integration', () => {
   describe('Topology', () => {
     describe('Node.js resource: Server Selection Timer', () => {
       describe('after a Topology is created through client.connect()', () => {
-        it('server selection timers are cleaned up by client.close()', async () => {
+        it.skip('server selection timers are cleaned up by client.close()', async () => {
           const run = async function ({
             MongoClient,
             uri,
@@ -133,7 +133,7 @@ describe.skip('MongoClient.close() Integration', () => {
         describe('MonitorInterval', () => {
           describe('Node.js resource: Timer', () => {
             describe('after a new monitor is made', () => {
-              it(
+              it.skip(
                 'monitor interval timer is cleaned up by client.close()',
                 metadata,
                 async function () {
@@ -164,7 +164,7 @@ describe.skip('MongoClient.close() Integration', () => {
             });
 
             describe('after a heartbeat fails', () => {
-              it(
+              it.skip(
                 'the new monitor interval timer is cleaned up by client.close()',
                 metadata,
                 async () => {
@@ -199,7 +199,7 @@ describe.skip('MongoClient.close() Integration', () => {
 
         describe('Connection Monitoring', () => {
           describe('Node.js resource: Socket', () => {
-            it('no sockets remain after client.close()', metadata, async function () {
+            it.skip('no sockets remain after client.close()', metadata, async function () {
               const run = async function ({ MongoClient, uri, expect }) {
                 const client = new MongoClient(uri);
                 await client.connect();
@@ -234,7 +234,7 @@ describe.skip('MongoClient.close() Integration', () => {
         describe('RTT Pinger', () => {
           describe('Node.js resource: Timer', () => {
             describe('after entering monitor streaming mode ', () => {
-              it(
+              it.skip(
                 'the rtt pinger timer is cleaned up by client.close()',
                 metadata,
                 async function () {
@@ -274,7 +274,7 @@ describe.skip('MongoClient.close() Integration', () => {
           describe('Connection', () => {
             describe('Node.js resource: Socket', () => {
               describe('when rtt monitoring is turned on', () => {
-                it('no sockets remain after client.close()', metadata, async () => {
+                it.skip('no sockets remain after client.close()', metadata, async () => {
                   const run = async ({ MongoClient, uri, expect, sleep }) => {
                     const heartbeatFrequencyMS = 100;
                     const client = new MongoClient(uri, {
@@ -331,7 +331,7 @@ describe.skip('MongoClient.close() Integration', () => {
       describe('ConnectionPool', () => {
         describe('Node.js resource: minPoolSize timer', () => {
           describe('after new connection pool is created', () => {
-            it('the minPoolSize timer is cleaned up by client.close()', async function () {
+            it.skip('the minPoolSize timer is cleaned up by client.close()', async function () {
               const run = async function ({ MongoClient, uri, expect, getTimerCount }) {
                 const client = new MongoClient(uri, { minPoolSize: 1 });
                 let minPoolSizeTimerCreated = false;
@@ -361,7 +361,7 @@ describe.skip('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 () {
+            it.skip('the wait queue timer is cleaned up by client.close()', async function () {
               const run = async function ({
                 MongoClient,
                 uri,
@@ -438,7 +438,7 @@ describe.skip('MongoClient.close() Integration', () => {
         describe('Connection', () => {
           describe('Node.js resource: Socket', () => {
             describe('after a minPoolSize has been set on the ConnectionPool', () => {
-              it('no sockets remain after client.close()', async function () {
+              it.skip('no sockets remain after client.close()', async function () {
                 const run = async function ({ MongoClient, uri, expect }) {
                   const connectionMonitoringReport = () =>
                     process.report.getReport().libuv.filter(r => r.type === 'tcp');
@@ -480,13 +480,13 @@ describe.skip('MongoClient.close() Integration', () => {
         };
 
         describe('after SRVPoller is created', () => {
-          it('timers are cleaned up by client.close()', metadata, async () => {
+          it.skip('timers are cleaned up by client.close()', metadata, async () => {
             const run = async function ({ MongoClient, uri, expect, getTimerCount }) {
               const client = new MongoClient(uri);
               await client.connect();
               const description = client.topology.s.description;
               // simulate transition to sharded
-              client.topology.emit('topologyDescriptionChanged', description, {
+              client.topology.emit.skip('topologyDescriptionChanged', description, {
                 ...description,
                 type: 'Sharded'
               });
@@ -504,83 +504,119 @@ describe.skip('MongoClient.close() Integration', () => {
   describe('ClientSession (Implicit)', () => {
     let idleSessionsBeforeClose;
     let idleSessionsAfterClose;
+    let client;
+    let utilClient;
+    let session;
+
+    const metadata: MongoDBMetadataUI = { requires: { topology: ['replicaset', 'sharded'] } };
 
     beforeEach(async function () {
-      const client = this.configuration.newClient();
+      client = this.configuration.newClient();
+      utilClient = this.configuration.newClient();
       await client.connect();
-      const session = client.startSession({ explicit: false });
+      session = client.startSession({ explicit: false });
       session.startTransaction();
       await client.db('db').collection('collection').insertOne({ x: 1 }, { session });
 
-      const opBefore = await client.db().admin().command({ currentOp: 1 });
+      const opBefore = await utilClient.db().admin().command({ currentOp: 1 });
       idleSessionsBeforeClose = opBefore.inprog.filter(s => s.type === 'idleSession');
 
       await client.close();
-      await client.connect();
 
-      const opAfter = await client.db().admin().command({ currentOp: 1 });
+      const opAfter = await utilClient.db().admin().command({ currentOp: 1 });
       idleSessionsAfterClose = opAfter.inprog.filter(s => s.type === 'idleSession');
 
-      await client.close();
+      await utilClient.close();
+    });
+
+    afterEach(async function () {
+      await utilClient?.close();
+      await session?.endSession();
+      await client?.close();
     });
 
     describe('Server resource: LSID/ServerSession', () => {
       describe('after a clientSession is implicitly created and used', () => {
-        it('the server-side ServerSession is cleaned up by client.close()', async function () {
-          expect(idleSessionsBeforeClose).to.not.be.empty;
-          expect(idleSessionsAfterClose).to.be.empty;
-        });
+        it(
+          'the server-side ServerSession is cleaned up by client.close()',
+          metadata,
+          async function () {
+            expect(idleSessionsBeforeClose).to.not.be.empty;
+            expect(idleSessionsAfterClose).to.be.empty;
+          }
+        );
       });
     });
 
     describe('Server resource: Transactions', () => {
       describe('after a clientSession is implicitly created and used', () => {
-        it('the server-side transaction is cleaned up by client.close()', async function () {
-          expect(idleSessionsBeforeClose[0].transaction.txnNumber).to.not.null;
-          expect(idleSessionsAfterClose).to.be.empty;
-        });
+        it(
+          'the server-side transaction is cleaned up by client.close()',
+          metadata,
+          async function () {
+            expect(idleSessionsBeforeClose[0].transaction.txnNumber).to.not.null;
+            expect(idleSessionsAfterClose).to.be.empty;
+          }
+        );
       });
     });
   });
 
   describe('ClientSession (Explicit)', () => {
     let idleSessionsBeforeClose;
     let idleSessionsAfterClose;
+    let client;
+    let utilClient;
+    let session;
+
+    const metadata: MongoDBMetadataUI = { requires: { topology: ['replicaset', 'sharded'] } };
 
     beforeEach(async function () {
-      const client = this.configuration.newClient();
+      client = this.configuration.newClient();
+      utilClient = this.configuration.newClient();
       await client.connect();
-      const session = client.startSession();
+      session = client.startSession();
       session.startTransaction();
       await client.db('db').collection('collection').insertOne({ x: 1 }, { session });
 
-      const opBefore = await client.db().admin().command({ currentOp: 1 });
+      const opBefore = await utilClient.db().admin().command({ currentOp: 1 });
       idleSessionsBeforeClose = opBefore.inprog.filter(s => s.type === 'idleSession');
 
       await client.close();
-      await client.connect();
 
-      const opAfter = await client.db().admin().command({ currentOp: 1 });
+      const opAfter = await utilClient.db().admin().command({ currentOp: 1 });
       idleSessionsAfterClose = opAfter.inprog.filter(s => s.type === 'idleSession');
+    });
 
-      await client.close();
+    afterEach(async function () {
+      await utilClient?.close();
+      await session?.endSession();
+      await client?.close();
     });
 
     describe('Server resource: LSID/ServerSession', () => {
       describe('after a clientSession is created and used', () => {
-        it('the server-side ServerSession is cleaned up by client.close()', async function () {
-          expect(idleSessionsBeforeClose).to.not.be.empty;
-          expect(idleSessionsAfterClose).to.be.empty;
-        });
+        it(
+          'the server-side ServerSession is cleaned up by client.close()',
+          metadata,
+          async function () {
+            expect(idleSessionsBeforeClose).to.not.be.empty;
+            expect(idleSessionsAfterClose).to.be.empty;
+          }
+        );
       });
     });
 
     describe('Server resource: Transactions', () => {
       describe('after a clientSession is created and used', () => {
-        it('the server-side transaction is cleaned up by client.close()', async function () {
-          expect(idleSessionsBeforeClose[0].transaction.txnNumber).to.not.null;
-          expect(idleSessionsAfterClose).to.be.empty;
-        });
+        it(
+          'the server-side transaction is cleaned up by client.close()',
+          metadata,
+          async function () {
+            expect(idleSessionsBeforeClose[0].transaction.txnNumber).to.not.null;
+            expect(idleSessionsAfterClose).to.be.empty;
+          }
+        );
       });
     });
   });
@@ -596,7 +632,7 @@ describe.skip('MongoClient.close() Integration', () => {
     describe('KMS Request', () => {
       describe('Node.js resource: TLS file read', () => {
         describe('when KMSRequest reads an infinite TLS file', () => {
-          it('the file read is interrupted by client.close()', async () => {
+          it.skip('the file read is interrupted by client.close()', async () => {
             await runScriptAndGetProcessInfo(
               'tls-file-read-auto-encryption',
               config,
@@ -693,20 +729,24 @@ describe.skip('MongoClient.close() Integration', () => {
       let client;
       let coll;
       let cursor;
+      let utilClient;
 
       beforeEach(async function () {
         client = this.configuration.newClient();
+        utilClient = this.configuration.newClient();
+        await client.connect();
         coll = client.db('db').collection('coll');
       });
 
       afterEach(async function () {
+        await utilClient?.close();
         await client?.close();
         await cursor?.close();
       });
 
-      it('all active server-side cursors are closed by client.close()', async function () {
+      it.skip('all active server-side cursors are closed by client.close()', async function () {
         const getCursors = async () => {
-          const res = await client
+          const res = await utilClient
             .db()
             .admin()
             .command({
@@ -720,13 +760,14 @@ describe.skip('MongoClient.close() Integration', () => {
         };
 
         await coll.insertMany([{ a: 1 }, { b: 2 }, { c: 3 }]);
+        await coll.insertMany([{ d: 4 }, { e: 5 }, { f: 3 }]);
         cursor = await coll.find();
+        await cursor.next();
 
         // assert creation
         expect(await getCursors()).to.not.be.empty;
 
         await client.close();
-        await client.connect();
 
         // assert clean-up
         expect(await getCursors()).to.be.empty;