test: add more unit tests

Author: cyber-hari

tests/config.test.ts

@@ -134,4 +134,66 @@ describe('config', () => {
 
     expect(actual).toEqual(expected);
   });
+
+  it('should support getConfig/setConfig aliases', () => {
+    const { getConfig, setConfig } = require('../src/config');
+
+    setConfig({ logger: { level: 'error' } });
+    const cfg = getConfig();
+
+    expect(cfg.logger.level).toBe('error');
+  });
+
+  it('should update and read server config using dedicated helpers', () => {
+    const { setCatbeeServerGlobalConfig, getCatbeeServerGlobalConfig } = require('../src/config');
+
+    setCatbeeServerGlobalConfig({ host: '127.0.0.1', metrics: { enable: true } });
+    const serverCfg = getCatbeeServerGlobalConfig();
+
+    expect(serverCfg.host).toBe('127.0.0.1');
+    expect(serverCfg.metrics.enable).toBe(true);
+  });
+
+  it('should evaluate requestLogging.ignorePaths predicate for skipped and non-skipped routes', () => {
+    const { getCatbeeGlobalConfig } = require('../src/config');
+    const cfg = getCatbeeGlobalConfig();
+
+    expect(cfg.server.requestLogging.ignorePaths({ path: '/healthz/ready' }, {})).toBe(true);
+    expect(cfg.server.requestLogging.ignorePaths({ path: '/api/users' }, {})).toBe(false);
+  });
+
+  it('should build enabled server option objects when env flags are true', () => {
+    jest.resetModules();
+    jest.doMock('../src/env', () =>
+      getEnvMockModule({
+        getBoolean: jest.fn((key: string, fallback: boolean) => {
+          const enabledKeys = new Set([
+            'SERVER_CORS_ENABLE',
+            'SERVER_HELMET_ENABLE',
+            'SERVER_COMPRESSION_ENABLE',
+            'SERVER_COOKIE_PARSER_ENABLE'
+          ]);
+          return enabledKeys.has(key) ? true : fallback;
+        }),
+        get: jest.fn((key: string, fallback: string) => {
+          if (key === 'SERVER_HEALTH_CHECK_PATH') return '/hc';
+          return fallback;
+        }),
+        isDev: jest.fn(() => false),
+        isTest: jest.fn(() => false)
+      })
+    );
+
+    const { getCatbeeGlobalConfig } = require('../src/config');
+    const cfg = getCatbeeGlobalConfig();
+
+    expect(cfg.server.cors).toEqual({});
+    expect(cfg.server.helmet).toEqual({});
+    expect(cfg.server.compression).toEqual({});
+    expect(cfg.server.cookieParser).toEqual({});
+    expect(cfg.server.healthCheck.path).toBe('/hc');
+
+    jest.resetModules();
+    jest.doMock('../src/env', () => getEnvMockModule());
+  });
 });

tests/server/server.test.ts

@@ -162,6 +162,27 @@ describe('ExpressServer', () => {
       await killServer(server);
     });
 
