Updated tests

Author: W-A-James

test/integration/crud/abstract_operation.test.ts

@@ -353,7 +353,7 @@ describe('abstract operation', async function () {
               subclassType.name === 'ProfilingLevelOperation' ? { ok: 1, was: 1 } : { ok: 1 };
             const cmdCallerStub = sinon
               .stub(Server.prototype, 'command')
-              .yieldsRight(undefined, yieldDoc);
+              .returns(Promise.resolve(yieldDoc));
             if (sameServerOnlyOperationSubclasses.includes(subclassType.name.toString())) {
               await subclassInstance.execute(constructorServer, client.session);
             } else {

test/integration/retryable-writes/non-server-retryable_writes.test.ts

@@ -33,11 +33,13 @@ describe('Non Server Retryable Writes', function () {
     { requires: { topology: 'replicaset', mongodb: '>=4.2.9' } },
     async () => {
       const serverCommandStub = sinon.stub(Server.prototype, 'command');
-      serverCommandStub.onCall(0).yieldsRight(new PoolClearedError('error'));
+      serverCommandStub.onCall(0).returns(Promise.reject(new PoolClearedError('error')));
       serverCommandStub
         .onCall(1)
-        .yieldsRight(
-          new MongoWriteConcernError({ errorLabels: ['NoWritesPerformed'], errorCode: 10107 }, {})
+        .returns(
+          Promise.reject(
+            new MongoWriteConcernError({ errorLabels: ['NoWritesPerformed'], errorCode: 10107 }, {})
+          )
         );
 
       const insertResult = await collection.insertOne({ _id: 1 }).catch(error => error);

test/integration/server-selection/operation_count.test.ts

@@ -170,9 +170,9 @@ describe('Server Operation Count Tests', function () {
           const server = Array.from(client.topology.s.servers.values())[0];
           expect(server.s.operationCount).to.equal(0);
 
-          sinon.stub(ConnectionPool.prototype, 'checkOut').callsFake(function (cb) {
-            cb(new Error('unable to checkout connection'), undefined);
-          });
+          sinon
+            .stub(ConnectionPool.prototype, 'checkOut')
+            .returns(Promise.reject(new Error('unable to checkout connection')));
           const commandSpy = sinon.spy(server, 'command');
 
           const error = await collection.insertOne({ count: 1 }).catch(e => e);

test/tools/cmap_spec_runner.ts

@@ -185,9 +185,7 @@ const compareInputToSpec = (input, expected, message) => {
 
 const getTestOpDefinitions = (threadContext: ThreadContext) => ({
   checkOut: async function (op) {
-    const connection: Connection = await promisify(ConnectionPool.prototype.checkOut).call(
-      threadContext.pool
-    );
+    const connection: Connection = await ConnectionPool.prototype.checkOut.call(threadContext.pool);
     if (op.label != null) {
       threadContext.connections.set(op.label, connection);
     } else {

test/unit/cmap/connection_pool.test.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { ConnectionPool } = require('../../mongodb');
+const { ConnectionPool, MongoError } = require('../../mongodb');
 const { WaitQueueTimeoutError } = require('../../mongodb');
 const mock = require('../../tools/mongodb-mock/index');
 const sinon = require('sinon');
@@ -69,7 +69,7 @@ describe('Connection Pool', function () {
     expect(closeEvent).have.property('reason').equal('error');
   });
 
-  it('should propagate socket timeouts to connections', function (done) {
+  it('should propagate socket timeouts to connections', async function () {
     mockMongod.setMessageHandler(request => {
       const doc = request.document;
       if (isHello(doc)) {
@@ -87,18 +87,12 @@ describe('Connection Pool', function () {
 
     pool.ready();
 
-    pool.withConnection(
-      (err, conn, cb) => {
-        expect(err).to.not.exist;
-        conn.command(ns('admin.$cmd'), { ping: 1 }, undefined, (err, result) => {
-          expect(err).to.exist;
-          expect(result).to.not.exist;
-          expect(err).to.match(/timed out/);
-          cb();
-        });
-      },
-      () => pool.close(done)
-    );
+    const conn = await pool.checkOut();
+    const maybeError = await conn.command(ns('admin.$cmd'), { ping: 1 }, undefined).catch(e => e);
+    expect(maybeError).to.be.instanceOf(MongoError);
+    expect(maybeError).to.match(/timed out/);
+
+    pool.checkIn(conn);
   });
 
   it('should clear timed out wait queue members if no connections are available', function (done) {
@@ -222,98 +216,4 @@ describe('Connection Pool', function () {
       expect(createConnStub).to.have.been.calledTwice;
     });
   });
-
-  describe('withConnection', function () {
-    it('should manage a connection for a successful operation', function (done) {
-      mockMongod.setMessageHandler(request => {
-        const doc = request.document;
-        if (isHello(doc)) {
-          request.reply(mock.HELLO);
-        }
-      });
-
-      const pool = new ConnectionPool(stubServer, { hostAddress: mockMongod.hostAddress() });
-      pool.ready();
-
-      const callback = (err, result) => {
-        expect(err).to.not.exist;
-        expect(result).to.exist;
-        pool.close(done);
-      };
-
-      pool.withConnection((err, conn, cb) => {
-        expect(err).to.not.exist;
-
-        conn.command(
-          ns('$admin.cmd'),
-          { [LEGACY_HELLO_COMMAND]: 1 },
-          undefined,
-          (cmdErr, hello) => {
-            expect(cmdErr).to.not.exist;
-            cb(undefined, hello);
-          }
-        );
-      }, callback);
-    });
-
-    it('should allow user interaction with an error', function (done) {
-      mockMongod.setMessageHandler(request => {
-        const doc = request.document;
-        if (isHello(doc)) {
-          request.connection.destroy();
-        }
-      });
-
-      const pool = new ConnectionPool(stubServer, {
-        waitQueueTimeoutMS: 200,
-        hostAddress: mockMongod.hostAddress()
-      });
-
-      pool.ready();
-
-      const callback = err => {
-        expect(err).to.exist;
-        expect(err).to.match(/closed/);
-        pool.close(done);
-      };
-
-      pool.withConnection(
-        undefined,
-        (err, conn, cb) => {
-          expect(err).to.exist;
-          expect(err).to.match(/closed/);
-          cb(err);
-        },
-        callback
-      );
-    });
-
-    it('should return an error to the original callback', function (done) {
-      mockMongod.setMessageHandler(request => {
-        const doc = request.document;
-        if (isHello(doc)) {
-          request.reply(mock.HELLO);
-        }
-      });
-
-      const pool = new ConnectionPool(stubServer, { hostAddress: mockMongod.hostAddress() });
-      pool.ready();
-
-      const callback = (err, result) => {
-        expect(err).to.exist;
-        expect(result).to.not.exist;
-        expect(err).to.match(/my great error/);
-        pool.close(done);
-      };
-
-      pool.withConnection(
-        undefined,
-        (err, conn, cb) => {
-          expect(err).to.not.exist;
-          cb(new Error('my great error'));
-        },
-        callback
-      );
-    });
-  });
 });