homeio

1/* @vitest-environment jsdom */
2
3import { act, renderHook } from "@testing-library/react";
4import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
5import { writePersistedPowerActionState } from "@/lib/desktop/reboot-state";
6import { dispatchSystemStreamStatus } from "@/lib/desktop/system-stream-status";
7import { queryKeys } from "@/lib/shared/query-keys";
8import { useServerConnection } from "@/modules/shell/hooks/useServerConnection";
9import { createTestQueryClient, createWrapper } from "@/test/query-client-wrapper";
10
11const { reloadBrowserWindowMock } = vi.hoisted(() => ({
12  reloadBrowserWindowMock: vi.fn(),
13}));
14
15vi.mock("@/lib/desktop/browser-reload", () => ({
16  reloadBrowserWindow: reloadBrowserWindowMock,
17}));
18
19// A fake Homeio: up or down, and one process at a time.
20function createServer() {
21  const server = {
22    up: true,
23    pid: 4242,
24    processStartedAt: Date.now() - 600_000,
25    snapshot() {
26      const now = Date.now();
27      return {
28        timestamp: new Date(now).toISOString(),
29        process: {
30          pid: server.pid,
31          uptimeSeconds: (now - server.processStartedAt) / 1_000,
32          nodeVersion: "v22",
33          runtime: "host" as const,
34        },
35      };
36    },
37    restart() {
38      server.pid += 1;
39      server.processStartedAt = Date.now();
40    },
41  };
42
43  const fetchMock = vi.fn(async (input: RequestInfo | URL) => {
44    const url = String(input);
45    if (url === "/icon.png") return { ok: false, status: 404 };
46    if (!server.up) throw new TypeError("Failed to fetch");
47    if (url === "/api/v1/system/metrics") {
48      return { ok: true, status: 200, json: async () => ({ data: server.snapshot() }) };
49    }
50    return { ok: true, status: 200 };
51  });
52
53  return { server, fetchMock };
54}
55
56async function advance(ms: number) {
57  await act(async () => {
58    await vi.advanceTimersByTimeAsync(ms);
59  });
60}
61
62describe("useServerConnection", () => {
63  beforeEach(() => {
64    vi.useFakeTimers();
65    localStorage.clear();
66    reloadBrowserWindowMock.mockReset();
67  });
68
69  afterEach(() => {
70    vi.useRealTimers();
71    vi.unstubAllGlobals();
72  });
73
74  function setup() {
75    const { server, fetchMock } = createServer();
76    vi.stubGlobal("fetch", fetchMock);
77    const client = createTestQueryClient();
78    client.setQueryData(queryKeys.systemMetrics, server.snapshot());
79    const hook = renderHook(() => useServerConnection(true), {
80      wrapper: createWrapper(client),
81    });
82    return { server, fetchMock, client, hook };
83  }
84
85  it("ignores a stream drop when the server still answers", async () => {
86    const { hook } = setup();
87
88    act(() => dispatchSystemStreamStatus("disconnected"));
89    await advance(0);
90
91    expect(hook.result.current.phase).toBe("online");
92  });
93
94  it("shows the screen on the first failed check after the stream drops", async () => {
95    const { server, hook } = setup();
96
97    // A service restart: Homeio is away for about a second.
98    server.up = false;
99    act(() => dispatchSystemStreamStatus("disconnected"));
100    await advance(0);
101
102    expect(hook.result.current.phase).toBe("lost");
103
104    server.restart();
105    server.up = true;
106    await advance(2_000);
107
108    expect(hook.result.current.phase).toBe("restored");
109  });
110
111  it("hides the screen without a reload when the same process is back", async () => {
112    const { server, client, hook } = setup();
113    const invalidateSpy = vi.spyOn(client, "invalidateQueries");
114
115    server.up = false;
116    act(() => dispatchSystemStreamStatus("disconnected"));
117    await advance(2_000);
118
119    expect(hook.result.current.phase).toBe("lost");
120    expect(hook.result.current.runtime).toBe("host");
121    expect(hook.result.current.lostSince).not.toBeNull();
122
123    // A network blip: the server kept running the whole time.
124    server.up = true;
125    await advance(2_000);
126
127    expect(hook.result.current.phase).toBe("restored");
128    expect(hook.result.current.serverRestarted).toBe(false);
129
130    await advance(1_200);
131
132    expect(hook.result.current.phase).toBe("online");
133    expect(reloadBrowserWindowMock).not.toHaveBeenCalled();
134    expect(invalidateSpy).toHaveBeenCalled();
135  });
136
137  it("reloads the page when a new process answers", async () => {
138    const { server, hook } = setup();
139
140    server.up = false;
141    act(() => dispatchSystemStreamStatus("disconnected"));
142    await advance(2_000);
143    expect(hook.result.current.phase).toBe("lost");
144
145    server.restart();
146    server.up = true;
147    await advance(2_000);
148
149    expect(hook.result.current.phase).toBe("restored");
150    expect(hook.result.current.serverRestarted).toBe(true);
151
152    await advance(1_200);
153
154    expect(reloadBrowserWindowMock).toHaveBeenCalledOnce();
155  });
156
157  it("checks right away when the user asks", async () => {
158    const { server, fetchMock, hook } = setup();
159
160    server.up = false;
161    act(() => dispatchSystemStreamStatus("disconnected"));
162    await advance(2_000);
163    expect(hook.result.current.phase).toBe("lost");
164
165    const callsBefore = fetchMock.mock.calls.length;
166    act(() => hook.result.current.checkNow());
167    await advance(0);
168
169    expect(fetchMock.mock.calls.length).toBe(callsBefore + 1);
170  });
171
172  it("leaves reboots and updates started from the desktop to their own screen", async () => {
173    const { server, fetchMock, hook } = setup();
174    writePersistedPowerActionState(localStorage, {
175      action: "reboot",
176      startedAt: new Date().toISOString(),
177    });
178
179    server.up = false;
180    act(() => dispatchSystemStreamStatus("disconnected"));
181    await advance(6_000);
182
183    expect(hook.result.current.phase).toBe("online");
184    expect(fetchMock).not.toHaveBeenCalledWith("/api/health", expect.anything());
185  });
186});
187