test: update UTs to improve coverage

Author: cyber-hari

src/utils/date.utils.ts

@@ -55,16 +55,29 @@ export interface DateFormatOptions {
  */
 export function formatDate(date: Date | number, options: DateFormatOptions = {}): string {
   const { format = 'yyyy-MM-dd', locale, timeZone } = options;
+  const d = date instanceof Date ? date : new Date(date);
 
-  // Use Intl.DateTimeFormat for complex formatting
+  // Custom formatter for common patterns
+  if (format === 'yyyy-MM-dd') {
+    const yyyy = d.getFullYear();
+    const mm = String(d.getMonth() + 1).padStart(2, '0');
+    const dd = String(d.getDate()).padStart(2, '0');
+    return `${yyyy}-${mm}-${dd}`;
+  }
+  if (format === 'yyyy-MM-dd HH:mm:ss') {
+    const yyyy = d.getFullYear();
+    const mm = String(d.getMonth() + 1).padStart(2, '0');
+    const dd = String(d.getDate()).padStart(2, '0');
+    const HH = String(d.getHours()).padStart(2, '0');
+    const MM = String(d.getMinutes()).padStart(2, '0');
+    const SS = String(d.getSeconds()).padStart(2, '0');
+    return `${yyyy}-${mm}-${dd} ${HH}:${MM}:${SS}`;
+  }
   if (format === 'relative') {
     return formatRelativeTime(date);
   }
 
-  // Handle standard date formatting patterns
-  const d = date instanceof Date ? date : new Date(date);
-
-  // Use built-in Intl.DateTimeFormat for locale-aware formatting
+  // Fallback to Intl.DateTimeFormat for other formats
   return new Intl.DateTimeFormat(locale, {
     timeZone,
     year: format.includes('yyyy') || format.includes('y') ? 'numeric' : undefined,
@@ -228,9 +241,15 @@ export function addToDate(
     case 'days':
       d.setDate(d.getDate() + amount);
       break;
-    case 'months':
-      d.setMonth(d.getMonth() + amount);
+    case 'months': {
+      const origDate = d.getDate();
+      const origMonth = d.getMonth();
+      d.setDate(1); // Prevent overflow
+      d.setMonth(origMonth + amount);
+      const lastDay = new Date(d.getFullYear(), d.getMonth() + 1, 0).getDate();
+      d.setDate(Math.min(origDate, lastDay));
       break;
+    }
     case 'years':
       d.setFullYear(d.getFullYear() + amount);
       break;

src/utils/performance.utils.ts

@@ -108,6 +108,9 @@ export function timeSync<T>(fn: () => T, options: TimingOptions = {}): { result:
       case 'error':
         logger.error({ timing }, message);
         break;
+      default:
+        logger.debug({ timing }, message);
+        break;
     }
   }
 
@@ -173,6 +176,9 @@ export async function timeAsync<T>(
       case 'error':
         logger.error({ timing }, message);
         break;
+      default:
+        logger.debug({ timing }, message);
+        break;
     }
   }
 
@@ -196,13 +202,26 @@ export async function timeAsync<T>(
  * ```
  */
 export function timed(options: TimingOptions = {}) {
-  return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
-    const originalMethod = descriptor.value;
+  return function (target: any, propertyKeyOrContext: string | symbol | any, descriptor?: PropertyDescriptor): void {
+    let propertyKey: string | symbol;
+    let actualDescriptor: PropertyDescriptor;
+
+    // ESNext decorator: second argument is context object
+    if (typeof propertyKeyOrContext === 'object' && propertyKeyOrContext !== null && 'name' in propertyKeyOrContext) {
+      propertyKey = propertyKeyOrContext.name;
+      actualDescriptor = descriptor ?? Object.getOwnPropertyDescriptor(target, propertyKey)!;
+    } else {
+      // Legacy decorator: second argument is property key
+      propertyKey = propertyKeyOrContext;
+      actualDescriptor = descriptor ?? Object.getOwnPropertyDescriptor(target, propertyKey)!;
+    }
+
+    const originalMethod = actualDescriptor.value;
 
-    descriptor.value = function (...args: any[]) {
+    actualDescriptor.value = function (...args: any[]) {
       const methodOptions = {
         ...options,
-        label: options.label || `${target.constructor.name}.${propertyKey}`
+        label: options.label || `${target.constructor.name}.${String(propertyKey)}`
       };
 
       if (originalMethod.constructor.name === 'AsyncFunction') {
@@ -212,7 +231,13 @@ export function timed(options: TimingOptions = {}) {
       }
     };
 
-    return descriptor;
+    // For legacy decorators, assign the new descriptor
+    if (descriptor) {
+      descriptor.value = actualDescriptor.value;
+    } else {
+      Object.defineProperty(target, propertyKey, actualDescriptor);
+    }
+    // No return needed for method decorators
   };
 }
 

src/utils/stream.utils.ts

@@ -154,15 +154,14 @@ export function createBatchStream(size: number, options: { objectMode?: boolean
         buffers.push(buffer);
         bufferSize += buffer.length;
 
-        if (bufferSize >= size) {
-          const result = Buffer.concat(buffers);
-          this.push(result.slice(0, size));
-
-          // Keep the remainder for the next batch
-          const remainder = result.slice(size);
-          buffers = remainder.length > 0 ? [remainder] : [];
-          bufferSize = remainder.length;
+        // Emit batches of exact size
+        let combined = Buffer.concat(buffers, bufferSize);
+        while (combined.length >= size) {
+          this.push(combined.slice(0, size));
+          combined = combined.slice(size);
         }
+        buffers = combined.length > 0 ? [combined] : [];
+        bufferSize = combined.length;
       }
 
       callback();
@@ -171,10 +170,16 @@ export function createBatchStream(size: number, options: { objectMode?: boolean
     flush(callback) {
       if (objectMode && batch.length > 0) {
         this.push(batch);
-      } else if (!objectMode && buffers.length > 0) {
-        this.push(Buffer.concat(buffers));
+      } else if (!objectMode && buffers.length > 0 && bufferSize > 0) {
+        let combined = Buffer.concat(buffers, bufferSize);
+        while (combined.length >= size) {
+          this.push(combined.slice(0, size));
+          combined = combined.slice(size);
+        }
+        if (combined.length > 0) {
+          this.push(combined);
+        }
       }
-
       callback();
     }
   });

src/utils/type.utils.ts

@@ -56,6 +56,11 @@ export function isPrimitiveType(
     return value === undefined;
   }
 
+  if (type === 'object') {
+    // Only plain objects, not arrays or null
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+  }
+
   return typeof value === type;
 }
 

tests/utils/async.utils.test.ts

@@ -13,7 +13,10 @@ import {
   abortable,
   createDeferred,
   waterfall,
-  rateLimit
+  rateLimit,
+  circuitBreaker,
+  CircuitBreakerOpenError,
+  runWithConcurrency
 } from '../../src/utils/async.utils';
 
 describe('sleep', () => {
@@ -351,3 +354,121 @@ describe('rateLimit', () => {
     jest.useRealTimers();
   });
 });
+
+describe('circuitBreaker', () => {
+  it('allows calls when closed and resets failures on success', async () => {
+    let count = 0;
+    const fn = async () => ++count;
+    const breaker = circuitBreaker(fn, { failureThreshold: 2, resetTimeout: 50 });
+    expect(await breaker()).toBe(1);
+    expect(await breaker()).toBe(2);
+  });
+
+  it('opens circuit after failures and blocks calls', async () => {
+    let fail = true;
+    const fn = async () => {
+      if (fail) throw new Error('fail');
+      return 'ok';
+    };
+    let opened = false;
+    const breaker = circuitBreaker(fn, {
+      failureThreshold: 2,
+      resetTimeout: 50,
+      onOpen: () => {
+        opened = true;
+      }
+    });
+    await expect(breaker()).rejects.toThrow('fail');
+    await expect(breaker()).rejects.toThrow('fail');
+    expect(opened).toBe(true);
+    await expect(breaker()).rejects.toBeInstanceOf(CircuitBreakerOpenError);
+  });
+
+  it('moves to half-open after resetTimeout and closes on success', async () => {
+    let fail = true;
+    let halfOpen = false,
+      closed = false;
+    const fn = async () => {
+      if (fail) throw new Error('fail');
+      return 'ok';
+    };
+    const breaker = circuitBreaker(fn, {
+      failureThreshold: 1,
+      resetTimeout: 10,
+      successThreshold: 1,
+      onHalfOpen: () => {
+        halfOpen = true;
+      },
+      onClose: () => {
+        closed = true;
+      }
+    });
+    await expect(breaker()).rejects.toThrow('fail');
+    await expect(breaker()).rejects.toBeInstanceOf(CircuitBreakerOpenError);
+    await new Promise(res => setTimeout(res, 12));
+    fail = false;
+    expect(await breaker()).toBe('ok');
+    expect(halfOpen).toBe(true);
+    expect(closed).toBe(true);
+  });
+
+  it('throws CircuitBreakerOpenError when open', async () => {
+    const fn = async () => {
+      throw new Error('fail');
+    };
+    const breaker = circuitBreaker(fn, { failureThreshold: 1, resetTimeout: 100 });
+    await expect(breaker()).rejects.toThrow('fail');
+    await expect(breaker()).rejects.toBeInstanceOf(CircuitBreakerOpenError);
+  });
+});
+
+describe('runWithConcurrency', () => {
+  it('runs tasks with concurrency', async () => {
+    const order: number[] = [];
+    const tasks = [1, 2, 3, 4, 5].map(n => async () => {
+      await sleep(10);
+      order.push(n);
+      return n;
+    });
+    const result = await runWithConcurrency(tasks, { concurrency: 2 });
+    expect(result.sort()).toEqual([1, 2, 3, 4, 5]);
+    expect(order.length).toBe(5);
+  });
+
+  it('calls onProgress callback', async () => {
+    const progress: number[] = [];
+    const tasks = [1, 2, 3].map(n => async () => n);
+    await runWithConcurrency(tasks, {
+      concurrency: 2,
+      onProgress: (completed, _total) => progress.push(completed)
+    });
+    expect(progress).toEqual([1, 2, 3]);
+  });
+
+  it('aborts if signal is triggered', async () => {
+    const ctrl = new AbortController();
+    const tasks = [
+      async () => {
+        await sleep(10);
+        return 1;
+      },
+      async () => {
+        await sleep(10);
+        return 2;
+      }
+    ];
+    setTimeout(() => ctrl.abort(), 5);
+    await expect(runWithConcurrency(tasks, { concurrency: 1, signal: ctrl.signal })).rejects.toThrow('Aborted');
+  });
+
+  it('returns empty array for no tasks', async () => {
+    const result = await runWithConcurrency([], { concurrency: 2 });
+    expect(result).toEqual([]);
+  });
+
+  it('throws if already aborted', async () => {
+    const ctrl = new AbortController();
+    ctrl.abort();
+    await expect(runWithConcurrency([async () => 1], { signal: ctrl.signal })).rejects.toThrow('Aborted');
+  });
+});