sinon tests working

Author: aditi-khare-mongoDB

src/connection_string.ts

@@ -529,7 +529,7 @@ export function parseOptions(
       ...mongoOptions[Symbol.for('@@mdb.internalLoggerConfig')]
     };
     loggerClientOptions = {
-      mongodbLogPath: mongoOptions.mongoLoggerClientOptions.mongodbLogPath
+      mongodbLogPath: mongoOptions.mongodbLogPath
     };
   }
   mongoOptions.mongoLoggerOptions = MongoLogger.resolveOptions(
@@ -1228,7 +1228,7 @@ export const OPTIONS = {
    * @internal
    * TODO: NODE-5671 - remove internal flag
    */
-  mongoLoggerClientOptions: { type: 'any' }
+  mongodbLogPath: { type: 'any' }
 } as Record<keyof MongoClientOptions, OptionDescriptor>;
 
 export const DEFAULT_OPTIONS = new CaseInsensitiveMap(

src/mongo_client.ts

@@ -21,11 +21,7 @@ import { MONGO_CLIENT_EVENTS } from './constants';
 import { Db, type DbOptions } from './db';
 import type { Encrypter } from './encrypter';
 import { MongoInvalidArgumentError } from './error';
-import {
-  MongoLogger,
-  type MongoLoggerMongoClientOptions,
-  type MongoLoggerOptions
-} from './mongo_logger';
+import { type MongoDBLogWritable, MongoLogger, type MongoLoggerOptions } from './mongo_logger';
 import { TypedEventEmitter } from './mongo_types';
 import { executeOperation } from './operations/execute_operation';
 import { RunAdminCommandOperation } from './operations/run_command';
@@ -260,7 +256,7 @@ export interface MongoClientOptions extends BSONSerializeOptions, SupportedNodeC
    * @internal
    * TODO: NODE-5671 - remove internal flag
    */
-  mongoLoggerClientOptions?: MongoLoggerMongoClientOptions;
+  mongodbLogPath?: 'stderr' | 'stdout' | MongoDBLogWritable;
 
   /** @internal */
   [featureFlag: symbol]: any;
@@ -843,5 +839,5 @@ export interface MongoOptions
    * @internal
    * TODO: NODE-5671 - remove internal flag
    */
-  mongoLoggerClientOptions?: MongoLoggerMongoClientOptions;
+  mongodbLogPath?: 'stderr' | 'stdout' | MongoDBLogWritable;
 }

test/tools/unified-spec-runner/entities.ts

@@ -191,7 +191,7 @@ export class UnifiedMongoClient extends MongoClient {
       [Symbol.for('@@mdb.internalLoggerConfig')]: componentSeverities,
       ...getEnvironmentalOptions(),
       ...(description.serverApi ? { serverApi: description.serverApi } : {}),
-      mongoLoggerClientOptions: { mongodbLogPath: logCollector }
+      mongodbLogPath: logCollector
     } as any);
     this.logCollector = logCollector;
 

test/unit/connection_string.test.ts

@@ -4,12 +4,14 @@ import * as process from 'node:process';
 import { expect } from 'chai';
 import * as dns from 'dns';
 import * as sinon from 'sinon';
+import { inspect } from 'util';
 
 import {
   AUTH_MECHS_AUTH_SRC_EXTERNAL,
   AuthMechanism,
   DEFAULT_ALLOWED_HOSTS,
   FEATURE_FLAGS,
+  type Log,
   MongoAPIError,
   MongoClient,
   MongoCredentials,
@@ -832,4 +834,47 @@ describe('Connection String', function () {
         .that.matches(/useUnifiedTopology has no effect/);
     });
   });
