@devries-cameron20 / t3code Mirror · read-only
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 04:45 UTC

main
tsx 109 lines 4.24 KB
Raw
1 import { act, render, type Screen } from "../../../test/render";
2 import { expect, it, vi } from "vite-plus/test";
3 import { AttachmentImage } from "./AttachmentImage";
4 import { decodeImagePreview } from "../files/decodeImagePreview";
5
6 vi.mock("../files/decodeImagePreview", () => ({
7 decodeImagePreview: vi.fn(),
8 }));
9
10 const revokeUrl = vi.fn();
11 const bitmap = new Blob(["png"], { type: "image/png" });
12
13 function setup() {
14 revokeUrl.mockReset();
15 vi.mocked(decodeImagePreview).mockReset().mockResolvedValue(bitmap);
16 }
17
18 function image(screen: Screen) {
19 const img = screen.container.querySelector("img");
20 expect(img).not.toBeNull();
21 return img!;
22 }
23
24 // Stands in for the browser failing to decode the current source.
25 async function failDecode(screen: Screen) {
26 const img = image(screen);
27 await act(() => {
28 img.dispatchEvent(new Event("error"));
29 });
30 await act(() => vi.dynamicImportSettled());
31 return img;
32 }
33
34 function expectDecodeErrorFor(onError: ReturnType<typeof vi.fn>, img: HTMLImageElement) {
35 expect(onError).toHaveBeenCalledWith(expect.objectContaining({ type: "error", target: img }));
36 }
37
38 it.each([
39 { name: "photo.HEIC", mimeType: undefined, heif: true },
40 { name: "photo.heif", mimeType: undefined, heif: true },
41 { name: "photo", mimeType: "image/heif", heif: true },
42 { name: "scan.TIFF", mimeType: undefined, heif: false },
43 { name: "scan", mimeType: "image/tiff", heif: false },
44 ])(
45 "converts $name after native decoding fails and releases its preview",
46 async ({ name, mimeType, heif }) => {
47 setup();
48 using _createUrl = vi.spyOn(URL, "createObjectURL").mockReturnValue("blob:jpeg");
49 using _revokeUrl = vi.spyOn(URL, "revokeObjectURL").mockImplementation(revokeUrl);
50 await using screen = await render(
51 <AttachmentImage src="https://environment.test/photo" name={name} mimeType={mimeType} />,
52 );
53 expect(decodeImagePreview).not.toHaveBeenCalled();
54 await failDecode(screen);
55 expect(image(screen).getAttribute("src")).toBe("blob:jpeg");
56 expect(decodeImagePreview).toHaveBeenCalledWith(
57 "https://environment.test/photo",
58 heif,
59 expect.any(AbortSignal),
60 );
61 await screen.unmount();
62 expect(revokeUrl).toHaveBeenCalledWith("blob:jpeg");
63 },
64 );
65
66 it("leaves PNG errors to the caller without fetching or converting", async () => {
67 setup();
68 using _createUrl = vi.spyOn(URL, "createObjectURL").mockReturnValue("blob:jpeg");
69 using _revokeUrl = vi.spyOn(URL, "revokeObjectURL").mockImplementation(revokeUrl);
70 const onError = vi.fn();
71 await using screen = await render(
72 <AttachmentImage src="blob:png" name="photo.png" onError={onError} />,
73 );
74 expectDecodeErrorFor(onError, await failDecode(screen));
75 expect(decodeImagePreview).not.toHaveBeenCalled();
76 });
77
78 it("reports failed HEIC conversion through the existing error handler", async () => {
79 setup();
80 using _createUrl = vi.spyOn(URL, "createObjectURL").mockReturnValue("blob:jpeg");
81 using _revokeUrl = vi.spyOn(URL, "revokeObjectURL").mockImplementation(revokeUrl);
82 const onError = vi.fn();
83 vi.mocked(decodeImagePreview).mockRejectedValue(new Error("unreadable"));
84 await using screen = await render(
85 <AttachmentImage src="blob:heic" name="photo.heif" onError={onError} />,
86 );
87 expectDecodeErrorFor(onError, await failDecode(screen));
88 expect(URL.createObjectURL).not.toHaveBeenCalled();
89 });
90
91 it("discards an old decode when navigating to a different source", async () => {
92 setup();
93 using _createUrl = vi.spyOn(URL, "createObjectURL").mockReturnValue("blob:jpeg");
94 using _revokeUrl = vi.spyOn(URL, "revokeObjectURL").mockImplementation(revokeUrl);
95 let finishDecode!: (result: Blob) => void;
96 vi.mocked(decodeImagePreview).mockReturnValue(
97 new Promise((resolve) => {
98 finishDecode = resolve;
99 }),
100 );
101 await using screen = await render(<AttachmentImage src="blob:first" name="photo.heic" />);
102 await failDecode(screen);
103 const secondSource = "data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg'/>";
104 await screen.rerender(<AttachmentImage src={secondSource} name="photo.heic" />);
105 await act(() => finishDecode(bitmap));
106 expect(image(screen).getAttribute("src")).toBe(secondSource);
107 expect(URL.createObjectURL).not.toHaveBeenCalled();
108 expect(vi.mocked(decodeImagePreview).mock.calls[0]?.[2].aborted).toBe(true);
109 });