feat: prepare 2.6.1-rc5 shared databases and build SSE

tests/lib/version-update.test.ts

@@ -0,0 +1,201 @@
+import { describe, expect, test } from "bun:test";
+import {
+  compareVersions,
+  createVersionObserver,
+  installVersion,
+} from "../../lib/version-update";
+
+const tick = () => new Promise<void>((resolve) => setTimeout(resolve, 0));
+
+describe("server version updates", () => {
+  test("compares strict SemVer precedence including prereleases and ignores build metadata", () => {
+    expect(compareVersions("2.6.1", "2.6.1-rc3")).toBe(1);
+    expect(compareVersions("2.6.1-rc.10", "2.6.1-rc.3")).toBe(1);
+    expect(compareVersions("2.6.1-alpha.1", "2.6.1-alpha.beta")).toBe(-1);
+    expect(compareVersions("2.6.1-rc3.1", "2.6.1-rc3")).toBe(1);
+    expect(compareVersions("2.6.1+new", "2.6.1+old")).toBe(0);
+    expect(compareVersions("3.0.0", "2.6.1")).toBe(1);
+    for (const invalid of [
+      "",
+      "v3.0.0",
+      "3.0",
+      "03.0.0",
+      "3.0.0-rc.01",
+      "3.0.0-",
+      "3.0.0+",
+      "3.0.0;touch /tmp/pwned",
+      "3.0.0\n",
+      "3.0.0-💥",
+      "9".repeat(129) + ".0.0",
+    ]) {
+      expect(compareVersions(invalid, "2.6.1-rc3")).toBeUndefined();
+    }
+  });
+
+  test("rejects invalid install arguments before spawning", async () => {
+    expect(await installVersion("2.7.0;echo hacked")).toBe(false);
+  });
+
+  test("uses a quiet detached timeout argument vector", async () => {
+    const calls: string[][] = [];
+    let unrefs = 0;
+    const spawn = (
+      argv: string[],
+      options: {
+        stdin: "ignore";
+        stdout: "ignore";
+        stderr: "ignore";
+        detached: true;
+      },
+    ) => {
+      calls.push(argv);
+      expect(options).toEqual({
+        stdin: "ignore",
+        stdout: "ignore",
+        stderr: "ignore",
+        detached: true,
+      });
+      return {
+        exited: Promise.resolve(0),
+        unref: () => {
+          unrefs++;
+        },
+      };
+    };
+    expect(await installVersion("2.7.0-rc.1+build.2", spawn, 1)).toBe(true);
+    expect(calls).toEqual([
+      [
+        "timeout",
+        "--signal=TERM",
+        "--kill-after=2s",
+        "1s",
+        "bun",
+        "i",
+        "-g",
+        "--no-cache",
+        "@dmgnr/[email protected]+build.2",
+      ],
+    ]);
+    expect(unrefs).toBe(1);
+  });
+
+  test("ignores malformed, equal, and older headers without attempting an install", async () => {
+    const runs: string[] = [];
+    const lines: string[] = [];
+    const observe = createVersionObserver({
+      currentVersion: "2.6.1-rc3",
+      runner: async (version) => {
+        runs.push(version);
+        return true;
+      },
+      report: (line) => lines.push(line),
+    });
+    for (const version of [
+      null,
+      "garbage",
+      "2.6.1-rc3",
+      "2.6.0",
+      "2.6.1-rc2",
+      "2.6.1-rc3+build",
+    ])
+      observe(version);
+    await tick();
+    expect(runs).toEqual([]);
+    expect(lines).toEqual([]);
+  });
+
+  test("starts once for concurrent newer responses, reports success in gray on stderr", async () => {
+    let finish!: (value: boolean) => void;
+    const pending = new Promise<boolean>((resolve) => {
+      finish = resolve;
+    });
+    const runs: string[] = [];
+    const lines: string[] = [];
+    const observe = createVersionObserver({
+      currentVersion: "2.6.1-rc3",
+      runner: (version) => {
+        runs.push(version);
+        return pending;
+      },
+      report: (line) => lines.push(line),
+    });
+    observe("2.6.1");
+    observe("9.0.0");
+    expect(runs).toEqual([]);
+    await tick();
+    expect(runs).toEqual(["2.6.1"]);
+    expect(lines).toEqual([]);
+    finish(true);
+    await tick();
+    expect(lines).toEqual(["\x1b[90m+ Updated to 2.6.1\x1b[0m\n"]);
+    observe("10.0.0");
+    await tick();
+    expect(runs).toHaveLength(1);
+  });
+
+  test("reports failure or rejection once without throwing into requests", async () => {
+    for (const runner of [
+      async () => false,
+      async () => {
+        throw new Error("offline");
+      },
+    ]) {
+      const lines: string[] = [];
+      const observe = createVersionObserver({
+        currentVersion: "2.6.1-rc3",
+        runner,
+        report: (line) => lines.push(line),
+      });
+      observe("2.7.0");
+      observe("2.8.0");
+      await tick();
+      expect(lines).toEqual([
+        "\x1b[90m+ New version available: 2.7.0\x1b[0m\n",
+      ]);
+    }
+  });
+
+  test("a detached pending install does not delay a short CLI or pollute its streams", async () => {
+    const url = new URL("../../lib/version-update.ts", import.meta.url).href;
+    const script = `
+      const { createVersionObserver } = await import(${JSON.stringify(url)});
+      createVersionObserver({ currentVersion: '2.6.1',
+        runner: () => new Promise(() => {}) })('2.7.0');
+    `;
+    const child = Bun.spawn([process.execPath, "-e", script], {
+      stdin: "ignore",
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const timeout = setTimeout(() => child.kill(), 1_000);
+    try {
+      expect(await child.exited).toBe(0);
+      expect(await new Response(child.stdout).text()).toBe("");
+      expect(await new Response(child.stderr).text()).toBe("");
+    } finally {
+      clearTimeout(timeout);
+    }
+  });
+
+  test("a short subprocess emits one outcome to stderr when its runner settles", async () => {
+    const url = new URL("../../lib/version-update.ts", import.meta.url).href;
+    for (const result of ["true", "false", "reject"]) {
+      const script = `
+        const { createVersionObserver } = await import(${JSON.stringify(url)});
+        createVersionObserver({ currentVersion: '2.6.1',
+          runner: async () => ${result === "reject" ? "Promise.reject(Error('offline'))" : result} })('2.7.0');
+        await new Promise(resolve => setTimeout(resolve, 20));
+      `;
+      const child = Bun.spawn([process.execPath, "-e", script], {
+        stdin: "ignore",
+        stdout: "pipe",
+        stderr: "pipe",
+      });
+      expect(await child.exited).toBe(0);
+      expect(await new Response(child.stdout).text()).toBe("");
+      expect(await new Response(child.stderr).text()).toBe(
+        `\x1b[90m+ ${result === "true" ? "Updated to " : "New version available: "}2.7.0\x1b[0m\n`,
+      );
+    }
+  });
+});