@jmruthers/pace-core 0.5.67 → 0.5.69

package/src/hooks/__tests__/useStorage.unit.test.ts

@@ -0,0 +1,751 @@
+import { renderHook, act, waitFor } from '@testing-library/react';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { useStorage, useFileUpload } from '../useStorage';
+import { SupabaseClient } from '@supabase/supabase-js';
+
+// Mock the storage utilities
+vi.mock('../../utils/storage', () => ({
+  uploadFile: vi.fn(),
+  getPublicUrl: vi.fn(),
+  getSignedUrl: vi.fn(),
+  deleteFile: vi.fn(),
+  listFiles: vi.fn(),
+  archiveFile: vi.fn(),
+}));
+
+import {
+  uploadFile,
+  getPublicUrl,
+  getSignedUrl,
+  deleteFile,
+  listFiles,
+  archiveFile,
+} from '../../utils/storage';
+
+// Mock Supabase client
+const mockSupabase = {
+  storage: {
+    from: vi.fn(() => ({
+      upload: vi.fn(),
+      getPublicUrl: vi.fn(),
+      createSignedUrl: vi.fn(),
+      remove: vi.fn(),
+      list: vi.fn(),
+    })),
+  },
+} as unknown as SupabaseClient;
+
+const mockFile = new File(['test content'], 'test.txt', { type: 'text/plain' });
+
+describe('useStorage Hook', () => {
+  const defaultProps = {
+    supabase: mockSupabase,
+    appName: 'test-app',
+    orgId: 'test-org',
+  };
+
+    describe('Initial State', () => {
+    it('should initialize with correct default values', () => {
+      const { result } = renderHook(() => useStorage(defaultProps));
+
+      expect(result.current.isUploading).toBe(false);
+      expect(result.current.uploadError).toBe(null);
+      expect(result.current.isListing).toBe(false);
+      expect(result.current.listError).toBe(null);
+      expect(result.current.files).toEqual([]);
+      expect(result.current.isLoading).toBe(false);
+      expect(result.current.error).toBe(null);
+    });
+
+    it('should provide all required functions', () => {
+      const { result } = renderHook(() => useStorage(defaultProps));
+
+      expect(typeof result.current.uploadFile).toBe('function');
+      expect(typeof result.current.getPublicUrl).toBe('function');
+      expect(typeof result.current.getSignedUrl).toBe('function');
+      expect(typeof result.current.getFileUrl).toBe('function');
+      expect(typeof result.current.deleteFile).toBe('function');
+      expect(typeof result.current.archiveFile).toBe('function');
+      expect(typeof result.current.listFiles).toBe('function');
+      expect(typeof result.current.refreshFiles).toBe('function');
+    });
+  });
+
+  describe('File Upload', () => {
+    it('should handle successful file upload', async () => {
+      const mockUploadResult = {
+        success: true,
+        path: 'test-org/files/test-file.txt',
+        publicUrl: 'https://example.com/test-file.txt',
+        metadata: {
+          mimeType: 'text/plain',
+          size: 1024,
+          orgId: 'test-org',
+          appName: 'test-app',
+          uploadedBy: 'user-1',
+          uploadedAt: '2024-01-01T00:00:00Z',
+          isPublic: false,
+        },
+      };
+
+      const mockListResult = {
+        files: [
+          {
+            name: 'test-file.txt',
+            path: 'test-org/files/test-file.txt',
+            size: 1024,
+            mimeType: 'text/plain',
+            lastModified: '2024-01-01T00:00:00Z',
+            metadata: mockUploadResult.metadata,
+          },
+        ],
+        totalCount: 1,
+        hasMore: false,
+      };
+
+      vi.mocked(uploadFile).mockResolvedValue(mockUploadResult);
+      vi.mocked(listFiles).mockResolvedValue(mockListResult);
+
+      const { result } = renderHook(() => useStorage(defaultProps));
+
+      let uploadResult: any;
+      await act(async () => {
+        uploadResult = await result.current.uploadFile(mockFile);
+      });
+
+      expect(uploadResult).toEqual(mockUploadResult);
+      expect(result.current.isUploading).toBe(false);
+      expect(result.current.uploadError).toBe(null);
+      expect(result.current.files).toEqual(mockListResult.files);
+      expect(uploadFile).toHaveBeenCalledWith(mockSupabase, mockFile, {
+        appName: 'test-app',
+        orgId: 'test-org',
+        isPublic: false,
+      });
+    });
+
+    it('should handle upload failure', async () => {
+      const mockUploadResult = {
+        success: false,
+        error: 'Upload failed: File too large',
+      };
+
+      vi.mocked(uploadFile).mockResolvedValue(mockUploadResult);
+
+      const { result } = renderHook(() => useStorage(defaultProps));
+
+      let uploadResult: any;
+      await act(async () => {
+        uploadResult = await result.current.uploadFile(mockFile);
+      });
+
+      expect(uploadResult).toEqual(mockUploadResult);
+      expect(result.current.isUploading).toBe(false);
+      expect(result.current.uploadError).toBe('Upload failed: File too large');
+    });
+
+    it('should handle upload with custom options', async () => {
+      const mockUploadResult = {
+        success: true,
+        path: 'test-org/custom/test-file.txt',
+      };
+
+      vi.mocked(uploadFile).mockResolvedValue(mockUploadResult);
+      vi.mocked(listFiles).mockResolvedValue({ files: [], totalCount: 0, hasMore: false });
+
+      const { result } = renderHook(() => useStorage(defaultProps));
+
+      const customOptions = {
+        isPublic: true,
+        tags: ['important'],
+        customPath: 'custom',
+        metadata: { category: 'documents' },
+      };
+
+      await act(async () => {
+        await result.current.uploadFile(mockFile, customOptions);
+      });
+
+      expect(uploadFile).toHaveBeenCalledWith(mockSupabase, mockFile, {
+        appName: 'test-app',
+        orgId: 'test-org',
+        isPublic: true,
+        tags: ['important'],
+        customPath: 'custom',
+        metadata: { category: 'documents' },
+      });
+    });
+
+    it('should handle upload exception', async () => {
+      vi.mocked(uploadFile).mockRejectedValue(new Error('Network error'));
+
+      const { result } = renderHook(() => useStorage(defaultProps));
+
+      let uploadResult: any;
+      await act(async () => {
+        uploadResult = await result.current.uploadFile(mockFile);
+      });
+
+      expect(uploadResult).toEqual({
+        success: false,
+        error: 'Network error',
+      });
+      expect(result.current.isUploading).toBe(false);
+      expect(result.current.uploadError).toBe('Network error');
+    });
+
+    it('should handle upload exception with non-Error object', async () => {
+      vi.mocked(uploadFile).mockRejectedValue('String error');
+
+      const { result } = renderHook(() => useStorage(defaultProps));
+
+      let uploadResult: any;
+      await act(async () => {
+        uploadResult = await result.current.uploadFile(mockFile);
+      });
+
+      expect(uploadResult).toEqual({
+        success: false,
+        error: 'Upload failed',
+      });
+      expect(result.current.uploadError).toBe('Upload failed');
+    });
+  });
+
+  describe('URL Generation', () => {
+    it('should get public URL', () => {
+      const mockUrl = 'https://example.com/public/test-file.txt';
+      vi.mocked(getPublicUrl).mockReturnValue(mockUrl);
+
+      const { result } = renderHook(() => useStorage(defaultProps));
+
+      const url = result.current.getPublicUrl('test-org/public/test-file.txt');
+
+      expect(url).toBe(mockUrl);
+      expect(getPublicUrl).toHaveBeenCalledWith(mockSupabase, 'test-org/public/test-file.txt');
+    });
+
+    it('should get file URL (alias for getPublicUrl)', () => {
+      const mockUrl = 'https://example.com/public/test-file.txt';
+      vi.mocked(getPublicUrl).mockReturnValue(mockUrl);
+
+      const { result } = renderHook(() => useStorage(defaultProps));
+
+      const url = result.current.getFileUrl('test-org/public/test-file.txt');
+
+      expect(url).toBe(mockUrl);
+      expect(getPublicUrl).toHaveBeenCalledWith(mockSupabase, 'test-org/public/test-file.txt');
+    });
+
+    it('should get signed URL successfully', async () => {
+      const mockSignedUrl = {
+        url: 'https://example.com/signed/test-file.txt',
+        expiresAt: '2024-01-01T01:00:00Z',
+      };
+
+      vi.mocked(getSignedUrl).mockResolvedValue(mockSignedUrl);
+
+      const { result } = renderHook(() => useStorage(defaultProps));
+
+      let signedUrl: string | null = null;
+      await act(async () => {
+        signedUrl = await result.current.getSignedUrl('test-org/files/test-file.txt', 3600);
+      });
+
+      expect(signedUrl).toBe('https://example.com/signed/test-file.txt');
+      expect(getSignedUrl).toHaveBeenCalledWith(mockSupabase, 'test-org/files/test-file.txt', {
+        appName: 'test-app',
+        orgId: 'test-org',
+        expiresIn: 3600,
+      });
+    });
+
+    it('should handle signed URL failure', async () => {
+      vi.mocked(getSignedUrl).mockRejectedValue(new Error('Signing failed'));
+
+      const { result } = renderHook(() => useStorage(defaultProps));
+
+      let signedUrl: string | null = null;
+      await act(async () => {
+        signedUrl = await result.current.getSignedUrl('test-org/files/test-file.txt');
+      });
+
+      expect(signedUrl).toBe(null);
+    });
+
+    it('should handle signed URL with null result', async () => {
+      vi.mocked(getSignedUrl).mockResolvedValue(null);
+
+      const { result } = renderHook(() => useStorage(defaultProps));
+
+      let signedUrl: string | null = null;
+      await act(async () => {
+        signedUrl = await result.current.getSignedUrl('test-org/files/test-file.txt');
+      });
+
+      expect(signedUrl).toBe(null);
+    });
+  });
+
+  describe('File Management', () => {
+    it('should delete file successfully', async () => {
+      const mockDeleteResult = { success: true };
+      const mockListResult = { files: [], totalCount: 0, hasMore: false };
+
+      vi.mocked(deleteFile).mockResolvedValue(mockDeleteResult);
+      vi.mocked(listFiles).mockResolvedValue(mockListResult);
+
+      const { result } = renderHook(() => useStorage(defaultProps));
+
+      let deleteResult: any;
+      await act(async () => {
+        deleteResult = await result.current.deleteFile('test-org/files/test-file.txt');
+      });
+
+      expect(deleteResult).toEqual(mockDeleteResult);
+      expect(deleteFile).toHaveBeenCalledWith(mockSupabase, 'test-org/files/test-file.txt');
+    });
+
+    it('should handle delete file failure', async () => {
+      const mockDeleteResult = { success: false, error: 'Delete failed' };
+
+      vi.mocked(deleteFile).mockResolvedValue(mockDeleteResult);
+
+      const { result } = renderHook(() => useStorage(defaultProps));
+
+      let deleteResult: any;
+      await act(async () => {
+        deleteResult = await result.current.deleteFile('test-org/files/test-file.txt');
+      });
+
+      expect(deleteResult).toEqual(mockDeleteResult);
+    });
+
+    it('should handle delete file exception', async () => {
+      vi.mocked(deleteFile).mockRejectedValue(new Error('Network error'));
+
+      const { result } = renderHook(() => useStorage(defaultProps));
+
+      let deleteResult: any;
+      await act(async () => {
+        deleteResult = await result.current.deleteFile('test-org/files/test-file.txt');
+      });
+
+      expect(deleteResult).toEqual({
+        success: false,
+        error: 'Network error',
+      });
+    });
+
+    it('should archive file successfully', async () => {
+      const mockArchiveResult = { success: true };
+      const mockListResult = { files: [], totalCount: 0, hasMore: false };
+
+      vi.mocked(archiveFile).mockResolvedValue(mockArchiveResult);
+      vi.mocked(listFiles).mockResolvedValue(mockListResult);
+
+      const { result } = renderHook(() => useStorage(defaultProps));
+
+      let archiveResult: any;
+      await act(async () => {
+        archiveResult = await result.current.archiveFile('test-org/files/test-file.txt');
+      });
+
+      expect(archiveResult).toEqual(mockArchiveResult);
+      expect(archiveFile).toHaveBeenCalledWith(mockSupabase, 'test-org/files/test-file.txt', {
+        appName: 'test-app',
+        orgId: 'test-org',
+      });
+    });
+
+    it('should handle archive file failure', async () => {
+      const mockArchiveResult = { success: false, error: 'Archive failed' };
+
+      vi.mocked(archiveFile).mockResolvedValue(mockArchiveResult);
+
+      const { result } = renderHook(() => useStorage(defaultProps));
+
+      let archiveResult: any;
+      await act(async () => {
+        archiveResult = await result.current.archiveFile('test-org/files/test-file.txt');
+      });
+
+      expect(archiveResult).toEqual(mockArchiveResult);
+    });
+
+    it('should handle archive file exception', async () => {
+      vi.mocked(archiveFile).mockRejectedValue(new Error('Network error'));
+
+      const { result } = renderHook(() => useStorage(defaultProps));
+
+      let archiveResult: any;
+      await act(async () => {
+        archiveResult = await result.current.archiveFile('test-org/files/test-file.txt');
+      });
+
+      expect(archiveResult).toEqual({
+        success: false,
+        error: 'Network error',
+      });
+    });
+  });
+
+  describe('File Listing', () => {
+    it('should list files successfully', async () => {
+      const mockListResult = {
+        files: [
+          {
+            name: 'test-file.txt',
+            path: 'test-org/files/test-file.txt',
+            size: 1024,
+            mimeType: 'text/plain',
+            lastModified: '2024-01-01T00:00:00Z',
+            metadata: {
+              mimeType: 'text/plain',
+              size: 1024,
+              orgId: 'test-org',
+              appName: 'test-app',
+              uploadedBy: 'user-1',
+              uploadedAt: '2024-01-01T00:00:00Z',
+              isPublic: false,
+            },
+          },
+        ],
+        totalCount: 1,
+        hasMore: false,
+      };
+
+      vi.mocked(listFiles).mockResolvedValue(mockListResult);
+
+      const { result } = renderHook(() => useStorage(defaultProps));
+
+      let listResult: any;
+      await act(async () => {
+        listResult = await result.current.listFiles();
+      });
+
+      expect(listResult).toEqual(mockListResult);
+      expect(result.current.files).toEqual(mockListResult.files);
+      expect(result.current.isListing).toBe(false);
+      expect(result.current.listError).toBe(null);
+      expect(listFiles).toHaveBeenCalledWith(mockSupabase, {
+        appName: 'test-app',
+        orgId: 'test-org',
+      });
+    });
+
+    it('should list files with custom options', async () => {
+      const mockListResult = { files: [], totalCount: 0, hasMore: false };
+
+      vi.mocked(listFiles).mockResolvedValue(mockListResult);
+
+      const { result } = renderHook(() => useStorage(defaultProps));
+
+      const customOptions = {
+        pathPrefix: 'documents',
+        tags: ['important'],
+        limit: 10,
+        offset: 0,
+      };
+
+      await act(async () => {
+        await result.current.listFiles(customOptions);
+      });
+
+      expect(listFiles).toHaveBeenCalledWith(mockSupabase, {
+        appName: 'test-app',
+        orgId: 'test-org',
+        pathPrefix: 'documents',
+        tags: ['important'],
+        limit: 10,
+        offset: 0,
+      });
+    });
+
+    it('should handle list files failure', async () => {
+      vi.mocked(listFiles).mockRejectedValue(new Error('List failed'));
+
+      const { result } = renderHook(() => useStorage(defaultProps));
+
+      let listResult: any;
+      await act(async () => {
+        listResult = await result.current.listFiles();
+      });
+
+      expect(listResult).toEqual({ files: [], totalCount: 0, hasMore: false });
+      expect(result.current.files).toEqual([]);
+      expect(result.current.isListing).toBe(false);
+      expect(result.current.listError).toBe('List failed');
+    });
+
+    it('should handle list files exception with non-Error object', async () => {
+      vi.mocked(listFiles).mockRejectedValue('String error');
+
+      const { result } = renderHook(() => useStorage(defaultProps));
+
+      let listResult: any;
+      await act(async () => {
+        listResult = await result.current.listFiles();
+      });
+
+      expect(listResult).toEqual({ files: [], totalCount: 0, hasMore: false });
+      expect(result.current.listError).toBe('List failed');
+    });
+
+    it('should refresh files', async () => {
+      const mockListResult = { files: [], totalCount: 0, hasMore: false };
+
+      vi.mocked(listFiles).mockResolvedValue(mockListResult);
+
+      const { result } = renderHook(() => useStorage(defaultProps));
+
+      await act(async () => {
+        await result.current.refreshFiles();
+      });
+
+      expect(listFiles).toHaveBeenCalledWith(mockSupabase, {
+        appName: 'test-app',
+        orgId: 'test-org',
+      });
+    });
+  });
+
+  describe('Loading States', () => {
+    it('should track upload loading state', async () => {
+      let resolveUpload: (value: any) => void;
+      const uploadPromise = new Promise((resolve) => {
+        resolveUpload = resolve;
+      });
+
+      vi.mocked(uploadFile).mockReturnValue(uploadPromise);
+
+      const { result } = renderHook(() => useStorage(defaultProps));
+
+      expect(result.current.isUploading).toBe(false);
+
+      act(() => {
+        result.current.uploadFile(mockFile);
+      });
+
+      expect(result.current.isUploading).toBe(true);
+
+      await act(async () => {
+        resolveUpload!({ success: true });
+        await uploadPromise;
+      });
+
+      expect(result.current.isUploading).toBe(false);
+    });
+
+    it('should track listing loading state', async () => {
+      let resolveList: (value: any) => void;
+      const listPromise = new Promise((resolve) => {
+        resolveList = resolve;
+      });
+
+      vi.mocked(listFiles).mockReturnValue(listPromise);
+
+      const { result } = renderHook(() => useStorage(defaultProps));
+
+      expect(result.current.isListing).toBe(false);
+
+      act(() => {
+        result.current.listFiles();
+      });
+
+      expect(result.current.isListing).toBe(true);
+
+      await act(async () => {
+        resolveList!({ files: [], totalCount: 0, hasMore: false });
+        await listPromise;
+      });
+
+      expect(result.current.isListing).toBe(false);
+    });
+  });
+
+  describe('Aliases', () => {
+    it('should provide isLoading alias for isListing', () => {
+      const { result } = renderHook(() => useStorage(defaultProps));
+
+      expect(result.current.isLoading).toBe(result.current.isListing);
+    });
+
+    it('should provide error alias for listError', () => {
+      const { result } = renderHook(() => useStorage(defaultProps));
+
+      expect(result.current.error).toBe(result.current.listError);
+    });
+  });
+});
+
+describe('useFileUpload Hook', () => {
+  const defaultProps = {
+    supabase: mockSupabase,
+    appName: 'test-app',
+    orgId: 'test-org',
+  };
+
+    describe('Initial State', () => {
+    it('should initialize with correct default values', () => {
+      const { result } = renderHook(() => useFileUpload(defaultProps));
+
+      expect(result.current.uploadProgress).toBe(0);
+      expect(result.current.isUploading).toBe(false);
+      expect(result.current.uploadError).toBe(null);
+    });
+  });
+
+  describe('Upload with Progress', () => {
+    it('should handle successful upload with progress simulation', async () => {
+      const mockUploadResult = {
+        success: true,
+        path: 'test-org/files/test-file.txt',
+      };
+
+      vi.mocked(uploadFile).mockResolvedValue(mockUploadResult);
+
+      const { result } = renderHook(() => useFileUpload(defaultProps));
+
+      let uploadResult: any;
+      await act(async () => {
+        uploadResult = await result.current.uploadWithProgress(mockFile);
+      });
+
+      expect(uploadResult).toEqual(mockUploadResult);
+      expect(result.current.uploadProgress).toBe(100);
+      expect(result.current.isUploading).toBe(false);
+      expect(result.current.uploadError).toBe(null);
+    });
+
+    it('should simulate progress during upload', async () => {
+      vi.useFakeTimers();
+      
+      let resolveUpload: (value: any) => void;
+      const uploadPromise = new Promise((resolve) => {
+        resolveUpload = resolve;
+      });
+
+      vi.mocked(uploadFile).mockReturnValue(uploadPromise);
+
+      const { result } = renderHook(() => useFileUpload(defaultProps));
+
+      act(() => {
+        result.current.uploadWithProgress(mockFile);
+      });
+
+      expect(result.current.uploadProgress).toBe(0);
+      expect(result.current.isUploading).toBe(true);
+
+      // Advance timers to simulate progress
+      act(() => {
+        vi.advanceTimersByTime(100);
+      });
+
+      expect(result.current.uploadProgress).toBe(10);
+
+      act(() => {
+        vi.advanceTimersByTime(100);
+      });
+
+      expect(result.current.uploadProgress).toBe(20);
+
+      // Complete upload
+      await act(async () => {
+        resolveUpload!({ success: true });
+        await uploadPromise;
+      });
+
+      expect(result.current.uploadProgress).toBe(100);
+      expect(result.current.isUploading).toBe(false);
+      
+      vi.useRealTimers();
+    });
+
+    it('should handle upload failure', async () => {
+      const mockUploadResult = {
+        success: false,
+        error: 'Upload failed',
+      };
+
+      vi.mocked(uploadFile).mockResolvedValue(mockUploadResult);
+
+      const { result } = renderHook(() => useFileUpload(defaultProps));
+
+      let uploadResult: any;
+      await act(async () => {
+        uploadResult = await result.current.uploadWithProgress(mockFile);
+      });
+
+      expect(uploadResult).toEqual(mockUploadResult);
+      expect(result.current.uploadProgress).toBe(100);
+      expect(result.current.isUploading).toBe(false);
+      expect(result.current.uploadError).toBe('Upload failed');
+    });
+
+    it('should handle upload exception', async () => {
+      vi.mocked(uploadFile).mockRejectedValue(new Error('Network error'));
+
+      const { result } = renderHook(() => useFileUpload(defaultProps));
+
+      let uploadResult: any;
+      await act(async () => {
+        uploadResult = await result.current.uploadWithProgress(mockFile);
+      });
+
+      expect(uploadResult).toEqual({
+        success: false,
+        error: 'Network error',
+      });
+      expect(result.current.uploadError).toBe('Network error');
+    });
+
+    it('should reset progress after delay', async () => {
+      vi.useFakeTimers();
+      
+      const mockUploadResult = { success: true };
+
+      vi.mocked(uploadFile).mockResolvedValue(mockUploadResult);
+
+      const { result } = renderHook(() => useFileUpload(defaultProps));
+
+      await act(async () => {
+        await result.current.uploadWithProgress(mockFile);
+      });
+
+      expect(result.current.uploadProgress).toBe(100);
+
+      act(() => {
+        vi.advanceTimersByTime(1000);
+      });
+
+      expect(result.current.uploadProgress).toBe(0);
+      
+      vi.useRealTimers();
+    });
+
+    it('should handle upload with custom options', async () => {
+      const mockUploadResult = { success: true };
+
+      vi.mocked(uploadFile).mockResolvedValue(mockUploadResult);
+
+      const { result } = renderHook(() => useFileUpload(defaultProps));
+
+      const customOptions = {
+        isPublic: true,
+        tags: ['important'],
+      };
+
+      await act(async () => {
+        await result.current.uploadWithProgress(mockFile, customOptions);
+      });
+
+      expect(uploadFile).toHaveBeenCalledWith(mockSupabase, mockFile, {
+        appName: 'test-app',
+        orgId: 'test-org',
+        isPublic: true,
+        tags: ['important'],
+      });
+    });
+  });
+});