Skip to content

πŸ™Œ OpenHands: AI-Driven Development

test: cover chat attachment hooks (#17291)

aivong-openhands46def9cd3160
diff --git a/__tests__/hooks/chat/use-chat-attachment-upload.test.tsx b/__tests__/hooks/chat/use-chat-attachment-upload.test.tsx
new file mode 100644
index 0000000000..0120c315e4
--- /dev/null
+++ b/__tests__/hooks/chat/use-chat-attachment-upload.test.tsx
@@ -0,0 +1,189 @@
+import { act, renderHook } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import { useChatAttachmentUpload } from "#/hooks/chat/use-chat-attachment-upload";
+
+const {
+ validateFilesMock,
+ processFilesMock,
+ processImagesMock,
+ displayErrorToastMock,
+ store,
+} = vi.hoisted(() => ({
+ validateFilesMock: vi.fn(),
+ processFilesMock: vi.fn(),
+ processImagesMock: vi.fn(),
+ displayErrorToastMock: vi.fn(),
+ store: {
+ images: [] as File[],
+ files: [] as File[],
+ addImages: vi.fn(),
+ addFiles: vi.fn(),
+ addFileLoading: vi.fn(),
+ removeFileLoading: vi.fn(),
+ addImageLoading: vi.fn(),
+ removeImageLoading: vi.fn(),
+ markImagesAsPasted: vi.fn(),
+ },
+}));
+
+vi.mock("#/utils/file-validation", () => ({
+ validateFiles: (...args: unknown[]) => validateFilesMock(...args),
+}));
+
+vi.mock("#/utils/file-processing", () => ({
+ processFiles: (...args: unknown[]) => processFilesMock(...args),
+ processImages: (...args: unknown[]) => processImagesMock(...args),
+}));
+
+vi.mock("#/utils/custom-toast-handlers", () => ({
+ displayErrorToast: (...args: unknown[]) => displayErrorToastMock(...args),
+}));
+
+vi.mock("#/stores/conversation-store", () => ({
+ useConversationStore: () => store,
+}));
+
+const createFile = (name: string, type: string) =>
+ new File([`${name} content`], name, { type });
+
+const setupMocks = () => {
+ vi.clearAllMocks();
+ store.images = [];
+ store.files = [];
+ validateFilesMock.mockReturnValue({ isValid: true });
+ processFilesMock.mockResolvedValue({ successful: [], failed: [] });
+ processImagesMock.mockResolvedValue({ successful: [], failed: [] });
+};
+
+describe("chat attachment upload", () => {
+ it("rejects invalid selections against all existing attachments", async () => {
+ setupMocks();
+ const existingImage = createFile("existing.png", "image/png");
+ const existingFile = createFile("existing.txt", "text/plain");
+ const selected = createFile("too-large.txt", "text/plain");
+ store.images = [existingImage];
+ store.files = [existingFile];
+ validateFilesMock.mockReturnValue({
+ isValid: false,
+ errorMessage: "Total size exceeds 3MB",
+ });
+ const { result } = renderHook(() => useChatAttachmentUpload());
+
+ await act(async () => result.current.handleUpload([selected]));
+
+ expect(validateFilesMock).toHaveBeenCalledWith(
+ [selected],
+ [existingImage, existingFile],
+ );
+ expect(displayErrorToastMock).toHaveBeenCalledWith(
+ "Error: Total size exceeds 3MB",
+ );
+ expect(processFilesMock).not.toHaveBeenCalled();
+ expect(processImagesMock).not.toHaveBeenCalled();
+ expect(store.addFileLoading).not.toHaveBeenCalled();
+ });
+
+ it("processes mixed files and images and publishes successful attachments", async () => {
+ setupMocks();
+ const textFile = createFile("notes.txt", "text/plain");
+ const image = createFile("diagram.png", "image/png");
+ processFilesMock.mockResolvedValue({
+ successful: [textFile],
+ failed: [],
+ });
+ processImagesMock.mockResolvedValue({
+ successful: [image],
+ failed: [],
+ });
+ const { result } = renderHook(() => useChatAttachmentUpload());
+
+ await act(async () =>
+ result.current.handleUpload([textFile, image], { fromPaste: true }),
+ );
+
+ expect(store.markImagesAsPasted).toHaveBeenCalledWith(["diagram.png"]);
+ expect(store.addFileLoading).toHaveBeenCalledWith("notes.txt");
+ expect(store.addImageLoading).toHaveBeenCalledWith("diagram.png");
+ expect(processFilesMock).toHaveBeenCalledWith([textFile]);
+ expect(processImagesMock).toHaveBeenCalledWith([image]);
+ expect(store.addFiles).toHaveBeenCalledWith([textFile]);
+ expect(store.addImages).toHaveBeenCalledWith([image]);
+ expect(store.removeFileLoading).toHaveBeenCalledWith("notes.txt");
+ expect(store.removeImageLoading).toHaveBeenCalledWith("diagram.png");
+ expect(displayErrorToastMock).not.toHaveBeenCalled();
+ });
+
+ it("reports individual file and image processing failures", async () => {
+ setupMocks();
+ const textFile = createFile("broken.txt", "text/plain");
+ const image = createFile("broken.png", "image/png");
+ processFilesMock.mockResolvedValue({
+ successful: [],
+ failed: [{ file: textFile, error: new Error("cannot read text") }],
+ });
+ processImagesMock.mockResolvedValue({
+ successful: [],
+ failed: [{ file: image, error: new Error("cannot decode image") }],
+ });
+ const { result } = renderHook(() => useChatAttachmentUpload());
+
+ await act(async () => result.current.handleUpload([textFile, image]));
+
+ expect(store.addFiles).not.toHaveBeenCalled();
+ expect(store.addImages).not.toHaveBeenCalled();
+ expect(store.removeFileLoading).toHaveBeenCalledWith("broken.txt");
+ expect(store.removeImageLoading).toHaveBeenCalledWith("broken.png");
+ expect(displayErrorToastMock).toHaveBeenCalledWith(
+ "Failed to process file broken.txt: cannot read text",
+ );
+ expect(displayErrorToastMock).toHaveBeenCalledWith(
+ "Failed to process image broken.png: cannot decode image",
+ );
+ });
+
+ it("cleans every loading marker when processing rejects unexpectedly", async () => {
+ setupMocks();
+ const textFile = createFile("notes.txt", "text/plain");
+ const image = createFile("diagram.png", "image/png");
+ processFilesMock.mockRejectedValue(new Error("worker crashed"));
+ const { result } = renderHook(() => useChatAttachmentUpload());
+
+ await act(async () => result.current.handleUpload([textFile, image]));
+
+ expect(store.removeFileLoading).toHaveBeenCalledWith("notes.txt");
+ expect(store.removeImageLoading).toHaveBeenCalledWith("diagram.png");
+ expect(displayErrorToastMock).toHaveBeenCalledWith(
+ "An unexpected error occurred while processing files",
+ );
+ });
+
+ it("handles a regular-file-only selection without marking pasted images", async () => {
+ setupMocks();
+ const textFile = createFile("notes.txt", "text/plain");
+ processFilesMock.mockResolvedValue({ successful: [textFile], failed: [] });
+ const { result } = renderHook(() => useChatAttachmentUpload());
+
+ await act(async () => result.current.handleUpload([textFile]));
+
+ expect(store.markImagesAsPasted).not.toHaveBeenCalled();
+ expect(processFilesMock).toHaveBeenCalledWith([textFile]);
+ expect(processImagesMock).toHaveBeenCalledWith([]);
+ expect(store.addFiles).toHaveBeenCalledWith([textFile]);
+ });
+
+ it("validates against the latest attachments after rerender", async () => {
+ setupMocks();
+ const selected = createFile("selected.txt", "text/plain");
+ const latestExisting = createFile("latest.txt", "text/plain");
+ const { result, rerender } = renderHook(() => useChatAttachmentUpload());
+
+ store.files = [latestExisting];
+ rerender();
+ await act(async () => result.current.handleUpload([selected]));
+
+ expect(validateFilesMock).toHaveBeenCalledWith(
+ [selected],
+ [latestExisting],
+ );
+ });
+});
diff --git a/__tests__/hooks/chat/use-file-handling.test.tsx b/__tests__/hooks/chat/use-file-handling.test.tsx
new file mode 100644
index 0000000000..c58fd39743
--- /dev/null
+++ b/__tests__/hooks/chat/use-file-handling.test.tsx
@@ -0,0 +1,247 @@
+import { act, renderHook } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { ChangeEvent, DragEvent as ReactDragEvent } from "react";
+import { useFileHandling } from "#/hooks/chat/use-file-handling";
+
+const createFile = (name: string) =>
+ new File([`${name} contents`], name, { type: "text/plain" });
+
+const createDragEvent = ({
+ files = [],
+ relatedTarget = null,
+}: {
+ files?: File[];
+ relatedTarget?: EventTarget | null;
+} = {}) =>
+ ({
+ preventDefault: vi.fn(),
+ dataTransfer: { files },
+ relatedTarget,
+ }) as unknown as ReactDragEvent<HTMLDivElement>;
+
+afterEach(() => {
+ document.body.replaceChildren();
+ vi.restoreAllMocks();
+});
+
+describe("file handling", () => {
+ it("forwards pasted files with paste metadata and ignores empty paste events", () => {
+ const addEventListener = vi.spyOn(document, "addEventListener");
+ const onFilesPaste = vi.fn();
+ renderHook(() => useFileHandling(onFilesPaste));
+ const pastedFile = createFile("pasted.txt");
+
+ act(() => {
+ document.dispatchEvent(
+ new CustomEvent("pasteFiles", {
+ detail: { files: [pastedFile] },
+ }),
+ );
+ document.dispatchEvent(
+ new CustomEvent("pasteFiles", { detail: { files: [] } }),
+ );
+ });
+
+ const pasteListener = addEventListener.mock.calls.find(
+ ([eventName]) => eventName === "pasteFiles",
+ )?.[1] as EventListener;
+ expect(() =>
+ act(() => {
+ pasteListener(
+ new CustomEvent("pasteFiles", { detail: { files: undefined } }),
+ );
+ }),
+ ).not.toThrow();
+
+ expect(onFilesPaste).toHaveBeenCalledOnce();
+ expect(onFilesPaste).toHaveBeenCalledWith([pastedFile], {
+ fromPaste: true,
+ });
+ });
+
+ it("removes its paste listener on unmount", () => {
+ const removeEventListener = vi.spyOn(document, "removeEventListener");
+ const onFilesPaste = vi.fn();
+ const { unmount } = renderHook(() => useFileHandling(onFilesPaste));
+
+ unmount();
+ document.dispatchEvent(
+ new CustomEvent("pasteFiles", {
+ detail: { files: [createFile("after-unmount.txt")] },
+ }),
+ );
+
+ expect(removeEventListener).toHaveBeenCalledWith(
+ "pasteFiles",
+ expect.any(Function),
+ );
+ expect(onFilesPaste).not.toHaveBeenCalled();
+ });
+
+ it("accepts paste events when no upload callback is configured", () => {
+ renderHook(() => useFileHandling());
+
+ expect(() => {
+ act(() => {
+ document.dispatchEvent(
+ new CustomEvent("pasteFiles", {
+ detail: { files: [createFile("unhandled.txt")] },
+ }),
+ );
+ });
+ }).not.toThrow();
+ });
+
+ it("opens the file chooser only when uploads are enabled and the input is mounted", () => {
+ const { result } = renderHook(() => useFileHandling());
+ const input = document.createElement("input");
+ const click = vi.spyOn(input, "click");
+
+ act(() => result.current.handleFileIconClick(false));
+ expect(click).not.toHaveBeenCalled();
+
+ result.current.fileInputRef.current = input;
+ act(() => result.current.handleFileIconClick(true));
+ expect(click).not.toHaveBeenCalled();
+
+ act(() => result.current.handleFileIconClick(false));
+ expect(click).toHaveBeenCalledOnce();
+ });
+
+ it("forwards selected input files and ignores a cleared input", () => {
+ const onFilesPaste = vi.fn();
+ const { result } = renderHook(() => useFileHandling(onFilesPaste));
+ const selectedFile = createFile("selected.txt");
+
+ act(() => {
+ result.current.handleFileInputChange({
+ target: { files: [selectedFile] },
+ } as unknown as ChangeEvent<HTMLInputElement>);
+ });
+ expect(onFilesPaste).toHaveBeenCalledWith([selectedFile], undefined);
+
+ act(() => {
+ result.current.handleFileInputChange({
+ target: { files: null },
+ } as unknown as ChangeEvent<HTMLInputElement>);
+ });
+ expect(onFilesPaste).toHaveBeenCalledOnce();
+ });
+
+ it("shows drag feedback only for enabled uploads", () => {
+ const { result } = renderHook(() => useFileHandling());
+ const disabledEvent = createDragEvent();
+
+ act(() => result.current.handleDragOver(disabledEvent, true));
+ expect(disabledEvent.preventDefault).not.toHaveBeenCalled();
+ expect(result.current.isDragOver).toBe(false);
+
+ const enabledEvent = createDragEvent();
+ act(() => result.current.handleDragOver(enabledEvent, false));
+ expect(enabledEvent.preventDefault).toHaveBeenCalledOnce();
+ expect(result.current.isDragOver).toBe(true);
+ });
+
+ it("keeps drag feedback while disabled or moving within the chat container", () => {
+ const { result } = renderHook(() => useFileHandling());
+ const container = document.createElement("div");
+ const child = document.createElement("span");
+ container.appendChild(child);
+ result.current.chatContainerRef.current = container;
+
+ act(() => result.current.handleDragOver(createDragEvent(), false));
+
+ const disabledEvent = createDragEvent();
+ act(() => result.current.handleDragLeave(disabledEvent, true));
+ expect(disabledEvent.preventDefault).not.toHaveBeenCalled();
+ expect(result.current.isDragOver).toBe(true);
+
+ const internalEvent = createDragEvent({ relatedTarget: child });
+ act(() => result.current.handleDragLeave(internalEvent, false));
+ expect(internalEvent.preventDefault).not.toHaveBeenCalled();
+ expect(result.current.isDragOver).toBe(true);
+ });
+
+ it("clears drag feedback when the pointer leaves the container or no container is mounted", () => {
+ const { result } = renderHook(() => useFileHandling());
+ const container = document.createElement("div");
+ const outside = document.createElement("div");
+ result.current.chatContainerRef.current = container;
+
+ act(() => result.current.handleDragOver(createDragEvent(), false));
+ const outsideEvent = createDragEvent({ relatedTarget: outside });
+ act(() => result.current.handleDragLeave(outsideEvent, false));
+ expect(outsideEvent.preventDefault).toHaveBeenCalledOnce();
+ expect(result.current.isDragOver).toBe(false);
+
+ act(() => result.current.handleDragOver(createDragEvent(), false));
+ result.current.chatContainerRef.current = null;
+ const unmountedEvent = createDragEvent({ relatedTarget: outside });
+ act(() => result.current.handleDragLeave(unmountedEvent, false));
+ expect(unmountedEvent.preventDefault).toHaveBeenCalledOnce();
+ expect(result.current.isDragOver).toBe(false);
+ });
+
+ it("ignores disabled drops without changing active drag feedback", () => {
+ const onFilesPaste = vi.fn();
+ const { result } = renderHook(() => useFileHandling(onFilesPaste));
+ act(() => result.current.handleDragOver(createDragEvent(), false));
+ const dropEvent = createDragEvent({ files: [createFile("ignored.txt")] });
+
+ act(() => result.current.handleDrop(dropEvent, true));
+
+ expect(dropEvent.preventDefault).not.toHaveBeenCalled();
+ expect(onFilesPaste).not.toHaveBeenCalled();
+ expect(result.current.isDragOver).toBe(true);
+ });
+
+ it("forwards enabled drops and always clears drag feedback", () => {
+ const onFilesPaste = vi.fn();
+ const { result } = renderHook(() => useFileHandling(onFilesPaste));
+ const droppedFile = createFile("dropped.txt");
+ act(() => result.current.handleDragOver(createDragEvent(), false));
+ const dropEvent = createDragEvent({ files: [droppedFile] });
+
+ act(() => result.current.handleDrop(dropEvent, false));
+
+ expect(dropEvent.preventDefault).toHaveBeenCalledOnce();
+ expect(onFilesPaste).toHaveBeenCalledWith([droppedFile], undefined);
+ expect(result.current.isDragOver).toBe(false);
+
+ act(() => result.current.handleDragOver(createDragEvent(), false));
+ const emptyDropEvent = createDragEvent();
+ act(() => result.current.handleDrop(emptyDropEvent, false));
+ expect(emptyDropEvent.preventDefault).toHaveBeenCalledOnce();
+ expect(onFilesPaste).toHaveBeenCalledOnce();
+ expect(result.current.isDragOver).toBe(false);
+ });
+
+ it("uses the latest upload callback for paste, input, and drop after rerender", () => {
+ const firstCallback = vi.fn();
+ const latestCallback = vi.fn();
+ const { result, rerender } = renderHook(
+ ({ callback }) => useFileHandling(callback),
+ { initialProps: { callback: firstCallback } },
+ );
+ const file = createFile("latest.txt");
+
+ rerender({ callback: latestCallback });
+ act(() => {
+ document.dispatchEvent(
+ new CustomEvent("pasteFiles", { detail: { files: [file] } }),
+ );
+ result.current.handleFileInputChange({
+ target: { files: [file] },
+ } as unknown as ChangeEvent<HTMLInputElement>);
+ result.current.handleDrop(createDragEvent({ files: [file] }), false);
+ });
+
+ expect(firstCallback).not.toHaveBeenCalled();
+ expect(latestCallback).toHaveBeenCalledTimes(3);
+ expect(latestCallback).toHaveBeenNthCalledWith(1, [file], {
+ fromPaste: true,
+ });
+ expect(latestCallback).toHaveBeenNthCalledWith(2, [file], undefined);
+ expect(latestCallback).toHaveBeenNthCalledWith(3, [file], undefined);
+ });
+});