+    it('should return configured port when server address is not an object', async () => {
+      const server = new ExpressServer({ ...baseConfig, port: 4012 });
+      await server.waitUntilReady();
+
+      (server as any).server = {
+        address: () => 'named-pipe',
+        listening: false
+      };
+
+      expect(server.getPort()).toBe(4012);
+      expect(server.isRunning()).toBe(false);
+    });
+
+    it('should treat null https as enabled in isHttps guard', async () => {
+      const server = new ExpressServer({ ...(baseConfig as any), https: null as any });
+      await server.waitUntilReady();
+
+      expect(server.isHttps()).toBe(true);
+      expect(server.getProtocol()).toBe('http');
+    });
+
     it('should handle HTTPS configuration', async () => {
       const httpsConfig = {
         ...baseConfig,
@@ -201,6 +222,13 @@ describe('ExpressServer', () => {
       expect(() => server.setPort(70000)).toThrow('Port must be a valid number between 0 and 65535');
     });
 
+    it('should throw when setting invalid host', async () => {
+      const server = new ExpressServer(baseConfig);
+      await server.waitUntilReady();
+
+      expect(() => server.setHost('not a valid host')).toThrow('Host must be a valid hostname or IP address');
+    });
+
     it('should allow setting host before server starts', async () => {
       const server = new ExpressServer(baseConfig);
       await server.waitUntilReady();

tests/utils/context-store.utils.test.ts

@@ -106,6 +106,12 @@ describe('ContextStoreUtils', () => {
     });
   });
 
+  it('ContextStore.patch throws outside active context', () => {
+    expect(() => ContextStore.patch({ [StoreKeys.USER_ID]: 'no-context' })).toThrow(
+      /Failed to patch: AsyncLocalStorage store is not initialized/
+    );
+  });
+
   it('ContextStore.withValue temporarily overrides value in context', () => {
     ContextStore.run({ [StoreKeys.REQUEST_ID]: 'orig' }, () => {
       const result = ContextStore.withValue(StoreKeys.REQUEST_ID, 'temp', () => {
@@ -116,6 +122,22 @@ describe('ContextStoreUtils', () => {
     });
   });
 
+  it('ContextStore.withValue restores by deleting when no original value existed', () => {
+    ContextStore.run({}, () => {
+      const valueInside = ContextStore.withValue(StoreKeys.USER_ID, 'temp-user', () =>
+        ContextStore.get(StoreKeys.USER_ID)
+      );
+      expect(valueInside).toBe('temp-user');
+      expect(ContextStore.get(StoreKeys.USER_ID)).toBeUndefined();
+    });
+  });
+
+  it('ContextStore.withValue throws outside active context', () => {
+    expect(() => ContextStore.withValue(StoreKeys.USER_ID, 'temp', () => 'ok')).toThrow(
+      /Failed to set temporary value: AsyncLocalStorage store is not initialized/
+    );
+  });
+
   it('ContextStore.extend creates a new context inheriting from current', () => {
     ContextStore.run({ [StoreKeys.REQUEST_ID]: 'base' }, () => {
       const result = ContextStore.extend({ [StoreKeys.USER_ID]: 'extended' }, () => ({
@@ -129,6 +151,13 @@ describe('ContextStoreUtils', () => {
     });
   });
 
+  it('ContextStore.extend works without an existing context', () => {
+    const result = ContextStore.extend({ [StoreKeys.REQUEST_ID]: 'new-root' }, () =>
+      ContextStore.get(StoreKeys.REQUEST_ID)
+    );
+    expect(result).toBe('new-root');
+  });
+
   it('TypedContextKey works for get/set/exists/delete', () => {
     const key = new TypedContextKey<string>(StoreKeys.CORRELATION_ID, 'def');
     ContextStore.run({}, () => {

tests/utils/date.builder.test.ts

@@ -281,6 +281,13 @@ describe('DateBuilder', () => {
       expect(result.getSecond()).toBe(59);
     });
 
+    it('should get end of week', () => {
+      const result = testDate.endOfWeek();
+      expect(result.getDayOfWeek()).toBe(6); // Saturday
+      expect(result.getHour()).toBe(23);
+      expect(result.getMinute()).toBe(59);
+    });
+
     it('should get end of month', () => {
       const result = testDate.endOfMonth();
       expect(result.getDay()).toBe(31); // May has 31 days
@@ -293,6 +300,13 @@ describe('DateBuilder', () => {
       expect(result.getDay()).toBe(31);
     });
 
+    it('should get end of quarter', () => {
+      const result = testDate.endOfQuarter();
+      expect(result.getMonth()).toBe(6); // May is in Q2, so quarter end is June
+      expect(result.getDay()).toBe(30);
+      expect(result.getHour()).toBe(23);
+    });
+
     it('should handle chaining end of periods', () => {
       const result = testDate.endOfMonth().endOfDay();
       expect(result.getDay()).toBe(31); // May has 31 days
@@ -335,6 +349,12 @@ describe('DateBuilder', () => {
       expect(baseDate.isBetween(baseDate, laterDate, false)).toBe(false);
     });
 
+    it('should accept Date instances in isBetween', () => {
+      const start = new Date('2024-05-10');
+      const end = new Date('2024-05-20');
+      expect(baseDate.isBetween(start, end)).toBe(true);
+    });
+
     it('should check isWeekend', () => {
       const saturday = DateBuilder.of(2024, 5, 18); // May 18, 2024 is Saturday
       const sunday = DateBuilder.of(2024, 5, 19); // May 19, 2024 is Sunday

tests/utils/date.utils.test.ts

@@ -140,6 +140,27 @@ describe('date.utils', () => {
       const future = new Date(now.getTime() + 2 * 24 * 60 * 60 * 1000);
       expect(formatRelativeTime(future, now)).toContain('day');
     });
+
+    it('uses default now and supports numeric input', () => {
+      const thirtySecondsAgo = Date.now() - 30 * 1000;
+      expect(formatRelativeTime(thirtySecondsAgo)).toContain('second');
+    });
+
+    it('returns minute/hour/month/year buckets', () => {
+      const now = new Date('2024-01-01T00:00:00Z');
+
+      const minutesAgo = new Date(now.getTime() - 5 * 60 * 1000);
+      expect(formatRelativeTime(minutesAgo, now, 'en-US')).toContain('minute');
+
+      const hoursAgo = new Date(now.getTime() - 3 * 60 * 60 * 1000);
+      expect(formatRelativeTime(hoursAgo, now, 'en-US')).toContain('hour');
+
+      const monthsAgo = new Date(now.getTime() - 70 * 24 * 60 * 60 * 1000);
+      expect(formatRelativeTime(monthsAgo, now, 'en-US')).toContain('month');
+
+      const yearsAgo = new Date(now.getTime() - 400 * 24 * 60 * 60 * 1000);
+      expect(formatRelativeTime(yearsAgo, now, 'en-US')).toContain('year');
+    });
   });
 
   describe('parseDate', () => {
@@ -566,6 +587,25 @@ describe('date.utils', () => {
       const end = new Date('2023-05-20');
       expect(isBetween(date, start, end, false)).toBe(false);
     });
+
+    it('supports numeric timestamps and inclusive boundaries', () => {
+      const start = new Date('2023-05-10').getTime();
+      const end = new Date('2023-05-20').getTime();
+      const boundary = start;
+
+      expect(isBetween(boundary, start, end, true)).toBe(true);
+      expect(isBetween(boundary, start, end, false)).toBe(false);
+    });
+
+    it('handles mixed date/number inputs consistently', () => {
+      const dateNumber = new Date('2023-05-15').getTime();
+      const startDate = new Date('2023-05-10');
+      const endDate = new Date('2023-05-20');
+
+      expect(isBetween(dateNumber, startDate, endDate.getTime(), true)).toBe(true);
+      expect(isBetween(dateNumber, startDate.getTime(), endDate, true)).toBe(true);
+      expect(isBetween(new Date('2023-05-15'), startDate.getTime(), endDate.getTime(), true)).toBe(true);
+    });
   });
 
   describe('isLeapYear', () => {
@@ -820,6 +860,12 @@ describe('date.utils', () => {
       const result = addYears(timestamp, 5);
       expect(result).toBeInstanceOf(Date);
     });
+
+    it('handles zero-year addition and preserves date value', () => {
+      const date = new Date('2024-03-01T12:00:00Z');
+      const result = addYears(date, 0);
+      expect(result.getTime()).toBe(date.getTime());
+    });
   });
 
   describe('quarterOf', () => {

tests/utils/logger.utils.test.ts

@@ -39,7 +39,34 @@ describe('LoggerUtils', () => {
     delete (loggerUtils._globalThis as any)[Symbol.for('logger')];
   });
 
+  it('exports default sensitive fields as a non-empty array', () => {
+    expect(Array.isArray(loggerUtils.defaultSensitiveFields)).toBe(true);
+    expect(loggerUtils.defaultSensitiveFields.length).toBeGreaterThan(0);
+    expect(loggerUtils.defaultSensitiveFields).toContain('password');
+  });
+
+  it('exposes default redact censor and allows replacing/restoring it', () => {
+    const original = loggerUtils.getRedactCensor();
+    const replacement = jest.fn().mockReturnValue('MASKED');
+
+    try {
+      loggerUtils.setRedactCensor(replacement);
+      expect(loggerUtils.getRedactCensor()).toBe(replacement);
+      expect(loggerUtils.redact('value', ['path'])).toBe('MASKED');
+    } finally {
+      loggerUtils.setRedactCensor(original);
+    }
+  });
+
   describe('getLogger', () => {
+    it('returns a fresh non-global logger when newInstance is true', () => {
+      (ContextStore.get as jest.Mock).mockReturnValue(undefined);
+      const logger = loggerUtils.getLogger(true);
+
+      expect(logger).toBe(mockLogger);
+      expect((loggerUtils._globalThis as any)[Symbol.for('logger')]).toBeUndefined();
+    });
+
     it('returns logger from context if available', () => {
       (ContextStore.get as jest.Mock).mockReturnValue(mockLogger);
       const logger = loggerUtils.getLogger();
@@ -160,6 +187,68 @@ describe('LoggerUtils', () => {
       );
       expect(logger).toBe(mockLogger);
     });
+
+    it('uses multistream transport when pretty and file logging are enabled', () => {
+      const transportMock = jest.fn().mockReturnValue('transported');
+      (pino as any).transport = transportMock;
+
+      setCatbeeGlobalConfig({
+        logger: {
+          pretty: true,
+          dir: 'logs',
+          level: 'info',
+          colorize: true,
+          singleLine: true
+        }
+      });
+
+      loggerUtils.getLogger();
+
+      expect(transportMock).toHaveBeenCalledWith(
+        expect.objectContaining({
+          targets: expect.arrayContaining([
+            expect.objectContaining({ target: 'pino-pretty' }),
+            expect.objectContaining({ target: 'pino/file' })
+          ])
+        })
+      );
+    });
+
+    it('uses file-only transport when only logger dir is configured', () => {
+      const transportMock = jest.fn().mockReturnValue('transported');
+      (pino as any).transport = transportMock;
+
+      setCatbeeGlobalConfig({
+        logger: {
+          pretty: false,
+          dir: 'logs'
+        }
+      });
+
+      loggerUtils.getLogger();
+
+      expect(transportMock).toHaveBeenCalledWith(
+        expect.objectContaining({
+          target: 'pino/file',
+          options: expect.objectContaining({ destination: 'logs/app.log' })
+        })
+      );
+    });
+
+    it('uses plain pino without transport when pretty and file logging are disabled', () => {
+      (pino as any).transport = jest.fn().mockReturnValue('transported');
+      setCatbeeGlobalConfig({
+        logger: {
+          pretty: false,
+          dir: ''
+        }
+      });
+
+      loggerUtils.getLogger();
+
+      expect((pino as any).transport).not.toHaveBeenCalled();
+      expect(pino).toHaveBeenCalledWith(expect.objectContaining({ level: 'info' }));
+    });
   });
 
   describe('redactCensor', () => {
@@ -206,6 +295,18 @@ describe('LoggerUtils', () => {
       expect(loggerUtils.getRedactCensor()({ key: 'value' } as any, ['object'])).toBe('***');
     });
 
+    it('should return original value for non-sensitive custom top-level path', () => {
+      expect(loggerUtils.getRedactCensor()('trace-123', ['meta', 'traceId'])).toBe('trace-123');
+    });
+
+    it('should fallback to "***" when authorization value is empty', () => {
+      expect(loggerUtils.getRedactCensor()('', ['req', 'headers', 'authorization'])).toBe('***');
+    });
+
+    it('should ignore non-string path segments while evaluating redaction', () => {
+      expect(loggerUtils.getRedactCensor()('safe', ['meta', 123 as unknown as string] as string[])).toBe('safe');
+    });
+
     describe('setRedactCensor and getRedactCensor', () => {
       it('should allow setting and getting a custom redaction function', () => {
         // Save original censor to restore after test