homeio

1import type * as NodeFsPromises from "node:fs/promises";
2import { afterEach, describe, expect, it, vi, beforeEach } from "vitest";
3
4const { execFileMock, statMock } = vi.hoisted(() => ({
5  execFileMock: vi.fn(),
6  statMock: vi.fn(),
7}));
8
9vi.mock("node:child_process", () => ({
10  execFile: execFileMock,
11}));
12
13vi.mock("node:fs/promises", async (importOriginal) => {
14  const original = await importOriginal<typeof NodeFsPromises>();
15  return { ...original, stat: statMock };
16});
17
18import {
19  buildLatestReleaseApiUrl,
20  buildRemotePackageJsonApiUrl,
21  buildRemotePackageJsonUrl,
22  compareVersions,
23  getSystemUpdateStatus,
24  resetUpdateStatusCacheForTests,
25  scheduleSystemUpdate,
26} from "@/lib/server/modules/system/update-service";
27import packageJson from "@/package.json";
28
29function resolveExecFileCallback(args: unknown[]) {
30  const maybeCallback = args.at(-1);
31  if (typeof maybeCallback !== "function") {
32    throw new Error("Expected execFile callback");
33  }
34
35  return maybeCallback as (error: Error | null, stdout?: string, stderr?: string) => void;
36}
37
38function bumpPatchVersion(version: string) {
39  const parts = version.split(".");
40  const last = Number.parseInt(parts.at(-1) ?? "0", 10);
41  parts[parts.length - 1] = String(Number.isFinite(last) ? last + 1 : 1);
42  return parts.join(".");
43}
44
45function releaseResponse(tag: string) {
46  return { ok: true, status: 200, json: async () => ({ tag_name: tag }) } as Response;
47}
48
49function branchResponse(version: string) {
50  return {
51    ok: true,
52    status: 200,
53    json: async () => ({
54      content: Buffer.from(JSON.stringify({ version }), "utf8").toString("base64"),
55      encoding: "base64",
56    }),
57  } as Response;
58}
59
60function succeedAllExecFileCalls() {
61  execFileMock.mockImplementation((_command: string, _args: string[], ...rest: unknown[]) => {
62    resolveExecFileCallback(rest)(null, "", "");
63  });
64}
65
66describe("update-service", () => {
67  beforeEach(() => {
68    vi.restoreAllMocks();
69    resetUpdateStatusCacheForTests();
70    execFileMock.mockReset();
71    // Release mode unless a test opts into following a branch.
72    vi.stubEnv("HOMEIO_REPO_BRANCH", "");
73    vi.stubEnv("HOMEIO_CONTAINER", "");
74  });
75
76  afterEach(() => {
77    vi.unstubAllEnvs();
78  });
79
80  it("compares semantic versions correctly", () => {
81    expect(compareVersions("0.1.75", "0.1.74")).toBe(1);
82    expect(compareVersions("0.1.74", "0.1.74")).toBe(0);
83    expect(compareVersions("0.1.73", "0.1.74")).toBe(-1);
84  });
85
86  it("builds a raw GitHub package.json url from the repo config", () => {
87    expect(
88      buildRemotePackageJsonUrl("https://github.com/doctor-io/homeio.git", "main"),
89    ).toBe("https://raw.githubusercontent.com/doctor-io/homeio/main/package.json");
90  });
91
92  it("builds a GitHub contents API url from the repo config", () => {
93    expect(
94      buildRemotePackageJsonApiUrl("https://github.com/doctor-io/homeio.git", "main"),
95    ).toBe("https://api.github.com/repos/doctor-io/homeio/contents/package.json?ref=main");
96  });
97
98  it("reports that the Docker image cannot update itself", async () => {
99    vi.stubEnv("HOMEIO_CONTAINER", "true");
100    vi.spyOn(globalThis, "fetch").mockResolvedValueOnce(releaseResponse(`v${packageJson.version}`));
101
102    const status = await getSystemUpdateStatus();
103    expect(status.canSelfUpdate).toBe(false);
104  });
105
106  it("offers the latest published release, not whatever main holds", async () => {
107    const nextVersion = bumpPatchVersion(packageJson.version);
108    const fetchMock = vi.spyOn(globalThis, "fetch").mockResolvedValueOnce(releaseResponse(`v${nextVersion}`));
109
110    const status = await getSystemUpdateStatus();
111
112    expect(status.currentVersion).toBe(packageJson.version);
113    expect(status.latestVersion).toBe(nextVersion);
114    expect(status.updateAvailable).toBe(true);
115    expect(status.checkedAt).toBeTruthy();
116    expect(status.canSelfUpdate).toBe(true);
117    const [requestUrl, requestInit] = fetchMock.mock.calls[0] ?? [];
118    expect(String(requestUrl)).toBe(buildLatestReleaseApiUrl());
119    expect(String(requestUrl)).toBe("https://api.github.com/repos/doctor-io/homeio/releases/latest");
120    expect(requestInit).toMatchObject({
121      cache: "no-store",
122      headers: {
123        Accept: "application/vnd.github+json",
124        "User-Agent": "homeio-update-check",
125      },
126    });
127  });
128
129  it("reports no update before the first release is published", async () => {
130    vi.spyOn(globalThis, "fetch").mockResolvedValueOnce({ ok: false, status: 404 } as Response);
131
132    const status = await getSystemUpdateStatus();
133
134    expect(status.latestVersion).toBeNull();
135    expect(status.updateAvailable).toBe(false);
136  });
137
138  it("rejects a latest release whose tag is not a version", async () => {
139    vi.spyOn(globalThis, "fetch").mockResolvedValueOnce(releaseResponse("main; rm -rf /"));
140
141    await expect(getSystemUpdateStatus()).rejects.toThrow("does not have a version tag");
142  });
143
144  it("follows HOMEIO_REPO_BRANCH when a server sets it", async () => {
145    vi.stubEnv("HOMEIO_REPO_BRANCH", "v2.0");
146    const fetchMock = vi.spyOn(globalThis, "fetch").mockResolvedValueOnce(branchResponse("2.0.13"));
147
148    const status = await getSystemUpdateStatus();
149
150    expect(status.latestVersion).toBe("2.0.13");
151    expect(String(fetchMock.mock.calls[0]?.[0])).toBe(
152      "https://api.github.com/repos/doctor-io/homeio/contents/package.json?ref=v2.0",
153    );
154  });
155
156  it("asks GitHub at most once an hour, however many desktops load", async () => {
157    const now = vi.spyOn(Date, "now").mockReturnValue(1_000_000);
158    const fetchMock = vi.spyOn(globalThis, "fetch").mockResolvedValue(releaseResponse("v9.9.9"));
159
160    await Promise.all([getSystemUpdateStatus(), getSystemUpdateStatus(), getSystemUpdateStatus()]);
161    now.mockReturnValue(1_000_000 + 59 * 60_000);
162    await getSystemUpdateStatus();
163    expect(fetchMock).toHaveBeenCalledTimes(1);
164
165    now.mockReturnValue(1_000_000 + 60 * 60_000);
166    await getSystemUpdateStatus();
167    expect(fetchMock).toHaveBeenCalledTimes(2);
168  });
169
170  it("serves the last known version when GitHub rate-limits the check", async () => {
171    const now = vi.spyOn(Date, "now").mockReturnValue(1_000_000);
172    vi.spyOn(globalThis, "fetch")
173      .mockResolvedValueOnce(releaseResponse("v9.9.9"))
174      .mockResolvedValueOnce({ ok: false, status: 403 } as Response);
175    const first = await getSystemUpdateStatus();
176
177    now.mockReturnValue(1_000_000 + 2 * 60 * 60_000);
178    const second = await getSystemUpdateStatus();
179
180    expect(second.latestVersion).toBe("9.9.9");
181    // The answer is as old as the last successful check, and says so.
182    expect(second.checkedAt).toBe(first.checkedAt);
183  });
184
185  it("asks GitHub and reports its failure when the user checks now", async () => {
186    const fetchMock = vi
187      .spyOn(globalThis, "fetch")
188      .mockResolvedValueOnce(releaseResponse("v9.9.9"))
189      .mockResolvedValueOnce({ ok: false, status: 403 } as Response);
190    await getSystemUpdateStatus();
191
192    await expect(getSystemUpdateStatus({ refresh: true })).rejects.toThrow("(403)");
193    expect(fetchMock).toHaveBeenCalledTimes(2);
194  });
195
196  it("still fails when GitHub cannot be reached and nothing is known yet", async () => {
197    vi.spyOn(globalThis, "fetch").mockResolvedValueOnce({ ok: false, status: 403 } as Response);
198
199    await expect(getSystemUpdateStatus()).rejects.toThrow("(403)");
200  });
201
202  it("waits five minutes before asking a rate-limiting GitHub again", async () => {
203    const now = vi.spyOn(Date, "now").mockReturnValue(1_000_000);
204    const fetchMock = vi
205      .spyOn(globalThis, "fetch")
206      .mockResolvedValueOnce({ ok: false, status: 429 } as Response)
207      .mockResolvedValueOnce(releaseResponse("v9.9.9"));
208
209    await expect(getSystemUpdateStatus()).rejects.toThrow("(429)");
210    now.mockReturnValue(1_000_000 + 4 * 60_000);
211    await expect(getSystemUpdateStatus()).rejects.toThrow("(429)");
212    expect(fetchMock).toHaveBeenCalledTimes(1);
213
214    now.mockReturnValue(1_000_000 + 5 * 60_000);
215    expect((await getSystemUpdateStatus()).latestVersion).toBe("9.9.9");
216    expect(fetchMock).toHaveBeenCalledTimes(2);
217  });
218
219  it("schedules the updater through a transient systemd unit, pinned to the latest release", async () => {
220    statMock.mockResolvedValueOnce({});
221    succeedAllExecFileCalls();
222    vi.spyOn(globalThis, "fetch").mockResolvedValueOnce(releaseResponse("v9.9.9"));
223
224    const result = await scheduleSystemUpdate();
225
226    expect(result).toEqual({
227      action: "update",
228      accepted: true,
229    });
230    expect(execFileMock).toHaveBeenCalledWith(
231      "systemd-run",
232      expect.arrayContaining([
233        "--quiet",
234        "--no-block",
235        "--collect",
236        "--property=Type=exec",
237        "--property=KillMode=control-group",
238        "--property=TimeoutStopSec=30s",
239        "--property=SendSIGKILL=yes",
240        "--setenv=HOMEIO_REPO_BRANCH=v9.9.9",
241        "--setenv=HOMEIO_REPO_URL=https://github.com/doctor-io/homeio.git",
242        "bash",
243        "-lc",
244        expect.stringContaining("scripts/update.sh"),
245      ]),
246      expect.any(Function),
247    );
248  });
249
250  it("installs the configured branch when the server follows one", async () => {
251    vi.stubEnv("HOMEIO_REPO_BRANCH", "v2.0");
252    statMock.mockResolvedValueOnce({});
253    succeedAllExecFileCalls();
254    const fetchMock = vi.spyOn(globalThis, "fetch");
255
256    await scheduleSystemUpdate();
257
258    expect(fetchMock).not.toHaveBeenCalled();
259    expect(execFileMock).toHaveBeenCalledWith(
260      "systemd-run",
261      expect.arrayContaining(["--setenv=HOMEIO_REPO_BRANCH=v2.0"]),
262      expect.any(Function),
263    );
264  });
265
266  it("refuses to update when no release has been published", async () => {
267    statMock.mockResolvedValueOnce({});
268    succeedAllExecFileCalls();
269    vi.spyOn(globalThis, "fetch").mockResolvedValueOnce({ ok: false, status: 404 } as Response);
270
271    await expect(scheduleSystemUpdate()).rejects.toThrow("no published Homeio release");
272    expect(execFileMock).not.toHaveBeenCalledWith("systemd-run", expect.anything(), expect.anything());
273  });
274
275  it("rejects scheduling when the update script does not exist", async () => {
276    statMock.mockRejectedValueOnce(Object.assign(new Error("ENOENT"), { code: "ENOENT" }));
277
278    await expect(scheduleSystemUpdate()).rejects.toThrow(
279      "Update script not found",
280    );
281    expect(execFileMock).not.toHaveBeenCalled();
282  });
283
284    it("rejects scheduling when running inside a container runtime", async () => {
285    process.env.HOMEIO_CONTAINER = "true";
286    try {
287      await expect(scheduleSystemUpdate()).rejects.toThrow(
288        "Homeio is running in a Docker container",
289      );
290    } finally {
291      delete process.env.HOMEIO_CONTAINER;
292    }
293  });
294});
295