test: update UTs for new methods

Author: cyber-hari

tests/config.test.ts

@@ -10,6 +10,7 @@ describe("Config", () => {
       Env: {
         get: jest.fn((key: string, fallback: string) => fallback),
         getBoolean: jest.fn(() => false),
+        getNumber: jest.fn((key: string, fallback: number) => fallback),
       },
     }));
 
@@ -39,6 +40,7 @@ describe("Config", () => {
         getBoolean: jest.fn((key: string, fallback: boolean) =>
           key === "LOGGER_ISO_TIMESTAMP" ? true : fallback,
         ),
+        getNumber: jest.fn((key: string, fallback: number) => fallback),
       },
     }));
 
@@ -60,6 +62,7 @@ describe("Config", () => {
           return key in values ? values[key] : fallback;
         }),
         getBoolean: jest.fn(() => false),
+        getNumber: jest.fn((key: string, fallback: number) => fallback),
       },
     }));
 
@@ -75,6 +78,7 @@ describe("Config", () => {
       Env: {
         get: jest.fn(() => "nonsense"),
         getBoolean: jest.fn(() => false),
+        getNumber: jest.fn((key: string, fallback: number) => fallback),
       },
     }));
 

tests/utils/array.utils.test.ts

@@ -9,6 +9,13 @@ import {
   difference,
   intersect,
   mergeSort,
+  zip,
+  partition,
+  range,
+  take,
+  takeWhile,
+  compact,
+  countBy,
 } from "../../src/utils/array.utils";
 
 jest.mock("../../src/utils/obj.utils", () => ({
@@ -197,4 +204,90 @@ describe("ArrayUtils", () => {
       expect(() => mergeSort(null, "x")).toThrow("Expected array");
     });
   });
+
+  describe("zip", () => {
+    it("zips arrays together", () => {
+      expect(zip([1, 2], ["a", "b"] as any)).toEqual([
+        [1, "a"],
+        [2, "b"],
+      ]);
+      expect(zip([1, 2, 3], ["a"] as any)).toEqual([[1, "a"]]);
+      expect(zip()).toEqual([]);
+      expect(() => zip([1], null as any)).toThrow(
+        "All arguments must be arrays",
+      );
+    });
+  });
+
+  describe("partition", () => {
+    it("splits array by predicate", () => {
+      expect(partition([1, 2, 3, 4], (x) => x % 2 === 0)).toEqual([
+        [2, 4],
+        [1, 3],
+      ]);
+    });
+    it("returns [[], []] for non-array", () => {
+      // @ts-expect-error
+      expect(partition(null, () => true)).toEqual([[], []]);
+    });
+  });
+
+  describe("range", () => {
+    it("generates a range of numbers", () => {
+      expect(range(0, 5)).toEqual([0, 1, 2, 3, 4]);
+      expect(range(5, 0, -2)).toEqual([5, 3, 1]);
+      expect(range(0, 0)).toEqual([]);
+    });
+    it("throws for invalid args", () => {
+      expect(() => range(NaN, 1)).toThrow();
+      expect(() => range(0, 1, 0)).toThrow();
+    });
+  });
+
+  describe("take", () => {
+    it("returns first n elements", () => {
+      expect(take([1, 2, 3], 2)).toEqual([1, 2]);
+      expect(take([1, 2, 3], 0)).toEqual([]);
+      expect(take([1, 2, 3])).toEqual([1]);
+      expect(take([], 2)).toEqual([]);
+      // @ts-expect-error
+      expect(take(null, 2)).toEqual([]);
+    });
+  });
+
+  describe("takeWhile", () => {
+    it("takes elements while predicate is true", () => {
+      expect(takeWhile([1, 2, 3, 0, 4], (x) => x > 0)).toEqual([1, 2, 3]);
+      expect(takeWhile([1, 2, 3], () => false)).toEqual([]);
+      // @ts-expect-error
+      expect(takeWhile(null, () => true)).toEqual([]);
+    });
+  });
+
+  describe("compact", () => {
+    it("removes falsy values", () => {
+      expect(compact([0, 1, false, 2, "", 3, null, undefined])).toEqual([
+        1, 2, 3,
+      ]);
+      expect(compact([])).toEqual([]);
+      // @ts-expect-error
+      expect(compact(null)).toEqual([]);
+    });
+  });
+
+  describe("countBy", () => {
+    it("counts elements by key function", () => {
+      expect(countBy(["a", "b", "a"], (x) => x)).toEqual({ a: 2, b: 1 });
+      expect(
+        countBy([1, 2, 3, 2], (x) => (x % 2 === 0 ? "even" : "odd")),
+      ).toEqual({
+        odd: 2,
+        even: 2,
+      });
+    });
+    it("returns {} for non-array", () => {
+      // @ts-expect-error
+      expect(countBy(null, () => "x")).toEqual({});
+    });
+  });
 });

