fix & updated test cases

Author: aman19K

packages/contentstack-utilities/src/logger/cliErrorHandler.ts

@@ -18,7 +18,8 @@ import { ERROR_TYPES } from '../constants/errorTypes';
  *
  * @remarks
  * This class is designed to handle a wide range of error types, including generic
- * JavaScript errors, API errors, and custom error objects. 
+ * JavaScript errors, API errors, and custom error objects. It also supports
+ * optional debugging and context metadata for enhanced error reporting.
  *
  * @example
  * ```typescript

packages/contentstack-utilities/test/unit/auth-handler.test.ts

@@ -79,7 +79,7 @@ describe('Auth Handler', () => {
 
       expect(createHTTPServerStub.calledOnce).to.be.true;
       expect(openOAuthURLStub.calledOnce).to.be.true;
-      expect(result).to.deep.equal({});
+      expect(result).to.be.undefined;
     });
   });
 
@@ -127,7 +127,6 @@ describe('Auth Handler', () => {
 
       sandbox.stub(authHandler, 'setOAuthBaseURL').resolves();
       sandbox.stub(crypto, 'createHash').returns({ update: () => {}, digest: () => {} });
-      sandbox.stub(authHandler, 'codeVerifier').value('CODE_VERIFIER');
       sandbox.stub(authHandler, 'OAuthBaseURL').value('https://example.com');
       sandbox.stub(authHandler, 'OAuthAppId').value('APP_ID');
       sandbox.stub(authHandler, 'OAuthResponseType').value('response_type');
@@ -355,13 +354,15 @@ describe('Auth Handler', () => {
       const data = {
         access_token: '',
       };
-
-      const userDetailsPromise = authHandler.getUserDetails(data);
-
-      return userDetailsPromise.catch((error) => {
-        expect(error).to.equal('Invalid/Empty access token');
-      });
-    });
+    
+      try {
+        await authHandler.getUserDetails(data);
+        throw new Error('Expected getUserDetails to throw'); // ensure failure if no error is thrown
+      } catch (error) {
+        expect(error).to.be.instanceOf(Error);
+        expect(error.message).to.equal('Invalid/Empty access token');
+      }
+    }); 
   });
 
   describe('isAuthenticated', () => {

packages/contentstack-utilities/test/unit/cliErrorHandler.test.ts

@@ -71,18 +71,6 @@ describe('CLIErrorHandler', () => {
     expect(classified.hidden).to.be.false;
   });
 
-  fancy.it('normalizeToError should handle object that throws', () => {
-    const badInput = {
-      get message() {
-        throw new Error('fail to access message');
-      },
-    };
-
-    const result = errorHandler['normalizeToError'](badInput);
-    expect(result).to.be.instanceOf(Error);
-    expect(result.message).to.include('fail');
-  });
-
   fancy.it('containsSensitiveInfo should return false for clean error', () => {
     const error = new Error('All good');
     const result = errorHandler['containsSensitiveInfo'](error);

packages/contentstack-utilities/test/unit/logger.test.ts

@@ -19,6 +19,11 @@ describe('Logger', () => {
     expect(winLogger.level).to.equal('error');
   });
 
+  fancy.it('should create hidden logger as error level', () => {
+    const hiddenLogger = logger.getLoggerInstance('hidden');
+    expect(hiddenLogger.level).to.equal('error');
+  });
+
   fancy.it('should redact sensitive keys', () => {
     const testMeta = {
       password: 'secret123',
@@ -34,6 +39,14 @@ describe('Logger', () => {
     expect(redacted.other).to.equal('safe');
   });
 
+  fancy.it('should detect valid LogEntry object', () => {
+    const validEntry = { level: 'info', message: 'Test message' };
+    expect(logger['isLogEntry'](validEntry)).to.equal(true);
+
+    const invalidEntry = { msg: 'nope' };
+    expect(logger['isLogEntry'](invalidEntry)).to.equal(false);
+  });
+
   fancy.it('should log error messages using error method', () => {
     const errorLogger = logger['loggers'].error;
     const spy = sinon.spy();
@@ -76,13 +89,17 @@ describe('Logger', () => {
     expect(spy.args[0][1].type).to.equal('success');
   });
 
-  fancy
-  .it('logError with hidden true logs to debug logger', () => {
-    const debugLogger = logger['loggers'].debug;
+  fancy.it('logError with hidden true logs to debug logger', () => {
+    const debugLogger = new Logger({
+      basePath: './logs',
+      consoleLogLevel: 'debug',
+      logLevel: 'debug',
+    });
+
     const spy = sinon.spy();
-    debugLogger.error = spy;
+    debugLogger['loggers'].debug.error = spy;
 
-    logger.logError({
+    debugLogger.logError({
       type: 'hiddenType',
       message: 'Something secret',
       error: new Error('oops'),
@@ -94,7 +111,6 @@ describe('Logger', () => {
     expect(logPayload.meta.type).to.equal('hiddenType');
   });
 
-
   fancy.it('redact handles splat symbol', () => {
     const obj = {
       token: 'abc',
@@ -104,4 +120,82 @@ describe('Logger', () => {
     expect(result.token).to.equal('[REDACTED]');
     expect(result[Symbol.for('splat')][0].password).to.equal('[REDACTED]');
   });
+
+  fancy.it('redact should return original if klona fails', () => {
+    const faultyLogger = new Logger({
+      basePath: './logs',
+      consoleLogLevel: 'info',
+      logLevel: 'info',
+    });
+
+    const obj = {
+      toJSON: () => {
+        throw new Error('klona fails');
+      }
+    };
+
+    const result = faultyLogger['redact'](obj);
+    expect(result).to.deep.equal(obj);
+  });
+
+  fancy.it('should call logWarn with correct meta', () => {
+    const warnSpy = sinon.spy();
+    logger['loggers'].warn.warn = warnSpy;
+
+    logger.logWarn({
+      type: 'testType',
+      message: 'Warn occurred',
+      context: 'warnContext',
+      meta: { custom: 'value' }
+    });
+
+    expect(warnSpy.calledOnce).to.be.true;
+    expect(warnSpy.args[0][0].meta.type).to.equal('testType');
+    expect(warnSpy.args[0][0].meta.custom).to.equal('value');
+  });
+
+  fancy.it('should call logInfo with correct meta', () => {
+    const infoSpy = sinon.spy();
+    logger['loggers'].info.info = infoSpy;
+
+    logger.logInfo({
+      type: 'infoType',
+      message: 'This is info',
+      meta: { foo: 'bar' },
+    });
+
+    expect(infoSpy.calledOnce).to.be.true;
+    expect(infoSpy.args[0][0].meta.foo).to.equal('bar');
+  });
+
+  fancy.it('should call logDebug with correct meta', () => {
+    const debugLogger = new Logger({
+      basePath: './logs',
+      consoleLogLevel: 'debug',
+      logLevel: 'debug',
+    });
+
+    const debugSpy = sinon.spy();
+    debugLogger['loggers'].debug.debug = debugSpy;
+
+    debugLogger.logDebug({
+      type: 'debugType',
+      message: 'Debug data',
+      meta: { extra: 'info' },
+    });
+
+    expect(debugSpy.calledOnce).to.be.true;
+    expect(debugSpy.args[0][0].meta.extra).to.equal('info');
+  });
+
+  fancy.it('shouldLog should default to info when config not defined', () => {
+    const defaultLogger = new Logger({
+      basePath: './logs',
+      consoleLogLevel: undefined as any,
+      logLevel: undefined as any,
+    });
+
+    expect(defaultLogger['shouldLog']('info', 'console')).to.equal(true);
+    expect(defaultLogger['shouldLog']('debug', 'console')).to.equal(false);
+  });
 });