about-system 0.10.15 → 0.10.17

package/src/info/memory.test.ts

@@ -0,0 +1,347 @@
+/**
+ * @fileoverview Memory and disk probes. Every function branches on the host
+ * platform, so `utils/platform` is mocked with live getters and each test
+ * picks the OS it wants to impersonate.
+ */
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const flags = vi.hoisted(() => ({ linux: true, mac: false, windows: false }));
+vi.mock("../utils/platform", () => ({
+  get IS_LINUX() {
+    return flags.linux;
+  },
+  get IS_MAC() {
+    return flags.mac;
+  },
+  get IS_WINDOWS() {
+    return flags.windows;
+  },
+}));
+
+const execCommand = vi.hoisted(() => vi.fn());
+vi.mock("../utils/command", () => ({ execCommand, commandExists: vi.fn() }));
+
+const fsMock = vi.hoisted(() => ({
+  readFileSync: vi.fn(),
+  existsSync: vi.fn(() => false),
+  writeFileSync: vi.fn(),
+}));
+vi.mock("fs", () => ({ ...fsMock, default: fsMock }));
+
+const osMock = vi.hoisted(() => ({
+  totalmem: vi.fn(() => 16 * 1024 ** 3),
+  freemem: vi.fn(() => 4 * 1024 ** 3),
+  tmpdir: vi.fn(() => "/tmp"),
+  platform: vi.fn(() => "linux"),
+}));
+vi.mock("os", () => ({ ...osMock, default: osMock }));
+
+const m = await import("./memory");
+import type { InfoContext } from "../types/internal-types";
+
+const ctx = (cache: InfoContext["cache"] = {}): InfoContext => ({ cache });
+const platform = (p: "linux" | "mac" | "windows") => {
+  flags.linux = p === "linux";
+  flags.mac = p === "mac";
+  flags.windows = p === "windows";
+};
+
+const MEMINFO = [
+  "MemTotal:       16777216 kB",
+  "MemFree:         4194304 kB",
+  "MemAvailable:    8388608 kB",
+  "SwapTotal:       2097152 kB",
+  "SwapFree:        1572864 kB",
+].join("\n");
+
+beforeEach(() => {
+  platform("linux");
+  execCommand.mockReset().mockReturnValue("");
+  fsMock.readFileSync.mockReset().mockReturnValue(MEMINFO);
+  osMock.totalmem.mockReturnValue(16 * 1024 ** 3);
+  osMock.freemem.mockReturnValue(4 * 1024 ** 3);
+});
+
+describe("ram_used", () => {
+  it("reads /proc/meminfo on Linux", () => {
+    expect(m.ram_used(ctx())).toBe("12/16GB");
+  });
+
+  it("falls back to os.totalmem when /proc/meminfo is unreadable", () => {
+    fsMock.readFileSync.mockImplementation(() => {
+      throw new Error("nope");
+    });
+    expect(m.ram_used(ctx())).toBe("12/16GB");
+  });
+
+  it("falls back to os.totalmem when meminfo lacks the keys", () => {
+    fsMock.readFileSync.mockReturnValue("garbage");
+    expect(m.ram_used(ctx())).toBe("12/16GB");
+  });
+
+  it("uses os memory on non-Linux hosts", () => {
+    platform("mac");
+    osMock.totalmem.mockReturnValue(8 * 1024 ** 3);
+    osMock.freemem.mockReturnValue(2 * 1024 ** 3);
+    expect(m.ram_used(ctx())).toBe("6/8GB");
+    expect(fsMock.readFileSync).not.toHaveBeenCalled();
+  });
+
+  it("serves a cached value and stores a fresh one", () => {
+    const cache = {};
+    expect(m.ram_used(ctx(cache))).toBe("12/16GB");
+    fsMock.readFileSync.mockReturnValue("MemTotal: 1 kB\nMemFree: 1 kB");
+    expect(m.ram_used(ctx(cache))).toBe("12/16GB");
+  });
+});
+
+describe("memory_available", () => {
+  it("reads MemAvailable on Linux", () => {
+    expect(m.memory_available()).toBe("8GB available");
+  });
+
+  it("returns empty when MemAvailable is missing or unreadable on Linux", () => {
+    fsMock.readFileSync.mockReturnValue("MemTotal: 1 kB");
+    expect(m.memory_available()).toBe("");
+    fsMock.readFileSync.mockImplementation(() => {
+      throw new Error("x");
+    });
+    expect(m.memory_available()).toBe("");
+  });
+
+  it("derives free+inactive pages from vm_stat on macOS", () => {
+    platform("mac");
+    execCommand.mockReturnValue(
+      [
+        "Mach Virtual Memory Statistics: (page size of 16384 bytes)",
+        "Pages free:                               262144.",
+        "Pages inactive:                           262144.",
+      ].join("\n"),
+    );
+    // (262144 + 262144) * 16384 bytes = 8 GiB
+    expect(m.memory_available()).toBe("8GB available");
+    expect(execCommand).toHaveBeenCalledWith("vm_stat");
+  });
+
+  it("returns empty on macOS when vm_stat output is unparseable", () => {
+    platform("mac");
+    execCommand.mockReturnValue("nonsense");
+    expect(m.memory_available()).toBe("");
+    execCommand.mockImplementation(() => {
+      throw new Error("x");
+    });
+    expect(m.memory_available()).toBe("");
+  });
+
+  it("returns empty on Windows", () => {
+    platform("windows");
+    expect(m.memory_available()).toBe("");
+  });
+});
+
+describe("swap_used", () => {
+  it("computes percent and MB on Linux", () => {
+    // 2 GiB total, 0.5 GiB used
+    expect(m.swap_used()).toBe("25% (512MB) swap");
+  });
+
+  it("returns empty when there is no swap or meminfo is bad", () => {
+    fsMock.readFileSync.mockReturnValue("SwapTotal: 0 kB\nSwapFree: 0 kB");
+    expect(m.swap_used()).toBe("");
+    fsMock.readFileSync.mockReturnValue("nothing");
+    expect(m.swap_used()).toBe("");
+    fsMock.readFileSync.mockImplementation(() => {
+      throw new Error("x");
+    });
+    expect(m.swap_used()).toBe("");
+  });
+
+  it("parses sysctl vm.swapusage on macOS", () => {
+    platform("mac");
+    execCommand.mockReturnValue("total = 2048.00M  used = 512.00M  free = 1536.00M  (encrypted)");
+    expect(m.swap_used()).toBe("25% (512MB) swap");
+  });
+
+  it("reports zero swap on macOS when total is 0", () => {
+    platform("mac");
+    execCommand.mockReturnValue("total = 0.00M  used = 0.00M  free = 0.00M");
+    expect(m.swap_used()).toBe("0% (0MB) swap");
+  });
+
+  it("returns empty on macOS with unparseable output, and on Windows", () => {
+    platform("mac");
+    execCommand.mockReturnValue("?");
+    expect(m.swap_used()).toBe("");
+    platform("windows");
+    expect(m.swap_used()).toBe("");
+  });
+});
+
+const DF_H = [
+  "Filesystem      Size  Used Avail Use% Mounted on",
+  "/dev/sda1       100G   45G   50G  47% /",
+  "tmpfs           1.0G     0  1.0G   0% /dev/shm",
+  "/dev/sdb1       500G  390G   80G  78% /mnt/data",
+].join("\n");
+
+describe("disk_used", () => {
+  it("finds the root filesystem percentage", () => {
+    execCommand.mockReturnValue(DF_H);
+    expect(m.disk_used(ctx())).toBe("47%");
+  });
+
+  it("falls back to a regex when no line ends in ' /' with a % column", () => {
+    execCommand.mockReturnValue("Filesystem Use% Mounted\nrootfs 33% /");
+    expect(m.disk_used(ctx())).toBe("33%");
+  });
+
+  it("returns empty when nothing matches", () => {
+    execCommand.mockReturnValue("Filesystem Size\nnone");
+    expect(m.disk_used(ctx())).toBe("");
+  });
+
+  it("reads the emulated storage line on Android", () => {
+    execCommand.mockReturnValue("/dev/fuse 100G 40G 60G 40% /storage/emulated");
+    expect(m.disk_used(ctx())).toBe("40%");
+    execCommand.mockReturnValue("/storage/emulated only");
+    expect(m.disk_used(ctx())).toBe("");
+  });
+
+  it("is empty on Windows, and caches the result", () => {
+    platform("windows");
+    const cache = {};
+    expect(m.disk_used(ctx(cache))).toBe("");
+    platform("linux");
+    execCommand.mockReturnValue(DF_H);
+    expect(m.disk_used(ctx(cache))).toBe("");
+  });
+
+  it("returns empty when df throws inside the probe", () => {
+    execCommand.mockImplementation(() => {
+      throw new Error("x");
+    });
+    expect(m.disk_used(ctx())).toBe("");
+  });
+});
+
+const GB = 1024 * 1024;
+const dfK = (rows: string[]) =>
+  ["Filesystem 1K-blocks Used Available Use% Mounted on", ...rows].join("\n");
+
+describe("disk_size", () => {
+  it("reports a single real disk without its mount point", () => {
+    execCommand.mockReturnValue(
+      dfK([
+        `/dev/sda1 ${100 * GB} ${45 * GB} ${50 * GB} 47% /`,
+        `tmpfs ${100 * GB} 0 ${100 * GB} 0% /run`,
+        `/dev/sda2 ${100 * GB} ${1 * GB} ${99 * GB} 1% /boot`,
+        `/dev/small 1000 10 990 1% /small`,
+        "short row",
+        `/dev/bad abc def 1 1% /bad`,
+      ]),
+    );
+    expect(m.disk_size(ctx())).toBe("45/100GB");
+  });
+
+  it("labels each disk by mount point when several are found", () => {
+    execCommand.mockReturnValue(
+      dfK([
+        `/dev/sda1 ${100 * GB} ${45 * GB} ${50 * GB} 47% /`,
+        `/dev/sdb1 ${500 * GB} ${390 * GB} ${80 * GB} 78% /mnt/data`,
+        `devtmpfs ${50 * GB} 0 ${50 * GB} 0% /dev`,
+        `overlay ${50 * GB} 0 ${50 * GB} 0% /var/lib/docker`,
+        `proc ${50 * GB} 0 ${50 * GB} 0% /proc`,
+        `sysfs ${50 * GB} 0 ${50 * GB} 0% /sys`,
+      ]),
+    );
+    expect(m.disk_size(ctx())).toBe("/(45/100GB) /mnt/data(390/500GB)");
+  });
+
+  it("returns empty when no disk qualifies", () => {
+    execCommand.mockReturnValue(dfK([`tmpfs ${100 * GB} 0 ${100 * GB} 0% /run`]));
+    expect(m.disk_size(ctx())).toBe("");
+  });
+
+  it("only counts / and /Volumes/* on macOS", () => {
+    platform("mac");
+    execCommand.mockReturnValue(
+      dfK([
+        `/dev/disk3s1 ${500 * GB} ${200 * GB} ${300 * GB} 40% /`,
+        `/dev/disk3s5 ${500 * GB} ${200 * GB} ${300 * GB} 40% /System/Volumes/Data`,
+        `/dev/disk4s1 ${1000 * GB} ${900 * GB} ${100 * GB} 90% /Volumes/Backup`,
+      ]),
+    );
+    expect(m.disk_size(ctx())).toBe("/(200/500GB) /Volumes/Backup(900/1000GB)");
+  });
+
+  it("is empty on Windows and when df throws", () => {
+    platform("windows");
+    expect(m.disk_size(ctx())).toBe("");
+    platform("linux");
+    execCommand.mockImplementation(() => {
+      throw new Error("x");
+    });
+    expect(m.disk_size(ctx())).toBe("");
+  });
+
+  it("serves the cached value", () => {
+    const cache = {};
+    execCommand.mockReturnValue(dfK([`/dev/sda1 ${100 * GB} ${45 * GB} 1 47% /`]));
+    expect(m.disk_size(ctx(cache))).toBe("45/100GB");
+    execCommand.mockReturnValue("");
+    expect(m.disk_size(ctx(cache))).toBe("45/100GB");
+  });
+});
+
+describe("mount_points", () => {
+  it("lists non-system mounts with usage on Linux (max 3)", () => {
+    execCommand.mockReturnValue(
+      [
+        "Filesystem Size Used Avail Use% Mounted on",
+        "/dev/sda1 100G 45G 50G 47% /",
+        "tmpfs 1G 0 1G 0% /dev/shm",
+        "/dev/sdb1 500G 390G 80G 78% /mnt/data",
+        "/dev/sdc1 500G 100G 80G 20% /home",
+        "/dev/sdd1 500G 100G 80G 21% /srv",
+        "/dev/sde1 500G 100G 80G 22% /opt",
+        "weird 1G",
+        "nopercent mount",
+        "/dev/x 1G 1G 0 1% /System/Volumes/Data",
+      ].join("\n"),
+    );
+    expect(m.mount_points(ctx())).toBe("/mnt/data(78%) /home(20%) /srv(21%)");
+  });
+
+  it("reports only /Volumes mounts on macOS", () => {
+    platform("mac");
+    execCommand.mockReturnValue(
+      [
+        "Filesystem Size Used Avail Capacity Mounted on",
+        "/dev/disk3s1 500G 200G 300G 40% /",
+        "/dev/disk4s1 1T 900G 100G 90% /Volumes/Backup",
+        "/dev/disk3s5 500G 200G 300G 40% /System/Volumes/Data",
+      ].join("\n"),
+    );
+    expect(m.mount_points(ctx())).toBe("/Volumes/Backup(90%)");
+  });
+
+  it("is empty on Windows and when df throws", () => {
+    platform("windows");
+    expect(m.mount_points(ctx())).toBe("");
+    platform("linux");
+    execCommand.mockImplementation(() => {
+      throw new Error("x");
+    });
+    expect(m.mount_points(ctx())).toBe("");
+  });
+
+  it("serves the cached value", () => {
+    const cache = {};
+    execCommand.mockReturnValue(
+      "h\n/dev/a 1G 1G 0 5% /mnt/a",
+    );
+    expect(m.mount_points(ctx(cache))).toBe("/mnt/a(5%)");
+    execCommand.mockReturnValue("");
+    expect(m.mount_points(ctx(cache))).toBe("/mnt/a(5%)");
+  });
+});

