test(NODE-7169): Migrate node-mongodb-native/test/unit tests

test/action/dependency.test.ts

@@ -5,7 +5,7 @@ import * as path from 'node:path';
 import { expect } from 'chai';
 
 import { dependencies, peerDependencies, peerDependenciesMeta } from '../../package.json';
-import { setDifference } from '../mongodb';
+import { setDifference } from '../../src/utils';
 import { alphabetically, itInNodeProcess, sorted } from '../tools/utils';
 
 const EXPECTED_DEPENDENCIES = sorted(

test/integration/auth/auth.prose.test.ts

@@ -1,7 +1,10 @@
 import { expect } from 'chai';
 import * as sinon from 'sinon';
 
-import { Connection, LEGACY_HELLO_COMMAND, type MongoClient, ScramSHA256 } from '../../mongodb';
+import { ScramSHA256 } from '../../../src/cmap/auth/scram';
+import { Connection } from '../../../src/cmap/connection';
+import { LEGACY_HELLO_COMMAND } from '../../../src/constants';
+import { type MongoClient } from '../../../src/mongo_client';
 import { type TestConfiguration } from '../../tools/runner/config';
 
 function makeConnectionString(config, username, password) {

test/integration/auth/mongodb_aws.test.ts

@@ -1,26 +1,18 @@
 import * as process from 'node:process';
 
+import { type Document } from 'bson';
 import { expect } from 'chai';
 import * as http from 'http';
 import { performance } from 'perf_hooks';
 import * as sinon from 'sinon';
 
 import { refreshKMSCredentials } from '../../../src/client-side-encryption/providers';
-import {
-  AWSSDKCredentialProvider,
-  type CommandOptions,
-  Connection,
-  type Document,
-  MongoAWSError,
-  type MongoClient,
-  MongoDBAWS,
-  type MongoDBNamespace,
-  type MongoDBResponseConstructor,
-  MongoMissingCredentialsError,
-  MongoMissingDependencyError,
-  MongoServerError,
-  setDifference
-} from '../../mongodb';
+import { AWSSDKCredentialProvider } from '../../../src/cmap/auth/aws_temporary_credentials';
+import { type CommandOptions, Connection } from '../../../src/cmap/connection';
+import { type MongoDBResponseConstructor } from '../../../src/cmap/wire_protocol/responses';
+import { MongoAWSError, MongoMissingDependencyError, MongoServerError } from '../../../src/error';
+import { type MongoClient } from '../../../src/mongo_client';
+import { type MongoDBNamespace } from '../../../src/utils';
 
 const isMongoDBAWSAuthEnvironment = (process.env.MONGODB_URI ?? '').includes('MONGODB-AWS');
 

test/integration/enumerate_databases.prose.test.ts

@@ -1,6 +1,6 @@
 import { expect } from 'chai';
 
-import type { MongoClient } from '../mongodb';
+import { type MongoClient } from '../../src/mongo_client';
 
 const REQUIRED_DBS = ['admin', 'local', 'config'];
 const DB_NAME = 'listDatabasesTest';

test/integration/enumerate_databases.test.ts

@@ -1,7 +1,8 @@
 import { expect } from 'chai';
 import { once } from 'events';
 
-import { type MongoClient, MongoServerError } from '../mongodb';
+import { MongoServerError } from '../../src/error';
+import { type MongoClient } from '../../src/mongo_client';
 import { TestBuilder, UnifiedTestSuiteBuilder } from '../tools/unified_suite_builder';
 
 const metadata: MongoDBMetadataUI = {

test/integration/index_management.test.ts

@@ -1,13 +1,13 @@
 import { expect } from 'chai';
 
 import {
-  type Collection,
   type CommandStartedEvent,
-  type CommandSucceededEvent,
-  type Db,
-  type MongoClient,
-  MongoServerError
-} from '../mongodb';
+  type CommandSucceededEvent
+} from '../../src/cmap/command_monitoring_events';
+import { type Collection } from '../../src/collection';
+import { type Db } from '../../src/db';
+import { MongoServerError } from '../../src/error';
+import { type MongoClient } from '../../src/mongo_client';
 import { type FailCommandFailPoint } from '../tools/utils';
 import { assert as test, filterForCommands, setupDatabase } from './shared';
 

test/tools/mongodb-mock/index.js

@@ -1,6 +1,6 @@
 const fs = require('fs');
 const { MockServer } = require('./src/server.js');
-const { LEGACY_HELLO_COMMAND } = require('../../mongodb');
+const { LEGACY_HELLO_COMMAND } = require('../../../src/constants.ts');
 
 let mockServers = [];
 

test/tools/runner/config.ts

@@ -1,25 +1,19 @@
 import * as util from 'node:util';
 import * as types from 'node:util/types';
 
+import { Double, Long, ObjectId } from 'bson';
 import { expect } from 'chai';
 import { type Context } from 'mocha';
 import ConnectionString from 'mongodb-connection-string-url';
 import { type CompressorName } from 'mongodb-legacy';
 import * as qs from 'querystring';
 import * as url from 'url';
 
-import {
-  type AuthMechanism,
-  Double,
-  HostAddress,
-  Long,
-  MongoClient,
-  type MongoClientOptions,
-  ObjectId,
-  type ServerApi,
-  TopologyType,
-  type WriteConcernSettings
-} from '../../mongodb';
+import { type AuthMechanism } from '../../../src/cmap/auth/providers';
+import { MongoClient, type MongoClientOptions, type ServerApi } from '../../../src/mongo_client';
+import { TopologyType } from '../../../src/sdam/common';
+import { HostAddress } from '../../../src/utils';
+import { type WriteConcernSettings } from '../../../src/write_concern';
 import { getEnvironmentalOptions } from '../utils';
 import { type Filter } from './filters/filter';
 import { flakyTests } from './flaky';

test/tools/runner/filters/filter.ts

@@ -1,4 +1,4 @@
-import { type MongoClient } from '../../../mongodb';
+import { type MongoClient } from '../../../../src/mongo_client';
 
 export abstract class Filter {
   async initializeFilter(_client: MongoClient, _context: Record<string, any>): Promise<void> {

test/tools/utils.ts

@@ -3,24 +3,18 @@ import { on, once } from 'node:events';
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 
-import { EJSON } from 'bson';
+import { type Document, EJSON } from 'bson';
 import * as BSON from 'bson';
 import { expect } from 'chai';
 import { Readable } from 'stream';
 import { setTimeout } from 'timers';
 import { inspect, promisify } from 'util';
 
-import {
-  type AnyClientBulkWriteModel,
-  type Document,
-  type HostAddress,
-  MongoClient,
-  type MongoClientOptions,
-  now,
-  OP_MSG,
-  Topology,
-  type TopologyOptions
-} from '../mongodb';
+import { OP_MSG } from '../../src/cmap/wire_protocol/constants';
+import { MongoClient, type MongoClientOptions } from '../../src/mongo_client';
+import { type AnyClientBulkWriteModel } from '../../src/operations/client_bulk_write/common';
+import { Topology, type TopologyOptions } from '../../src/sdam/topology';
+import { type HostAddress, now } from '../../src/utils';
 import { type TestConfiguration } from './runner/config';
 
 export function ensureCalledWith(stub: any, args: any[]) {

test/unit/assorted/polling_srv_records_for_mongos_discovery.prose.test.ts

@@ -98,12 +98,9 @@ describe('Polling Srv Records for Mongos Discovery', () => {
       return mock.cleanup();
     });
 
-    afterEach(function (done) {
+    afterEach(function () {
       if (context.topology) {
         context.topology.close();
-        done();
-      } else {
-        done();
       }
     });
 

test/unit/bson.test.ts

@@ -1,7 +1,6 @@
+import { BSON } from 'bson';
 import { expect } from 'chai';
 
-import { BSON } from '../mongodb';
-
 describe('When importing BSON', function () {
   const types = [
     ['Long', 23],

test/unit/change_stream.test.ts

@@ -2,7 +2,9 @@ import { Long, Timestamp } from 'bson';
 import { expect } from 'chai';
 import * as sinon from 'sinon';
 
-import { ChangeStreamCursor, MongoClient, MongoDBNamespace } from '../mongodb';
+import { ChangeStreamCursor } from '../../src/cursor/change_stream_cursor';
+import { MongoClient } from '../../src/mongo_client';
+import { MongoDBNamespace } from '../../src/utils';
 
 describe('ChangeStreamCursor', function () {
   afterEach(function () {

test/unit/client-side-encryption/auto_encrypter.test.ts

@@ -1,13 +1,14 @@
+import { BSON } from 'bson';
 import { expect } from 'chai';
 import * as fs from 'fs';
 import * as net from 'net';
 import * as sinon from 'sinon';
 
 import { AutoEncrypter } from '../../../src/client-side-encryption/auto_encrypter';
+import { type DataKey } from '../../../src/client-side-encryption/client_encryption';
 import { MongocryptdManager } from '../../../src/client-side-encryption/mongocryptd_manager';
 import { StateMachine } from '../../../src/client-side-encryption/state_machine';
 import { MongoClient } from '../../../src/mongo_client';
-import { BSON, type DataKey } from '../../mongodb';
 import * as requirements from './requirements.helper';
 
 const bson = BSON;

test/unit/client-side-encryption/client_encryption.test.ts

@@ -1,3 +1,4 @@
+import { Binary, BSON, deserialize } from 'bson';
 import { expect } from 'chai';
 import * as fs from 'fs';
 import { resolve } from 'path';
@@ -10,7 +11,7 @@ import {
   MongoCryptCreateEncryptedCollectionError
 } from '../../../src/client-side-encryption/errors';
 import { StateMachine } from '../../../src/client-side-encryption/state_machine';
-import { Binary, BSON, deserialize, MongoClient } from '../../mongodb';
+import { MongoClient } from '../../../src/mongo_client';
 
 const { EJSON } = BSON;
 

test/unit/client-side-encryption/errors.test.ts

@@ -7,7 +7,7 @@ import {
   MongoCryptError,
   MongoCryptInvalidArgumentError
 } from '../../../src/client-side-encryption/errors';
-import { MongoError } from '../../mongodb';
+import { MongoError } from '../../../src/error';
 
 describe('MongoCryptError', function () {
   const errors = [

test/unit/client-side-encryption/providers/credentialsProvider.test.ts

@@ -13,8 +13,8 @@ import {
   tokenCache
 } from '../../../../src/client-side-encryption/providers/azure';
 import { AWSSDKCredentialProvider } from '../../../../src/cmap/auth/aws_temporary_credentials';
+import { MongoNetworkTimeoutError } from '../../../../src/error';
 import * as utils from '../../../../src/utils';
-import { MongoNetworkTimeoutError } from '../../../mongodb';
 import * as requirements from '../requirements.helper';
 
 const originalAccessKeyId = process.env.AWS_ACCESS_KEY_ID;

test/unit/client-side-encryption/state_machine.test.ts

@@ -1,27 +1,21 @@
+import { BSON, Int32, Long, serialize } from 'bson';
 import { expect } from 'chai';
 import { EventEmitter, once } from 'events';
 import * as fs from 'fs/promises';
 import { type MongoCryptKMSRequest } from 'mongodb-client-encryption';
 import * as net from 'net';
 import * as sinon from 'sinon';
-import { setTimeout } from 'timers';
 import { setTimeout as setTimeoutAsync } from 'timers/promises';
 import * as tls from 'tls';
 
 import { StateMachine } from '../../../src/client-side-encryption/state_machine';
+import { Collection } from '../../../src/collection';
+import { CursorTimeoutContext } from '../../../src/cursor/abstract_cursor';
 import { Db } from '../../../src/db';
-import {
-  BSON,
-  Collection,
-  CSOTTimeoutContext,
-  CursorTimeoutContext,
-  type FindOptions,
-  Int32,
-  Long,
-  MongoClient,
-  serialize,
-  squashError
-} from '../../mongodb';
+import { MongoClient } from '../../../src/mongo_client';
+import { type FindOptions } from '../../../src/operations/find';
+import { CSOTTimeoutContext } from '../../../src/timeout';
+import { squashError } from '../../../src/utils';
 import { sleep } from '../../tools/utils';
 
 describe('StateMachine', function () {
@@ -129,7 +123,7 @@ describe('StateMachine', function () {
         });
       });
 
-      it('should only resolve once bytesNeeded drops to zero', function (done) {
+      it('should only resolve once bytesNeeded drops to zero', async function () {
         const stateMachine = new StateMachine({} as any);
         const request = new MockRequest(Buffer.from('foobar'), 500);
         let status = 'pending';
@@ -143,22 +137,21 @@ describe('StateMachine', function () {
           .catch(() => {});
 
         this.fakeSocket.emit('connect');
-        setTimeout(() => {
-          expect(status).to.equal('pending');
-          expect(request.bytesNeeded).to.equal(500);
-          expect(request.kmsProvider).to.equal('aws');
-          this.fakeSocket.emit('data', Buffer.alloc(300));
-          setTimeout(() => {
-            expect(status).to.equal('pending');
-            expect(request.bytesNeeded).to.equal(200);
-            this.fakeSocket.emit('data', Buffer.alloc(200));
-            setTimeout(() => {
-              expect(status).to.equal('resolved');
-              expect(request.bytesNeeded).to.equal(0);
-              done();
-            });
-          });
-        });
+        await sleep();
+
+        expect(status).to.equal('pending');
+        expect(request.bytesNeeded).to.equal(500);
+        expect(request.kmsProvider).to.equal('aws');
+        this.fakeSocket.emit('data', Buffer.alloc(300));
+        await sleep();
+
+        expect(status).to.equal('pending');
+        expect(request.bytesNeeded).to.equal(200);
+        this.fakeSocket.emit('data', Buffer.alloc(200));
+        await sleep();
+
+        expect(status).to.equal('resolved');
+        expect(request.bytesNeeded).to.equal(0);
       });
     });
 
@@ -196,13 +189,15 @@ describe('StateMachine', function () {
               } as any);
               const request = new MockRequest(Buffer.from('foobar'), 500);
 
-              it('rejects with the validation error', function (done) {
-                stateMachine.kmsRequest(request).catch(err => {
+              it('rejects with the validation error', async function () {
+                try {
+                  await stateMachine.kmsRequest(request);
+                  expect.fail('should have failed with validation error');
+                } catch (err) {
                   expect(err.message).to.equal(
                     `Insecure TLS options prohibited for aws: ${option}`
                   );
-                  done();
-                });
+                }
               });
             });
           }

test/unit/cmap/auth/auth_provider.test.ts

@@ -1,6 +1,7 @@
 import { expect } from 'chai';
 
-import { type AuthContext, AuthProvider, MongoRuntimeError } from '../../../mongodb';
+import { type AuthContext, AuthProvider } from '../../../../src/cmap/auth/auth_provider';
+import { MongoRuntimeError } from '../../../../src/error';
 
 describe('AuthProvider', function () {
   describe('#reauth', function () {

test/unit/cmap/auth/gssapi.test.ts

@@ -6,7 +6,7 @@ import {
   GSSAPICanonicalizationValue,
   performGSSAPICanonicalizeHostName,
   resolveCname
-} from '../../../mongodb';
+} from '../../../../src/cmap/auth/gssapi';
 
 describe('GSSAPI', () => {
   let lookupSpy;

test/unit/cmap/auth/mongodb_oidc/automated_callback_workflow.test.ts

@@ -1,14 +1,12 @@
 import { expect } from 'chai';
 import * as sinon from 'sinon';
 
+import { MongoCredentials } from '../../../../../src/cmap/auth/mongo_credentials';
+import { AutomatedCallbackWorkflow } from '../../../../../src/cmap/auth/mongodb_oidc/automated_callback_workflow';
+import { CallbackWorkflow } from '../../../../../src/cmap/auth/mongodb_oidc/callback_workflow';
 import { callback } from '../../../../../src/cmap/auth/mongodb_oidc/gcp_machine_workflow';
 import { TokenCache } from '../../../../../src/cmap/auth/mongodb_oidc/token_cache';
-import {
-  AutomatedCallbackWorkflow,
-  CallbackWorkflow,
-  Connection,
-  MongoCredentials
-} from '../../../../mongodb';
+import { Connection } from '../../../../../src/cmap/connection';
 
 describe('AutomatedCallbackWorkflow', function () {
   describe('#execute', function () {