homeio

1/* @vitest-environment jsdom */
2
3import { act, renderHook, waitFor } from "@testing-library/react";
4import { describe, expect, it, vi, beforeEach } from "vitest";
5import { queryKeys } from "@/lib/shared/query-keys";
6import { createTestQueryClient, createWrapper } from "@/test/query-client-wrapper";
7
8const { toastSuccessMock, toastInfoMock, toastErrorMock } = vi.hoisted(() => ({
9  toastSuccessMock: vi.fn(),
10  toastInfoMock: vi.fn(),
11  toastErrorMock: vi.fn(),
12}));
13
14const mockUseCurrentUser = vi.fn();
15const mockUseSystemMetrics = vi.fn();
16const mockUseNetworkStatus = vi.fn();
17const mockUseWifiNetworks = vi.fn();
18const mockUseLocalFolderShares = vi.fn();
19const mockUseNetworkShares = vi.fn();
20const mockUseDockerStatsSnapshot = vi.fn();
21
22vi.mock("@/hooks/useCurrentUser", () => ({
23  useCurrentUser: () => mockUseCurrentUser(),
24}));
25
26vi.mock("@/modules/system/hooks/useSystemMetrics", () => ({
27  useSystemMetrics: () => mockUseSystemMetrics(),
28}));
29
30vi.mock("@/modules/system/hooks/useNetworkStatus", () => ({
31  useNetworkStatus: () => mockUseNetworkStatus(),
32}));
33
34vi.mock("@/modules/system/hooks/useWifiNetworks", () => ({
35  useWifiNetworks: () => mockUseWifiNetworks(),
36}));
37
38vi.mock("@/modules/files/hooks/useLocalFolderShares", () => ({
39  useLocalFolderShares: () => mockUseLocalFolderShares(),
40}));
41
42vi.mock("@/modules/files/hooks/useNetworkShares", () => ({
43  useNetworkShares: () => mockUseNetworkShares(),
44}));
45
46vi.mock("@/modules/system/hooks/useDockerStats", () => ({
47  useDockerStatsSnapshot: () => mockUseDockerStatsSnapshot(),
48}));
49
50vi.mock("sonner", () => ({
51  toast: {
52    success: toastSuccessMock,
53    info: toastInfoMock,
54    error: toastErrorMock,
55  },
56}));
57
58import { useSettingsBackend } from "@/modules/settings/hooks/useSettingsBackend";
59
60function mockOkJson<T>(data: T) {
61  return { ok: true, json: async () => ({ data }) };
62}
63
64type FetchHandler = (
65  url: string,
66  init?: RequestInit,
67) => ReturnType<typeof mockOkJson> | null | undefined;
68
69function createFetchMock(actionHandler?: FetchHandler) {
70  return vi.fn().mockImplementation(async (input: RequestInfo | URL, init?: RequestInit) => {
71    const url = String(input);
72
73    const override = actionHandler?.(url, init);
74    if (override != null) return override;
75
76    if (url === "/api/v1/system/preferences") {
77      return mockOkJson({ hostname: "home-node", timezone: "Europe/Paris" });
78    }
79    if (url === "/api/v1/system/power/schedule") {
80      return mockOkJson({ enabled: false, frequency: "weekly", dayOfWeek: "sunday", time: "03:00" });
81    }
82    if (url === "/api/v1/system/power/capabilities") {
83      return mockOkJson({ reboot: true, shutdown: true, factoryReset: true, scheduledReboot: true });
84    }
85    if (url === "/api/v1/system/security") {
86      return mockOkJson({
87        firewallEnabled: true,
88        firewallIncomingPolicy: "deny",
89        firewallOutgoingPolicy: "allow",
90        fail2banEnabled: true,
91        fail2banMaxRetries: 5,
92        fail2banBanDurationSeconds: 3600,
93      });
94    }
95    if (url === "/api/v1/system/updates") {
96      return mockOkJson({
97        currentVersion: "0.1.74",
98        latestVersion: "0.1.75",
99        updateAvailable: true,
100        checkedAt: "2026-03-08T10:00:00.000Z",
101      });
102    }
103    if (url === "/api/v1/system/backups") {
104      return mockOkJson({
105        settings: { enabled: false, frequency: "weekly", dayOfWeek: "sunday", time: "03:00", retentionCount: 7 },
106        backups: [],
107        backupRoot: "/DATA/Backups/homeio",
108      });
109    }
110    return { ok: true, json: async () => ({ data: [] }) };
111  });
112}
113
114function setDefaultMocks() {
115  mockUseCurrentUser.mockReturnValue({
116    data: {
117      id: "u1",
118      username: "ahmed",
119    },
120    isLoading: false,
121    error: null,
122  });
123
124  mockUseSystemMetrics.mockReturnValue({
125    data: {
126      timestamp: "2026-02-27T10:00:00.000Z",
127      hostname: "home-node",
128      platform: "linux",
129      uptimeSeconds: 90061,
130      cpu: {
131        oneMinute: 0.3,
132        fiveMinute: 0.2,
133        fifteenMinute: 0.1,
134        normalizedPercent: 32,
135      },
136      memory: {
137        totalBytes: 8 * 1024 * 1024 * 1024,
138        freeBytes: 3 * 1024 * 1024 * 1024,
139        usedBytes: 5 * 1024 * 1024 * 1024,
140        usedPercent: 62.5,
141      },
142      temperature: {
143        mainCelsius: 47.2,
144        maxCelsius: 49,
145        coresCelsius: [46.5, 47.8],
146      },
147      battery: {
148        hasBattery: false,
149        isCharging: false,
150        percent: null,
151        timeRemainingMinutes: null,
152        acConnected: null,
153        manufacturer: null,
154        cycleCount: null,
155        designedCapacityWh: null,
156        maxCapacityWh: null,
157        designToMaxCapacityPercent: null,
158      },
159      wifi: {
160        connected: true,
161        iface: "wlan0",
162        ssid: "HomeNet",
163        bssid: "11:22:33:44",
164        signalPercent: 78,
165        txRateMbps: 150,
166        downloadMbps: 30,
167        uploadMbps: 10,
168        ipv4: "192.168.1.20",
169        ipv6: null,
170        availableNetworks: [],
171      },
172      process: {
173        pid: 123,
174        uptimeSeconds: 7200,
175        nodeVersion: "v22.17.0",
176      },
177      storage: {
178        mountPath: "/DATA",
179        totalBytes: 4 * 1024 * 1024 * 1024 * 1024,
180        availableBytes: 2200 * 1024 * 1024 * 1024,
181        usedBytes: 1800 * 1024 * 1024 * 1024,
182        usedPercent: 45,
183      },
184    },
185    isLoading: false,
186    error: null,
187  });
188
189  mockUseNetworkStatus.mockReturnValue({
190    data: {
191      connected: true,
192      iface: "wlan0",
193      ssid: "HomeNet",
194      ipv4: "192.168.1.20",
195      signalPercent: 78,
196    },
197    isLoading: false,
198    error: null,
199  });
200
201  mockUseWifiNetworks.mockReturnValue({
202    data: [
203      {
204        ssid: "HomeNet",
205        bssid: "11:22:33:44",
206        signalPercent: 80,
207        channel: 6,
208        frequencyMhz: 2437,
209        security: "wpa2",
210      },
211      {
212        ssid: "GuestNet",
213        bssid: "aa:bb:cc:dd",
214        signalPercent: 42,
215        channel: 11,
216        frequencyMhz: 2462,
217        security: "wpa2",
218      },
219    ],
220    isLoading: false,
221    error: null,
222  });
223
224  mockUseDockerStatsSnapshot.mockReturnValue({
225    stats: [
226      {
227        id: "container123456789",
228        name: "plex",
229        state: "running",
230        cpuPercent: 3.4,
231        memoryUsed: 512 * 1024 * 1024,
232        memoryLimit: 2 * 1024 * 1024 * 1024,
233        memoryPercent: 25,
234        networkRx: 10,
235        networkTx: 15,
236        blockRead: 1,
237        blockWrite: 2,
238      },
239    ],
240    isLoading: false,
241    error: null,
242  });
243
244  mockUseLocalFolderShares.mockReturnValue({
245    data: [
246      {
247        id: "local-1",
248        shareName: "Media",
249        sourcePath: "Media",
250        sharedPath: "Shared/Media",
251        isMounted: true,
252        isExported: true,
253      },
254    ],
255    isLoading: false,
256    error: null,
257  });
258
259  mockUseNetworkShares.mockReturnValue({
260    data: [
261      {
262        id: "network-1",
263        host: "nas.local",
264        share: "Public",
265        username: "guest",
266        mountPath: "Network/nas.local/Public",
267        isMounted: true,
268      },
269    ],
270    isLoading: false,
271    error: null,
272  });
273
274}
275
276describe("useSettingsBackend", () => {
277  beforeEach(() => {
278    vi.clearAllMocks();
279    localStorage.clear();
280    setDefaultMocks();
281    vi.stubGlobal(
282      "fetch",
283      createFetchMock((url) => {
284        if (url === "/api/v1/system/backups") {
285          return mockOkJson({
286            settings: { enabled: false, frequency: "weekly", dayOfWeek: "sunday", time: "03:00", retentionCount: 7 },
287            backups: [
288              {
289                id: "backup-1",
290                createdAt: "2026-03-08T09:00:00.000Z",
291                sizeBytes: 1024,
292                appVersion: "0.1.72",
293                hostname: "home-node",
294                backupPath: "/DATA/Backups/homeio/backup-1.tar.gz",
295                dbDumpIncluded: true,
296                dataRootIncluded: true,
297                stacksRootIncluded: true,
298                status: "completed",
299              },
300            ],
301            backupRoot: "/DATA/Backups/homeio",
302          });
303        }
304        return null;
305      }),
306    );
307  });
308
309  it("maps live settings data and capability flags", async () => {
310    const client = createTestQueryClient();
311    const { result } = renderHook(() => useSettingsBackend(), {
312      wrapper: createWrapper(client),
313    });
314
315    expect(result.current.general.hostname).toBe("home-node");
316    expect(result.current.general.uptime).toContain("1 day");
317    expect(result.current.network.iface).toBe("wlan0");
318    expect(result.current.network.topSsids).toEqual(["HomeNet", "GuestNet"]);
319    expect(result.current.storage.mountPath).toBe("/DATA");
320    expect(result.current.storage.shares).toHaveLength(2);
321    expect(result.current.docker.containers).toHaveLength(1);
322    expect(result.current.power.reboot.isPending).toBe(false);
323    await waitFor(() => {
324      expect(result.current.power.reboot.available).toBe(true);
325      expect(result.current.power.shutdown.available).toBe(true);
326      expect(result.current.power.factoryReset.available).toBe(true);
327    });
328    await waitFor(() => {
329      expect(result.current.generalPreferences.timezone).toBe("Europe/Paris");
330    });
331    expect(result.current.generalPreferences.hostname).toBe("home-node");
332    await waitFor(() => {
333      expect(result.current.security.firewall.enabled).toBe(true);
334    });
335    expect(result.current.security.fail2ban.maxRetries).toBe(5);
336    expect(result.current.backup.backups).toHaveLength(1);
337    expect(result.current.backup.backupRoot).toBe("/DATA/Backups/homeio");
338    expect(result.current.power.scheduledReboot.time).toBe("03:00");
339    expect(result.current.capabilities.general.hostname.disabled).toBe(false);
340    await waitFor(() => {
341      expect(result.current.updates.currentVersion).toBe("0.1.74");
342      expect(result.current.updates.latestVersion).toBe("0.1.75");
343      expect(result.current.updates.updateAvailable).toBe(true);
344    });
345    expect(result.current.capabilities.updates.checkForUpdates.disabled).toBe(false);
346    expect(result.current.capabilities.saveBySection.security).toBe(true);
347  });
348
349  it("marks sections unavailable when source hooks fail", () => {
350    mockUseSystemMetrics.mockReturnValue({
351      data: undefined,
352      isLoading: false,
353      error: new Error("metrics down"),
354    });
355
356    mockUseNetworkStatus.mockReturnValue({
357      data: undefined,
358      isLoading: false,
359      error: new Error("network down"),
360    });
361
362    mockUseDockerStatsSnapshot.mockReturnValue({
363      stats: [],
364      isLoading: false,
365      error: "docker down",
366    });
367
368    const client = createTestQueryClient();
369    vi.stubGlobal(
370      "fetch",
371      createFetchMock((url) => {
372        if (url === "/api/v1/system/updates") {
373          return { ok: false, json: async () => ({ error: "updates down" }) };
374        }
375        return null;
376      }),
377    );
378    const { result } = renderHook(() => useSettingsBackend(), {
379      wrapper: createWrapper(client),
380    });
381
382    expect(result.current.general.unavailable).toBe(true);
383    expect(result.current.network.unavailable).toBe(true);
384    expect(result.current.docker.unavailable).toBe(true);
385    return waitFor(() => {
386      expect(result.current.updates.unavailable).toBe(true);
387    });
388  });
389
390  it("triggers Homeio update check mutation and invalidates system updates", async () => {
391    const client = createTestQueryClient();
392    const invalidateSpy = vi.spyOn(client, "invalidateQueries");
393    const fetchMock = createFetchMock((url, init) => {
394      if (url === "/api/v1/system/updates/check" && init?.method === "POST") {
395        return mockOkJson({ currentVersion: "0.1.74", latestVersion: "0.1.75", updateAvailable: true, checkedAt: "2026-03-08T10:00:00.000Z" });
396      }
397      return null;
398    });
399    vi.stubGlobal("fetch", fetchMock);
400
401    const { result } = renderHook(() => useSettingsBackend(), {
402      wrapper: createWrapper(client),
403    });
404
405    await act(async () => {
406      await result.current.actions.checkForUpdates();
407    });
408
409    expect(fetchMock).toHaveBeenCalledWith("/api/v1/system/updates/check", {
410      method: "POST",
411      headers: {
412        "Content-Type": "application/json",
413      },
414    });
415    expect(invalidateSpy).toHaveBeenCalledWith({
416      queryKey: queryKeys.systemUpdates,
417    });
418    expect(toastSuccessMock).toHaveBeenCalledWith("Homeio 0.1.75 is available.");
419  });
420
421  it("persists update recovery state and redirects to the dedicated updating screen", async () => {
422    const client = createTestQueryClient();
423    const fetchMock = createFetchMock((url, init) => {
424      if (url === "/api/v1/system/updates") {
425        return mockOkJson({ currentVersion: "0.1.79", latestVersion: "0.1.80", updateAvailable: true, checkedAt: "2026-03-11T10:00:00.000Z" });
426      }
427      if (url === "/api/v1/system/updates/apply" && init?.method === "POST") {
428        return mockOkJson({ action: "update", accepted: true });
429      }
430      return null;
431    });
432    vi.stubGlobal("fetch", fetchMock);
433
434    const { result } = renderHook(() => useSettingsBackend(), {
435      wrapper: createWrapper(client),
436    });
437
438    await act(async () => {
439      await expect(result.current.actions.applySystemUpdate()).resolves.toBeUndefined();
440    });
441
442    expect(
443      JSON.parse(localStorage.getItem("system.power.action.v1") ?? "{}"),
444    ).toMatchObject({
445      action: "update",
446      requestDispatchedAt: expect.any(String),
447    });
448    expect(fetchMock).toHaveBeenCalledWith(
449      "/api/v1/system/updates/apply",
450      {
451        method: "POST",
452      },
453    );
454  });
455
456  it("keeps update recovery active after redirecting to the dedicated updating screen", async () => {
457    const client = createTestQueryClient();
458    const fetchMock = createFetchMock((url, init) => {
459      if (url === "/api/v1/system/updates") {
460        return mockOkJson({ currentVersion: "0.1.81", latestVersion: "0.1.82", updateAvailable: true, checkedAt: "2026-03-11T21:49:04.000Z" });
461      }
462      if (url === "/api/v1/system/updates/apply" && init?.method === "POST") {
463        return mockOkJson({ action: "update", accepted: true });
464      }
465      return null;
466    });
467    vi.stubGlobal("fetch", fetchMock);
468
469    const { result } = renderHook(() => useSettingsBackend(), {
470      wrapper: createWrapper(client),
471    });
472
473    await act(async () => {
474      await expect(result.current.actions.applySystemUpdate()).resolves.toBeUndefined();
475    });
476
477    expect(
478      JSON.parse(localStorage.getItem("system.power.action.v1") ?? "{}"),
479    ).toMatchObject({
480      action: "update",
481    });
482    expect(result.current.updates.isRecoveryActive).toBe(true);
483  });
484
485  it("surfaces update scheduling failures without entering recovery", async () => {
486    const client = createTestQueryClient();
487    const fetchMock = createFetchMock((url, init) => {
488      if (url === "/api/v1/system/updates") {
489        return mockOkJson({ currentVersion: "0.1.81", latestVersion: "0.1.82", updateAvailable: true, checkedAt: "2026-03-11T21:49:04.000Z" });
490      }
491      if (url === "/api/v1/system/updates/apply" && init?.method === "POST") {
492        return { ok: false, status: 500, json: async () => ({ error: "Update runner failed" }) };
493      }
494      return null;
495    });
496    vi.stubGlobal("fetch", fetchMock);
497
498    const { result } = renderHook(() => useSettingsBackend(), {
499      wrapper: createWrapper(client),
500    });
501
502    await act(async () => {
503      await expect(result.current.actions.applySystemUpdate()).resolves.toBeUndefined();
504    });
505
506    expect(localStorage.getItem("system.power.action.v1")).toBeNull();
507    await waitFor(() => {
508      expect(result.current.updates.isRecoveryActive).toBe(false);
509      expect(result.current.updates.applyError).toBe("Update runner failed");
510    });
511  });
512
513  it("suppresses Homeio update fetches while update recovery is active", async () => {
514    localStorage.setItem(
515      "system.power.action.v1",
516      JSON.stringify({
517        action: "update",
518        startedAt: new Date().toISOString(),
519      }),
520    );
521
522    const fetchMock = createFetchMock();
523    vi.stubGlobal("fetch", fetchMock);
524
525    const client = createTestQueryClient();
526    const { result } = renderHook(() => useSettingsBackend(), {
527      wrapper: createWrapper(client),
528    });
529
530    await waitFor(() => {
531      expect(result.current.updates.isRecoveryActive).toBe(true);
532    });
533
534    expect(fetchMock).not.toHaveBeenCalledWith("/api/v1/system/updates", expect.anything());
535    expect(result.current.updates.unavailable).toBe(false);
536    expect(result.current.updates.checkError).toBeNull();
537  });
538
539  it("triggers reboot mutation and persists reboot recovery state", async () => {
540    const client = createTestQueryClient();
541    const fetchMock = createFetchMock((url, init) => {
542      if (url === "/api/v1/system/power/reboot" && init?.method === "POST") {
543        return mockOkJson({ action: "reboot", accepted: true });
544      }
545      return null;
546    });
547    vi.stubGlobal("fetch", fetchMock);
548
549    const { result } = renderHook(() => useSettingsBackend(), {
550      wrapper: createWrapper(client),
551    });
552
553    await act(async () => {
554      await result.current.actions.rebootNow();
555    });
556
557    expect(fetchMock).toHaveBeenCalledWith("/api/v1/system/power/reboot", {
558      method: "POST",
559    });
560    expect(
561      JSON.parse(localStorage.getItem("system.power.action.v1") ?? "{}"),
562    ).toMatchObject({
563      action: "reboot",
564    });
565  });
566
567  it("saves scheduled reboot configuration", async () => {
568    const client = createTestQueryClient();
569    const fetchMock = createFetchMock((url, init) => {
570      if (url === "/api/v1/system/power/schedule" && init?.method === "PUT") {
571        return mockOkJson(JSON.parse(String(init.body)));
572      }
573      return null;
574    });
575    vi.stubGlobal("fetch", fetchMock);
576
577    const { result } = renderHook(() => useSettingsBackend(), {
578      wrapper: createWrapper(client),
579    });
580
581    await act(async () => {
582      await result.current.actions.saveScheduledReboot({
583        enabled: true,
584        frequency: "daily",
585        dayOfWeek: "sunday",
586        time: "04:00",
587      });
588    });
589
590    expect(fetchMock).toHaveBeenCalledWith("/api/v1/system/power/schedule", {
591      method: "PUT",
592      headers: {
593        "Content-Type": "application/json",
594      },
595      body: JSON.stringify({
596        enabled: true,
597        frequency: "daily",
598        dayOfWeek: "sunday",
599        time: "04:00",
600      }),
601    });
602  });
603
604  it("saves general preferences and invalidates system queries", async () => {
605    const client = createTestQueryClient();
606    const invalidateSpy = vi.spyOn(client, "invalidateQueries");
607    const fetchMock = createFetchMock((url, init) => {
608      if (url === "/api/v1/system/preferences" && init?.method === "PUT") {
609        return mockOkJson({ hostname: "homeio-box", timezone: "Europe/Berlin" });
610      }
611      if (url === "/api/v1/system/security" && init?.method === "PUT") {
612        return mockOkJson(JSON.parse(String(init.body)));
613      }
614      return null;
615    });
616    vi.stubGlobal("fetch", fetchMock);
617
618    const { result } = renderHook(() => useSettingsBackend(), {
619      wrapper: createWrapper(client),
620    });
621
622    await act(async () => {
623      await result.current.actions.saveGeneralPreferences({
624        hostname: "homeio-box",
625        timezone: "Europe/Berlin",
626      });
627    });
628
629    expect(fetchMock).toHaveBeenCalledWith("/api/v1/system/preferences", {
630      method: "PUT",
631      headers: {
632        "Content-Type": "application/json",
633      },
634      body: JSON.stringify({
635        hostname: "homeio-box",
636        timezone: "Europe/Berlin",
637      }),
638    });
639    expect(invalidateSpy).toHaveBeenCalledWith({
640      queryKey: queryKeys.systemPreferences,
641    });
642    expect(invalidateSpy).toHaveBeenCalledWith({
643      queryKey: queryKeys.systemMetrics,
644    });
645  });
646
647  it("saves security settings and invalidates the security query", async () => {
648    const client = createTestQueryClient();
649    const invalidateSpy = vi.spyOn(client, "invalidateQueries");
650    const fetchMock = createFetchMock((url, init) => {
651      if (url === "/api/v1/system/security" && init?.method === "PUT") {
652        return mockOkJson(JSON.parse(String(init.body)));
653      }
654      return null;
655    });
656    vi.stubGlobal("fetch", fetchMock);
657
658    const { result } = renderHook(() => useSettingsBackend(), {
659      wrapper: createWrapper(client),
660    });
661
662    await act(async () => {
663      await result.current.actions.saveSecuritySettings({
664        firewallEnabled: false,
665        firewallIncomingPolicy: "reject",
666        firewallOutgoingPolicy: "deny",
667        fail2banEnabled: false,
668        fail2banMaxRetries: 7,
669        fail2banBanDurationSeconds: 7200,
670      });
671    });
672
673    expect(fetchMock).toHaveBeenCalledWith("/api/v1/system/security", {
674      method: "PUT",
675      headers: {
676        "Content-Type": "application/json",
677      },
678      body: JSON.stringify({
679        firewallEnabled: false,
680        firewallIncomingPolicy: "reject",
681        firewallOutgoingPolicy: "deny",
682        fail2banEnabled: false,
683        fail2banMaxRetries: 7,
684        fail2banBanDurationSeconds: 7200,
685      }),
686    });
687    expect(invalidateSpy).toHaveBeenCalledWith({
688      queryKey: queryKeys.systemSecurity,
689    });
690  });
691
692  it("prunes docker images and volumes and invalidates docker queries", async () => {
693    const client = createTestQueryClient();
694    const invalidateSpy = vi.spyOn(client, "invalidateQueries");
695    const fetchMock = createFetchMock((url, init) => {
696      if (url === "/api/v1/docker/prune/images" && init?.method === "POST") {
697        return mockOkJson({ command: "images", output: "Deleted Images:\nsha256:deadbeef" });
698      }
699      if (url === "/api/v1/docker/prune/volumes" && init?.method === "POST") {
700        return mockOkJson({ command: "volumes", output: "Deleted Volumes:\nold-volume" });
701      }
702      return null;
703    });
704    vi.stubGlobal("fetch", fetchMock);
705
706    const { result } = renderHook(() => useSettingsBackend(), {
707      wrapper: createWrapper(client),
708    });
709
710    await act(async () => {
711      await result.current.actions.pruneDockerImages();
712      await result.current.actions.pruneDockerVolumes();
713    });
714
715    expect(fetchMock).toHaveBeenCalledWith("/api/v1/docker/prune/images", {
716      method: "POST",
717    });
718    expect(fetchMock).toHaveBeenCalledWith("/api/v1/docker/prune/volumes", {
719      method: "POST",
720    });
721    expect(invalidateSpy).toHaveBeenCalledWith({
722      queryKey: queryKeys.dockerInfo,
723    });
724    expect(invalidateSpy).toHaveBeenCalledWith({
725      queryKey: queryKeys.systemMetrics,
726    });
727  });
728
729  it("saves backup settings and invalidates backup queries", async () => {
730    const client = createTestQueryClient();
731    const invalidateSpy = vi.spyOn(client, "invalidateQueries");
732    const fetchMock = createFetchMock((url, init) => {
733      if (url === "/api/v1/system/backups/settings" && init?.method === "PUT") {
734        return mockOkJson(JSON.parse(String(init.body)));
735      }
736      return null;
737    });
738    vi.stubGlobal("fetch", fetchMock);
739
740    const { result } = renderHook(() => useSettingsBackend(), {
741      wrapper: createWrapper(client),
742    });
743
744    await act(async () => {
745      await result.current.actions.saveBackupSettings({
746        enabled: true,
747        frequency: "daily",
748        dayOfWeek: "monday",
749        time: "02:30",
750        retentionCount: 14,
751      });
752    });
753
754    expect(fetchMock).toHaveBeenCalledWith("/api/v1/system/backups/settings", {
755      method: "PUT",
756      headers: {
757        "Content-Type": "application/json",
758      },
759      body: JSON.stringify({
760        enabled: true,
761        frequency: "daily",
762        dayOfWeek: "monday",
763        time: "02:30",
764        retentionCount: 14,
765      }),
766    });
767    expect(invalidateSpy).toHaveBeenCalledWith({
768      queryKey: queryKeys.systemBackups,
769    });
770  });
771
772  it("persists restore recovery state when a backup restore starts", async () => {
773    const client = createTestQueryClient();
774    const fetchMock = createFetchMock((url, init) => {
775      if (url === "/api/v1/system/backups/backup-1/restore" && init?.method === "POST") {
776        return mockOkJson({ action: "restore", accepted: true, backupId: "backup-1" });
777      }
778      return null;
779    });
780    vi.stubGlobal("fetch", fetchMock);
781
782    const { result } = renderHook(() => useSettingsBackend(), {
783      wrapper: createWrapper(client),
784    });
785
786    await act(async () => {
787      await result.current.actions.restoreBackup("backup-1");
788    });
789
790    expect(
791      JSON.parse(localStorage.getItem("system.power.action.v1") ?? "{}"),
792    ).toMatchObject({
793      action: "restore",
794    });
795  });
796});
797