package/src/info/network.test.ts

@@ -0,0 +1,174 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const flags = vi.hoisted(() => ({ linux: true, mac: false, windows: false }));
+vi.mock("../utils/platform", () => ({
+  get IS_LINUX() {
+    return flags.linux;
+  },
+  get IS_MAC() {
+    return flags.mac;
+  },
+  get IS_WINDOWS() {
+    return flags.windows;
+  },
+}));
+
+const execCommand = vi.hoisted(() => vi.fn());
+vi.mock("../utils/command", () => ({ execCommand, commandExists: vi.fn() }));
+
+const osMock = vi.hoisted(() => ({
+  networkInterfaces: vi.fn(),
+  tmpdir: vi.fn(() => "/tmp"),
+  platform: vi.fn(() => "linux"),
+}));
+vi.mock("os", () => ({ ...osMock, default: osMock }));
+
+const n = await import("./network");
+import type { InfoContext } from "../types/internal-types";
+
+const ctx = (extra: Partial<InfoContext> = {}): InfoContext => ({ cache: {}, ...extra });
+const platform = (p: "linux" | "mac" | "windows") => {
+  flags.linux = p === "linux";
+  flags.mac = p === "mac";
+  flags.windows = p === "windows";
+};
+
+const iface = (address: string, internal = false, family = "IPv4") => ({
+  address,
+  family,
+  internal,
+});
+
+beforeEach(() => {
+  platform("linux");
+  execCommand.mockReset().mockReturnValue("");
+  osMock.networkInterfaces.mockReset().mockReturnValue({});
+});
+
+describe("ipinfo-derived fields", () => {
+  const info = { ip: "1.2.3.4", city: "Paris", hostname: "host.example", org: "AS123 Example Net Inc" };
+
+  it("ip / city read from the context", () => {
+    expect(n.ip(ctx({ ipInfo: info }))).toBe("1.2.3.4");
+    expect(n.city(ctx({ ipInfo: info }))).toBe("Paris");
+    expect(n.ip(ctx())).toBe("");
+    expect(n.city(ctx())).toBe("");
+  });
+
+  it("domain prefixes http:// only when a hostname is known", () => {
+    expect(n.domain(ctx({ ipInfo: info }))).toBe("http://host.example");
+    expect(n.domain(ctx())).toBe("");
+  });
+
+  it("isp drops the leading AS number", () => {
+    expect(n.isp(ctx({ ipInfo: info }))).toBe("Example Net Inc");
+    expect(n.isp(ctx())).toBe("");
+  });
+});
+
+describe("iplocal", () => {
+  it("prefers the wlan0 address from ifconfig on Linux", () => {
+    execCommand.mockReturnValue("eth0: flags\n  inet 10.0.0.2\nwlan0: flags\n  inet 192.168.1.50 netmask");
+    expect(n.iplocal()).toBe("192.168.1.50");
+  });
+
+  it("falls back to `ip addr`, skipping loopback", () => {
+    execCommand.mockImplementation((c: string) =>
+      c.startsWith("ifconfig")
+        ? ""
+        : "inet 127.0.0.1/8 lo\ninet 10.0.0.5/24 eth0\ninet 172.16.0.9/16 eth1",
+    );
+    expect(n.iplocal()).toBe("10.0.0.5 172.16.0.9");
+  });
+
+  it("falls back to os.networkInterfaces when the shell tools find nothing", () => {
+    osMock.networkInterfaces.mockReturnValue({
+      lo: [iface("127.0.0.1", true)],
+      eth0: [iface("10.1.1.1"), iface("fe80::1", false, "IPv6")],
+      wl: undefined,
+    });
+    expect(n.iplocal()).toBe("10.1.1.1");
+  });
+
+  it("survives the shell helpers throwing", () => {
+    execCommand.mockImplementation(() => {
+      throw new Error("x");
+    });
+    osMock.networkInterfaces.mockReturnValue({ en0: [iface("192.168.0.2")] });
+    expect(n.iplocal()).toBe("192.168.0.2");
+  });
+
+  it("uses os.networkInterfaces directly on macOS", () => {
+    platform("mac");
+    osMock.networkInterfaces.mockReturnValue({ en0: [iface("192.168.0.9")] });
+    expect(n.iplocal()).toBe("192.168.0.9");
+    expect(execCommand).not.toHaveBeenCalled();
+  });
+});
+
+describe("network_interfaces", () => {
+  it("lists active non-loopback IPv4 interfaces", () => {
+    osMock.networkInterfaces.mockReturnValue({
+      lo: [iface("127.0.0.1", true)],
+      eth0: [iface("10.0.0.1")],
+      docker0: [iface("172.17.0.1", true)],
+      wlan0: [iface("fe80::1", false, "IPv6"), iface("10.0.0.2")],
+      empty: undefined,
+    });
+    expect(n.network_interfaces(ctx())).toBe("eth0 wlan0");
+  });
+
+  it("is empty on Windows", () => {
+    platform("windows");
+    expect(n.network_interfaces(ctx())).toBe("");
+  });
+
+  it("is empty when os.networkInterfaces throws", () => {
+    osMock.networkInterfaces.mockImplementation(() => {
+      throw new Error("x");
+    });
+    expect(n.network_interfaces(ctx())).toBe("");
+  });
+
+  it("serves from the cache", () => {
+    const c = ctx();
+    osMock.networkInterfaces.mockReturnValue({ eth0: [iface("10.0.0.1")] });
+    expect(n.network_interfaces(c)).toBe("eth0");
+    osMock.networkInterfaces.mockReturnValue({});
+    expect(n.network_interfaces(c)).toBe("eth0");
+  });
+});
+
+describe("ports", () => {
+  const LSOF = [
+    "COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME",
+    "node 100 me 20u IPv4 0x1 0t0 TCP *:3000 (LISTEN)".replace("*:3000 (LISTEN)", "*:3000"),
+    "nginx-wo 101 me 6u IPv6 0x2 0t0 TCP [::1]:8080",
+    "node 102 me 21u IPv4 0x3 0t0 TCP *:3000",
+    "short line",
+    "weird 103 me 5u IPv4 0x4 0t0 TCP noport",
+  ].join("\n");
+
+  it("lists unique port+process pairs", () => {
+    execCommand.mockReturnValue(LSOF);
+    expect(n.ports(ctx())).toBe("3000node 8080ngin");
+  });
+
+  it("is empty on Windows and when lsof throws", () => {
+    platform("windows");
+    expect(n.ports(ctx())).toBe("");
+    platform("linux");
+    execCommand.mockImplementation(() => {
+      throw new Error("x");
+    });
+    expect(n.ports(ctx())).toBe("");
+  });
+
+  it("serves from the cache", () => {
+    const c = ctx();
+    execCommand.mockReturnValue(LSOF);
+    n.ports(c);
+    execCommand.mockReturnValue("");
+    expect(n.ports(c)).toBe("3000node 8080ngin");
+  });
+});

