homeio

1import { afterEach, describe, expect, it, vi, beforeEach } from "vitest";
2
3const { execFileMock, readFileMock } = vi.hoisted(() => ({
4  execFileMock: vi.fn(),
5  readFileMock: vi.fn(),
6}));
7
8vi.mock("node:child_process", () => ({
9  execFile: execFileMock,
10}));
11
12vi.mock("node:fs/promises", () => ({
13  readFile: readFileMock,
14  writeFile: vi.fn(),
15  mkdir: vi.fn(),
16  stat: vi.fn(),
17}));
18
19import {
20  getDiskInventory,
21  invalidateDiskList,
22  mountPartition,
23  unmountPartition,
24  wipeDisk,
25} from "@/lib/server/modules/system/disk-service";
26
27describe("disk-service safety validations", () => {
28  beforeEach(() => {
29    vi.restoreAllMocks();
30    execFileMock.mockReset();
31    readFileMock.mockReset();
32  });
33
34  describe("wipeDisk", () => {
35    it("rejects invalid or dangerous device paths", async () => {
36      await expect(wipeDisk("/dev/sda; rm -rf /")).rejects.toThrow("Invalid disk device path");
37      await expect(wipeDisk("/dev/../etc/passwd")).rejects.toThrow("Invalid disk device path");
38      await expect(wipeDisk("sda")).rejects.toThrow("Invalid disk device path");
39      await expect(wipeDisk("/dev/sda1")).rejects.toThrow("Invalid disk device path");
40    });
41
42    it("rejects wiping a disk containing active mounts in /proc/mounts", async () => {
43      readFileMock.mockResolvedValueOnce(
44        "/dev/sdb1 /data ext4 rw,relatime 0 0\n" +
45        "/dev/sda2 / ext4 rw,relatime 0 0\n"
46      );
47
48      await expect(wipeDisk("/dev/sdb")).rejects.toThrow("Cannot modify active mounted device");
49    });
50
51    it("rejects wiping a system disk mounted at /", async () => {
52      readFileMock.mockResolvedValueOnce(
53        "/dev/sda1 /boot/efi vfat rw 0 0\n" +
54        "/dev/sda2 / ext4 rw,relatime 0 0\n"
55      );
56
57      await expect(wipeDisk("/dev/sda")).rejects.toThrow("Cannot modify system device containing critical mountpoint");
58    });
59  });
60
61  describe("mountPartition", () => {
62    it("rejects invalid partition device paths", async () => {
63      await expect(mountPartition("/dev/sda", "/mnt/data"))
64        .rejects.toThrow("Invalid partition device path");
65      await expect(mountPartition("/dev/sda1; rm -rf /", "/mnt/data"))
66        .rejects.toThrow("Invalid partition device path");
67    });
68
69    it("rejects mountpoints containing newlines or carriage returns", async () => {
70      await expect(mountPartition("/dev/sdb1", "/mnt/data\n/dev/sdc1 /"))
71        .rejects.toThrow("Mount point must be a safe, absolute path");
72      await expect(mountPartition("/dev/sdb1", "/mnt/data\r\n"))
73        .rejects.toThrow("Mount point must be a safe, absolute path");
74      await expect(mountPartition("/dev/sdb1", "relative/path"))
75        .rejects.toThrow("Mount point must be a safe, absolute path");
76    });
77
78    it("rejects dangerous system mountpoints", async () => {
79      await expect(mountPartition("/dev/sdb1", "/"))
80        .rejects.toThrow("Cannot mount partition over critical system directory: /");
81      await expect(mountPartition("/dev/sdb1", "/etc"))
82        .rejects.toThrow("Cannot mount partition over critical system directory: /etc");
83    });
84
85    it("only mounts inside /mnt, /media, /srv or /DATA", async () => {
86      for (const mountPoint of ["/opt/data", "/etc/ssh", "/root/.ssh", "/usr/local/bin", "/mnt", "/DATA", "/mnt/../etc/x"]) {
87        await expect(mountPartition("/dev/sdb1", mountPoint)).rejects.toThrow(/Mount point must be/);
88      }
89      expect(execFileMock).not.toHaveBeenCalled();
90    });
91
92    it("mounts inside an allowed folder, normalizing the path", async () => {
93      execFileMock.mockImplementation((...args: unknown[]) => (args.at(-1) as (...a: unknown[]) => void)(null, "", ""));
94      await mountPartition("/dev/sdb1", "/mnt//data/");
95      expect(execFileMock).toHaveBeenCalledWith("mount", ["/dev/sdb1", "/mnt/data"], expect.any(Function));
96    });
97  });
98
99  describe("unmountPartition", () => {
100    it("rejects unmounting root or system directories", async () => {
101      await expect(unmountPartition("/")).rejects.toThrow("Cannot unmount critical system directory: /");
102      await expect(unmountPartition("/boot")).rejects.toThrow("Cannot unmount critical system directory: /boot");
103    });
104  });
105});
106
107describe("getDiskInventory", () => {
108  const originalPlatform = process.platform;
109
110  function setPlatform(platform: NodeJS.Platform) {
111    Object.defineProperty(process, "platform", { value: platform, configurable: true });
112  }
113
114  beforeEach(() => {
115    execFileMock.mockReset();
116    invalidateDiskList();
117    setPlatform("linux");
118    vi.stubEnv("HOMEIO_CONTAINER", "");
119  });
120
121  afterEach(() => {
122    setPlatform(originalPlatform);
123    vi.unstubAllEnvs();
124  });
125
126  function lsblkReturns(blockdevices: unknown[]) {
127    // promisify(execFile) resolves to { stdout, stderr }; the mock has no custom promisify.
128    execFileMock.mockImplementation((...args: unknown[]) =>
129      (args.at(-1) as (...a: unknown[]) => void)(null, { stdout: JSON.stringify({ blockdevices }), stderr: "" }),
130    );
131  }
132
133  it("lists real disks and leaves out empty and in-memory devices", async () => {
134    lsblkReturns([
135      { name: "sda", size: 500_000_000_000, type: "disk", rm: false, rota: false, children: [] },
136      { name: "nbd0", size: 0, type: "disk" },
137      { name: "zram0", size: 1_000_000_000, type: "disk" },
138      { name: "mmcblk0", size: 0, type: "disk" },
139      { name: "loop3", size: 50_000_000, type: "loop" },
140    ]);
141
142    const inventory = await getDiskInventory();
143
144    expect(inventory.disks.map((d) => d.name)).toEqual(["sda"]);
145    expect(inventory.unavailableReason).toBeNull();
146    expect(inventory.readOnly).toBe(false);
147  });
148
149  it("reuses the disk list between polls, and reads it again after a disk command", async () => {
150    lsblkReturns([{ name: "sda", type: "disk", size: 500_000_000_000, children: [] }]);
151
152    await getDiskInventory();
153    await getDiskInventory();
154    expect(execFileMock).toHaveBeenCalledTimes(1);
155
156    await unmountPartition("/dev/sda1").catch(() => {});
157    await getDiskInventory();
158    const lsblkCalls = execFileMock.mock.calls.filter(([command]) => command === "lsblk");
159    expect(lsblkCalls).toHaveLength(2);
160  });
161
162  it("says lsblk is missing instead of reporting no disks", async () => {
163    execFileMock.mockImplementation((...args: unknown[]) =>
164      (args.at(-1) as (...a: unknown[]) => void)(Object.assign(new Error("spawn lsblk ENOENT"), { code: "ENOENT" })),
165    );
166
167    const host = await getDiskInventory();
168    expect(host.disks).toEqual([]);
169    expect(host.unavailableReason).toContain("apt install util-linux");
170
171    vi.stubEnv("HOMEIO_CONTAINER", "true");
172    const container = await getDiskInventory();
173    expect(container.unavailableReason).toContain("missing from this container image");
174    expect(container.readOnly).toBe(true);
175  });
176
177  it("explains that disk management needs Linux", async () => {
178    setPlatform("darwin");
179    execFileMock.mockImplementation((...args: unknown[]) =>
180      (args.at(-1) as (...a: unknown[]) => void)(Object.assign(new Error("spawn lsblk ENOENT"), { code: "ENOENT" })),
181    );
182
183    const inventory = await getDiskInventory();
184    expect(inventory.unavailableReason).toBe("Disk management needs Linux; this machine runs darwin.");
185  });
186});
187