homeio

1import type * as NodeFsPromises from "node:fs/promises";
2import type * as DataRootModule from "@/lib/server/storage/data-root";
3import { beforeEach, describe, expect, it, vi } from "vitest";
4
5const { execFileMock, statMock } = vi.hoisted(() => ({
6  execFileMock: vi.fn(),
7  statMock: vi.fn(),
8}));
9
10const { serverEnvMock } = vi.hoisted(() => ({
11  serverEnvMock: {
12    DATABASE_URL: "postgres://postgres:postgres@localhost:5432/homeio",
13  },
14}));
15
16vi.mock("node:child_process", () => ({
17  execFile: execFileMock,
18}));
19
20vi.mock("node:fs/promises", async (importOriginal) => {
21  const original = await importOriginal<typeof NodeFsPromises>();
22  return { ...original, stat: statMock };
23});
24
25vi.mock("@/lib/server/env", () => ({
26  serverEnv: serverEnvMock,
27}));
28
29vi.mock("@/lib/server/storage/data-root", async (importOriginal) => {
30  const actual =
31    await importOriginal<typeof DataRootModule>();
32  return {
33    ...actual,
34    resolveDataRootDirectory: () => "/DATA",
35    resolveStoreStacksRoot: () => "/DATA/Apps",
36  };
37});
38
39import {
40  scheduleFactoryReset,
41  scheduleSystemReboot,
42  scheduleSystemShutdown,
43} from "@/lib/server/modules/system/power-service";
44
45function resolveExecFileCallback(args: unknown[]) {
46  const maybeCallback = args.at(-1);
47  if (typeof maybeCallback !== "function") {
48    throw new Error("Expected execFile callback");
49  }
50
51  return maybeCallback as (
52    error: Error | null,
53    stdout?: string,
54    stderr?: string,
55  ) => void;
56}
57
58describe("power-service", () => {
59  beforeEach(() => {
60    execFileMock.mockReset();
61    statMock.mockReset();
62    // Script exists by default
63    statMock.mockResolvedValue({});
64    execFileMock.mockImplementation(
65      (_command: string, _args: string[], ...rest: unknown[]) => {
66        const callback = resolveExecFileCallback(rest);
67        callback(null, "", "");
68      },
69    );
70  });
71
72  it("schedules reboot through a transient systemd unit", async () => {
73    await scheduleSystemReboot();
74
75    expect(execFileMock).toHaveBeenCalledWith(
76      "systemd-run",
77      expect.arrayContaining([
78        "--quiet",
79        "--no-block",
80        "--collect",
81        "--property=Type=exec",
82        "--property=KillMode=control-group",
83        "--property=TimeoutStopSec=30s",
84        "--property=SendSIGKILL=yes",
85        "bash",
86        "-lc",
87        "sleep 2; systemctl reboot",
88      ]),
89      expect.any(Function),
90    );
91  });
92
93  it("schedules shutdown through a transient systemd unit", async () => {
94    await scheduleSystemShutdown();
95
96    expect(execFileMock).toHaveBeenCalledWith(
97      "systemd-run",
98      expect.arrayContaining(["bash", "-lc", "sleep 2; systemctl poweroff"]),
99      expect.any(Function),
100    );
101  });
102
103  it("schedules factory reset via script file with env vars injected through --setenv", async () => {
104    await scheduleFactoryReset();
105
106    // execFileMock called twice: "which npm" then "systemd-run"
107    expect(execFileMock).toHaveBeenCalledTimes(2);
108    expect(execFileMock).toHaveBeenCalledWith(
109      "which",
110      ["npm"],
111      expect.any(Function),
112    );
113
114    const systemdCall = execFileMock.mock.calls[1];
115    expect(systemdCall?.[0]).toBe("systemd-run");
116
117    const args: string[] = systemdCall?.[1] ?? [];
118
119    // Systemd unit flags
120    expect(args).toContain("--quiet");
121    expect(args).toContain("--no-block");
122    expect(args).toContain("--collect");
123    expect(args).toContain("--property=Type=exec");
124
125    // Environment variables injected via --setenv (no shell interpolation)
126    const setenvPairs = args
127      .map((arg, i) => (args[i - 1] === "--setenv" ? arg : null))
128      .filter(Boolean) as string[];
129
130    const envMap = Object.fromEntries(
131      setenvPairs.map((pair) => {
132        const eq = pair.indexOf("=");
133        return [pair.slice(0, eq), pair.slice(eq + 1)];
134      }),
135    );
136
137    expect(envMap.DATABASE_URL).toBe(serverEnvMock.DATABASE_URL);
138    expect(envMap.HOMEIO_RESET_DATA_ROOT).toBe("/DATA");
139    expect(envMap.HOMEIO_RESET_STACKS_ROOT).toBe("/DATA/Apps");
140    expect(envMap.HOMEIO_RESET_WORKDIR).toBeTruthy();
141    expect(envMap.HOMEIO_RESET_NPM_BIN).toBeTruthy();
142
143    // Script path is the last argument — no inline bash command string
144    const scriptArg = args.at(-1) ?? "";
145    expect(scriptArg).toMatch(/factory-reset\.sh$/);
146    expect(args).not.toContain("-lc");
147  });
148
149  it("rejects factory reset when the script does not exist", async () => {
150    statMock.mockRejectedValueOnce(
151      Object.assign(new Error("ENOENT"), { code: "ENOENT" }),
152    );
153
154    await expect(scheduleFactoryReset()).rejects.toThrow(
155      "Factory reset script not found",
156    );
157    expect(execFileMock).not.toHaveBeenCalledWith(
158      "systemd-run",
159      expect.anything(),
160      expect.anything(),
161    );
162  });
163});
164