homeio

1/* @vitest-environment jsdom */
2
3import { act, renderHook, waitFor } from "@testing-library/react";
4import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
5import { queryKeys } from "@/lib/shared/query-keys";
6import { createTestQueryClient, createWrapper } from "@/test/query-client-wrapper";
7
8const fetchStoreOperationSnapshotMock = vi.fn();
9const subscribeToStoreOperationEventsMock = vi.fn();
10
11vi.mock("@/modules/apps/hooks/useStoreOperation", () => ({
12  fetchStoreOperationSnapshot: (...args: unknown[]) => fetchStoreOperationSnapshotMock(...args),
13  subscribeToStoreOperationEvents: (...args: unknown[]) => subscribeToStoreOperationEventsMock(...args),
14}));
15
16import { useStoreActions } from "@/modules/apps/hooks/useStoreActions";
17
18describe("useStoreActions", () => {
19  beforeEach(() => {
20    fetchStoreOperationSnapshotMock.mockReset();
21    subscribeToStoreOperationEventsMock.mockReset();
22  });
23
24  afterEach(() => {
25    vi.useRealTimers();
26  });
27
28  it(
29    "starts install lifecycle and invalidates queries on completion",
30    async () => {
31    const fetchMock = vi.fn().mockResolvedValue({
32      ok: true,
33      json: async () => ({ operationId: "op-install-1" }),
34    });
35    vi.stubGlobal("fetch", fetchMock);
36
37    fetchStoreOperationSnapshotMock.mockResolvedValue({
38      id: "op-install-1",
39      appId: "plex",
40      action: "install",
41      status: "running",
42      progressPercent: 10,
43      currentStep: "Queued",
44      errorMessage: null,
45      startedAt: "2026-02-23T10:00:00.000Z",
46      finishedAt: null,
47      updatedAt: "2026-02-23T10:00:00.000Z",
48    });
49
50    let streamHandlers:
51      | {
52          onEvent?: (payload: {
53            operationId: string;
54            appId: string;
55            action: "install" | "update" | "redeploy" | "uninstall";
56            status: "queued" | "running" | "success" | "error";
57            timestamp: string;
58            progressPercent: number;
59            step: string;
60            message?: string;
61          }) => void;
62        }
63      | undefined;
64
65    const cleanup = vi.fn();
66    subscribeToStoreOperationEventsMock.mockImplementation(
67      (_operationId: string, options: typeof streamHandlers) => {
68        streamHandlers = options;
69        return cleanup;
70      },
71    );
72
73    const client = createTestQueryClient();
74    const invalidateSpy = vi.spyOn(client, "invalidateQueries");
75
76    const { result } = renderHook(() => useStoreActions(), {
77      wrapper: createWrapper(client),
78    });
79
80    await act(async () => {
81      await result.current.installApp({
82        appId: "plex",
83        webUiPort: 32400,
84        env: { TZ: "UTC" },
85      });
86    });
87
88    expect(fetchMock).toHaveBeenCalledWith("/api/v1/store/apps/plex/install", {
89      method: "POST",
90      headers: {
91        "Content-Type": "application/json",
92      },
93      body: JSON.stringify({
94        displayName: undefined,
95        env: { TZ: "UTC" },
96        webUiPort: 32400,
97      }),
98    });
99
100    await waitFor(() => {
101      expect(result.current.operationsByApp.plex?.operationId).toBe("op-install-1");
102    });
103
104    act(() => {
105      streamHandlers?.onEvent?.({
106        operationId: "op-install-1",
107        appId: "plex",
108        action: "install",
109        status: "success",
110        timestamp: "2026-02-23T10:00:02.000Z",
111        progressPercent: 100,
112        step: "Completed",
113      });
114    });
115
116    await waitFor(() => {
117      expect(cleanup).toHaveBeenCalledTimes(1);
118    });
119
120    await waitFor(() => {
121      expect(result.current.operationsByApp.plex).toBeUndefined();
122    }, { timeout: 4_000 });
123
124    expect(invalidateSpy).toHaveBeenCalledWith({ queryKey: queryKeys.storeCatalog });
125    expect(invalidateSpy).toHaveBeenCalledWith({ queryKey: queryKeys.installedApps });
126    expect(invalidateSpy).toHaveBeenCalledWith({ queryKey: queryKeys.storeApp("plex") });
127    expect(invalidateSpy).toHaveBeenCalledWith({
128      queryKey: queryKeys.appCompose("plex", "installed"),
129    });
130    expect(invalidateSpy).toHaveBeenCalledWith({
131      queryKey: queryKeys.appCompose("plex", "catalog"),
132    });
133      expect(invalidateSpy).toHaveBeenCalledWith({
134        queryKey: queryKeys.storeOperation("op-install-1"),
135      });
136    },
137    10_000,
138  );
139
140  it("calls update, redeploy and uninstall endpoints", async () => {
141    const fetchMock = vi
142      .fn()
143      .mockResolvedValueOnce({
144        ok: true,
145        json: async () => ({ operationId: "op-update-1" }),
146      })
147      .mockResolvedValueOnce({
148        ok: true,
149        json: async () => ({ operationId: "op-redeploy-1" }),
150      })
151      .mockResolvedValueOnce({
152        ok: true,
153        json: async () => ({ operationId: "op-uninstall-1" }),
154      });
155    vi.stubGlobal("fetch", fetchMock);
156
157    fetchStoreOperationSnapshotMock.mockResolvedValue(null);
158    subscribeToStoreOperationEventsMock.mockReturnValue(() => undefined);
159
160    const client = createTestQueryClient();
161    const { result } = renderHook(() => useStoreActions(), {
162      wrapper: createWrapper(client),
163    });
164
165    await act(async () => {
166      await result.current.updateApp({
167        appId: "jellyfin",
168      });
169      await result.current.redeployApp({
170        appId: "jellyfin",
171        webUiPort: 8096,
172        env: { TZ: "UTC" },
173      });
174      await result.current.uninstallApp({
175        appId: "jellyfin",
176        removeVolumes: true,
177      });
178    });
179
180    expect(fetchMock).toHaveBeenNthCalledWith(1, "/api/v1/store/apps/jellyfin/update", {
181      method: "POST",
182      headers: {
183        "Content-Type": "application/json",
184      },
185      body: JSON.stringify({}),
186    });
187
188    expect(fetchMock).toHaveBeenNthCalledWith(2, "/api/v1/store/apps/jellyfin/redeploy", {
189      method: "POST",
190      headers: {
191        "Content-Type": "application/json",
192      },
193      body: JSON.stringify({
194        env: { TZ: "UTC" },
195        webUiPort: 8096,
196      }),
197    });
198
199    expect(fetchMock).toHaveBeenNthCalledWith(3, "/api/v1/store/apps/jellyfin/uninstall", {
200      method: "POST",
201      headers: {
202        "Content-Type": "application/json",
203      },
204      body: JSON.stringify({
205        removeVolumes: true,
206      }),
207    });
208  });
209
210  it("sends the link override to the settings endpoint", async () => {
211    const fetchMock = vi.fn().mockResolvedValue({
212      ok: true,
213      json: async () => ({ saved: true }),
214    });
215    vi.stubGlobal("fetch", fetchMock);
216
217    fetchStoreOperationSnapshotMock.mockResolvedValue(null);
218    subscribeToStoreOperationEventsMock.mockReturnValue(() => undefined);
219
220    const client = createTestQueryClient();
221    const { result } = renderHook(() => useStoreActions(), {
222      wrapper: createWrapper(client),
223    });
224
225    await act(async () => {
226      await result.current.saveAppSettings({
227        appId: "jellyfin",
228        displayName: "Jellyfin",
229        webUiUrl: "https://jellyfin.example.com",
230      });
231    });
232
233    // The body is assembled field by field, so a new setting has to be added
234    // here too or it is dropped silently between the form and the API.
235    const [, requestInit] = fetchMock.mock.calls[0] as [string, RequestInit];
236    expect(JSON.parse(String(requestInit.body))).toMatchObject({
237      webUiUrl: "https://jellyfin.example.com",
238    });
239  });
240
241  it("calls custom install endpoint and tracks operation by returned app id", async () => {
242    const fetchMock = vi.fn().mockResolvedValue({
243      ok: true,
244      json: async () => ({ appId: "custom-my-app", operationId: "op-custom-1" }),
245    });
246    vi.stubGlobal("fetch", fetchMock);
247
248    fetchStoreOperationSnapshotMock.mockResolvedValue({
249      id: "op-custom-1",
250      appId: "custom-my-app",
251      action: "install",
252      status: "running",
253      progressPercent: 5,
254      currentStep: "Queued",
255      errorMessage: null,
256      startedAt: "2026-02-23T10:00:00.000Z",
257      finishedAt: null,
258      updatedAt: "2026-02-23T10:00:00.000Z",
259    });
260    subscribeToStoreOperationEventsMock.mockReturnValue(() => undefined);
261
262    const client = createTestQueryClient();
263    const { result } = renderHook(() => useStoreActions(), {
264      wrapper: createWrapper(client),
265    });
266
267    await act(async () => {
268      await result.current.installCustomApp({
269        name: "My App",
270        iconUrl: "https://example.com/icon.png",
271        sourceType: "docker-run",
272        source: "docker run --name myapp -p 8088:80 nginx:latest",
273      });
274    });
275
276    expect(fetchMock).toHaveBeenCalledWith("/api/v1/store/custom-apps/install", {
277      method: "POST",
278      headers: {
279        "Content-Type": "application/json",
280      },
281      body: JSON.stringify({
282        name: "My App",
283        iconUrl: "https://example.com/icon.png",
284        sourceType: "docker-run",
285        source: "docker run --name myapp -p 8088:80 nginx:latest",
286      }),
287    });
288
289    await waitFor(() => {
290      expect(result.current.operationsByApp["custom-my-app"]?.operationId).toBe("op-custom-1");
291    });
292  });
293
294  it("surfaces API error message and code for install failures", async () => {
295    const fetchMock = vi.fn().mockResolvedValue({
296      ok: false,
297      status: 503,
298      json: async () => ({
299        error: "Unable to start install operation",
300        code: "helper_unavailable",
301      }),
302    });
303    vi.stubGlobal("fetch", fetchMock);
304
305    fetchStoreOperationSnapshotMock.mockResolvedValue(null);
306    subscribeToStoreOperationEventsMock.mockReturnValue(() => undefined);
307
308    const client = createTestQueryClient();
309    const { result } = renderHook(() => useStoreActions(), {
310      wrapper: createWrapper(client),
311    });
312
313    await expect(
314      act(async () => {
315        await result.current.installApp({
316          appId: "plex",
317        });
318      }),
319    ).rejects.toThrow(
320      "Unable to start install operation [helper_unavailable]",
321    );
322  });
323
324  it(
325    "updates operation state from snapshot polling when stream events are missing",
326    async () => {
327      vi.useFakeTimers();
328
329      const fetchMock = vi.fn().mockResolvedValue({
330        ok: true,
331        json: async () => ({ operationId: "op-install-poll" }),
332      });
333      vi.stubGlobal("fetch", fetchMock);
334
335      fetchStoreOperationSnapshotMock
336        .mockResolvedValueOnce({
337          id: "op-install-poll",
338          appId: "2fauth",
339          action: "install",
340          status: "running",
341          progressPercent: 1,
342          currentStep: "start",
343          errorMessage: null,
344          startedAt: "2026-02-24T19:00:00.000Z",
345          finishedAt: null,
346          updatedAt: "2026-02-24T19:00:00.000Z",
347        })
348        .mockResolvedValueOnce({
349          id: "op-install-poll",
350          appId: "2fauth",
351          action: "install",
352          status: "running",
353          progressPercent: 85,
354          currentStep: "compose-up",
355          errorMessage: null,
356          startedAt: "2026-02-24T19:00:00.000Z",
357          finishedAt: null,
358          updatedAt: "2026-02-24T19:00:02.000Z",
359        })
360        .mockResolvedValueOnce({
361          id: "op-install-poll",
362          appId: "2fauth",
363          action: "install",
364          status: "success",
365          progressPercent: 100,
366          currentStep: "completed",
367          errorMessage: null,
368          startedAt: "2026-02-24T19:00:00.000Z",
369          finishedAt: "2026-02-24T19:00:04.000Z",
370          updatedAt: "2026-02-24T19:00:04.000Z",
371        });
372
373      const cleanup = vi.fn();
374      subscribeToStoreOperationEventsMock.mockReturnValue(cleanup);
375
376      const client = createTestQueryClient();
377      const invalidateSpy = vi.spyOn(client, "invalidateQueries");
378
379      const { result } = renderHook(() => useStoreActions(), {
380        wrapper: createWrapper(client),
381      });
382
383      await act(async () => {
384        await result.current.installApp({
385          appId: "2fauth",
386        });
387      });
388
389      await act(async () => {
390        await Promise.resolve();
391      });
392
393      expect(result.current.operationsByApp["2fauth"]?.progressPercent).toBe(1);
394
395      await act(async () => {
396        await vi.advanceTimersByTimeAsync(1_500);
397      });
398
399      expect(result.current.operationsByApp["2fauth"]?.progressPercent).toBe(85);
400
401      await act(async () => {
402        await vi.advanceTimersByTimeAsync(1_500);
403      });
404
405      await act(async () => {
406        await vi.advanceTimersByTimeAsync(2_600);
407      });
408
409      expect(result.current.operationsByApp["2fauth"]).toBeUndefined();
410
411      expect(cleanup).toHaveBeenCalledTimes(1);
412      expect(invalidateSpy).toHaveBeenCalledWith({ queryKey: queryKeys.storeCatalog });
413      expect(invalidateSpy).toHaveBeenCalledWith({ queryKey: queryKeys.installedApps });
414      expect(invalidateSpy).toHaveBeenCalledWith({ queryKey: queryKeys.storeApp("2fauth") });
415      expect(invalidateSpy).toHaveBeenCalledWith({
416        queryKey: queryKeys.appCompose("2fauth", "installed"),
417      });
418      expect(invalidateSpy).toHaveBeenCalledWith({
419        queryKey: queryKeys.appCompose("2fauth", "catalog"),
420      });
421      expect(invalidateSpy).toHaveBeenCalledWith({
422        queryKey: queryKeys.storeOperation("op-install-poll"),
423      });
424    },
425    12_000,
426  );
427
428  it("clears optimistic operation state when the backend snapshot never appears", async () => {
429    vi.useFakeTimers();
430
431    const fetchMock = vi.fn().mockResolvedValue({
432      ok: true,
433      json: async () => ({ operationId: "op-missing-1" }),
434    });
435    vi.stubGlobal("fetch", fetchMock);
436
437    fetchStoreOperationSnapshotMock.mockResolvedValue(null);
438    const cleanup = vi.fn();
439    subscribeToStoreOperationEventsMock.mockReturnValue(cleanup);
440
441    const client = createTestQueryClient();
442    const invalidateSpy = vi.spyOn(client, "invalidateQueries");
443    const { result } = renderHook(() => useStoreActions(), {
444      wrapper: createWrapper(client),
445    });
446
447    await act(async () => {
448      await result.current.installApp({
449        appId: "ghost-app",
450      });
451    });
452
453    expect(result.current.operationsByApp["ghost-app"]?.operationId).toBe("op-missing-1");
454
455    await act(async () => {
456      await vi.advanceTimersByTimeAsync(7_200);
457    });
458
459    expect(result.current.operationsByApp["ghost-app"]).toBeUndefined();
460
461    expect(cleanup).toHaveBeenCalledTimes(1);
462    expect(invalidateSpy).toHaveBeenCalledWith({ queryKey: queryKeys.storeCatalog });
463    expect(invalidateSpy).toHaveBeenCalledWith({ queryKey: queryKeys.installedApps });
464    expect(invalidateSpy).toHaveBeenCalledWith({
465      queryKey: queryKeys.storeApp("ghost-app"),
466    });
467  });
468});
469