fix(NODE-4192): remove connect from tests part 1

Author: nbbeeken

global.d.ts

@@ -1,18 +1,13 @@
 import { OneOrMore } from './src/mongo_types';
 import type { TestConfiguration } from './test/tools/runner/config';
 
-type WithExclusion<T extends string> = `!${T}`;
-/** Defined in test/tools/runner/filters/mongodb_topology_filter.js (topologyTypeToString) */
-type TopologyTypes = 'single' | 'replicaset' | 'sharded' | 'load-balanced';
-type TopologyTypeRequirement = OneOrMore<TopologyTypes> | OneOrMore<WithExclusion<TopologyTypes>>;
-
 declare global {
   interface MongoDBMetadataUI {
     requires?: {
       topology?: TopologyTypeRequirement;
       mongodb?: string;
       os?: NodeJS.Platform | `!${NodeJS.Platform}`;
-      apiVersion?: '1';
+      apiVersion?: '1' | boolean;
       clientSideEncryption?: boolean;
       serverless?: 'forbid' | 'allow' | 'require';
       auth?: 'enabled' | 'disabled';
@@ -23,6 +18,11 @@ declare global {
     };
   }
 
+  type WithExclusion<T extends string> = `!${T}`;
+  /** Defined in test/tools/runner/filters/mongodb_topology_filter.js (topologyTypeToString) */
+  type TopologyTypes = 'single' | 'replicaset' | 'sharded' | 'load-balanced';
+  type TopologyTypeRequirement = OneOrMore<TopologyTypes> | OneOrMore<WithExclusion<TopologyTypes>>;
+
   interface MetadataAndTest<Fn> {
     metadata: MongoDBMetadataUI;
     test: Fn;

test/integration/auth/auth.prose.test.js

@@ -4,10 +4,15 @@ const sinon = require('sinon');
 const { expect } = require('chai');
 const { Connection } = require('../../../src/cmap/connection');
 const { ScramSHA256 } = require('../../../src/cmap/auth/scram');
-const { setupDatabase, withClient } = require('../shared');
+const { setupDatabase } = require('../shared');
 const { LEGACY_HELLO_COMMAND } = require('../../../src/constants');
 
-describe('auth prose tests', () => {
+// TODO(NODE-XXX): withClient usage prevented these tests from running
+// the import has been removed since the function is being deleted, this is here to keep modifications minimal
+// so that the implementer of the fix for these tests can try to reference the original intent
+const withClient = () => null;
+
+describe.skip('auth prose tests', () => {
   describe('SCRAM-SHA-256 prose test', () => {
     describe('SCRAM-SHA-256 prose test Steps 1-3', function () {
       const test = {};

test/integration/auth/mongodb_aws.test.js

@@ -15,37 +15,28 @@ describe('MONGODB-AWS', function () {
     }
   });
 
-  it('should not authorize when not authenticated', function (done) {
-    const config = this.configuration;
-    const url = removeAuthFromConnectionString(config.url());
-    const client = config.newClient(url); // strip provided URI of credentials
-    client.connect(err => {
-      expect(err).to.not.exist;
-      this.defer(() => client.close());
+  it('should not authorize when not authenticated', async function () {
+    const url = removeAuthFromConnectionString(this.configuration.url());
+    const client = this.configuration.newClient(url); // strip provided URI of credentials
 
-      client.db('aws').command({ count: 'test' }, (err, count) => {
-        expect(err).to.exist;
-        expect(count).to.not.exist;
+    const error = await client
+      .db('aws')
+      .command({ ping: 1 })
+      .catch(error => error);
 
-        done();
-      });
-    });
+    expect(error).to.be.instanceOf(MongoAWSError);
   });
 
-  it('should authorize when successfully authenticated', function (done) {
-    const config = this.configuration;
-    const client = config.newClient(process.env.MONGODB_URI); // use the URI built by the test environment
-    client.connect(err => {
-      expect(err).to.not.exist;
-      this.defer(() => client.close());
+  it('should authorize when successfully authenticated', async function () {
+    const client = this.configuration.newClient(process.env.MONGODB_URI); // use the URI built by the test environment
 
-      client.db('aws').command({ count: 'test' }, (err, count) => {
-        expect(err).to.not.exist;
-        expect(count).to.exist;
+    const result = await client
+      .db('aws')
+      .command({ ping: 1 })
+      .catch(error => error);
 
-        done();
-      });
-    });
+    expect(result).to.not.be.instanceOf(MongoAWSError);
+    expect(result).to.have.property('ok', 1);
   });
 
   it('should allow empty string in authMechanismProperties.AWS_SESSION_TOKEN to override AWS_SESSION_TOKEN environment variable', function () {
@@ -84,10 +75,10 @@ describe('MONGODB-AWS', function () {
       client = config.newClient(process.env.MONGODB_URI, { authMechanism: 'MONGODB-AWS' }); // use the URI built by the test environment
       const startTime = performance.now();
 
-      let caughtError = null;
-      await client.connect().catch(err => {
-        caughtError = err;
-      });
+      const caughtError = await client
+        .db()
+        .command({ ping: 1 })
+        .catch(error => error);
 
       const endTime = performance.now();
       const timeTaken = endTime - startTime;

test/integration/auth/scram_sha_1.test.js

@@ -0,0 +1,29 @@
+import { expect } from 'chai';
+
+import type { MongoClient } from '../../../src';
+
+describe('SCRAM-SHA-1', function () {
+  let client: MongoClient;
+
+  beforeEach(async function () {
+    const onlyScram1AuthMech =
+      this.configuration.parameters?.authenticationMechanisms.length === 1 &&
+      this.configuration.parameters?.authenticationMechanisms[0] === 'SCRAM-SHA-1';
+
+    if (!onlyScram1AuthMech) {
+      this.currentTest.skipReason = `MongoDB auth mechanism must only be SCRAM-SHA-1, got ${this.configuration.parameters?.authenticationMechanisms}`;
+      return this.skip();
+    }
+
+    client = this.configuration.newClient();
+  });
+
+  afterEach(async () => {
+    await client?.close();
+  });
+
+  it('successfuly authenticates', async () => {
+    const result = await client.db().admin().command({ ping: 1 });
+    expect(result).to.have.property('ok', 1);
+  });
+});

test/integration/auth/scram_sha_1.test.ts

@@ -4,7 +4,7 @@ const sinon = require('sinon');
 const { expect } = require('chai');
 const { Connection } = require('../../../src/cmap/connection');
 const { ScramSHA256 } = require('../../../src/cmap/auth/scram');
-const { setupDatabase, withClient } = require('../shared');
+const { setupDatabase } = require('../shared');
 const { LEGACY_HELLO_COMMAND } = require('../../../src/constants');
 
 describe('SCRAM_SHA_256', function () {
@@ -29,35 +29,35 @@ describe('SCRAM_SHA_256', function () {
     return setupDatabase(this.configuration);
   });
 
-  before(function () {
-    return withClient(this.configuration.newClient(), client => {
-      test.oldDbName = this.configuration.db;
-      this.configuration.db = 'admin';
-      const db = client.db(this.configuration.db);
-
-      const createUserCommands = users.map(user => ({
-        createUser: user.username,
-        pwd: user.password,
-        roles: ['root'],
-        mechanisms: user.mechanisms
-      }));
-
-      return Promise.all(createUserCommands.map(cmd => db.command(cmd)));
-    });
+  before(async function () {
+    const client = this.configuration.newClient();
+    test.oldDbName = this.configuration.db;
+    this.configuration.db = 'admin';
+    const db = client.db(this.configuration.db);
+
+    const createUserCommands = users.map(user => ({
+      createUser: user.username,
+      pwd: user.password,
+      roles: ['root'],
+      mechanisms: user.mechanisms
+    }));
+
+    await Promise.all(createUserCommands.map(cmd => db.command(cmd)));
+    await client.close();
   });
 
-  after(function () {
-    return withClient(this.configuration.newClient(), client => {
-      const db = client.db(this.configuration.db);
-      this.configuration.db = test.oldDbName;
+  after(async function () {
+    const client = this.configuration.newClient();
+    const db = client.db(this.configuration.db);
+    this.configuration.db = test.oldDbName;
 
-      return Promise.all(users.map(user => db.removeUser(user.username)));
-    });
+    await Promise.all(users.map(user => db.removeUser(user.username)));
+    await client.close();
   });
 
   it('should shorten SCRAM conversations if the server supports it', {
     metadata: { requires: { mongodb: '>=4.4', topology: ['single'] } },
-    test: function () {
+    test: async function () {
       const options = {
         auth: {
           username: userMap.both.username,
@@ -79,15 +79,16 @@ describe('SCRAM_SHA_256', function () {
         auth.apply(this, [authContext, _callback]);
       });
 
-      return withClient(this.configuration.newClient({}, options), () => {
-        expect(runCommandSpy.callCount).to.equal(1);
-      });
+      const client = this.configuration.newClient({}, options);
+      await client.db().command({ ping: 1 });
+      expect(runCommandSpy.callCount).to.equal(1);
+      await client.close();
     }
   });
 
   it('should send speculativeAuthenticate on initial handshake on MongoDB 4.4+', {
     metadata: { requires: { mongodb: '>=4.4', topology: ['single'] } },
-    test: function () {
+    test: async function () {
       const options = {
         auth: {
           username: userMap.both.username,
@@ -97,16 +98,17 @@ describe('SCRAM_SHA_256', function () {
       };
 
       const commandSpy = test.sandbox.spy(Connection.prototype, 'command');
-      return withClient(this.configuration.newClient({}, options), () => {
-        const calls = commandSpy
-          .getCalls()
-          .filter(c => c.thisValue.id !== '<monitor>') // ignore all monitor connections
-          .filter(c => c.args[1][LEGACY_HELLO_COMMAND]); // only consider handshakes
-
-        expect(calls).to.have.length(1);
-        const handshakeDoc = calls[0].args[1];
-        expect(handshakeDoc).to.have.property('speculativeAuthenticate');
-      });
+      const client = this.configuration.newClient({}, options);
+      await client.db().command({ ping: 1 });
+      const calls = commandSpy
+        .getCalls()
+        .filter(c => c.thisValue.id !== '<monitor>') // ignore all monitor connections
+        .filter(c => c.args[1][LEGACY_HELLO_COMMAND]); // only consider handshakes
+
+      expect(calls).to.have.length(1);
+      const handshakeDoc = calls[0].args[1];
+      expect(handshakeDoc).to.have.property('speculativeAuthenticate');
+      await client.close();
     }
   });
 });