homeio

1/* @vitest-environment jsdom */
2
3import { act, renderHook, waitFor } from "@testing-library/react";
4import { describe, expect, it, vi } from "vitest";
5import {
6  fetchStoreOperationSnapshot,
7  subscribeToStoreOperationEvents,
8  useStoreOperation,
9} from "@/modules/apps/hooks/useStoreOperation";
10import { queryKeys } from "@/lib/shared/query-keys";
11import { createTestQueryClient, createWrapper } from "@/test/query-client-wrapper";
12
13type Listener = (event: { data: string }) => void;
14
15class MockEventSource {
16  static instances: MockEventSource[] = [];
17
18  listeners = new Map<string, Set<Listener>>();
19  closed = false;
20
21  constructor(readonly url: string) {
22    MockEventSource.instances.push(this);
23  }
24
25  addEventListener(type: string, listener: Listener) {
26    if (!this.listeners.has(type)) {
27      this.listeners.set(type, new Set());
28    }
29    this.listeners.get(type)?.add(listener);
30  }
31
32  removeEventListener(type: string, listener: Listener) {
33    this.listeners.get(type)?.delete(listener);
34  }
35
36  close() {
37    this.closed = true;
38  }
39
40  emit(type: string, payload: unknown) {
41    const serialized = JSON.stringify(payload);
42    this.listeners.get(type)?.forEach((listener) => {
43      listener({ data: serialized });
44    });
45  }
46
47  emitRaw(type: string, data: string) {
48    this.listeners.get(type)?.forEach((listener) => {
49      listener({ data });
50    });
51  }
52}
53
54describe("useStoreOperation", () => {
55  it("fetches operation snapshot and merges stream events", async () => {
56    const fetchMock = vi.fn().mockResolvedValue({
57      ok: true,
58      json: async () => ({
59        data: {
60          id: "op-1",
61          appId: "plex",
62          action: "install",
63          status: "running",
64          progressPercent: 15,
65          currentStep: "Pulling images",
66          errorMessage: null,
67          startedAt: "2026-02-23T10:00:00.000Z",
68          finishedAt: null,
69          updatedAt: "2026-02-23T10:00:00.000Z",
70        },
71      }),
72    });
73    vi.stubGlobal("fetch", fetchMock);
74    vi.stubGlobal("EventSource", MockEventSource as unknown as typeof EventSource);
75
76    const client = createTestQueryClient();
77    const invalidateSpy = vi.spyOn(client, "invalidateQueries");
78
79    const { result, unmount } = renderHook(() => useStoreOperation("op-1"), {
80      wrapper: createWrapper(client),
81    });
82
83    await waitFor(() => {
84      expect(result.current.operation?.status).toBe("running");
85    });
86
87    const source = MockEventSource.instances[0];
88    expect(source.url).toBe("/api/v1/store/operations/op-1/stream");
89
90    act(() => {
91      source.emit("operation.pull.progress", {
92        type: "operation.pull.progress",
93        operationId: "op-1",
94        appId: "plex",
95        action: "install",
96        status: "running",
97        timestamp: "2026-02-23T10:00:02.000Z",
98        progressPercent: 45,
99        step: "Pulling layer",
100      });
101    });
102
103    await waitFor(() => {
104      expect(result.current.operation?.progressPercent).toBe(45);
105      expect(result.current.operation?.currentStep).toBe("Pulling layer");
106    });
107
108    act(() => {
109      source.emit("operation.completed", {
110        type: "operation.completed",
111        operationId: "op-1",
112        appId: "plex",
113        action: "install",
114        status: "success",
115        timestamp: "2026-02-23T10:00:03.000Z",
116        progressPercent: 100,
117        step: "Completed",
118      });
119    });
120
121    await waitFor(() => {
122      expect(result.current.operation?.status).toBe("success");
123    });
124
125    expect(invalidateSpy).toHaveBeenCalledWith({ queryKey: queryKeys.storeCatalog });
126    expect(invalidateSpy).toHaveBeenCalledWith({ queryKey: queryKeys.installedApps });
127    expect(invalidateSpy).toHaveBeenCalledWith({ queryKey: queryKeys.storeApp("plex") });
128    expect(invalidateSpy).toHaveBeenCalledWith({ queryKey: queryKeys.storeOperation("op-1") });
129
130    unmount();
131    expect(source.closed).toBe(true);
132  });
133
134  it("returns null when operation snapshot is not found", async () => {
135    vi.stubGlobal(
136      "fetch",
137      vi.fn().mockResolvedValue({
138        ok: false,
139        status: 404,
140      }),
141    );
142
143    const data = await fetchStoreOperationSnapshot("missing");
144    expect(data).toBeNull();
145  });
146
147  it("calls onError when stream event payload is invalid", () => {
148    vi.stubGlobal("EventSource", MockEventSource as unknown as typeof EventSource);
149
150    const onEvent = vi.fn();
151    const onError = vi.fn();
152
153    const unsubscribe = subscribeToStoreOperationEvents("op-2", {
154      onEvent,
155      onError,
156    });
157
158    const source = MockEventSource.instances.at(-1);
159    if (!source) {
160      throw new Error("Expected EventSource instance");
161    }
162
163    source.emitRaw("operation.step", "{invalid");
164
165    expect(onEvent).not.toHaveBeenCalled();
166    expect(onError).toHaveBeenCalledTimes(1);
167
168    unsubscribe();
169    expect(source.closed).toBe(true);
170  });
171});
172