homeio

1import { beforeEach, describe, expect, it, vi } from "vitest";
2
3vi.mock("@/lib/server/modules/network/helper-client", () => ({
4  connectWifiFromHelper: vi.fn(),
5  disconnectWifiFromHelper: vi.fn(),
6  getNetworkStatusFromHelper: vi.fn(),
7  scanWifiNetworksFromHelper: vi.fn(),
8  isNetworkHelperUnavailableError: vi.fn(),
9}));
10
11vi.mock("@/lib/server/modules/system/service", () => ({
12  getSystemMetricsSnapshot: vi.fn(),
13}));
14
15import {
16  connectNetwork,
17  disconnectNetwork,
18  getNetworkStatus,
19  getWifiNetworks,
20} from "@/lib/server/modules/network/service";
21import type { NetworkServiceError } from "@/lib/server/modules/network/service";
22import {
23  connectWifiFromHelper,
24  disconnectWifiFromHelper,
25  getNetworkStatusFromHelper,
26  isNetworkHelperUnavailableError,
27  scanWifiNetworksFromHelper,
28} from "@/lib/server/modules/network/helper-client";
29import { getSystemMetricsSnapshot } from "@/lib/server/modules/system/service";
30
31describe("network service", () => {
32  beforeEach(() => {
33    vi.clearAllMocks();
34  });
35
36  it("returns helper network status when helper is available", async () => {
37    vi.mocked(getNetworkStatusFromHelper).mockResolvedValueOnce({
38      connected: true,
39      iface: "wlan0",
40      ssid: "HomeNet",
41      ipv4: "192.168.1.44",
42      signalPercent: 78,
43    });
44
45    const result = await getNetworkStatus({
46      requestId: "req-1",
47    });
48
49    expect(result.source).toBe("helper");
50    expect(result.data.connected).toBe(true);
51    expect(getSystemMetricsSnapshot).not.toHaveBeenCalled();
52  });
53
54  it("falls back to metrics when helper is unavailable", async () => {
55    vi.mocked(getNetworkStatusFromHelper).mockRejectedValueOnce(
56      new Error("helper down"),
57    );
58    vi.mocked(scanWifiNetworksFromHelper).mockRejectedValueOnce(
59      new Error("helper down"),
60    );
61    vi.mocked(isNetworkHelperUnavailableError).mockReturnValue(true);
62    vi.mocked(getSystemMetricsSnapshot).mockResolvedValue({
63      timestamp: "2026-02-23T00:00:00.000Z",
64      hostname: "homeio",
65      platform: "linux",
66      architecture: "x64",
67      uptimeSeconds: 1_000,
68      cpu: {
69        oneMinute: 0,
70        fiveMinute: 0,
71        fifteenMinute: 0,
72        normalizedPercent: 0,
73      },
74      memory: {
75        totalBytes: 1,
76        freeBytes: 1,
77        usedBytes: 0,
78        usedPercent: 0,
79      },
80      temperature: {
81        mainCelsius: null,
82        maxCelsius: null,
83        coresCelsius: [],
84      },
85      battery: {
86        hasBattery: false,
87        isCharging: false,
88        percent: null,
89        timeRemainingMinutes: null,
90        acConnected: null,
91        manufacturer: null,
92        cycleCount: null,
93        designedCapacityWh: null,
94        maxCapacityWh: null,
95        designToMaxCapacityPercent: null,
96      },
97      wifi: {
98        connected: true,
99        iface: "wlan0",
100        ssid: "FallbackNet",
101        bssid: null,
102        signalPercent: 55,
103        txRateMbps: null,
104        downloadMbps: null,
105        uploadMbps: null,
106        ipv4: "192.168.1.12",
107        ipv6: null,
108        availableNetworks: [
109          {
110            ssid: "FallbackNet",
111            channel: 11,
112            qualityPercent: 55,
113            security: "WPA2",
114          },
115        ],
116      },
117      process: {
118        pid: 1,
119        uptimeSeconds: 1,
120        nodeVersion: "v22",
121      },
122    });
123
124    const statusResult = await getNetworkStatus();
125    const networksResult = await getWifiNetworks();
126
127    expect(statusResult.source).toBe("fallback");
128    expect(statusResult.data.ssid).toBe("FallbackNet");
129    expect(networksResult.source).toBe("fallback");
130    expect(networksResult.data[0]?.ssid).toBe("FallbackNet");
131  });
132
133  it("reuses fallback cache between network status requests", async () => {
134    vi.useFakeTimers();
135    vi.setSystemTime(new Date("2026-02-24T19:00:00.000Z"));
136
137    vi.mocked(getNetworkStatusFromHelper).mockRejectedValue(new Error("helper down"));
138    vi.mocked(isNetworkHelperUnavailableError).mockReturnValue(true);
139    vi.mocked(getSystemMetricsSnapshot).mockResolvedValue({
140      timestamp: "2026-02-23T00:00:00.000Z",
141      hostname: "homeio",
142      platform: "linux",
143      architecture: "x64",
144      uptimeSeconds: 1_000,
145      cpu: {
146        oneMinute: 0,
147        fiveMinute: 0,
148        fifteenMinute: 0,
149        normalizedPercent: 0,
150      },
151      memory: {
152        totalBytes: 1,
153        freeBytes: 1,
154        usedBytes: 0,
155        usedPercent: 0,
156      },
157      temperature: {
158        mainCelsius: null,
159        maxCelsius: null,
160        coresCelsius: [],
161      },
162      battery: {
163        hasBattery: false,
164        isCharging: false,
165        percent: null,
166        timeRemainingMinutes: null,
167        acConnected: null,
168        manufacturer: null,
169        cycleCount: null,
170        designedCapacityWh: null,
171        maxCapacityWh: null,
172        designToMaxCapacityPercent: null,
173      },
174      wifi: {
175        connected: true,
176        iface: "wlan0",
177        ssid: "FallbackNet",
178        bssid: null,
179        signalPercent: 55,
180        txRateMbps: null,
181        downloadMbps: null,
182        uploadMbps: null,
183        ipv4: "192.168.1.12",
184        ipv6: null,
185        availableNetworks: [],
186      },
187      process: {
188        pid: 1,
189        uptimeSeconds: 1,
190        nodeVersion: "v22",
191      },
192    });
193
194    try {
195      const first = await getNetworkStatus();
196      const second = await getNetworkStatus();
197
198      expect(first.source).toBe("fallback");
199      expect(second.source).toBe("fallback");
200      expect(vi.mocked(getSystemMetricsSnapshot).mock.calls.length).toBeLessThanOrEqual(1);
201    } finally {
202      vi.useRealTimers();
203    }
204  });
205
206  it("validates connect payload and maps helper errors", async () => {
207    await expect(connectNetwork({})).rejects.toMatchObject({
208      code: "invalid_request",
209      statusCode: 400,
210    } satisfies Partial<NetworkServiceError>);
211
212    const helperError = Object.assign(new Error("auth failed"), {
213      name: "NetworkHelperError",
214      code: "auth_failed",
215      statusCode: 401,
216    });
217    vi.mocked(connectWifiFromHelper).mockRejectedValueOnce(helperError);
218
219    await expect(connectNetwork({ ssid: "HomeNet", password: "bad" })).rejects.toMatchObject(
220      {
221        code: "auth_failed",
222        statusCode: 401,
223      } satisfies Partial<NetworkServiceError>,
224    );
225  });
226
227  it("validates disconnect payload and forwards helper result", async () => {
228    await expect(disconnectNetwork({ iface: "" })).rejects.toMatchObject({
229      code: "invalid_request",
230      statusCode: 400,
231    } satisfies Partial<NetworkServiceError>);
232
233    vi.mocked(disconnectWifiFromHelper).mockResolvedValueOnce({
234      connected: false,
235      iface: "wlan0",
236      ssid: null,
237      ipv4: null,
238      signalPercent: null,
239    });
240
241    const result = await disconnectNetwork({
242      iface: "wlan0",
243    });
244
245    expect(result.connected).toBe(false);
246  });
247});
248