Skip to content

Garry's Opinionated OpenClaw/Hermes Agent Brain

TypeScript
3.9 KB
Raw Blame
/**
 * Tests for src/core/parallel.ts (v0.40 Federated Sync v2).
 *
 * Pins: result order matches input order, one rejection doesn't kill others,
 * concurrency cap is a hard ceiling, empty input returns empty, invalid
 * concurrency throws TypeError.
 */
import { describe, test, expect } from 'bun:test';
import { pMapAllSettled } from '../src/core/parallel.ts';

describe('pMapAllSettled', () => {
  test('returns results in input order', async () => {
    const items = [1, 2, 3, 4, 5];
    const results = await pMapAllSettled(items, 2, async (n) => n * 10);
    expect(results).toHaveLength(5);
    expect(results.map((r) => (r.status === 'fulfilled' ? r.value : null))).toEqual([10, 20, 30, 40, 50]);
  });

  test('one rejection does not kill other items', async () => {
    const items = ['a', 'b', 'c'];
    const results = await pMapAllSettled(items, 2, async (s) => {
      if (s === 'b') throw new Error('intentional');
      return s.toUpperCase();
    });
    expect(results[0]).toEqual({ status: 'fulfilled', value: 'A' });
    expect(results[1].status).toBe('rejected');
    expect(results[1].status === 'rejected' && (results[1].reason as Error).message).toBe('intentional');
    expect(results[2]).toEqual({ status: 'fulfilled', value: 'C' });
  });

  test('hard ceiling: never exceeds concurrency in flight', async () => {
    let inFlight = 0;
    let peak = 0;
    const items = Array.from({ length: 20 }, (_, i) => i);
    await pMapAllSettled(items, 3, async () => {
      inFlight++;
      peak = Math.max(peak, inFlight);
      await new Promise((r) => setTimeout(r, 5));
      inFlight--;
      return 'ok';
    });
    expect(peak).toBeLessThanOrEqual(3);
    expect(peak).toBeGreaterThan(0);
  });

  test('empty input returns empty array', async () => {
    const results = await pMapAllSettled([], 5, async () => 'x');
    expect(results).toEqual([]);
  });

  test('concurrency > items.length runs all in parallel (no semaphore stall)', async () => {
    // Every task waits at a barrier that opens only once all of them have
    // started, so a stalled semaphore never opens it. The timeout is a hang
    // guard, not the pass condition.
    const items = [1, 2, 3];
    let inFlight = 0;
    let peak = 0;
    let open!: () => void;
    const barrier = new Promise<void>((resolve) => { open = resolve; });
    let guard: ReturnType<typeof setTimeout> | undefined;
    const stalled = new Promise<never>((_, reject) => {
      guard = setTimeout(() => reject(new Error(`semaphore stall: ${inFlight} of ${items.length} tasks started`)), 5_000);
    });
    try {
      const results = await Promise.race([
        pMapAllSettled(items, 100, async () => {
          inFlight++;
          peak = Math.max(peak, inFlight);
          if (inFlight === items.length) open();
          await barrier;
          inFlight--;
          return 'ok';
        }),
        stalled,
      ]);
      expect(results.every((r) => r.status === 'fulfilled')).toBe(true);
    } finally {
      clearTimeout(guard);
    }
    expect(peak).toBe(items.length);
  });

  test('throws TypeError on concurrency < 1', async () => {
    await expect(pMapAllSettled([1], 0, async (x) => x)).rejects.toThrow(TypeError);
    await expect(pMapAllSettled([1], -3, async (x) => x)).rejects.toThrow(TypeError);
  });

  test('throws TypeError on non-integer concurrency', async () => {
    await expect(pMapAllSettled([1], 1.5, async (x) => x)).rejects.toThrow(TypeError);
    await expect(pMapAllSettled([1], NaN, async (x) => x)).rejects.toThrow(TypeError);
  });

  test('passes index to fn', async () => {
    const seen: Array<[string, number]> = [];
    await pMapAllSettled(['a', 'b', 'c'], 2, async (item, i) => {
      seen.push([item, i]);
      return item;
    });
    // Sort by item since execution order isn't guaranteed.
    seen.sort((a, b) => a[0].localeCompare(b[0]));
    expect(seen).toEqual([['a', 0], ['b', 1], ['c', 2]]);
  });
});