Merge pull request #10531 from ChrisiPK/patch-logger-error-call

fix(common): correct order for logger error parameters
nestjs · Feb 1, 2023 · 38c3652 · 38c3652
2 parents 80b8c86 + 584015b
commit 38c3652
Show file tree

Hide file tree

Showing 2 changed files with 72 additions and 26 deletions.
diff --git a/packages/common/services/logger.service.ts b/packages/common/services/logger.service.ts
@@ -125,7 +125,9 @@ export class Logger implements LoggerService {
   @Logger.WrapBuffer
   error(message: any, ...optionalParams: any[]) {
     optionalParams = this.context
-      ? optionalParams.concat(this.context)
+      ? (optionalParams.length ? optionalParams : [undefined]).concat(
+          this.context,
+        )
       : optionalParams;
 
     this.localInstance?.error(message, ...optionalParams);

diff --git a/packages/common/test/services/logger.service.spec.ts b/packages/common/test/services/logger.service.spec.ts
@@ -480,43 +480,87 @@ describe('Logger', () => {
         warn(message: any, context?: string) {}
       }
 
-      const customLogger = new CustomLogger();
-      const originalLogger = new Logger();
+      describe('with global context', () => {
+        const customLogger = new CustomLogger();
+        const globalContext = 'RandomContext';
+        const originalLogger = new Logger(globalContext);
 
-      let previousLoggerRef: LoggerService;
+        let previousLoggerRef: LoggerService;
 
-      beforeEach(() => {
-        previousLoggerRef =
-          Logger['localInstanceRef'] || Logger['staticInstanceRef'];
-        Logger.overrideLogger(customLogger);
-      });
+        beforeEach(() => {
+          previousLoggerRef =
+            Logger['localInstanceRef'] || Logger['staticInstanceRef'];
+          Logger.overrideLogger(customLogger);
+        });
 
-      afterEach(() => {
-        Logger.overrideLogger(previousLoggerRef);
-      });
+        afterEach(() => {
+          Logger.overrideLogger(previousLoggerRef);
+        });
 
-      it('should call custom logger "#log()" method', () => {
-        const message = 'random message';
-        const context = 'RandomContext';
+        it('should call custom logger "#log()" method with context as second argument', () => {
+          const message = 'random log message with global context';
 
-        const customLoggerLogSpy = sinon.spy(customLogger, 'log');
+          const customLoggerLogSpy = sinon.spy(customLogger, 'log');
 
-        originalLogger.log(message, context);
+          originalLogger.log(message);
 
-        expect(customLoggerLogSpy.called).to.be.true;
-        expect(customLoggerLogSpy.calledWith(message, context)).to.be.true;
+          expect(customLoggerLogSpy.called).to.be.true;
+          expect(customLoggerLogSpy.calledWith(message, globalContext)).to.be
+            .true;
+        });
+        it('should call custom logger "#error()" method with context as third argument', () => {
+          const message = 'random error message with global context';
+
+          const customLoggerErrorSpy = sinon.spy(customLogger, 'error');
+
+          originalLogger.error(message);
+
+          expect(customLoggerErrorSpy.called).to.be.true;
+          expect(
+            customLoggerErrorSpy.calledWith(message, undefined, globalContext),
+          ).to.be.true;
+        });
       });
+      describe('without global context', () => {
+        const customLogger = new CustomLogger();
+        const originalLogger = new Logger();
 
-      it('should call custom logger "#error()" method', () => {
-        const message = 'random message';
-        const context = 'RandomContext';
+        let previousLoggerRef: LoggerService;
 
-        const customLoggerErrorSpy = sinon.spy(customLogger, 'error');
+        beforeEach(() => {
+          previousLoggerRef =
+            Logger['localInstanceRef'] || Logger['staticInstanceRef'];
+          Logger.overrideLogger(customLogger);
+        });
 
-        originalLogger.error(message, context);
+        afterEach(() => {
+          Logger.overrideLogger(previousLoggerRef);
+        });
 
-        expect(customLoggerErrorSpy.called).to.be.true;
-        expect(customLoggerErrorSpy.calledWith(message, context)).to.be.true;
+        it('should call custom logger "#log()" method', () => {
+          const message = 'random message';
+          const context = 'RandomContext';
+
+          const customLoggerLogSpy = sinon.spy(customLogger, 'log');
+
+          originalLogger.log(message, context);
+
+          expect(customLoggerLogSpy.called).to.be.true;
+          expect(customLoggerLogSpy.calledWith(message, context)).to.be.true;
+        });
+
+        it('should call custom logger "#error()" method', () => {
+          const message = 'random message';
+          const context = 'RandomContext';
+
+          const customLoggerErrorSpy = sinon.spy(customLogger, 'error');
+
+          originalLogger.error(message, undefined, context);
+
+          expect(customLoggerErrorSpy.called).to.be.true;
+          expect(customLoggerErrorSpy.calledWith(message, undefined, context))
+            .to.be.true;
+        });
       });
     });
   });