homeio

1/* @vitest-environment jsdom */
2
3import { act, renderHook, waitFor } from "@testing-library/react";
4import { beforeEach, describe, expect, it, vi } from "vitest";
5import {
6  POWER_ACTION_COMPLETION_STORAGE_KEY,
7  POWER_ACTION_STATE_CHANGED_EVENT,
8  readPersistedPowerActionCompletion,
9  writePersistedPowerActionState,
10} from "@/lib/desktop/reboot-state";
11import { queryKeys } from "@/lib/shared/query-keys";
12import { useRebootRecovery } from "@/modules/shell/hooks/useRebootRecovery";
13import { createTestQueryClient, createWrapper } from "@/test/query-client-wrapper";
14
15const { reloadBrowserWindowMock } = vi.hoisted(() => ({
16  reloadBrowserWindowMock: vi.fn(),
17}));
18
19vi.mock("@/lib/desktop/browser-reload", () => ({
20  reloadBrowserWindow: reloadBrowserWindowMock,
21}));
22
23describe("useRebootRecovery", () => {
24  beforeEach(() => {
25    vi.useRealTimers();
26    localStorage.clear();
27    vi.restoreAllMocks();
28    reloadBrowserWindowMock.mockReset();
29  });
30
31  it("recovers from persisted reboot state and clears it after health/auth succeed", async () => {
32    writePersistedPowerActionState(localStorage, {
33      action: "reboot",
34      startedAt: new Date(Date.now() - 10_000).toISOString(),
35    });
36
37    const fetchMock = vi
38      .fn()
39      .mockRejectedValueOnce(new Error("down"))
40      .mockResolvedValueOnce({ ok: true, status: 200 })
41      .mockResolvedValueOnce({ ok: true, status: 200 });
42    vi.stubGlobal("fetch", fetchMock);
43
44    const client = createTestQueryClient();
45    const invalidateSpy = vi.spyOn(client, "invalidateQueries");
46
47    const { result } = renderHook(() => useRebootRecovery(), {
48      wrapper: createWrapper(client),
49    });
50
51    await waitFor(() => {
52      expect(result.current.isHydrated).toBe(true);
53      expect(result.current.isActive).toBe(true);
54    });
55
56    await waitFor(() => {
57      expect(fetchMock).toHaveBeenCalledTimes(3);
58    }, { timeout: 4_000 });
59
60    await waitFor(() => {
61      expect(result.current.isActive).toBe(false);
62    }, { timeout: 4_000 });
63
64    expect(localStorage.getItem("system.power.action.v1")).toBeNull();
65    expect(invalidateSpy).toHaveBeenCalledWith({
66      queryKey: queryKeys.currentUser,
67    });
68    expect(invalidateSpy).toHaveBeenCalledWith({
69      queryKey: queryKeys.systemMetrics,
70    });
71    expect(invalidateSpy).toHaveBeenCalledWith({
72      queryKey: queryKeys.installedApps,
73    });
74    expect(invalidateSpy).toHaveBeenCalledWith({
75      queryKey: queryKeys.powerSchedule,
76    });
77    expect(invalidateSpy).toHaveBeenCalledWith({
78      queryKey: queryKeys.systemBackups,
79    });
80    expect(invalidateSpy).toHaveBeenCalledWith({
81      queryKey: queryKeys.systemUpdates,
82    });
83  });
84
85  it("clears reboot state on 401 after service recovery", async () => {
86    writePersistedPowerActionState(localStorage, {
87      action: "factory-reset",
88      startedAt: new Date(Date.now() - 20_000).toISOString(),
89    });
90
91    const fetchMock = vi
92      .fn()
93      .mockResolvedValueOnce({ ok: true, status: 200 })
94      .mockResolvedValueOnce({ ok: false, status: 401 });
95    vi.stubGlobal("fetch", fetchMock);
96
97    const client = createTestQueryClient();
98
99    const { result } = renderHook(() => useRebootRecovery(), {
100      wrapper: createWrapper(client),
101    });
102
103    await waitFor(() => {
104      expect(result.current.isHydrated).toBe(true);
105    });
106
107    await waitFor(() => {
108      expect(result.current.isActive).toBe(false);
109    }, { timeout: 4_000 });
110
111    expect(localStorage.getItem("system.power.action.v1")).toBeNull();
112  });
113
114  it("keeps the restore overlay active until health and auth recover", async () => {
115    writePersistedPowerActionState(localStorage, {
116      action: "restore",
117      startedAt: new Date(Date.now() - 10_000).toISOString(),
118    });
119
120    const fetchMock = vi
121      .fn()
122      .mockResolvedValueOnce({ ok: false, status: 503 })
123      .mockResolvedValueOnce({ ok: true, status: 200 })
124      .mockResolvedValueOnce({ ok: true, status: 200 });
125    vi.stubGlobal("fetch", fetchMock);
126
127    const client = createTestQueryClient();
128
129    const { result } = renderHook(() => useRebootRecovery(), {
130      wrapper: createWrapper(client),
131    });
132
133    await waitFor(() => {
134      expect(result.current.isHydrated).toBe(true);
135      expect(result.current.action).toBe("restore");
136    });
137
138    await waitFor(() => {
139      expect(result.current.isActive).toBe(false);
140    }, { timeout: 4_000 });
141
142    expect(localStorage.getItem("system.power.action.v1")).toBeNull();
143  });
144
145  it("keeps the update overlay active until health and auth recover", async () => {
146    writePersistedPowerActionState(localStorage, {
147      action: "update",
148      startedAt: new Date(Date.now() - 20_000).toISOString(),
149    });
150
151    const fetchMock = vi
152      .fn()
153      .mockResolvedValueOnce({ ok: true, status: 200 })
154      .mockResolvedValueOnce({ ok: true, status: 200 });
155    vi.stubGlobal("fetch", fetchMock);
156
157    const client = createTestQueryClient();
158
159    const { result } = renderHook(() => useRebootRecovery(), {
160      wrapper: createWrapper(client),
161    });
162
163    await waitFor(() => {
164      expect(result.current.isHydrated).toBe(true);
165      expect(result.current.action).toBe("update");
166    });
167
168    await waitFor(() => {
169      expect(result.current.isActive).toBe(false);
170    }, { timeout: 4_000 });
171
172    expect(localStorage.getItem("system.power.action.v1")).toBeNull();
173    expect(readPersistedPowerActionCompletion(localStorage)).toMatchObject({
174      action: "update",
175    });
176    expect(reloadBrowserWindowMock).toHaveBeenCalledTimes(1);
177  });
178
179  it("does not clear update recovery before the service actually goes away", async () => {
180    writePersistedPowerActionState(localStorage, {
181      action: "update",
182      startedAt: new Date().toISOString(),
183    });
184
185    const fetchMock = vi
186      .fn()
187      .mockResolvedValueOnce({ ok: true, status: 200 })
188      .mockRejectedValueOnce(new Error("gateway down"))
189      .mockResolvedValueOnce({ ok: true, status: 200 })
190      .mockResolvedValueOnce({ ok: true, status: 200 });
191    vi.stubGlobal("fetch", fetchMock);
192
193    const client = createTestQueryClient();
194
195    const { result } = renderHook(() => useRebootRecovery(), {
196      wrapper: createWrapper(client),
197    });
198
199    await waitFor(() => {
200      expect(result.current.isHydrated).toBe(true);
201      expect(result.current.isActive).toBe(true);
202      expect(result.current.action).toBe("update");
203    });
204
205    await waitFor(() => {
206      expect(fetchMock).toHaveBeenCalledTimes(1);
207      expect(result.current.isActive).toBe(true);
208    });
209
210    await waitFor(() => {
211      expect(fetchMock).toHaveBeenCalledTimes(4);
212      expect(result.current.isActive).toBe(false);
213    }, { timeout: 8_000 });
214
215    expect(reloadBrowserWindowMock).toHaveBeenCalledTimes(1);
216  });
217
218  it("reacts immediately when a power action is written in the same tab", async () => {
219    vi.stubGlobal("fetch", vi.fn().mockRejectedValue(new Error("still rebooting")));
220
221    const client = createTestQueryClient();
222
223    const { result } = renderHook(() => useRebootRecovery(), {
224      wrapper: createWrapper(client),
225    });
226
227    await waitFor(() => {
228      expect(result.current.isHydrated).toBe(true);
229      expect(result.current.isActive).toBe(false);
230    });
231
232    act(() => {
233      writePersistedPowerActionState(localStorage, {
234        action: "update",
235        startedAt: new Date().toISOString(),
236      });
237      window.dispatchEvent(new Event(POWER_ACTION_STATE_CHANGED_EVENT));
238    });
239
240    await waitFor(() => {
241      expect(result.current.isActive).toBe(true);
242      expect(result.current.action).toBe("update");
243    });
244    expect(localStorage.getItem(POWER_ACTION_COMPLETION_STORAGE_KEY)).toBeNull();
245  });
246});
247