π 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.tsxnew file mode 100644index 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.tsxnew file mode 100644index 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);+ });+});