homeio

1import { beforeEach, describe, expect, it, vi } from "vitest";
2
3const { env, row, updates, runtime } = vi.hoisted(() => ({
4  runtime: { container: false },
5  env: {
6    HOMEIO_TELEMETRY: true,
7    HOMEIO_TELEMETRY_URL: "https://homeio.app/api/stats",
8    DEMO_MODE: false,
9    NODE_ENV: "production",
10  },
11  row: { current: { enabled: true, instanceId: null as string | null } },
12  updates: [] as Array<Record<string, unknown>>,
13}));
14
15vi.mock("@/lib/server/env", () => ({ serverEnv: env }));
16vi.mock("@/lib/server/logging/logger", () => ({ logServerAction: vi.fn() }));
17vi.mock("@/lib/server/modules/system/update-service", () => ({
18  isContainerRuntime: () => runtime.container,
19}));
20vi.mock("@/lib/server/db/drizzle", () => ({
21  db: {
22    execute: vi.fn(async () => undefined),
23    select: () => ({
24      from: () => ({
25        where: () => ({ limit: async () => [row.current] }),
26      }),
27    }),
28    update: () => ({
29      set: (values: Record<string, unknown>) => ({
30        where: async () => {
31          updates.push(values);
32          if (typeof values.telemetryInstanceId === "string") {
33            row.current = { ...row.current, instanceId: values.telemetryInstanceId };
34          }
35          if (typeof values.telemetryEnabled === "boolean") {
36            row.current = { ...row.current, enabled: values.telemetryEnabled };
37          }
38        },
39      }),
40    }),
41  },
42}));
43
44import {
45  getTelemetrySettings,
46  parseOsRelease,
47  sendTelemetryPing,
48  setTelemetryEnabled,
49} from "@/lib/server/modules/telemetry/service";
50
51function okFetch() {
52  return vi.fn(async () => new Response(null, { status: 204 })) as unknown as typeof fetch & {
53    mock: { calls: Array<[string, RequestInit]> };
54  };
55}
56
57describe("telemetry service", () => {
58  beforeEach(() => {
59    env.HOMEIO_TELEMETRY = true;
60    env.DEMO_MODE = false;
61    env.NODE_ENV = "production";
62    row.current = { enabled: true, instanceId: null };
63    updates.length = 0;
64    runtime.container = false;
65  });
66
67  it("sends only the documented fields", async () => {
68    const fetchImpl = okFetch();
69
70    expect(await sendTelemetryPing(fetchImpl)).toBe(true);
71
72    const [url, init] = fetchImpl.mock.calls[0];
73    expect(url).toBe("https://homeio.app/api/stats");
74    const body = JSON.parse(String(init.body));
75    expect(Object.keys(body).sort()).toEqual([
76      "arch",
77      "distro",
78      "distroVersion",
79      "install",
80      "instanceId",
81      "platform",
82      "version",
83    ]);
84    expect(body.install).toBe("host");
85    expect(body.instanceId).toMatch(/^[0-9a-f-]{36}$/);
86    expect(body.arch).toBe(process.arch);
87    expect(body.platform).toBe(process.platform);
88  });
89
90  it("reports Docker without a distro, since os-release would name the image", async () => {
91    runtime.container = true;
92    const fetchImpl = okFetch();
93
94    await sendTelemetryPing(fetchImpl);
95
96    const body = JSON.parse(String(fetchImpl.mock.calls[0][1].body));
97    expect(body).toMatchObject({ install: "docker", distro: null, distroVersion: null });
98  });
99
100  it("keeps the same instance ID across pings", async () => {
101    const fetchImpl = okFetch();
102
103    await sendTelemetryPing(fetchImpl);
104    await sendTelemetryPing(fetchImpl);
105
106    const ids = fetchImpl.mock.calls.map(([, init]) => JSON.parse(String(init.body)).instanceId);
107    expect(ids[0]).toBe(ids[1]);
108    expect(updates.filter((values) => "telemetryInstanceId" in values)).toHaveLength(1);
109  });
110
111  it("sends nothing when turned off in settings", async () => {
112    await setTelemetryEnabled(false);
113    const fetchImpl = okFetch();
114
115    expect(await sendTelemetryPing(fetchImpl)).toBe(false);
116    expect(fetchImpl).not.toHaveBeenCalled();
117  });
118
119  it("sends nothing when HOMEIO_TELEMETRY=false, whatever the setting says", async () => {
120    env.HOMEIO_TELEMETRY = false;
121    const fetchImpl = okFetch();
122
123    expect(await sendTelemetryPing(fetchImpl)).toBe(false);
124    expect(fetchImpl).not.toHaveBeenCalled();
125    expect(await getTelemetrySettings()).toEqual({ enabled: false, disabledByEnv: true });
126  });
127
128  it("sends nothing outside production or in demo mode", async () => {
129    const fetchImpl = okFetch();
130
131    env.NODE_ENV = "development";
132    expect(await sendTelemetryPing(fetchImpl)).toBe(false);
133
134    env.NODE_ENV = "production";
135    env.DEMO_MODE = true;
136    expect(await sendTelemetryPing(fetchImpl)).toBe(false);
137
138    expect(fetchImpl).not.toHaveBeenCalled();
139  });
140
141  it("swallows network failures", async () => {
142    const fetchImpl = vi.fn(async () => {
143      throw new Error("offline");
144    }) as unknown as typeof fetch;
145
146    await expect(sendTelemetryPing(fetchImpl)).resolves.toBe(false);
147  });
148});
149
150describe("parseOsRelease", () => {
151  it("reads ID and VERSION_ID, quoted or not", () => {
152    expect(parseOsRelease('PRETTY_NAME="Debian GNU/Linux 12 (bookworm)"\nID=debian\nVERSION_ID="12"\n')).toEqual({
153      distro: "debian",
154      distroVersion: "12",
155    });
156    expect(parseOsRelease("ID=ubuntu\nVERSION_ID='24.04'\n")).toEqual({ distro: "ubuntu", distroVersion: "24.04" });
157  });
158
159  it("keeps a rolling release without a version", () => {
160    expect(parseOsRelease("ID=arch\nBUILD_ID=rolling\n")).toEqual({ distro: "arch", distroVersion: null });
161  });
162
163  it("drops values that are not plain identifiers", () => {
164    expect(parseOsRelease('ID="My Custom Distro"\nVERSION_ID=1\n')).toEqual({ distro: null, distroVersion: null });
165    expect(parseOsRelease("")).toEqual({ distro: null, distroVersion: null });
166  });
167});
168