package/src/info/platform-os.test.ts

@@ -0,0 +1,121 @@
+/**
+ * @fileoverview The Windows and macOS branches of the platform facts, which
+ * the Linux-only suite in platform.test.ts cannot reach.
+ */
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const flags = vi.hoisted(() => ({ linux: false, mac: false, windows: false }));
+vi.mock("../utils/platform", () => ({
+  get IS_LINUX() {
+    return flags.linux;
+  },
+  get IS_MAC() {
+    return flags.mac;
+  },
+  get IS_WINDOWS() {
+    return flags.windows;
+  },
+}));
+
+const execCommand = vi.hoisted(() => vi.fn());
+const commandExists = vi.hoisted(() => vi.fn());
+vi.mock("../utils/command", () => ({ execCommand, commandExists }));
+
+const osMock = vi.hoisted(() => ({
+  platform: vi.fn(() => "freebsd"),
+  release: vi.fn(() => "14.0"),
+  hostname: vi.fn(() => "h"),
+  userInfo: vi.fn(() => ({ username: "u" })),
+  tmpdir: vi.fn(() => "/tmp"),
+}));
+vi.mock("os", () => ({ ...osMock, default: osMock }));
+
+const fsMock = vi.hoisted(() => ({
+  existsSync: vi.fn(() => false),
+  readFileSync: vi.fn(() => ""),
+}));
+vi.mock("fs", () => ({ ...fsMock, default: fsMock }));
+
+const p = await import("./platform");
+import type { InfoContext } from "../types/internal-types";
+
+const ctx = (): InfoContext => ({ cache: {} });
+const only = (k: "linux" | "mac" | "windows" | "none") => {
+  flags.linux = k === "linux";
+  flags.mac = k === "mac";
+  flags.windows = k === "windows";
+};
+
+beforeEach(() => {
+  only("none");
+  execCommand.mockReset().mockReturnValue("");
+  commandExists.mockReset().mockReturnValue(false);
+});
+
+describe("os_info off Linux", () => {
+  it("falls back to '<platform> <release>' on an unknown OS", () => {
+    expect(p.os_info(ctx())).toBe("freebsd 14.0");
+  });
+
+  it("combines the macOS product name and version from sw_vers", () => {
+    only("mac");
+    execCommand.mockImplementation((c: string) =>
+      c.endsWith("productName") ? "macOS" : "14.4.1",
+    );
+    expect(p.os_info(ctx())).toBe("macOS 14.4.1");
+  });
+
+  it("falls back to 'macOS <release>' when sw_vers is silent", () => {
+    only("mac");
+    expect(p.os_info(ctx())).toBe("macOS 14.0");
+  });
+
+  it("parses the Windows version from `ver`", () => {
+    only("windows");
+    execCommand.mockReturnValue("Microsoft Windows [Version 10.0.22631.3447]");
+    expect(p.os_info(ctx())).toBe("Windows 10.0.22631.3447");
+  });
+
+  it("falls back to the kernel release when `ver` is unparseable or throws", () => {
+    only("windows");
+    execCommand.mockReturnValue("garbage");
+    expect(p.os_info(ctx())).toBe("Windows 14.0");
+    execCommand.mockImplementation(() => {
+      throw new Error("x");
+    });
+    expect(p.os_info(ctx())).toBe("Windows 14.0");
+  });
+});
+
+describe("device off Linux", () => {
+  it("reads the Windows model from wmic", () => {
+    only("windows");
+    execCommand.mockReturnValue("Name=Surface Laptop 5\r\n");
+    expect(p.device(ctx())).toBe("Surface Laptop 5");
+  });
+
+  it("falls back to PowerShell on Windows when wmic gives nothing", () => {
+    only("windows");
+    execCommand.mockImplementation((c: string) =>
+      c.startsWith("wmic") ? "" : "ThinkPad X1\r\n",
+    );
+    expect(p.device(ctx())).toBe("ThinkPad X1");
+  });
+
+  it("is empty on Windows when neither tool answers", () => {
+    only("windows");
+    expect(p.device(ctx())).toBe("");
+  });
+
+  it("reads the macOS model name from system_profiler", () => {
+    only("mac");
+    execCommand.mockReturnValue("Hardware:\n  Model Name: MacBook Pro\n  Chip: M3");
+    expect(p.device(ctx())).toBe("MacBook Pro");
+  });
+
+  it("is empty on macOS when system_profiler has no model line", () => {
+    only("mac");
+    execCommand.mockReturnValue("nothing");
+    expect(p.device(ctx())).toBe("");
+  });
+});