homeio

1/* @vitest-environment jsdom */
2
3import { act, renderHook, waitFor } from "@testing-library/react";
4import { describe, expect, it, vi } from "vitest";
5import {
6  buildAssetUrl,
7  toFilePath,
8  useCreateFile,
9  useCreateFolder,
10  useFileContent,
11  useFilesDirectory,
12  usePasteFileEntry,
13  useSaveFileContent,
14} from "@/modules/files/hooks/useFiles";
15import { queryKeys } from "@/lib/shared/query-keys";
16import { createTestQueryClient, createWrapper } from "@/test/query-client-wrapper";
17
18describe("useFiles hooks", () => {
19  it("loads directory entries from files API", async () => {
20    const fetchMock = vi.fn().mockResolvedValueOnce({
21      ok: true,
22      json: async () => ({
23        data: {
24          root: "/",
25          cwd: "Documents",
26          entries: [],
27        },
28        meta: {
29          count: 0,
30        },
31      }),
32    });
33    vi.stubGlobal("fetch", fetchMock);
34
35    const client = createTestQueryClient();
36    const { result } = renderHook(() => useFilesDirectory(["Documents"]), {
37      wrapper: createWrapper(client),
38    });
39
40    await waitFor(() => {
41      expect(result.current.isSuccess).toBe(true);
42    });
43
44    expect(fetchMock).toHaveBeenCalledWith("/api/v1/files?path=Documents", {
45      cache: "no-store",
46    });
47  });
48
49  it("loads file content by path", async () => {
50    const fetchMock = vi.fn().mockResolvedValueOnce({
51      ok: true,
52      json: async () => ({
53        data: {
54          root: "/",
55          path: "Documents/notes.txt",
56          name: "notes.txt",
57          ext: "txt",
58          mode: "text",
59          mimeType: "text/plain; charset=utf-8",
60          sizeBytes: 6,
61          modifiedAt: "2026-02-26T12:00:00.000Z",
62          mtimeMs: 11,
63          content: "hello!",
64        },
65      }),
66    });
67    vi.stubGlobal("fetch", fetchMock);
68
69    const client = createTestQueryClient();
70    const { result } = renderHook(
71      () => useFileContent("Documents/notes.txt"),
72      {
73        wrapper: createWrapper(client),
74      },
75    );
76
77    await waitFor(() => {
78      expect(result.current.isSuccess).toBe(true);
79    });
80
81    expect(fetchMock).toHaveBeenCalledWith(
82      "/api/v1/files/content?path=Documents%2Fnotes.txt",
83      {
84        cache: "no-store",
85      },
86    );
87  });
88
89  it("saves file content and invalidates related queries", async () => {
90    const fetchMock = vi.fn().mockResolvedValueOnce({
91      ok: true,
92      json: async () => ({
93        data: {
94          root: "/",
95          path: "Documents/notes.txt",
96          sizeBytes: 7,
97          modifiedAt: "2026-02-26T12:00:05.000Z",
98          mtimeMs: 22,
99        },
100      }),
101    });
102    vi.stubGlobal("fetch", fetchMock);
103
104    const client = createTestQueryClient();
105    const invalidateSpy = vi.spyOn(client, "invalidateQueries");
106
107    const { result } = renderHook(() => useSaveFileContent(), {
108      wrapper: createWrapper(client),
109    });
110
111    await act(async () => {
112      await result.current.mutateAsync({
113        path: "Documents/notes.txt",
114        content: "updated",
115        expectedMtimeMs: 11,
116      });
117    });
118
119    expect(fetchMock).toHaveBeenCalledWith("/api/v1/files/content", {
120      method: "PUT",
121      headers: {
122        "Content-Type": "application/json",
123      },
124      body: JSON.stringify({
125        path: "Documents/notes.txt",
126        content: "updated",
127        expectedMtimeMs: 11,
128      }),
129    });
130    expect(invalidateSpy).toHaveBeenCalledWith({
131      queryKey: queryKeys.fileContent("Documents/notes.txt"),
132    });
133    expect(invalidateSpy).toHaveBeenCalledWith({
134      queryKey: ["files", "list", "Documents"],
135    });
136  });
137
138  it("exports path helpers", () => {
139    expect(toFilePath(["Documents", "notes.txt"])).toBe("Documents/notes.txt");
140    expect(toFilePath(["Trash", "notes.txt"])).toBe("Trash/notes.txt");
141    expect(buildAssetUrl("Media/photo.png")).toBe(
142      "/api/v1/files/asset?path=Media%2Fphoto.png",
143    );
144  });
145
146  it("creates a folder via files ops endpoint", async () => {
147    const fetchMock = vi.fn().mockResolvedValueOnce({
148      ok: true,
149      json: async () => ({
150        data: {
151          root: "/",
152          path: "Documents/New Folder",
153          type: "folder",
154        },
155      }),
156    });
157    vi.stubGlobal("fetch", fetchMock);
158
159    const client = createTestQueryClient();
160    const invalidateSpy = vi.spyOn(client, "invalidateQueries");
161    const { result } = renderHook(() => useCreateFolder(), {
162      wrapper: createWrapper(client),
163    });
164
165    await act(async () => {
166      await result.current.mutateAsync({
167        parentPath: "Documents",
168        name: "New Folder",
169      });
170    });
171
172    expect(fetchMock).toHaveBeenCalledWith("/api/v1/files/ops", {
173      method: "POST",
174      headers: {
175        "Content-Type": "application/json",
176      },
177      body: JSON.stringify({
178        action: "create_folder",
179        parentPath: "Documents",
180        name: "New Folder",
181      }),
182    });
183    expect(invalidateSpy).toHaveBeenCalledWith({
184      queryKey: ["files", "list", "Documents"],
185    });
186  });
187
188  it("creates a file via files ops endpoint", async () => {
189    const fetchMock = vi.fn().mockResolvedValueOnce({
190      ok: true,
191      json: async () => ({
192        data: {
193          root: "/",
194          path: "Documents/notes.txt",
195          type: "file",
196        },
197      }),
198    });
199    vi.stubGlobal("fetch", fetchMock);
200
201    const client = createTestQueryClient();
202    const { result } = renderHook(() => useCreateFile(), {
203      wrapper: createWrapper(client),
204    });
205
206    await act(async () => {
207      await result.current.mutateAsync({
208        parentPath: "Documents",
209        name: "notes.txt",
210      });
211    });
212
213    expect(fetchMock).toHaveBeenCalledWith("/api/v1/files/ops", {
214      method: "POST",
215      headers: {
216        "Content-Type": "application/json",
217      },
218      body: JSON.stringify({
219        action: "create_file",
220        parentPath: "Documents",
221        name: "notes.txt",
222      }),
223    });
224  });
225
226  it("pastes copied entries via files ops endpoint", async () => {
227    const fetchMock = vi.fn().mockResolvedValueOnce({
228      ok: true,
229      json: async () => ({
230        data: {
231          root: "/",
232          path: "Documents/photo.jpg",
233          type: "file",
234        },
235      }),
236    });
237    vi.stubGlobal("fetch", fetchMock);
238
239    const client = createTestQueryClient();
240    const invalidateSpy = vi.spyOn(client, "invalidateQueries");
241    const { result } = renderHook(() => usePasteFileEntry(), {
242      wrapper: createWrapper(client),
243    });
244
245    await act(async () => {
246      await result.current.mutateAsync({
247        sourcePath: "Media/photo.jpg",
248        destinationPath: "Documents",
249        operation: "copy",
250      });
251    });
252
253    expect(fetchMock).toHaveBeenCalledWith("/api/v1/files/ops", {
254      method: "POST",
255      headers: {
256        "Content-Type": "application/json",
257      },
258      body: JSON.stringify({
259        action: "paste",
260        sourcePath: "Media/photo.jpg",
261        destinationPath: "Documents",
262        operation: "copy",
263      }),
264    });
265    expect(invalidateSpy).toHaveBeenCalledWith({
266      queryKey: ["files", "list", "Documents"],
267    });
268    expect(invalidateSpy).toHaveBeenCalledWith({
269      queryKey: ["files", "list", "Media"],
270    });
271  });
272});
273