+
+  describe('when mongodbLogPath is in options', function () {
+    const loggerFeatureFlag = Symbol.for('@@mdb.enableMongoLogger');
+
+    let stderrStub;
+    let stdoutStub;
+
+    before(() => {
+      stdoutStub = sinon.stub(process.stdout);
+      stderrStub = sinon.stub(process.stderr);
+    });
+
+    after(() => {
+      sinon.restore();
+    });
+
+    it('when option is `stderr`, it is accessible through mongoLogger.logDestination', function () {
+      const client = new MongoClient('mongodb://a/?mongodbLogPath=stderr', {
+        [loggerFeatureFlag]: true
+      });
+      const log: Log = { t: new Date(), c: 'ConnectionStringStdErr', s: 'error' };
+      client.options.mongoLoggerOptions.logDestination.write(log);
+      expect(stderrStub.write).calledWith(inspect(log, { breakLength: Infinity, compact: true }));
+    });
+
+    it('when option is `stdout`, it is accessible through mongoLogger.logDestination', function () {
+      const client = new MongoClient('mongodb://a/?mongodbLogPath=stdout', {
+        [loggerFeatureFlag]: true
+      });
+      const log: Log = { t: new Date(), c: 'ConnectionStringStdOut', s: 'error' };
+      client.options.mongoLoggerOptions.logDestination.write(log);
+      expect(stdoutStub.write).calledWith(inspect(log, { breakLength: Infinity, compact: true }));
+    });
+
+    it('when option is invalid, it defaults to stderr', function () {
+      const client = new MongoClient('mongodb://a/?mongodbLogPath=stdnothing', {
+        [loggerFeatureFlag]: true
+      });
+      const log: Log = { t: new Date(), c: 'ConnectionStringInvalidOption', s: 'error' };
+      client.options.mongoLoggerOptions.logDestination.write(log);
+      expect(stderrStub.write).calledWith(inspect(log, { breakLength: Infinity, compact: true }));
+    });
+  });
 });

test/unit/mongo_client.test.js

@@ -1,4 +1,6 @@
-'use strict';
+import { inspect } from 'util';
+
+('use strict');
 const os = require('os');
 const fs = require('fs');
 const { expect } = require('chai');
@@ -813,4 +815,60 @@ describe('MongoOptions', function () {
       expect(client.options).to.have.property('mongoLoggerOptions').to.equal(expectedLoggingObject);
     });
   });
+
+  context('when mongodbLogPath is in options', function () {
+    const loggerFeatureFlag = Symbol.for('@@mdb.enableMongoLogger');
+
+    let stderrStub;
+    let stdoutStub;
+
+    before(() => {
+      stdoutStub = sinon.stub(process.stdout);
+      stderrStub = sinon.stub(process.stderr);
+    });
+
+    after(() => {
+      sinon.restore();
+    });
+
+    it('when option is `stderr`, it is accessible through mongoLogger.logDestination', function () {
+      const client = new MongoClient('mongodb://a/', {
+        [loggerFeatureFlag]: true,
+        mongodbLogPath: 'stderr'
+      });
+      const log = { t: new Date(), c: 'constructorStdErr', s: 'error' };
+      client.options.mongoLoggerOptions.logDestination.write(log);
+      expect(stderrStub.write).calledWith(inspect(log, { breakLength: Infinity, compact: true }));
+    });
+
+    it('when option is a Writable stream, it is accessible through mongoLogger.logDestination', function () {
+      const writable = new Writable();
+      const client = new MongoClient('mongodb://a/', {
+        [loggerFeatureFlag]: true,
+        mongodbLogPath: writable
+      });
+      expect(client.options.mongoLoggerOptions.logDestination).to.deep.equal(writable);
+    });
+
+    it('when option is `stdout`, it is accessible through mongoLogger.logDestination', function () {
+      const client = new MongoClient('mongodb://a/', {
+        [loggerFeatureFlag]: true,
+        mongodbLogPath: 'stdout'
+      });
+      const log = { t: new Date(), c: 'constructorStdOut', s: 'error' };
+      client.options.mongoLoggerOptions.logDestination.write(log);
+      expect(stdoutStub.write).calledWith(inspect(log, { breakLength: Infinity, compact: true }));
+    });
+
+    it('when option is invalid, it defaults to stderr', function () {
+      const invalidOption = 'stdnothing';
+      const client = new MongoClient('mongodb://a/', {
+        [loggerFeatureFlag]: true,
+        mongodbLogPath: invalidOption
+      });
+      const log = { t: new Date(), c: 'constructorInvalidOption', s: 'error' };
+      client.options.mongoLoggerOptions.logDestination.write(log);
+      expect(stderrStub.write).calledWith(inspect(log, { breakLength: Infinity, compact: true }));
+    });
+  });
 });