test: adjust unit tests

Author: adamrturman

src/core/components/ChatInput.tsx

@@ -86,8 +86,7 @@ const ChatInput = ({ setShouldAutoScroll }: ChatInputProps) => {
   const hasAvailableUploads = useAvailableUploads({
     uploadedFiles,
     maximumFileUploads,
-    setUploadingState,
-    resetUploadState,
+    setUploadError,
   });
 
   const buttonRef = useRef<HTMLButtonElement>(null);

src/core/hooks/useAvailableUploads.test.ts

@@ -3,6 +3,8 @@ import { useAvailableUploads } from './useAvailableUploads';
 import { renderHook } from '@testing-library/react';
 
 describe('useAvailableUploads', () => {
+  const setUploadError = vi.fn();
+
   beforeEach(() => {
     vi.useFakeTimers();
   });
@@ -13,30 +15,24 @@ describe('useAvailableUploads', () => {
     vi.useRealTimers();
   });
 
-  it('should return a function that returns true when imageIDs length is less than maximumFileUploads', () => {
-    const setUploadingState = vi.fn();
-    const resetUploadState = vi.fn();
-
+  it('no error when imageIDs length is less than maximumFileUploads', () => {
     const { result } = renderHook(() =>
       useAvailableUploads({
         uploadedFiles: [
           { id: 'image1', fileName: 'mock 1', fileType: 'image/png' },
           { id: 'image2', fileName: 'mock2', fileType: 'image/png' },
         ],
         maximumFileUploads: 4,
-        setUploadingState,
-        resetUploadState,
+        setUploadError,
       }),
     );
 
     expect(result.current()).toBe(true);
-    expect(setUploadingState).not.toHaveBeenCalled();
-    expect(resetUploadState).not.toHaveBeenCalled();
+    expect(setUploadError).not.toHaveBeenCalled();
   });
 
-  it('should return a function that returns false and sets error state when imageIDs length equals maximumFileUploads', () => {
-    const setUploadingState = vi.fn();
-    const resetUploadState = vi.fn();
+  it('sets error state when imageIDs length equals maximumFileUploads', () => {
+    const setUploadError = vi.fn();
 
     const { result } = renderHook(() =>
       useAvailableUploads({
@@ -47,23 +43,15 @@ describe('useAvailableUploads', () => {
           { id: 'image4', fileName: 'mock 4', fileType: 'image/png' },
         ],
         maximumFileUploads: 4,
-        setUploadingState,
-        resetUploadState,
+        setUploadError,
       }),
     );
 
     expect(result.current()).toBe(false);
-    expect(setUploadingState).toHaveBeenCalledWith({
-      isActive: true,
-      isSupportedFile: false,
-      errorMessage: 'Maximum 4 files allowed!',
-    });
+    expect(setUploadError).toHaveBeenCalledWith('Maximum 4 files allowed!');
   });
 
-  it('should return a function that returns false and sets error state when imageIDs length exceeds maximumFileUploads', () => {
-    const setUploadingState = vi.fn();
-    const resetUploadState = vi.fn();
-
+  it('sets error state when imageIDs length exceeds maximumFileUploads', () => {
     const { result } = renderHook(() =>
       useAvailableUploads({
         uploadedFiles: [
@@ -74,50 +62,15 @@ describe('useAvailableUploads', () => {
           { id: 'image5', fileName: 'mock 5', fileType: 'image/png' },
         ],
         maximumFileUploads: 4,
-        setUploadingState,
-        resetUploadState,
+        setUploadError,
       }),
     );
 
     expect(result.current()).toBe(false);
-    expect(setUploadingState).toHaveBeenCalledWith({
-      isActive: true,
-      isSupportedFile: false,
-      errorMessage: 'Maximum 4 files allowed!',
-    });
-  });
-
-  it('should call resetUploadState after timeout when exceeding maximumFileUploads', () => {
-    const setUploadingState = vi.fn();
-    const resetUploadState = vi.fn();
-
-    const { result } = renderHook(() =>
-      useAvailableUploads({
-        uploadedFiles: [
-          { id: 'image1', fileName: 'mock 1', fileType: 'image/png' },
-          { id: 'image2', fileName: 'mock 2', fileType: 'image/png' },
-          { id: 'image3', fileName: 'mock 3', fileType: 'image/png' },
-          { id: 'image4', fileName: 'mock 4', fileType: 'image/png' },
-          { id: 'image5', fileName: 'mock 5', fileType: 'image/png' },
-        ],
-        maximumFileUploads: 4,
-        setUploadingState,
-        resetUploadState,
-      }),
-    );
-
-    result.current();
-
-    expect(resetUploadState).not.toHaveBeenCalled();
-
-    vi.advanceTimersByTime(2000);
-
-    expect(resetUploadState).toHaveBeenCalledTimes(1);
+    expect(setUploadError).toHaveBeenCalledWith('Maximum 4 files allowed!');
   });
 
   it('should update error message based on maximumFileUploads value', () => {
-    const setUploadingState = vi.fn();
-    const resetUploadState = vi.fn();
     const customMaxUploads = 2;
 
     const { result } = renderHook(() =>
@@ -127,36 +80,28 @@ describe('useAvailableUploads', () => {
           { id: 'image2', fileName: 'mock 2', fileType: 'image/png' },
         ],
         maximumFileUploads: customMaxUploads,
-        setUploadingState,
-        resetUploadState,
+        setUploadError,
       }),
     );
 
     result.current();
 
-    expect(setUploadingState).toHaveBeenCalledWith({
-      isActive: true,
-      isSupportedFile: false,
-      errorMessage: `Maximum ${customMaxUploads} files allowed!`,
-    });
+    expect(setUploadError).toHaveBeenCalledWith(
+      `Maximum ${customMaxUploads} files allowed!`,
+    );
   });
 
   it('should handle different input scenarios correctly', () => {
-    const setUploadingState = vi.fn();
-    const resetUploadState = vi.fn();
-
     let { result } = renderHook(() =>
       useAvailableUploads({
         uploadedFiles: [],
         maximumFileUploads: 4,
-        setUploadingState,
-        resetUploadState,
+        setUploadError,
       }),
     );
     expect(result.current()).toBe(true);
 
-    setUploadingState.mockClear();
-    resetUploadState.mockClear();
+    setUploadError.mockClear();
 
     result = renderHook(() =>
       useAvailableUploads({
@@ -167,25 +112,22 @@ describe('useAvailableUploads', () => {
           { id: 'image4', fileName: 'mock 4', fileType: 'image/png' },
         ],
         maximumFileUploads: 4,
-        setUploadingState,
-        resetUploadState,
+        setUploadError,
       }),
     ).result;
     expect(result.current()).toBe(false);
-    expect(setUploadingState).toHaveBeenCalled();
+    expect(setUploadError).toHaveBeenCalled();
 
-    setUploadingState.mockClear();
-    resetUploadState.mockClear();
+    setUploadError.mockClear();
 
     result = renderHook(() =>
       useAvailableUploads({
         uploadedFiles: [],
         maximumFileUploads: 0,
-        setUploadingState,
-        resetUploadState,
+        setUploadError,
       }),
     ).result;
     expect(result.current()).toBe(false);
-    expect(setUploadingState).toHaveBeenCalled();
+    expect(setUploadError).toHaveBeenCalled();
   });
 });

src/core/hooks/useAvailableUploads.ts

@@ -1,11 +1,10 @@
-import type { FileUpload, UploadingState } from '../components/ChatInput';
-import { Dispatch, SetStateAction, useCallback } from 'react';
+import type { FileUpload } from '../components/ChatInput';
+import { useCallback } from 'react';
 
 interface UseAvailableUploadsParams {
   uploadedFiles: FileUpload[];
   maximumFileUploads: number;
-  setUploadingState: Dispatch<SetStateAction<UploadingState>>;
-  resetUploadState: () => void;
+  setUploadError: (errorMessage: string) => void;
 }
 
 /**
@@ -22,28 +21,14 @@ interface UseAvailableUploadsParams {
 export const useAvailableUploads = ({
   uploadedFiles,
   maximumFileUploads,
-  setUploadingState,
-  resetUploadState,
+  setUploadError,
 }: UseAvailableUploadsParams): (() => boolean) => {
   return useCallback((): boolean => {
     if (uploadedFiles.length >= maximumFileUploads) {
-      setUploadingState({
-        isActive: true,
-        isSupportedFile: false,
-        errorMessage: `Maximum ${maximumFileUploads} files allowed!`,
-      });
-
-      setTimeout(() => {
-        resetUploadState();
-      }, 2000);
+      setUploadError(`Maximum ${maximumFileUploads} files allowed!`);
 
       return false;
     }
     return true;
-  }, [
-    uploadedFiles.length,
-    maximumFileUploads,
-    setUploadingState,
-    resetUploadState,
-  ]);
+  }, [uploadedFiles.length, maximumFileUploads, setUploadError]);
 };