Merge branch 'mongodb:main' into NODE-7180

Author: PavelSafronov

test/integration/sessions/sessions.prose.test.ts

@@ -1,17 +1,14 @@
+import { ObjectId } from 'bson';
 import { expect } from 'chai';
 import { type ChildProcess, spawn } from 'child_process';
 import { once } from 'events';
 import * as os from 'os';
 import * as path from 'path';
 
-import {
-  type Collection,
-  type CommandStartedEvent,
-  MongoClient,
-  MongoDriverError,
-  MongoInvalidArgumentError,
-  ObjectId
-} from '../../mongodb';
+import { type CommandStartedEvent } from '../../../src/cmap/command_monitoring_events';
+import { type Collection } from '../../../src/collection';
+import { MongoDriverError, MongoInvalidArgumentError } from '../../../src/error';
+import { MongoClient } from '../../../src/mongo_client';
 import { sleep } from '../../tools/utils';
 
 describe('Sessions Prose Tests', () => {

test/integration/sessions/sessions.test.ts

@@ -3,16 +3,15 @@ import { MongoClient as LegacyMongoClient } from 'mongodb-legacy';
 
 import {
   type CommandStartedEvent,
-  type CommandSucceededEvent,
-  LEGACY_HELLO_COMMAND,
-  type MongoClient,
-  MongoServerError
-} from '../../mongodb';
+  type CommandSucceededEvent
+} from '../../../src/cmap/command_monitoring_events';
+import { LEGACY_HELLO_COMMAND } from '../../../src/constants';
+import { MongoServerError } from '../../../src/error';
+import { type MongoClient } from '../../../src/mongo_client';
 import type { TestConfiguration } from '../../tools/runner/config';
 import { setupDatabase } from '../shared';
 
 const ignoredCommands = [LEGACY_HELLO_COMMAND];
-let hasInitialPingOccurred = false;
 const test: {
   client: MongoClient;
   commands: { started: CommandStartedEvent[]; succeeded: CommandSucceededEvent[] };
@@ -24,16 +23,7 @@ const test: {
     this.commands = { started: [], succeeded: [] };
     this.client = config.newClient({ w: 1 }, { maxPoolSize: 1, monitorCommands: true });
 
-    // Because we have a MongoClient.connect method, an extra 'ping' event is sent to the
-    // server when authentication is enabled.  We have to detect the scenario when auth is
-    // enabled for the test and ignore the initial ping.  This will be addressed in NODE-2149.
-    const auth = config.options.auth;
-    const isAuthEnabled = !!(auth && auth.username && auth.password);
     this.client.on('commandStarted', event => {
-      if (event.commandName === 'ping' && isAuthEnabled && !hasInitialPingOccurred) {
-        hasInitialPingOccurred = true;
-        return;
-      }
       if (ignoredCommands.indexOf(event.commandName) === -1) {
         this.commands.started.push(event);
       }
@@ -70,19 +60,16 @@ describe('Sessions Spec', function () {
         await test.setup(this.configuration);
       });
 
-      it('should send endSessions for multiple sessions', function (done) {
+      it('should send endSessions for multiple sessions', async function () {
         const client = test.client;
         const sessions = [client.startSession(), client.startSession()].map(s => s.id);
 
-        client.close(err => {
-          expect(err).to.not.exist;
-          expect(test.commands.started).to.have.length(1);
-          expect(test.commands.started[0].commandName).to.equal('endSessions');
-          expect(test.commands.started[0].command.endSessions).to.include.deep.members(sessions);
-          expect(client.s.activeSessions.size).to.equal(0);
+        await client.close();
 
-          done();
-        });
+        expect(test.commands.started).to.have.length(1);
+        expect(test.commands.started[0].commandName).to.equal('endSessions');
+        expect(test.commands.started[0].command.endSessions).to.include.deep.members(sessions);
+        expect(client.s.activeSessions.size).to.equal(0);
       });
     });
 

test/integration/transactions/transactions.prose.test.ts

@@ -1,6 +1,7 @@
+import { type ObjectId } from 'bson';
 import { expect } from 'chai';
 
-import { type MongoClient, type ObjectId } from '../../mongodb';
+import { type MongoClient } from '../../../src/mongo_client';
 
 const metadata: MongoDBMetadataUI = {
   requires: {

test/integration/transactions/transactions.test.ts

@@ -1,14 +1,10 @@
 import { expect } from 'chai';
 
-import {
-  ClientSession,
-  type Collection,
-  type CommandStartedEvent,
-  type MongoClient,
-  MongoInvalidArgumentError,
-  MongoNetworkError,
-  type ServerSessionPool
-} from '../../mongodb';
+import { type CommandStartedEvent } from '../../../src/cmap/command_monitoring_events';
+import { type Collection } from '../../../src/collection';
+import { MongoInvalidArgumentError, MongoNetworkError } from '../../../src/error';
+import { type MongoClient } from '../../../src/mongo_client';
+import { ClientSession, type ServerSessionPool } from '../../../src/sessions';
 import { type FailCommandFailPoint } from '../../tools/utils';
 
 describe('Transactions', function () {
@@ -55,18 +51,14 @@ describe('Transactions', function () {
       metadata: {
         requires: { topology: ['replicaset', 'sharded'] }
       },
-      test: function (done) {
+      test: async function () {
         function fnThatReturnsBadPromise() {
           return Promise.reject();
         }
 
-        session
-          .withTransaction(fnThatReturnsBadPromise)
-          .then(() => done(Error('Expected error')))
-          .catch(err => {
-            expect(err).to.equal(undefined);
-            session.endSession(done);
-          });
+        const err = await session.withTransaction(fnThatReturnsBadPromise).catch(err => err);
+        expect(err).to.equal(undefined);
+        await session.endSession();
       }
     });
 
@@ -179,23 +171,21 @@ describe('Transactions', function () {
   describe('startTransaction', function () {
     it('should not error if transactions are supported', {
       metadata: { requires: { topology: ['sharded'] } },
-      test: function (done) {
+      test: async function () {
         const configuration = this.configuration;
         const client = configuration.newClient(configuration.url());
 
-        client.connect(err => {
-          expect(err).to.not.exist;
+        await client.connect();
 
-          const session = client.startSession();
-          const db = client.db(configuration.db);
-          const coll = db.collection('transaction_error_test');
-          coll.insertOne({ a: 1 }, err => {
-            expect(err).to.not.exist;
-            expect(() => session.startTransaction()).to.not.throw();
+        const session = client.startSession();
+        const db = client.db(configuration.db);
+        const coll = db.collection('transaction_error_test');
+        await coll.insertOne({ a: 1 });
+        session.startTransaction();
 
-            session.abortTransaction(() => session.endSession(() => client.close(done)));
-          });
-        });
+        await session.abortTransaction();
+        await session.endSession();
+        await client.close();
       }
     });
   });