test: 添加一大堆测试文件

src/utils/__tests__/generators.test.ts

@@ -0,0 +1,114 @@
+import { describe, expect, test } from "bun:test";
+import { lastX, returnValue, all, toArray, fromArray } from "../generators";
+
+async function* range(n: number): AsyncGenerator<number, void> {
+  for (let i = 0; i < n; i++) {
+    yield i;
+  }
+}
+
+describe("lastX", () => {
+  test("returns last yielded value", async () => {
+    const result = await lastX(range(5));
+    expect(result).toBe(4);
+  });
+
+  test("returns only value from single-yield generator", async () => {
+    const result = await lastX(range(1));
+    expect(result).toBe(0);
+  });
+
+  test("throws on empty generator", async () => {
+    await expect(lastX(range(0))).rejects.toThrow("No items in generator");
+  });
+});
+
+describe("returnValue", () => {
+  test("returns generator return value", async () => {
+    async function* gen(): AsyncGenerator<number, string> {
+      yield 1;
+      return "done";
+    }
+    const result = await returnValue(gen());
+    expect(result).toBe("done");
+  });
+
+  test("returns undefined for void return", async () => {
+    async function* gen(): AsyncGenerator<number, void> {
+      yield 1;
+    }
+    const result = await returnValue(gen());
+    expect(result).toBeUndefined();
+  });
+});
+
+describe("toArray", () => {
+  test("collects all yielded values", async () => {
+    const result = await toArray(range(4));
+    expect(result).toEqual([0, 1, 2, 3]);
+  });
+
+  test("returns empty array for empty generator", async () => {
+    const result = await toArray(fromArray([]));
+    expect(result).toEqual([]);
+  });
+
+  test("preserves order", async () => {
+    const result = await toArray(fromArray(["c", "b", "a"]));
+    expect(result).toEqual(["c", "b", "a"]);
+  });
+});
+
+describe("fromArray", () => {
+  test("yields all array elements", async () => {
+    const result = await toArray(fromArray([10, 20, 30]));
+    expect(result).toEqual([10, 20, 30]);
+  });
+
+  test("yields nothing for empty array", async () => {
+    const result = await toArray(fromArray([]));
+    expect(result).toEqual([]);
+  });
+});
+
+describe("all", () => {
+  test("merges multiple generators preserving yield order", async () => {
+    const gen1 = fromArray([1, 2]);
+    const gen2 = fromArray([3, 4]);
+    const result = await toArray(all([gen1, gen2]));
+    // All values from both generators should be present
+    expect(result.sort()).toEqual([1, 2, 3, 4]);
+  });
+
+  test("respects concurrency cap", async () => {
+    const gen1 = fromArray([1]);
+    const gen2 = fromArray([2]);
+    const gen3 = fromArray([3]);
+    const result = await toArray(all([gen1, gen2, gen3], 2));
+    expect(result.sort()).toEqual([1, 2, 3]);
+  });
+
+  test("handles empty generator array", async () => {
+    const result = await toArray(all([]));
+    expect(result).toEqual([]);
+  });
+
+  test("handles single generator", async () => {
+    const result = await toArray(all([fromArray([42])]));
+    expect(result).toEqual([42]);
+  });
+
+  test("handles generators of different lengths", async () => {
+    const gen1 = fromArray([1, 2, 3]);
+    const gen2 = fromArray([10]);
+    const result = await toArray(all([gen1, gen2]));
+    // all() merges concurrently, just verify all values are present
+    expect([...result].sort((a, b) => a - b)).toEqual([1, 2, 3, 10]);
+  });
+
+  test("yields all values from all generators", async () => {
+    const gens = [fromArray([1]), fromArray([2]), fromArray([3])];
+    const result = await toArray(all(gens));
+    expect(result).toHaveLength(3);
+  });
+});