SnowLuma v2.4.2 source snapshot

packages/common/tests/concurrency.test.ts

@@ -0,0 +1,81 @@
+import { describe, it, expect } from 'vitest';
+import { mapWithConcurrency } from '../src/concurrency';
+
+const tick = () => new Promise<void>((r) => setTimeout(r, 0));
+
+describe('mapWithConcurrency', () => {
+    it('returns results in input order', async () => {
+        const out = await mapWithConcurrency([1, 2, 3, 4, 5], 2, async (n) => n * 10);
+        expect(out).toEqual([10, 20, 30, 40, 50]);
+    });
+
+    it('passes the absolute index (across batch boundaries)', async () => {
+        const seen: Array<[number, number]> = [];
+        await mapWithConcurrency(['a', 'b', 'c', 'd', 'e'], 2, async (item, i) => {
+            seen.push([i, item.charCodeAt(0)]);
+            return i;
+        });
+        expect(seen.map(([i]) => i).sort((x, y) => x - y)).toEqual([0, 1, 2, 3, 4]);
+    });
+
+    it('never runs more than `concurrency` at once (batched), and serializes across batches', async () => {
+        let inFlight = 0;
+        let peak = 0;
+        const order: number[] = [];
+        await mapWithConcurrency([0, 1, 2, 3, 4, 5, 6], 3, async (n) => {
+            inFlight++;
+            peak = Math.max(peak, inFlight);
+            await tick();
+            order.push(n);
+            inFlight--;
+            return n;
+        });
+        expect(peak).toBeLessThanOrEqual(3);
+        // batched: first 3 (0,1,2) settle before the next batch (3,4,5) starts.
+        expect(order.slice(0, 3).sort((a, b) => a - b)).toEqual([0, 1, 2]);
+        expect(order.slice(3, 6).sort((a, b) => a - b)).toEqual([3, 4, 5]);
+        expect(order[6]).toBe(6);
+    });
+
+    it('handles a length not divisible by concurrency (short final batch)', async () => {
+        const out = await mapWithConcurrency([1, 2, 3, 4, 5], 3, async (n) => n);
+        expect(out).toEqual([1, 2, 3, 4, 5]);
+    });
+
+    it('runs everything in one batch when concurrency >= length', async () => {
+        let peak = 0,
+            inFlight = 0;
+        const out = await mapWithConcurrency([1, 2, 3], 10, async (n) => {
+            inFlight++;
+            peak = Math.max(peak, inFlight);
+            await tick();
+            inFlight--;
+            return n;
+        });
+        expect(out).toEqual([1, 2, 3]);
+        expect(peak).toBe(3);
+    });
+
+    it('returns [] for an empty input without calling fn', async () => {
+        let called = 0;
+        const out = await mapWithConcurrency([], 4, async (n) => {
+            called++;
+            return n;
+        });
+        expect(out).toEqual([]);
+        expect(called).toBe(0);
+    });
+
+    it('treats concurrency < 1 as 1 (fully serial)', async () => {
+        let peak = 0,
+            inFlight = 0;
+        await mapWithConcurrency([1, 2, 3], 0, async (n) => {
+            inFlight++;
+            peak = Math.max(peak, inFlight);
+            await tick();
+            inFlight--;
+            return n;
+        });
+        expect(peak).toBe(1);
+    });
+});