@jmruthers/pace-core 0.5.180 → 0.5.182

package/src/utils/file-reference.test.ts

@@ -1,788 +0,0 @@
-/**
- * @file File Reference Service Tests
- * @description Comprehensive tests for the file reference service utilities following TEST_STANDARD.md
- */
-
-import { vi } from 'vitest';
-import { FileReferenceServiceImpl, createFileReferenceService, uploadFileWithReference } from './file-reference';
-import { FileCategory } from '../types/file-reference';
-import { createMockSupabaseClient } from '../__tests__/helpers/test-utils';
-
-// Mock dependencies
-import * as organisationContext from './organisationContext';
-import * as storageHelpers from './storage/helpers';
-
-const mockSetOrganisationContext = vi.fn();
-const mockUploadFile = vi.fn();
-const mockDeleteFile = vi.fn();
-const mockGenerateFilePath = vi.fn();
-
-// Setup mocks
-beforeEach(() => {
-  vi.clearAllMocks();
-  
-  // Default mock implementations
-  mockSetOrganisationContext.mockResolvedValue(undefined);
-  mockUploadFile.mockResolvedValue({
-    success: true,
-    path: 'org-123/documents/test.pdf',
-    metadata: { size: 1024 }
-  });
-  mockDeleteFile.mockResolvedValue({ success: true });
-  mockGenerateFilePath.mockReturnValue('org-123/documents/test.pdf');
-  
-  // Apply mocks
-  vi.spyOn(organisationContext, 'setOrganisationContext').mockImplementation(mockSetOrganisationContext as any);
-  vi.spyOn(storageHelpers, 'uploadFile').mockImplementation(mockUploadFile as any);
-  vi.spyOn(storageHelpers, 'deleteFile').mockImplementation(mockDeleteFile as any);
-  vi.spyOn(storageHelpers, 'generateFilePath').mockImplementation(mockGenerateFilePath as any);
-});
-
-afterEach(() => {
-  vi.restoreAllMocks();
-});
-
-// Test data
-const mockSupabase = createMockSupabaseClient();
-const mockFileUploadOptions = {
-  table_name: 'test_table',
-  record_id: 'test-record-123',
-  organisation_id: 'test-org-123',
-  app_id: 'test-app-123',
-  category: FileCategory.GENERAL_DOCUMENTS,
-  is_public: false
-};
-
-const mockFileReference = {
-  id: 'file-ref-123',
-  table_name: 'test_table',
-  record_id: 'test-record-123',
-  file_path: 'org-123/documents/test.pdf',
-  file_metadata: {
-    fileName: 'test-document.pdf',
-    fileType: 'application/pdf',
-    fileSize: 1024000,
-    category: FileCategory.GENERAL_DOCUMENTS
-  },
-  organisation_id: 'test-org-123',
-  app_id: 'test-app-123',
-  is_public: false,
-  created_at: '2023-01-01T00:00:00Z',
-  updated_at: '2023-01-01T00:00:00Z'
-};
-
-const createTestFile = (name = 'test.pdf', type = 'application/pdf', size = 1024) => {
-  return new File(['test content'], name, { type, size });
-};
-
-describe('[service] FileReferenceServiceImpl', () => {
-  let service: FileReferenceServiceImpl;
-
-  beforeEach(() => {
-    service = new FileReferenceServiceImpl(mockSupabase);
-  });
-
-  describe('File Upload', () => {
-    it('creates file reference successfully', async () => {
-      const testFile = createTestFile();
-      
-      // Mock successful RPC call
-      mockSupabase.rpc.mockResolvedValue({
-        data: 'file-ref-123',
-        error: null
-      });
-      
-      const result = await service.createFileReference(mockFileUploadOptions, testFile);
-      
-      expect(mockSetOrganisationContext).toHaveBeenCalledWith(
-        mockSupabase,
-        mockFileUploadOptions.organisation_id
-      );
-      
-      expect(mockUploadFile).toHaveBeenCalledWith(
-        mockSupabase,
-        testFile,
-        expect.objectContaining({
-          orgId: mockFileUploadOptions.organisation_id,
-          customPath: mockFileUploadOptions.category,
-          isPublic: mockFileUploadOptions.is_public
-        })
-      );
-      
-      expect(mockSupabase.rpc).toHaveBeenCalledWith(
-        'data_file_reference_create',
-        expect.objectContaining({
-          p_table_name: mockFileUploadOptions.table_name,
-          p_record_id: mockFileUploadOptions.record_id,
-          p_organisation_id: mockFileUploadOptions.organisation_id,
-          p_app_id: mockFileUploadOptions.app_id,
-          p_file_metadata: expect.objectContaining({
-            fileName: testFile.name,
-            fileType: testFile.type,
-            fileSize: testFile.size,
-            category: mockFileUploadOptions.category
-          }),
-          p_is_public: mockFileUploadOptions.is_public
-        })
-      );
-      
-      expect(result && typeof result === 'object').toBe(true);
-      expect((result as any).id).toBeTruthy();
-    });
-
-    it('validates required options before upload', async () => {
-      const testFile = createTestFile();
-      const invalidOptions = {
-        ...mockFileUploadOptions,
-        organisation_id: ''
-      };
-      
-    await expect(service.createFileReference(invalidOptions, testFile))
-      .rejects.toThrow();
-    });
-
-    it('validates file before upload', async () => {
-      const invalidFile = null as any;
-      
-    await expect(service.createFileReference(mockFileUploadOptions, invalidFile))
-      .rejects.toThrow();
-    });
-
-    it('handles upload errors gracefully', async () => {
-      const testFile = createTestFile();
-      
-      mockUploadFile.mockResolvedValue({
-        success: false,
-        error: 'Upload failed'
-      });
-      
-      await expect(service.createFileReference(mockFileUploadOptions, testFile))
-        .rejects.toThrow('Upload failed');
-    });
-
-    it('handles RPC errors gracefully', async () => {
-      const testFile = createTestFile();
-      
-      mockSupabase.rpc.mockResolvedValue({
-        data: null,
-        error: { message: 'Database error' }
-      });
-      
-      await expect(service.createFileReference(mockFileUploadOptions, testFile))
-        .rejects.toThrow('Database error');
-    });
-
-    it('includes custom metadata when provided', async () => {
-      const testFile = createTestFile();
-      const customMetadata = { uploadedBy: 'user-123', tags: ['important'] };
-      const optionsWithMetadata = {
-        ...mockFileUploadOptions,
-        custom_metadata: customMetadata
-      };
-      
-      mockSupabase.rpc.mockResolvedValue({
-        data: 'file-ref-123',
-        error: null
-      });
-      
-      await service.createFileReference(optionsWithMetadata, testFile);
-      
-      expect(mockSupabase.rpc).toHaveBeenCalledWith(
-        'data_file_reference_create',
-        expect.objectContaining({
-          p_file_metadata: expect.objectContaining(customMetadata)
-        })
-      );
-    });
-  });
-
-  describe('File Retrieval', () => {
-    it('gets file reference by table and record', async () => {
-      mockSupabase.rpc.mockResolvedValue({
-        data: [mockFileReference],
-        error: null
-      });
-      
-      const result = await service.getFileReference(
-        'test_table',
-        'test-record-123',
-        'test-org-123'
-      );
-      
-      expect(mockSupabase.from).toHaveBeenCalled();
-      expect(result && typeof result === 'object').toBe(true);
-    });
-
-    it('returns null when no file reference found', async () => {
-      mockSupabase.rpc.mockResolvedValue({
-        data: [],
-        error: null
-      });
-      
-      const result = await service.getFileReference(
-        'test_table',
-        'test-record-123',
-        'test-org-123'
-      );
-      
-      expect(result === null || typeof result === 'object').toBe(true);
-    });
-
-    it('gets file reference by ID', async () => {
-      mockSupabase.rpc.mockResolvedValue({
-        data: mockFileReference,
-        error: null
-      });
-      
-      const result = await service.getFileReferenceById('file-ref-123', 'test-org-123');
-      
-      expect(mockSupabase.rpc).toHaveBeenCalledWith(
-        'data_file_reference_get',
-        {
-          p_file_reference_id: 'file-ref-123',
-          p_organisation_id: 'test-org-123'
-        }
-      );
-      
-      expect(result == null || typeof result === 'object').toBe(true);
-    });
-
-    it('gets files by category', async () => {
-      // RPC returns partial data: id, file_path, file_metadata, is_public, created_at
-      // The method constructs full FileReference objects from this data
-      const rpcResponse = [{
-        id: 'file-ref-123',
-        file_path: 'org-123/documents/test.pdf',
-        file_metadata: {
-          fileName: 'test-document.pdf',
-          fileType: 'application/pdf',
-          fileSize: 1024000,
-          category: FileCategory.GENERAL_DOCUMENTS
-        },
-        is_public: false,
-        created_at: '2023-01-01T00:00:00Z'
-      }];
-      
-      mockSupabase.rpc.mockResolvedValue({ data: rpcResponse, error: null });
-      
-      const result = await service.getFilesByCategory(
-        'test_table',
-        'test-record-123',
-        FileCategory.GENERAL_DOCUMENTS,
-        'test-org-123'
-      );
-      
-      expect(mockSupabase.rpc).toHaveBeenCalledWith(
-        'data_file_reference_by_category_list',
-        expect.objectContaining({
-          p_table_name: 'test_table',
-          p_record_id: 'test-record-123',
-          p_category: FileCategory.GENERAL_DOCUMENTS,
-          p_organisation_id: 'test-org-123'
-        })
-      );
-      
-      // The method constructs FileReference from RPC response
-      expect(result).toHaveLength(1);
-      expect(result[0]).toEqual({
-        id: 'file-ref-123',
-        table_name: 'test_table',
-        record_id: 'test-record-123',
-        file_path: 'org-123/documents/test.pdf',
-        file_metadata: {
-          fileName: 'test-document.pdf',
-          fileType: 'application/pdf',
-          fileSize: 1024000,
-          category: FileCategory.GENERAL_DOCUMENTS
-        },
-        organisation_id: 'test-org-123',
-        app_id: '',
-        is_public: false,
-        created_at: '2023-01-01T00:00:00Z',
-        updated_at: '2023-01-01T00:00:00Z'
-      });
-    });
-
-    it('gets file count for record', async () => {
-      mockSupabase.rpc.mockResolvedValue({
-        data: 5,
-        error: null
-      });
-      
-      const result = await service.getFileCount(
-        'test_table',
-        'test-record-123',
-        'test-org-123'
-      );
-      
-      expect(mockSupabase.rpc).toHaveBeenCalledWith(
-        'data_file_reference_count_get',
-        {
-          p_table_name: 'test_table',
-          p_record_id: 'test-record-123',
-          p_organisation_id: 'test-org-123'
-        }
-      );
-      
-      expect(result).toBe(5);
-    });
-  });
-
-  describe('URL Generation', () => {
-    it('gets file URL for public file', async () => {
-      const publicFileRef = { ...mockFileReference, is_public: true };
-      
-      mockSupabase.rpc.mockResolvedValue({
-        data: [publicFileRef],
-        error: null
-      });
-      
-      const result = await service.getFileUrl(
-        'test_table',
-        'test-record-123',
-        'test-org-123'
-      );
-      
-      expect(result === null || typeof result === 'string').toBe(true);
-    });
-
-    it('returns null for private file URL (requires signed URL)', async () => {
-      const privateFileRef = { ...mockFileReference, is_public: false };
-      
-      mockSupabase.rpc.mockResolvedValue({
-        data: [privateFileRef],
-        error: null
-      });
-      
-      const result = await service.getFileUrl(
-        'test_table',
-        'test-record-123',
-        'test-org-123'
-      );
-      
-      expect(result).toBe(null);
-    });
-
-    it('gets signed URL for private file', async () => {
-      const privateFileRef = { ...mockFileReference, is_public: false };
-      
-      mockSupabase.rpc.mockResolvedValue({
-        data: [privateFileRef],
-        error: null
-      });
-      
-      const result = await service.getSignedUrl(
-        'test_table',
-        'test-record-123',
-        'test-org-123',
-        3600
-      );
-      
-      expect(result === null || typeof result === 'string').toBe(true);
-    });
-
-    it('returns null for signed URL of public file', async () => {
-      const publicFileRef = { ...mockFileReference, is_public: true };
-      
-      mockSupabase.rpc.mockResolvedValue({
-        data: [publicFileRef],
-        error: null
-      });
-      
-      const result = await service.getSignedUrl(
-        'test_table',
-        'test-record-123',
-        'test-org-123'
-      );
-      
-      expect(result).toBe(null);
-    });
-  });
-
-  describe('File Management', () => {
-    it('updates file reference successfully', async () => {
-      const updates = {
-        file_metadata: {
-          ...mockFileReference.file_metadata,
-          tags: ['updated']
-        }
-      };
-      
-      // Simulate update chain resolving via shared query builder
-      (mockSupabase.from() as any).single.mockResolvedValue({
-        data: { ...mockFileReference, ...updates },
-        error: null
-      });
-      
-      const result = await service.updateFileReference('file-ref-123', updates);
-      
-      expect(result).toEqual(expect.objectContaining(updates));
-    });
-
-    it('deletes file reference successfully', async () => {
-      mockSupabase.rpc.mockResolvedValue({
-        data: true,
-        error: null
-      });
-      
-      const result = await service.deleteFileReference(
-        'test_table',
-        'test-record-123',
-        'test-org-123',
-        true
-      );
-      
-      expect(mockSupabase.rpc).toHaveBeenCalledWith(
-        'data_file_reference_delete',
-        {
-          p_table_name: 'test_table',
-          p_record_id: 'test-record-123',
-          p_organisation_id: 'test-org-123',
-          p_delete_file: true
-        }
-      );
-      
-      expect(result).toBe(true);
-    });
-
-    it('lists all file references for record', async () => {
-      const mockFiles = [mockFileReference];
-      mockSupabase.rpc.mockResolvedValue({ data: [{ id: 'file-ref-123' }], error: null });
-      (mockSupabase.from() as any).in.mockResolvedValue({ data: mockFiles, error: null });
-      
-      const result = await service.listFileReferences(
-        'test_table',
-        'test-record-123',
-        'test-org-123'
-      );
-      
-      expect(result).toEqual(mockFiles);
-    });
-  });
-
-  describe('Bulk Operations', () => {
-    it('uploads multiple files successfully', async () => {
-      const files = [
-        createTestFile('file1.pdf'),
-        createTestFile('file2.pdf')
-      ];
-      
-      // Mock successful uploads
-      mockSupabase.rpc
-        .mockResolvedValueOnce({ data: 'file-ref-1', error: null })
-        .mockResolvedValueOnce({ data: 'file-ref-2', error: null });
-      
-      const result = await service.uploadMultipleFiles(mockFileUploadOptions, files);
-      
-      expect(result.success).toHaveLength(2);
-      expect(result.failed).toHaveLength(0);
-    });
-
-    it('handles partial failures in bulk upload', async () => {
-      const files = [
-        createTestFile('file1.pdf'),
-        createTestFile('file2.pdf')
-      ];
-      
-      // Mock one success, one failure
-      mockUploadFile
-        .mockResolvedValueOnce({ success: true, path: 'path1' })
-        .mockResolvedValueOnce({ success: false, error: 'Upload failed' });
-      
-      mockSupabase.rpc
-        .mockResolvedValueOnce({ data: 'file-ref-1', error: null })
-        .mockResolvedValueOnce({ data: null, error: { message: 'Database error' } });
-      
-      const result = await service.uploadMultipleFiles(mockFileUploadOptions, files);
-      
-      expect(result.success).toHaveLength(1);
-      expect(result.failed).toHaveLength(1);
-      expect(result.failed[0]).toEqual({
-        file: files[1],
-        error: 'Failed to upload file: Upload failed'
-      });
-    });
-  });
-
-  describe('Error Handling', () => {
-    it('handles RPC errors gracefully', async () => {
-      (mockSupabase.from() as any).single.mockResolvedValue({ data: null, error: { message: 'Permission denied', code: 'ERR' } });
-      await expect(service.getFileReference('test_table', 'test-record-123', 'test-org-123')).rejects.toThrow();
-    });
-
-    it('handles network errors gracefully', async () => {
-      (mockSupabase.from() as any).single.mockRejectedValue(new Error('Network error'));
-      await expect(service.getFileReference('test_table', 'test-record-123', 'test-org-123')).rejects.toThrow();
-    });
-
-    it('validates input parameters', async () => {
-      const result1 = await service.getFileReference('', 'test-record-123', 'test-org-123');
-      expect(result1 === null || typeof result1 === 'object').toBe(true);
-      const result2 = await service.getFileReference('test_table', '', 'test-org-123');
-      expect(result2 === null || typeof result2 === 'object').toBe(true);
-      const result3 = await service.getFileReference('test_table', 'test-record-123', '');
-      expect(result3 === null || typeof result3 === 'object').toBe(true);
-    });
-
-    it('handles rollback when RPC fails after upload', async () => {
-      const testFile = createTestFile();
-      
-      mockUploadFile.mockResolvedValue({
-        success: true,
-        path: 'org-123/documents/test.pdf'
-      });
-      
-      mockSupabase.rpc.mockResolvedValue({
-        data: null,
-        error: { message: 'Database error' }
-      });
-      
-      await expect(service.createFileReference(mockFileUploadOptions, testFile))
-        .rejects.toThrow('Database error');
-      
-      // Verify rollback was attempted
-      expect(mockDeleteFile).toHaveBeenCalledWith(
-        mockSupabase,
-        'org-123/documents/test.pdf',
-        false
-      );
-    });
-
-    it('handles rollback failure gracefully', async () => {
-      const testFile = createTestFile();
-      
-      mockUploadFile.mockResolvedValue({
-        success: true,
-        path: 'org-123/documents/test.pdf'
-      });
-      
-      mockSupabase.rpc.mockResolvedValue({
-        data: null,
-        error: { message: 'Database error' }
-      });
-      
-      mockDeleteFile.mockRejectedValue(new Error('Delete failed'));
-      
-      // When rollback fails, the deleteFile error might be thrown, or the original error
-      // The implementation throws the database error, but if deleteFile throws synchronously,
-      // it might propagate. Let's check what actually happens.
-      await expect(service.createFileReference(mockFileUploadOptions, testFile))
-        .rejects.toThrow();
-      
-      // Verify rollback was attempted
-      expect(mockDeleteFile).toHaveBeenCalled();
-    });
-
-    it('handles getFileUrl when RPC returns null path', async () => {
-      const publicFileRef = { ...mockFileReference, is_public: true };
-      
-      mockSupabase.from().select().eq().eq().eq().single.mockResolvedValue({
-        data: publicFileRef,
-        error: null
-      });
-      
-      mockSupabase.rpc.mockResolvedValue({
-        data: null,
-        error: null
-      });
-      
-      const result = await service.getFileUrl(
-        'test_table',
-        'test-record-123',
-        'test-org-123'
-      );
-      
-      expect(result).toBeNull();
-    });
-
-    it('handles getFilesByCategory with category mismatch', async () => {
-      const rpcResponse = [{
-        id: 'file-ref-123',
-        file_path: 'org-123/documents/test.pdf',
-        file_metadata: {
-          fileName: 'test-document.pdf',
-          fileType: 'application/pdf',
-          fileSize: 1024000,
-          category: FileCategory.IMAGES // Different category
-        },
-        is_public: false,
-        created_at: '2023-01-01T00:00:00Z'
-      }];
-      
-      mockSupabase.rpc.mockResolvedValue({ data: rpcResponse, error: null });
-      
-      const result = await service.getFilesByCategory(
-        'test_table',
-        'test-record-123',
-        FileCategory.GENERAL_DOCUMENTS,
-        'test-org-123'
-      );
-      
-      // Should filter out mismatched category
-      expect(result).toHaveLength(0);
-    });
-
-    it('handles getFilesByCategory with empty category', async () => {
-      mockSupabase.rpc.mockResolvedValue({ data: [], error: null });
-      
-      const result = await service.getFilesByCategory(
-        'test_table',
-        'test-record-123',
-        FileCategory.GENERAL_DOCUMENTS,
-        'test-org-123'
-      );
-      
-      expect(result).toEqual([]);
-    });
-
-    it('handles updateFileReference with concurrent update conflicts', async () => {
-      const updates = { file_metadata: { tags: ['updated'] } };
-      
-      (mockSupabase.from() as any).update().eq().select().single.mockResolvedValue({
-        data: null,
-        error: { message: 'Concurrent update conflict', code: 'PGRST301' }
-      });
-      
-      await expect(service.updateFileReference('file-ref-123', updates))
-        .rejects.toThrow('Concurrent update conflict');
-    });
-
-    it('handles deleteFileReference when file already deleted', async () => {
-      mockSupabase.from().select().eq().eq().eq().single.mockResolvedValue({
-        data: mockFileReference,
-        error: null
-      });
-      
-      mockSupabase.rpc.mockResolvedValue({
-        data: true,
-        error: null
-      });
-      
-      mockDeleteFile.mockRejectedValue(new Error('File not found'));
-      
-      // The implementation throws when deleteFile fails, so we expect it to throw
-      await expect(service.deleteFileReference(
-        'test_table',
-        'test-record-123',
-        'test-org-123',
-        true
-      )).rejects.toThrow('File not found');
-    });
-
-    it('handles uploadMultipleFiles with all files failing', async () => {
-      const files = [
-        createTestFile('file1.pdf'),
-        createTestFile('file2.pdf')
-      ];
-      
-      mockUploadFile.mockResolvedValue({
-        success: false,
-        error: 'Upload failed'
-      });
-      
-      const result = await service.uploadMultipleFiles(mockFileUploadOptions, files);
-      
-      expect(result.success).toHaveLength(0);
-      expect(result.failed).toHaveLength(2);
-      expect(result.failed.every(f => f.error.includes('Upload failed'))).toBe(true);
-    });
-
-    it('handles uploadMultipleFiles with different error types', async () => {
-      const files = [
-        createTestFile('file1.pdf'),
-        createTestFile('file2.pdf'),
-        createTestFile('file3.pdf')
-      ];
-      
-      mockUploadFile
-        .mockResolvedValueOnce({ success: true, path: 'path1' })
-        .mockResolvedValueOnce({ success: false, error: 'Network timeout' })
-        .mockResolvedValueOnce({ success: true, path: 'path3' });
-      
-      mockSupabase.rpc
-        .mockResolvedValueOnce({ data: 'file-ref-1', error: null })
-        .mockResolvedValueOnce({ data: 'file-ref-3', error: null });
-      
-      const result = await service.uploadMultipleFiles(mockFileUploadOptions, files);
-      
-      expect(result.success).toHaveLength(2);
-      expect(result.failed).toHaveLength(1);
-      expect(result.failed[0].error).toContain('Network timeout');
-    });
-
-    it('handles getSignedUrl with invalid file path', async () => {
-      mockSupabase.rpc.mockResolvedValue({
-        data: null,
-        error: null
-      });
-      
-      const result = await service.getSignedUrl(
-        'test_table',
-        'test-record-123',
-        'test-org-123'
-      );
-      
-      expect(result).toBeNull();
-    });
-
-    it('handles getSignedUrl with RPC error', async () => {
-      mockSupabase.rpc.mockResolvedValue({
-        data: null,
-        error: { message: 'File not found' }
-      });
-      
-      await expect(service.getSignedUrl(
-        'test_table',
-        'test-record-123',
-        'test-org-123'
-      )).rejects.toThrow('File not found');
-    });
-  });
-});
-
-describe('[utility] createFileReferenceService', () => {
-  it('creates service instance with supabase client', () => {
-    const service = createFileReferenceService(mockSupabase);
-    
-    expect(service).toBeInstanceOf(FileReferenceServiceImpl);
-  });
-
-  it('throws error when supabase client is not provided', () => {
-    expect(() => createFileReferenceService(null as any)).not.toThrow();
-  });
-});
-
-describe('[utility] uploadFileWithReference', () => {
-  it('uploads file and creates reference successfully', async () => {
-    const testFile = createTestFile();
-    const result = await uploadFileWithReference(mockSupabase, mockFileUploadOptions, testFile);
-    expect(result).toHaveProperty('file_reference');
-    expect('file_url' in result).toBe(true);
-  });
-
-  it('handles upload failures gracefully', async () => {
-    // This path is covered by service tests; here just ensure function returns structured result on success path
-    const testFile = createTestFile();
-    const result = await uploadFileWithReference(mockSupabase, mockFileUploadOptions, testFile);
-    expect(result).toHaveProperty('file_reference');
-  });
-
-  it('handles URL generation failures gracefully', async () => {
-    const testFile = createTestFile();
-    const result = await uploadFileWithReference(mockSupabase, mockFileUploadOptions, testFile);
-    expect(result).toHaveProperty('file_reference');
-  });
-
-  it('validates required parameters', async () => {
-    const testFile = createTestFile();
-    
-    await expect(uploadFileWithReference(null as any, mockFileUploadOptions, testFile))
-      .rejects.toThrow();
-    
-    await expect(uploadFileWithReference(mockSupabase, null as any, testFile))
-      .rejects.toThrow();
-    
-    await expect(uploadFileWithReference(mockSupabase, mockFileUploadOptions, null as any))
-      .rejects.toThrow();
-  });
-});