tests/utils/async.utils.test.ts

@@ -1,4 +1,3 @@
-// asyncUtils.spec.ts
 import {
   sleep,
   debounce,
@@ -10,13 +9,18 @@ import {
   settleAll,
   createTaskQueue,
   runInSeries,
+  memoizeAsync,
+  abortable,
+  createDeferred,
+  waterfall,
+  rateLimit,
 } from "../../src/utils/async.utils";
 
 describe("sleep", () => {
   it("delays for at least the given ms", async () => {
     const start = Date.now();
     await sleep(30);
-    expect(Date.now() - start).toBeGreaterThanOrEqual(30);
+    expect(Date.now() - start).toBeGreaterThanOrEqual(30 - 5); // allow some margin for test environment
   });
 });
 
@@ -261,3 +265,105 @@ describe("runInSeries", () => {
     expect(result).toEqual([1, 2, 3]);
   });
 });
+
+describe("memoizeAsync", () => {
+  it("caches results for identical arguments", async () => {
+    const fn = jest.fn(async (x: number) => x * 2);
+    const memo = memoizeAsync(fn);
+    expect(await memo(2)).toBe(4);
+    expect(await memo(2)).toBe(4);
+    expect(fn).toHaveBeenCalledTimes(1);
+  });
+
+  it("respects TTL option", async () => {
+    jest.useFakeTimers();
+    const fn = jest.fn(async (x: number) => x + 1);
+    const memo = memoizeAsync(fn, { ttl: 100 });
+    await expect(memo(1)).resolves.toBe(2);
+    jest.advanceTimersByTime(99);
+    await expect(memo(1)).resolves.toBe(2);
+    jest.advanceTimersByTime(2);
+    await expect(memo(1)).resolves.toBe(2);
+    expect(fn).toHaveBeenCalledTimes(2);
+    jest.useRealTimers();
+  });
+
+  it("supports custom keyFn", async () => {
+    const fn = jest.fn(async (a: number, b: number) => a + b);
+    const memo = memoizeAsync(fn, { keyFn: ([a, b]) => `${a}-${b}` });
+    await expect(memo(1, 2)).resolves.toBe(3);
+    await expect(memo(1, 2)).resolves.toBe(3);
+    expect(fn).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("abortable", () => {
+  it("resolves if not aborted", async () => {
+    const ctrl = new AbortController();
+    await expect(abortable(Promise.resolve("ok"), ctrl.signal)).resolves.toBe(
+      "ok",
+    );
+  });
+
+  it("rejects if aborted before promise resolves", async () => {
+    const ctrl = new AbortController();
+    const p = abortable(
+      new Promise((r) => setTimeout(() => r("late"), 50)),
+      ctrl.signal,
+      "aborted",
+    );
+    ctrl.abort();
+    await expect(p).rejects.toBe("aborted");
+  });
+
+  it("rejects immediately if already aborted", async () => {
+    const ctrl = new AbortController();
+    ctrl.abort();
+    await expect(
+      abortable(Promise.resolve("x"), ctrl.signal, "gone"),
+    ).rejects.toBe("gone");
+  });
+});
+
+describe("createDeferred", () => {
+  it("resolves externally", async () => {
+    const [p, resolve] = createDeferred<number>();
+    setTimeout(() => resolve(42), 10);
+    await expect(p).resolves.toBe(42);
+  });
+
+  it("rejects externally", async () => {
+    const [p, , reject] = createDeferred<number>();
+    setTimeout(() => reject("fail"), 10);
+    await expect(p).rejects.toBe("fail");
+  });
+});
+
+describe("waterfall", () => {
+  it("chains async functions in order", async () => {
+    const fns = [
+      async (x: number) => x + 1,
+      async (x: number) => x * 2,
+      async (x: number) => `Result: ${x}`,
+    ];
+    const wf = waterfall<string>(fns);
+    await expect(wf(3)).resolves.toBe("Result: 8");
+  });
+});
+
+describe("rateLimit", () => {
+  it("limits calls per interval", async () => {
+    jest.useFakeTimers();
+    const fn = jest.fn(async (x: number) => x);
+    const limited = rateLimit(fn, 2, 100);
+    const p1 = limited(1);
+    const p2 = limited(2);
+    const p3 = limited(3);
+    jest.advanceTimersByTime(101);
+    const p4 = limited(4);
+    jest.advanceTimersByTime(101);
+    await expect(Promise.all([p1, p2, p3, p4])).resolves.toEqual([1, 2, 3, 4]);
+    expect(fn).toHaveBeenCalledTimes(4);
+    jest.useRealTimers();
+  });
+});

tests/utils/cache.utils.test.ts

@@ -6,13 +6,13 @@ describe("CacheUtils", () => {
   afterEach(() => jest.useRealTimers());
 
   it("set() + get() returns value before TTL expires", () => {
-    const cache = new TTLCache<string, number>(1000);
+    const cache = new TTLCache<string, number>({ ttlMs: 1000 });
     cache.set("foo", 42);
     expect(cache.get("foo")).toBe(42);
   });
 
   it("get() returns undefined after TTL expires and deletes key", () => {
-    const cache = new TTLCache<string, number>(1000);
+    const cache = new TTLCache<string, number>({ ttlMs: 1000 });
     cache.set("foo", 1);
     jest.advanceTimersByTime(1001);
     expect(cache.get("foo")).toBeUndefined();
@@ -33,7 +33,7 @@ describe("CacheUtils", () => {
   });
 
   it("has() only true for fresh entry, false after expiry", () => {
-    const cache = new TTLCache<string, number>(1000);
+    const cache = new TTLCache<string, number>({ ttlMs: 1000 });
     expect(cache.has("x")).toBe(false);
     cache.set("x", 500);
     expect(cache.has("x")).toBe(true);
@@ -60,7 +60,7 @@ describe("CacheUtils", () => {
   });
 
   it("size() returns current Map size (includes expired until cleanup/get)", () => {
-    const cache = new TTLCache<string, number>(100);
+    const cache = new TTLCache<string, number>({ ttlMs: 100 });
     cache.set("a", 1);
     cache.set("b", 2);
     expect(cache.size()).toBe(2);
@@ -124,4 +124,71 @@ describe("CacheUtils", () => {
     cache.set(99, "great");
     expect(Array.from(cache.keys()).sort()).toEqual([77, 99]);
   });
+
+  it("getOrCompute returns cached value or computes and caches if missing", async () => {
+    const cache = new TTLCache<string, number>({ ttlMs: 100 });
+    const producer = jest.fn(async () => 123);
+    // Not present, should call producer
+    await expect(cache.getOrCompute("a", producer)).resolves.toBe(123);
+    expect(producer).toHaveBeenCalledTimes(1);
+    // Present, should not call producer again
+    await expect(cache.getOrCompute("a", producer)).resolves.toBe(123);
+    expect(producer).toHaveBeenCalledTimes(1);
+    // After expiry, should call producer again
+    jest.advanceTimersByTime(101);
+    await expect(cache.getOrCompute("a", producer)).resolves.toBe(123);
+    expect(producer).toHaveBeenCalledTimes(2);
+  });
+
+  it("setMany and getMany work as expected", () => {
+    const cache = new TTLCache<string, number>();
+    cache.setMany([
+      ["a", 1],
+      ["b", 2],
+      ["c", 3],
+    ]);
+    expect(cache.getMany(["a", "b", "c", "d"])).toEqual([1, 2, 3, undefined]);
+  });
+
+  it("refresh extends the TTL of an entry", () => {
+    const cache = new TTLCache<string, number>({ ttlMs: 100 });
+    cache.set("foo", 1);
+    jest.advanceTimersByTime(90);
+    expect(cache.refresh("foo")).toBe(true);
+    jest.advanceTimersByTime(90);
+    // Should still be valid after refresh
+    expect(cache.get("foo")).toBe(1);
+    jest.advanceTimersByTime(101);
+    // Now expired
+    expect(cache.get("foo")).toBeUndefined();
+  });
+
+  it("refresh returns false for missing or expired keys", () => {
+    const cache = new TTLCache<string, number>({ ttlMs: 50 });
+    expect(cache.refresh("nope")).toBe(false);
+    cache.set("x", 1);
+    jest.advanceTimersByTime(51);
+    expect(cache.refresh("x")).toBe(false);
+  });
+
+  it("stats returns correct cache statistics", () => {
+    const cache = new TTLCache<string, number>({ ttlMs: 100, maxSize: 10 });
+    cache.set("a", 1);
+    cache.set("b", 2);
+    jest.advanceTimersByTime(101);
+    cache.set("c", 3);
+    const stats = cache.stats();
+    expect(stats.size).toBe(3);
+    expect(stats.validEntries).toBe(1);
+    expect(stats.expiredEntries).toBe(2);
+    expect(stats.maxSize).toBe(10);
+  });
+
+  it("destroy stops auto-cleanup interval", () => {
+    const cache = new TTLCache<string, number>({ autoCleanupMs: 100 });
+    const spy = jest.spyOn(global, "clearInterval");
+    cache.destroy();
+    expect(spy).toHaveBeenCalled();
+    spy.mockRestore();
+  });
 });