kuber/tests/lib/version-update.test.ts

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`,
      );
    }
  });
});