@jmruthers/pace-core 0.6.9 → 0.6.11

package/src/hooks/useFileReference.test.ts

@@ -1,10 +1,10 @@
 /**
  * @file useFileReference Hook Tests
- * @description Comprehensive tests for the useFileReference hook following TEST_STANDARD.md
+ * @description Comprehensive tests for the useFileReference hook following testing standards
  */
 
 import { renderHook, act, waitFor } from '@testing-library/react';
-import { vi } from 'vitest';
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
 import { useFileReference, useFileReferenceById, useFilesByCategory, useFileReferenceForRecord } from './useFileReference';
 import { FileCategory } from '../types/file-reference';
 import { createMockSupabaseClient } from '../__tests__/helpers/test-utils';
@@ -33,22 +33,25 @@ beforeEach(() => {
     updateFileReference: vi.fn(),
     deleteFileReference: vi.fn(),
     listFileReferences: vi.fn(),
-    getFilesByCategory: vi.fn().mockResolvedValue([]),
+    getFilesByCategory: vi.fn().mockResolvedValue({ ok: true, data: [] }),
     getFileCount: vi.fn(),
     uploadMultipleFiles: vi.fn()
   };
   
   mockCreateFileReferenceService.mockReturnValue(serviceMock);
   mockUploadFileWithReference.mockResolvedValue({
-    file_reference: { id: 'test-file-ref' },
-    file_url: 'test-url'
+    ok: true,
+    data: {
+      file_reference: { id: 'test-file-ref' },
+      file_url: 'test-url'
+    }
   });
   mockGetPublicUrl.mockReturnValue('https://example.com/public-file.jpg');
   mockGetSignedUrl.mockResolvedValue({ 
     url: 'https://example.com/signed-file.jpg', 
     expiresAt: new Date(Date.now() + 3600 * 1000).toISOString() 
   });
-  // Mock batch URL generation to return URLs for all files
+  // Mock batch URL generation to return ApiResult with URLs for all files
   mockGenerateFileUrlsBatch.mockImplementation(async (supabase, files) => {
     const urlMap = new Map<string, string>();
     for (const file of files) {
@@ -58,7 +61,7 @@ beforeEach(() => {
         urlMap.set(file.id, `https://example.com/signed/${file.file_path}`);
       }
     }
-    return urlMap;
+    return { ok: true, data: urlMap };
   });
   
   // Apply mocks
@@ -118,6 +121,7 @@ describe('[hook] useFileReference', () => {
       expect(typeof result.current.uploadFile).toBe('function');
       expect(typeof result.current.getFileReference).toBe('function');
       expect(typeof result.current.deleteFileReference).toBe('function');
+      expect(typeof result.current.clearError).toBe('function');
     });
 
     it('creates file reference service with supabase client', () => {
@@ -128,7 +132,7 @@ describe('[hook] useFileReference', () => {
   });
 
   describe('File Upload', () => {
-    it('uploads file successfully', async () => {
+    it('uploads file successfully and returns result', async () => {
       const { result } = renderHook(() => useFileReference(mockSupabase));
       const testFile = createTestFile();
       const expectedResult = {
@@ -136,7 +140,7 @@ describe('[hook] useFileReference', () => {
         file_url: 'test-url'
       };
       
-      mockUploadFileWithReference.mockResolvedValue(expectedResult);
+      mockUploadFileWithReference.mockResolvedValue({ ok: true, data: expectedResult });
       
       let uploadResult;
       await act(async () => {
@@ -153,7 +157,7 @@ describe('[hook] useFileReference', () => {
       expect(result.current.error).toBe(null);
     });
 
-    it('handles upload errors gracefully', async () => {
+    it('handles upload errors and sets error state', async () => {
       const { result } = renderHook(() => useFileReference(mockSupabase));
       const testFile = createTestFile();
       const errorMessage = 'Upload failed';
@@ -170,31 +174,50 @@ describe('[hook] useFileReference', () => {
       expect(result.current.error).toBe(errorMessage);
     });
 
-    it('sets loading state during upload', async () => {
+    it('handles non-Error exceptions during upload', async () => {
+      const { result } = renderHook(() => useFileReference(mockSupabase));
+      const testFile = createTestFile();
+      
+      mockUploadFileWithReference.mockRejectedValue('String error');
+      
+      let uploadResult;
+      await act(async () => {
+        uploadResult = await result.current.uploadFile(mockFileUploadOptions, testFile);
+      });
+      
+      expect(uploadResult).toBe(null);
+      expect(result.current.error).toBe('Upload failed');
+    });
+
+    it('manages loading state during upload', async () => {
       const { result } = renderHook(() => useFileReference(mockSupabase));
       const testFile = createTestFile();
       
       // Mock a delayed response
-      mockUploadFileWithReference.mockImplementation(() => {
-        return new Promise(resolve => {
-          setTimeout(() => {
-            resolve({
-              file_reference: { id: 'test-file-ref' },
-              file_url: 'test-url'
-            });
-          }, 100);
-        });
+      let resolveUpload: (value: any) => void;
+      const uploadPromise = new Promise((resolve) => {
+        resolveUpload = resolve;
       });
       
+      mockUploadFileWithReference.mockReturnValue(uploadPromise);
+      
       act(() => {
         result.current.uploadFile(mockFileUploadOptions, testFile);
       });
       
       expect(result.current.isLoading).toBe(true);
       
+      await act(async () => {
+        resolveUpload!({
+          file_reference: { id: 'test-file-ref' },
+          file_url: 'test-url'
+        });
+        await uploadPromise;
+      });
+      
       await waitFor(() => {
         expect(result.current.isLoading).toBe(false);
-      });
+      }, { timeout: 1000 });
     });
 
     it('clears previous errors before new upload', async () => {
@@ -212,8 +235,8 @@ describe('[hook] useFileReference', () => {
       
       // Second upload succeeds
       mockUploadFileWithReference.mockResolvedValueOnce({
-        file_reference: { id: 'test-file-ref' },
-        file_url: 'test-url'
+        ok: true,
+        data: { file_reference: { id: 'test-file-ref' }, file_url: 'test-url' }
       });
       
       await act(async () => {
@@ -225,11 +248,11 @@ describe('[hook] useFileReference', () => {
   });
 
   describe('File Reference Operations', () => {
-    it('gets file reference successfully', async () => {
+    it('retrieves file reference successfully', async () => {
       const { result } = renderHook(() => useFileReference(mockSupabase));
       const mockService = mockCreateFileReferenceService();
       
-      mockService.getFileReference.mockResolvedValue(mockFileReference);
+      mockService.getFileReference.mockResolvedValue({ ok: true, data: mockFileReference });
       
       let fileRef;
       await act(async () => {
@@ -246,13 +269,14 @@ describe('[hook] useFileReference', () => {
         'test-org-123'
       );
       expect(fileRef).toEqual(mockFileReference);
+      expect(result.current.isLoading).toBe(false);
     });
 
-    it('handles get file reference errors', async () => {
+    it('handles get file reference errors gracefully', async () => {
       const { result } = renderHook(() => useFileReference(mockSupabase));
       const mockService = mockCreateFileReferenceService();
       
-      mockService.getFileReference.mockRejectedValue(new Error('Not found'));
+      mockService.getFileReference.mockResolvedValue({ ok: false, error: { code: 'NOT_FOUND', message: 'Not found' } });
       
       let fileRef;
       await act(async () => {
@@ -265,13 +289,35 @@ describe('[hook] useFileReference', () => {
       
       expect(fileRef).toBe(null);
       expect(result.current.error).toBe('Not found');
+      expect(result.current.isLoading).toBe(false);
+    });
+
+    it('updates file reference successfully', async () => {
+      const { result } = renderHook(() => useFileReference(mockSupabase));
+      const mockService = mockCreateFileReferenceService();
+      const updatedReference = { ...mockFileReference, file_metadata: { ...mockFileReference.file_metadata, fileName: 'updated.pdf' } };
+      
+      mockService.updateFileReference.mockResolvedValue({ ok: true, data: updatedReference });
+      
+      let updateResult;
+      await act(async () => {
+        updateResult = await result.current.updateFileReference('file-ref-123', {
+          file_metadata: { ...mockFileReference.file_metadata, fileName: 'updated.pdf' }
+        });
+      });
+      
+      expect(mockService.updateFileReference).toHaveBeenCalledWith(
+        'file-ref-123',
+        expect.objectContaining({ file_metadata: expect.any(Object) })
+      );
+      expect(updateResult).toEqual(updatedReference);
     });
 
     it('deletes file reference successfully', async () => {
       const { result } = renderHook(() => useFileReference(mockSupabase));
       const mockService = mockCreateFileReferenceService();
       
-      mockService.deleteFileReference.mockResolvedValue(true);
+      mockService.deleteFileReference.mockResolvedValue({ ok: true, data: true });
       
       let deleteResult;
       await act(async () => {
@@ -291,14 +337,71 @@ describe('[hook] useFileReference', () => {
       );
       expect(deleteResult).toBe(true);
     });
+
+    it('handles delete failure gracefully', async () => {
+      const { result } = renderHook(() => useFileReference(mockSupabase));
+      const mockService = mockCreateFileReferenceService();
+      
+      mockService.deleteFileReference.mockResolvedValue({ ok: false, error: { code: 'DELETE_FAILED', message: 'Delete failed' } });
+      
+      let deleteResult;
+      await act(async () => {
+        deleteResult = await result.current.deleteFileReference(
+          'test_table',
+          'test-record-123',
+          'test-org-123'
+        );
+      });
+      
+      expect(deleteResult).toBe(false);
+      expect(result.current.error).toBe('Delete failed');
+    });
+
+    it('lists file references successfully', async () => {
+      const { result } = renderHook(() => useFileReference(mockSupabase));
+      const mockService = mockCreateFileReferenceService();
+      const mockFiles = [mockFileReference];
+      
+      mockService.listFileReferences.mockResolvedValue({ ok: true, data: mockFiles });
+      
+      let files;
+      await act(async () => {
+        files = await result.current.listFileReferences(
+          'test_table',
+          'test-record-123',
+          'test-org-123'
+        );
+      });
+      
+      expect(files).toEqual(mockFiles);
+    });
+
+    it('returns empty array when list fails', async () => {
+      const { result } = renderHook(() => useFileReference(mockSupabase));
+      const mockService = mockCreateFileReferenceService();
+      
+      mockService.listFileReferences.mockResolvedValue({ ok: false, error: { code: 'LIST_FAILED', message: 'List failed' } });
+      
+      let files;
+      await act(async () => {
+        files = await result.current.listFileReferences(
+          'test_table',
+          'test-record-123',
+          'test-org-123'
+        );
+      });
+      
+      expect(files).toEqual([]);
+      expect(result.current.error).toBe('List failed');
+    });
   });
 
   describe('URL Generation', () => {
-    it('gets file URL successfully', async () => {
+    it('gets public file URL successfully', async () => {
       const { result } = renderHook(() => useFileReference(mockSupabase));
       const mockService = mockCreateFileReferenceService();
       
-      mockService.getFileUrl.mockResolvedValue('https://example.com/file.pdf');
+      mockService.getFileUrl.mockResolvedValue({ ok: true, data: 'https://example.com/file.pdf' });
       
       let fileUrl;
       await act(async () => {
@@ -312,11 +415,11 @@ describe('[hook] useFileReference', () => {
       expect(fileUrl).toBe('https://example.com/file.pdf');
     });
 
-    it('gets signed URL successfully', async () => {
+    it('gets signed URL with custom expiration', async () => {
       const { result } = renderHook(() => useFileReference(mockSupabase));
       const mockService = mockCreateFileReferenceService();
       
-      mockService.getSignedUrl.mockResolvedValue('https://example.com/signed-file.pdf');
+      mockService.getSignedUrl.mockResolvedValue({ ok: true, data: 'https://example.com/signed-file.pdf' });
       
       let signedUrl;
       await act(async () => {
@@ -324,7 +427,7 @@ describe('[hook] useFileReference', () => {
           'test_table',
           'test-record-123',
           'test-org-123',
-          3600
+          7200
         );
       });
       
@@ -332,10 +435,29 @@ describe('[hook] useFileReference', () => {
         'test_table',
         'test-record-123',
         'test-org-123',
-        3600
+        7200
       );
       expect(signedUrl).toBe('https://example.com/signed-file.pdf');
     });
+
+    it('handles URL generation errors', async () => {
+      const { result } = renderHook(() => useFileReference(mockSupabase));
+      const mockService = mockCreateFileReferenceService();
+      
+      mockService.getFileUrl.mockResolvedValue({ ok: false, error: { code: 'URL_FAILED', message: 'URL generation failed' } });
+      
+      let fileUrl;
+      await act(async () => {
+        fileUrl = await result.current.getFileUrl(
+          'test_table',
+          'test-record-123',
+          'test-org-123'
+        );
+      });
+      
+      expect(fileUrl).toBe(null);
+      expect(result.current.error).toBe('URL generation failed');
+    });
   });
 
   describe('Bulk Operations', () => {
@@ -344,7 +466,7 @@ describe('[hook] useFileReference', () => {
       const mockService = mockCreateFileReferenceService();
       const mockFiles = [mockFileReference];
       
-      mockService.getFilesByCategory.mockResolvedValue(mockFiles);
+      mockService.getFilesByCategory.mockResolvedValue({ ok: true, data: mockFiles });
       
       let files;
       await act(async () => {
@@ -365,11 +487,31 @@ describe('[hook] useFileReference', () => {
       expect(files).toEqual(mockFiles);
     });
 
+    it('returns empty array when category query fails', async () => {
+      const { result } = renderHook(() => useFileReference(mockSupabase));
+      const mockService = mockCreateFileReferenceService();
+      
+      mockService.getFilesByCategory.mockResolvedValue({ ok: false, error: { code: 'LIST_FAILED', message: 'Category query failed' } });
+      
+      let files;
+      await act(async () => {
+        files = await result.current.getFilesByCategory(
+          'test_table',
+          'test-record-123',
+          FileCategory.GENERAL_DOCUMENTS,
+          'test-org-123'
+        );
+      });
+      
+      expect(files).toEqual([]);
+      expect(result.current.error).toBe('Category query failed');
+    });
+
     it('gets file count successfully', async () => {
       const { result } = renderHook(() => useFileReference(mockSupabase));
       const mockService = mockCreateFileReferenceService();
       
-      mockService.getFileCount.mockResolvedValue(5);
+      mockService.getFileCount.mockResolvedValue({ ok: true, data: 5 });
       
       let count;
       await act(async () => {
@@ -382,55 +524,107 @@ describe('[hook] useFileReference', () => {
       
       expect(count).toBe(5);
     });
+
+    it('returns zero when file count query fails', async () => {
+      const { result } = renderHook(() => useFileReference(mockSupabase));
+      const mockService = mockCreateFileReferenceService();
+      
+      mockService.getFileCount.mockResolvedValue({ ok: false, error: { code: 'COUNT_FAILED', message: 'Count query failed' } });
+      
+      let count;
+      await act(async () => {
+        count = await result.current.getFileCount(
+          'test_table',
+          'test-record-123',
+          'test-org-123'
+        );
+      });
+      
+      expect(count).toBe(0);
+      expect(result.current.error).toBe('Count query failed');
+    });
+  });
+
+  describe('Error Management', () => {
+    it('clears error when clearError is called', async () => {
+      const { result } = renderHook(() => useFileReference(mockSupabase));
+      const mockService = mockCreateFileReferenceService();
+      
+      mockService.getFileReference.mockResolvedValue({ ok: false, error: { code: 'ERR', message: 'Test error' } });
+      
+      await act(async () => {
+        await result.current.getFileReference('test_table', 'test-record-123', 'test-org-123');
+      });
+      
+      expect(result.current.error).toBe('Test error');
+      
+      act(() => {
+        result.current.clearError();
+      });
+      
+      expect(result.current.error).toBe(null);
+    });
   });
 });
 
 describe('[hook] useFileReferenceById', () => {
-  it('initializes state and settles without error', async () => {
+  it('loads file reference on mount when ID is provided', async () => {
+    const mockService = mockCreateFileReferenceService();
+    mockService.getFileReferenceById.mockResolvedValue({ ok: true, data: mockFileReference });
+    
     const { result } = renderHook(() => 
       useFileReferenceById(mockSupabase, 'file-ref-123', 'test-org-123')
     );
     
     await waitFor(() => {
-      expect(result.current.isLoading).toBeTypeOf('boolean');
-    });
+      expect(result.current.fileReference).toEqual(mockFileReference);
+      expect(result.current.isLoading).toBe(false);
+    }, { timeout: 1000 });
   });
 
-  it('loads file reference on mount', async () => {
-    const mockService = mockCreateFileReferenceService();
-    mockService.getFileReferenceById.mockResolvedValue(mockFileReference);
+  it('does not load when ID is null', async () => {
+    const { result } = renderHook(() => 
+      useFileReferenceById(mockSupabase, null, 'test-org-123')
+    );
     
+    await waitFor(() => {
+      expect(result.current.fileReference).toBe(null);
+      expect(result.current.fileUrl).toBe(null);
+    }, { timeout: 1000 });
+  });
+
+  it('does not load when organisation ID is null', async () => {
     const { result } = renderHook(() => 
-      useFileReferenceById(mockSupabase, 'file-ref-123', 'test-org-123')
+      useFileReferenceById(mockSupabase, 'file-ref-123', null)
     );
     
     await waitFor(() => {
-      expect(result.current.fileReference).toEqual(mockFileReference);
-      expect(result.current.isLoading).toBe(false);
-    });
+      expect(result.current.fileReference).toBe(null);
+      expect(result.current.fileUrl).toBe(null);
+    }, { timeout: 1000 });
   });
 
   it('generates file URL when file reference is loaded', async () => {
     const mockService = mockCreateFileReferenceService();
-    mockService.getFileReferenceById.mockResolvedValue(mockFileReference);
+    mockService.getFileReferenceById.mockResolvedValue({ ok: true, data: mockFileReference });
+    mockService.getFileUrl.mockResolvedValue({ ok: true, data: 'https://example.com/file.pdf' });
     
     const { result } = renderHook(() => 
       useFileReferenceById(mockSupabase, 'file-ref-123', 'test-org-123')
     );
     
-    // Ensure reference is loaded
     await waitFor(() => {
       expect(result.current.fileReference).toEqual(mockFileReference);
-    });
+    }, { timeout: 1000 });
     
-    // Depending on hook behavior, fileUrl may be computed automatically or remain null
-    const url = result.current.fileUrl;
-    expect(url == null || typeof url === 'string').toBe(true);
+    await waitFor(() => {
+      expect(result.current.fileUrl).toBe('https://example.com/file.pdf');
+    }, { timeout: 1000 });
   });
 
   it('handles errors gracefully', async () => {
     const mockService = mockCreateFileReferenceService();
-    mockService.getFileReferenceById.mockRejectedValue(new Error('Not found'));
+    mockService.getFileReferenceById.mockResolvedValue({ ok: false, error: { code: 'NOT_FOUND', message: 'Not found' } });
     
     const { result } = renderHook(() => 
       useFileReferenceById(mockSupabase, 'file-ref-123', 'test-org-123')
@@ -439,14 +633,42 @@ describe('[hook] useFileReferenceById', () => {
     await waitFor(() => {
       expect(result.current.error).toBe('Not found');
       expect(result.current.isLoading).toBe(false);
-    });
+    }, { timeout: 1000 });
+  });
+
+  it('reloads when ID changes', async () => {
+    const mockService = mockCreateFileReferenceService();
+    const firstRef = { ...mockFileReference, id: 'file-ref-1' };
+    const secondRef = { ...mockFileReference, id: 'file-ref-2' };
+    
+    mockService.getFileReferenceById
+      .mockResolvedValueOnce({ ok: true, data: firstRef })
+      .mockResolvedValueOnce({ ok: true, data: secondRef });
+    
+    const { result, rerender } = renderHook(
+      ({ id, orgId }) => useFileReferenceById(mockSupabase, id, orgId),
+      { initialProps: { id: 'file-ref-1', orgId: 'test-org-123' } }
+    );
+    
+    await waitFor(() => {
+      expect(result.current.fileReference?.id).toBe('file-ref-1');
+    }, { timeout: 1000 });
+    
+    rerender({ id: 'file-ref-2', orgId: 'test-org-123' });
+    
+    await waitFor(() => {
+      expect(result.current.fileReference?.id).toBe('file-ref-2');
+    }, { timeout: 1000 });
   });
 });
 
 describe('[hook] useFilesByCategory', () => {
   const mockFiles = [mockFileReference];
 
-  it('initializes with correct default state', () => {
+  it('loads files by category on mount', async () => {
+    const mockService = mockCreateFileReferenceService();
+    mockService.getFilesByCategory.mockResolvedValue({ ok: true, data: mockFiles });
+    
     const { result } = renderHook(() => 
       useFilesByCategory(
         mockSupabase,
@@ -457,34 +679,48 @@ describe('[hook] useFilesByCategory', () => {
       )
     );
     
-    expect(result.current.fileReferences).toEqual([]);
-    expect(result.current.fileUrls).toBeInstanceOf(Map);
-    expect(typeof result.current.isLoading).toBe('boolean');
-    expect(result.current.error === null || typeof result.current.error === 'string').toBe(true);
+    await waitFor(() => {
+      expect(result.current.fileReferences).toEqual(mockFiles);
+    }, { timeout: 1000 });
   });
 
-  it('loads files by category on mount', async () => {
-    const mockService = mockCreateFileReferenceService();
-    mockService.getFilesByCategory.mockResolvedValue(mockFiles);
+  it('does not load when category is null', async () => {
+    const { result } = renderHook(() => 
+      useFilesByCategory(
+        mockSupabase,
+        'test_table',
+        'test-record-123',
+        null,
+        'test-org-123'
+      )
+    );
     
+    await waitFor(() => {
+      expect(result.current.fileReferences).toEqual([]);
+      expect(result.current.fileUrls.size).toBe(0);
+    }, { timeout: 1000 });
+  });
+
+  it('does not load when organisation ID is null', async () => {
     const { result } = renderHook(() => 
       useFilesByCategory(
         mockSupabase,
         'test_table',
         'test-record-123',
         FileCategory.GENERAL_DOCUMENTS,
-        'test-org-123'
+        null
       )
     );
     
     await waitFor(() => {
-      expect(Array.isArray(result.current.fileReferences)).toBe(true);
-    });
+      expect(result.current.fileReferences).toEqual([]);
+      expect(result.current.fileUrls.size).toBe(0);
+    }, { timeout: 1000 });
   });
 
   it('generates URLs for loaded files', async () => {
     const mockService = mockCreateFileReferenceService();
-    mockService.getFilesByCategory.mockResolvedValue(mockFiles);
+    mockService.getFilesByCategory.mockResolvedValue({ ok: true, data: mockFiles });
     
     const { result } = renderHook(() => 
       useFilesByCategory(
@@ -497,8 +733,9 @@ describe('[hook] useFilesByCategory', () => {
     );
     
     await waitFor(() => {
+      expect(result.current.fileUrls.get('file-ref-123')).toBeDefined();
       expect(typeof result.current.fileUrls.get('file-ref-123')).toBe('string');
-    });
+    }, { timeout: 1000 });
   });
 
   it('handles different URL types based on is_public flag', async () => {
@@ -506,7 +743,7 @@ describe('[hook] useFilesByCategory', () => {
     const privateFile = { ...mockFileReference, id: 'private-file', is_public: false };
     
     const mockService = mockCreateFileReferenceService();
-    mockService.getFilesByCategory.mockResolvedValue([publicFile, privateFile]);
+    mockService.getFilesByCategory.mockResolvedValue({ ok: true, data: [publicFile, privateFile] });
     
     const { result } = renderHook(() => 
       useFilesByCategory(
@@ -519,7 +756,6 @@ describe('[hook] useFilesByCategory', () => {
     );
     
     await waitFor(() => {
-      // Verify batch URL generation was called with both files
       expect(mockGenerateFileUrlsBatch).toHaveBeenCalledWith(
         mockSupabase,
         [publicFile, privateFile],
@@ -529,10 +765,40 @@ describe('[hook] useFilesByCategory', () => {
           expiresIn: 3600
         })
       );
-      // Verify URLs were generated
       expect(result.current.fileUrls.get(publicFile.id)).toBeDefined();
       expect(result.current.fileUrls.get(privateFile.id)).toBeDefined();
-    });
+    }, { timeout: 1000 });
+  });
+
+  it('reloads when category changes', async () => {
+    const mockService = mockCreateFileReferenceService();
+    const generalFiles = [mockFileReference];
+    const imageFiles = [{ ...mockFileReference, id: 'image-ref', file_metadata: { ...mockFileReference.file_metadata, category: FileCategory.IMAGES } }];
+    
+    mockService.getFilesByCategory
+      .mockResolvedValueOnce({ ok: true, data: generalFiles })
+      .mockResolvedValueOnce({ ok: true, data: imageFiles });
+    
+    const { result, rerender } = renderHook(
+      ({ category, orgId }) => useFilesByCategory(
+        mockSupabase,
+        'test_table',
+        'test-record-123',
+        category,
+        orgId
+      ),
+      { initialProps: { category: FileCategory.GENERAL_DOCUMENTS, orgId: 'test-org-123' } }
+    );
+    
+    await waitFor(() => {
+      expect(result.current.fileReferences).toEqual(generalFiles);
+    }, { timeout: 1000 });
+    
+    rerender({ category: FileCategory.IMAGES, orgId: 'test-org-123' });
+    
+    await waitFor(() => {
+      expect(result.current.fileReferences).toEqual(imageFiles);
+    }, { timeout: 1000 });
   });
 });
 
@@ -555,7 +821,10 @@ describe('[hook] useFileReferenceForRecord', () => {
     expect(result.current.fileCount).toBe(0);
   });
 
-  it('provides all necessary methods', () => {
+  it('loads file reference successfully', async () => {
+    const mockService = mockCreateFileReferenceService();
+    mockService.getFileReference.mockResolvedValue({ ok: true, data: mockFileReference });
+    
     const { result } = renderHook(() => 
       useFileReferenceForRecord(
         mockSupabase,
@@ -565,17 +834,16 @@ describe('[hook] useFileReferenceForRecord', () => {
       )
     );
     
-    expect(typeof result.current.loadFileReference).toBe('function');
-    expect(typeof result.current.loadFileUrl).toBe('function');
-    expect(typeof result.current.loadFileReferences).toBe('function');
-    expect(typeof result.current.loadFileCount).toBe('function');
-    expect(typeof result.current.deleteFile).toBe('function');
-    expect(typeof result.current.clearError).toBe('function');
+    await act(async () => {
+      await result.current.loadFileReference();
+    });
+    
+    expect(result.current.fileReference).toEqual(mockFileReference);
   });
 
-  it('loads file reference successfully', async () => {
+  it('loads file URL successfully', async () => {
     const mockService = mockCreateFileReferenceService();
-    mockService.getFileReference.mockResolvedValue(mockFileReference);
+    mockService.getFileUrl.mockResolvedValue({ ok: true, data: 'https://example.com/file.pdf' });
     
     const { result } = renderHook(() => 
       useFileReferenceForRecord(
@@ -587,18 +855,15 @@ describe('[hook] useFileReferenceForRecord', () => {
     );
     
     await act(async () => {
-      await result.current.loadFileReference();
+      await result.current.loadFileUrl();
     });
     
-    expect(result.current.fileReference).toEqual(mockFileReference);
+    expect(result.current.fileUrl).toBe('https://example.com/file.pdf');
   });
 
-  it('refreshes signed URLs before expiration', async () => {
-    serviceMock.getFileReference.mockResolvedValue({
-      ...mockFileReference,
-      is_public: false
-    });
-    serviceMock.getSignedUrl.mockResolvedValue('https://example.com/signed-file.jpg');
+  it('loads file count successfully', async () => {
+    const mockService = mockCreateFileReferenceService();
+    mockService.getFileCount.mockResolvedValue({ ok: true, data: 5 });
     
     const { result } = renderHook(() => 
       useFileReferenceForRecord(
@@ -610,15 +875,36 @@ describe('[hook] useFileReferenceForRecord', () => {
     );
     
     await act(async () => {
-      await result.current.loadFileReference();
-      await result.current.loadFileUrl();
+      await result.current.loadFileCount();
     });
     
-    // Assert no errors occurred during subsequent refresh attempt
+    expect(result.current.fileCount).toBe(5);
+  });
+
+  it('deletes file and updates count', async () => {
+    const mockService = mockCreateFileReferenceService();
+    mockService.deleteFileReference.mockResolvedValue({ ok: true, data: true });
+    mockService.getFileCount.mockResolvedValue({ ok: true, data: 0 });
+    
+    const { result } = renderHook(() => 
+      useFileReferenceForRecord(
+        mockSupabase,
+        'test_table',
+        'test-record-123',
+        'test-org-123'
+      )
+    );
+    
     await act(async () => {
-      await result.current.loadFileUrl();
+      const success = await result.current.deleteFile(true);
+      expect(success).toBe(true);
     });
-    expect(result.current.error).toBe(null);
+    
+    expect(result.current.fileReference).toBe(null);
+    expect(result.current.fileUrl).toBe(null);
+    await waitFor(() => {
+      expect(result.current.fileCount).toBe(0);
+    }, { timeout: 1000 });
   });
 
   it('clears error state', async () => {
@@ -633,7 +919,7 @@ describe('[hook] useFileReferenceForRecord', () => {
     
     // Simulate an error
     const mockService = mockCreateFileReferenceService();
-    mockService.getFileReference.mockRejectedValue(new Error('Test error'));
+    mockService.getFileReference.mockResolvedValue({ ok: false, error: { code: 'ERR', message: 'Test error' } });
     
     await act(async () => {
       await result.current.loadFileReference();
@@ -641,7 +927,6 @@ describe('[hook] useFileReferenceForRecord', () => {
     
     expect(result.current.error).toBe('Test error');
     
-    // Clear the error
     act(() => {
       result.current.clearError();
     });
@@ -649,9 +934,9 @@ describe('[hook] useFileReferenceForRecord', () => {
     expect(result.current.error).toBe(null);
   });
 
-  it('deletes file successfully', async () => {
-    const mockService = mockCreateFileReferenceService();
-    mockService.deleteFileReference.mockResolvedValue(true);
+  it('does not refresh URLs for public files', async () => {
+    const publicFileRef = { ...mockFileReference, is_public: true };
+    serviceMock.getFileReference.mockResolvedValue({ ok: true, data: publicFileRef });
     
     const { result } = renderHook(() => 
       useFileReferenceForRecord(
@@ -662,17 +947,13 @@ describe('[hook] useFileReferenceForRecord', () => {
       )
     );
     
-    let deleteResult;
     await act(async () => {
-      deleteResult = await result.current.deleteFile(true);
+      await result.current.loadFileReference();
+      await result.current.loadFileUrl();
     });
     
-    expect(deleteResult).toBe(true);
-    expect(mockService.deleteFileReference).toHaveBeenCalledWith(
-      'test_table',
-      'test-record-123',
-      'test-org-123',
-      true
-    );
+    // Public files should not trigger URL refresh subscription
+    // This is tested implicitly - if subscription was created, it would be an error
+    expect(result.current.fileReference?.is_public).toBe(true);
   });
 });