test: add json.ts and asyncPool unit tests

Cover jsonRespond, spreadWhen, spreadDefined, truncateLines,
truncateText, readPackageVersion, readMcpServerVersion, and
asyncPool concurrency/ordering/error behavior. 26 tests total.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: AlbinoGeek

src/server/github-client.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, test } from "bun:test";
+
+import { asyncPool } from "./github-client.js";
+
+describe("asyncPool", () => {
+  test("processes all items and returns results", async () => {
+    const items = [1, 2, 3, 4, 5];
+    const results = await asyncPool(items, 2, async (n) => n * 10);
+    // Results may arrive in any order due to concurrency
+    expect(results.sort((a, b) => a - b)).toEqual([10, 20, 30, 40, 50]);
+  });
+
+  test("respects concurrency limit", async () => {
+    let running = 0;
+    let maxRunning = 0;
+
+    const items = [1, 2, 3, 4, 5, 6];
+    await asyncPool(items, 2, async (n) => {
+      running++;
+      maxRunning = Math.max(maxRunning, running);
+      // Simulate async work
+      await new Promise((resolve) => setTimeout(resolve, 10));
+      running--;
+      return n;
+    });
+
+    expect(maxRunning).toBeLessThanOrEqual(2);
+  });
+
+  test("handles empty input", async () => {
+    const results = await asyncPool([], 4, async (n: number) => n);
+    expect(results).toEqual([]);
+  });
+
+  test("propagates errors", async () => {
+    const items = [1, 2, 3];
+    await expect(
+      asyncPool(items, 2, async (n) => {
+        if (n === 2) throw new Error("boom");
+        return n;
+      }),
+    ).rejects.toThrow("boom");
+  });
+
+  test("concurrency 1 processes sequentially", async () => {
+    const order: number[] = [];
+    const items = [1, 2, 3];
+    await asyncPool(items, 1, async (n) => {
+      order.push(n);
+      await new Promise((resolve) => setTimeout(resolve, 5));
+      return n;
+    });
+    expect(order).toEqual([1, 2, 3]);
+  });
+});

src/server/json.test.ts

@@ -0,0 +1,117 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  jsonRespond,
+  MCP_JSON_FORMAT_VERSION,
+  readMcpServerVersion,
+  readPackageVersion,
+  spreadDefined,
+  spreadWhen,
+  truncateLines,
+  truncateText,
+} from "./json.js";
+
+describe("MCP_JSON_FORMAT_VERSION", () => {
+  test("is '1'", () => {
+    expect(MCP_JSON_FORMAT_VERSION).toBe("1");
+  });
+});
+
+describe("readPackageVersion", () => {
+  test("returns a semver string from package.json", () => {
+    const v = readPackageVersion();
+    expect(v).toMatch(/^\d+\.\d+\.\d+/);
+  });
+});
+
+describe("readMcpServerVersion", () => {
+  test("returns major.minor.patch format", () => {
+    const v = readMcpServerVersion();
+    expect(v).toMatch(/^\d+\.\d+\.\d+$/);
+  });
+});
+
+describe("jsonRespond", () => {
+  test("returns minified JSON", () => {
+    const result = jsonRespond({ a: 1, b: "two" });
+    expect(result).toBe('{"a":1,"b":"two"}');
+  });
+
+  test("handles nested objects", () => {
+    const result = jsonRespond({ x: { y: [1, 2] } });
+    expect(result).toBe('{"x":{"y":[1,2]}}');
+  });
+
+  test("handles empty object", () => {
+    expect(jsonRespond({})).toBe("{}");
+  });
+});
+
+describe("spreadWhen", () => {
+  test("returns fields when condition is true", () => {
+    const result = { base: 1, ...spreadWhen(true, { extra: 2 }) };
+    expect(result).toEqual({ base: 1, extra: 2 });
+  });
+
+  test("returns empty object when condition is false", () => {
+    const result = { base: 1, ...spreadWhen(false, { extra: 2 }) };
+    expect(result).toEqual({ base: 1 });
+  });
+});
+
+describe("spreadDefined", () => {
+  test("spreads key when value is defined", () => {
+    const result = { a: 1, ...spreadDefined("b", 42) };
+    expect(result).toEqual({ a: 1, b: 42 });
+  });
+
+  test("spreads nothing when value is undefined", () => {
+    const result = { a: 1, ...spreadDefined("b", undefined) };
+    expect(result).toEqual({ a: 1 });
+  });
+
+  test("spreads falsy values that are not undefined", () => {
+    expect({ ...spreadDefined("x", 0) }).toEqual({ x: 0 });
+    expect({ ...spreadDefined("x", "") }).toEqual({ x: "" });
+    expect({ ...spreadDefined("x", false) }).toEqual({ x: false });
+    expect({ ...spreadDefined("x", null) }).toEqual({ x: null });
+  });
+});
+
+describe("truncateLines", () => {
+  test("returns text unchanged when within limit", () => {
+    const text = "line1\nline2\nline3";
+    expect(truncateLines(text, 5)).toBe(text);
+  });
+
+  test("returns text unchanged at exact limit", () => {
+    const text = "a\nb\nc";
+    expect(truncateLines(text, 3)).toBe(text);
+  });
+
+  test("truncates and appends notice when over limit", () => {
+    const text = "1\n2\n3\n4\n5";
+    const result = truncateLines(text, 2);
+    expect(result).toBe("1\n2\n... [3 lines truncated]");
+  });
+
+  test("single line over limit keeps first line", () => {
+    // 1 line, limit 1 — no truncation
+    expect(truncateLines("only", 1)).toBe("only");
+  });
+});
+
+describe("truncateText", () => {
+  test("returns text unchanged when within limit", () => {
+    expect(truncateText("short", 100)).toBe("short");
+  });
+
+  test("returns text unchanged at exact limit", () => {
+    expect(truncateText("12345", 5)).toBe("12345");
+  });
+
+  test("truncates and appends notice when over limit", () => {
+    const result = truncateText("abcdef", 3);
+    expect(result).toBe("abc\n... [truncated]");
+  });
+});