@jmruthers/pace-core 0.6.9 → 0.6.11

package/src/components/FileDisplay/usePublicFileDisplay.test.ts

@@ -0,0 +1,729 @@
+/**
+ * @file Unit Tests for usePublicFileDisplay Hook
+ * @package @jmruthers/pace-core
+ * @module Hooks/Public
+ * @since 1.0.0
+ */
+
+import { renderHook, waitFor } from '@testing-library/react';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { usePublicFileDisplay, clearPublicFileDisplayCache, getPublicFileDisplayCacheStats } from './usePublicFileDisplay';
+import { createMockSupabaseClient } from '../../__tests__/helpers/supabaseMock';
+import { generateFileUrlsBatch } from '../../utils/storage/helpers';
+import type { SupabaseClient } from '@supabase/supabase-js';
+import type { Database } from '../../types/database';
+import { FileCategory } from '../../types/file-reference';
+
+// Following testing standards: use timeout parameter to prevent hanging
+const TEST_TIMEOUT = 10000; // 10 seconds per test
+
+vi.mock('../../utils/core/logger', () => ({
+  logger: {
+    debug: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn()
+  }
+}));
+
+vi.mock('../../utils/storage/helpers', () => ({
+  getPublicUrl: vi.fn((_supabase, path) => `https://cdn.example.com/${path}`),
+  generateFileUrlsBatch: vi.fn().mockImplementation(async (_supabase, files: Array<{ id: string; file_path: string }>) => {
+    const map = new Map<string, string>();
+    for (const f of files) {
+      map.set(f.id, `https://cdn.example.com/${f.file_path}`);
+    }
+    return { ok: true, data: map };
+  })
+}));
+
+const VALID_ORG_ID = '123e4567-e89b-12d3-a456-426614174000';
+
+describe('[unit] usePublicFileDisplay', () => {
+  let mockSupabase: SupabaseClient<Database>;
+
+  beforeEach(() => {
+    mockSupabase = createMockSupabaseClient() as unknown as SupabaseClient<Database>;
+    clearPublicFileDisplayCache();
+
+    // Re-apply after clearAllMocks so generateFileUrlsBatch always returns ApiResult shape
+    vi.mocked(generateFileUrlsBatch).mockImplementation(async (_supabase, files: Array<{ id: string; file_path: string }>) => {
+      const map = new Map<string, string>();
+      for (const f of files) {
+        map.set(f.id, `https://cdn.example.com/${f.file_path}`);
+      }
+      return { ok: true, data: map };
+    });
+
+    // Setup default mock for RPC calls
+    (mockSupabase.rpc as any) = vi.fn().mockResolvedValue({ data: [], error: null });
+
+    // Setup default mock for query builder
+    const mockQueryBuilder = {
+      select: vi.fn().mockReturnThis(),
+      eq: vi.fn().mockReturnThis(),
+      in: vi.fn().mockResolvedValue({ data: [], error: null })
+    };
+    (mockSupabase.from as any).mockReturnValue(mockQueryBuilder);
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+    clearPublicFileDisplayCache();
+  });
+
+  describe('Initialization', () => {
+    it('returns initial state when parameters are missing', () => {
+      const { result } = renderHook(() =>
+        usePublicFileDisplay(undefined, undefined, undefined, undefined, {
+          supabase: mockSupabase
+        })
+      );
+
+      expect(result.current.fileUrl).toBeNull();
+      expect(result.current.fileReference).toBeNull();
+      expect(result.current.fileReferences).toEqual([]);
+      expect(result.current.fileUrls.size).toBe(0);
+      expect(result.current.fileCount).toBe(0);
+      expect(result.current.isLoading).toBe(false);
+      expect(result.current.error).toBeNull();
+    }, TEST_TIMEOUT);
+
+    it('returns loading state when parameters are provided', () => {
+      const { result } = renderHook(() =>
+        usePublicFileDisplay('core_events', 'event-123', VALID_ORG_ID, FileCategory.EVENT_LOGOS, {
+          supabase: mockSupabase
+        })
+      );
+
+      expect(result.current.isLoading).toBe(true);
+    }, TEST_TIMEOUT);
+  });
+
+  describe('Cache Management', () => {
+    it('clears cached file entries when clearPublicFileDisplayCache is called', () => {
+      clearPublicFileDisplayCache();
+      const stats = getPublicFileDisplayCacheStats();
+      expect(stats.size).toBe(0);
+    }, TEST_TIMEOUT);
+
+    it('provides cache statistics', () => {
+      const stats = getPublicFileDisplayCacheStats();
+      expect(stats).toHaveProperty('size');
+      expect(stats).toHaveProperty('keys');
+      expect(Array.isArray(stats.keys)).toBe(true);
+    }, TEST_TIMEOUT);
+  });
+
+  describe('Refetch Functionality', () => {
+    it('provides refetch function', () => {
+      const { result } = renderHook(() =>
+        usePublicFileDisplay('core_events', 'event-123', VALID_ORG_ID, FileCategory.EVENT_LOGOS, {
+          supabase: mockSupabase
+        })
+      );
+
+      expect(typeof result.current.refetch).toBe('function');
+    }, TEST_TIMEOUT);
+
+    it('refetch is callable without errors', async () => {
+      const { result } = renderHook(() =>
+        usePublicFileDisplay('core_events', 'event-123', VALID_ORG_ID, FileCategory.EVENT_LOGOS, {
+          supabase: mockSupabase
+        })
+      );
+
+      await waitFor(() => expect(result.current.isLoading).toBe(false), { timeout: TEST_TIMEOUT });
+
+      // Should complete without throwing
+      expect(result.current).toBeDefined();
+    }, TEST_TIMEOUT);
+  });
+
+  describe('Options', () => {
+    it('accepts cache options', () => {
+      const { result } = renderHook(() =>
+        usePublicFileDisplay('core_events', 'event-123', VALID_ORG_ID, FileCategory.EVENT_LOGOS, {
+          supabase: mockSupabase,
+          cacheTtl: 60000,
+          enableCache: true
+        })
+      );
+
+      expect(result.current).toBeDefined();
+    }, TEST_TIMEOUT);
+
+    it('accepts disabled cache option', () => {
+      const { result } = renderHook(() =>
+        usePublicFileDisplay('core_events', 'event-123', VALID_ORG_ID, FileCategory.EVENT_LOGOS, {
+          supabase: mockSupabase,
+          enableCache: false
+        })
+      );
+
+      expect(result.current).toBeDefined();
+    }, TEST_TIMEOUT);
+  });
+
+  describe('Edge Cases', () => {
+    it('handles missing table_name gracefully', async () => {
+      const { result } = renderHook(() =>
+        usePublicFileDisplay(undefined, 'event-123', VALID_ORG_ID, FileCategory.EVENT_LOGOS, {
+          supabase: mockSupabase
+        })
+      );
+
+      await waitFor(() => expect(result.current.isLoading).toBe(false), { timeout: TEST_TIMEOUT });
+      expect(result.current.fileUrl).toBeNull();
+      expect(result.current.fileCount).toBe(0);
+    }, TEST_TIMEOUT);
+
+    it('handles missing record_id gracefully', async () => {
+      const { result } = renderHook(() =>
+        usePublicFileDisplay('core_events', undefined, VALID_ORG_ID, FileCategory.EVENT_LOGOS, {
+          supabase: mockSupabase
+        })
+      );
+
+      await waitFor(() => expect(result.current.isLoading).toBe(false), { timeout: TEST_TIMEOUT });
+      expect(result.current.fileUrl).toBeNull();
+      expect(result.current.fileCount).toBe(0);
+    }, TEST_TIMEOUT);
+
+    it('handles missing category (multiple files mode)', () => {
+      const { result } = renderHook(() =>
+        usePublicFileDisplay('core_events', 'event-123', VALID_ORG_ID, undefined, {
+          supabase: mockSupabase
+        })
+      );
+
+      expect(result.current).toBeDefined();
+      expect(result.current.fileUrl).toBeNull(); // Multiple files mode doesn't set fileUrl
+    }, TEST_TIMEOUT);
+  });
+
+  describe('Single File Mode (with category)', () => {
+    it('fetches single file when category is provided', async () => {
+      const fileData = {
+        id: 'file-1',
+        file_path: 'path/to/file.png',
+        file_metadata: { category: FileCategory.EVENT_LOGOS },
+        is_public: true
+      };
+
+      (mockSupabase.rpc as any).mockResolvedValueOnce({
+        data: [fileData],
+        error: null
+      });
+
+      const { result } = renderHook(() =>
+        usePublicFileDisplay('core_events', 'event-123', VALID_ORG_ID, FileCategory.EVENT_LOGOS, {
+          supabase: mockSupabase
+        })
+      );
+
+      await waitFor(() => expect(result.current.isLoading).toBe(false), { timeout: TEST_TIMEOUT });
+      expect(mockSupabase.rpc).toHaveBeenCalledWith(
+        'data_file_reference_by_category_list',
+        expect.objectContaining({
+          p_table_name: 'core_events',
+          p_record_id: 'event-123',
+          p_category: FileCategory.EVENT_LOGOS
+        })
+      );
+    }, TEST_TIMEOUT);
+
+    it('sets fileUrl and fileReference in single file mode', async () => {
+      const fileData = {
+        id: 'file-1',
+        file_path: 'path/to/file.png',
+        file_metadata: { category: FileCategory.EVENT_LOGOS },
+        is_public: true,
+        created_at: '2024-01-01T00:00:00Z'
+      };
+
+      (mockSupabase.rpc as any).mockResolvedValueOnce({
+        data: [fileData],
+        error: null
+      });
+
+      const { result } = renderHook(() =>
+        usePublicFileDisplay('core_events', 'event-123', VALID_ORG_ID, FileCategory.EVENT_LOGOS, {
+          supabase: mockSupabase
+        })
+      );
+
+      await waitFor(() => expect(result.current.isLoading).toBe(false), { timeout: TEST_TIMEOUT });
+      expect(result.current.fileUrl).toBeDefined();
+      expect(result.current.fileReference).toBeDefined();
+      expect(result.current.fileReference?.id).toBe('file-1');
+    }, TEST_TIMEOUT);
+  });
+
+  describe('Multiple Files Mode (without category)', () => {
+    it('fetches all files when category is not provided', async () => {
+      const fileIds = [{ id: 'file-1' }, { id: 'file-2' }];
+
+      (mockSupabase.rpc as any).mockResolvedValueOnce({
+        data: fileIds,
+        error: null
+      });
+
+      const mockQueryBuilder = {
+        select: vi.fn().mockReturnThis(),
+        in: vi.fn().mockReturnThis(),
+        eq: vi.fn().mockResolvedValue({
+          data: [
+            { id: 'file-1', file_path: 'path/to/file1.png', is_public: true },
+            { id: 'file-2', file_path: 'path/to/file2.png', is_public: true }
+          ],
+          error: null
+        })
+      };
+      (mockSupabase.from as any).mockReturnValue(mockQueryBuilder);
+
+      const { result } = renderHook(() =>
+        usePublicFileDisplay('core_events', 'event-123', VALID_ORG_ID, undefined, {
+          supabase: mockSupabase
+        })
+      );
+
+      await waitFor(() => expect(result.current.isLoading).toBe(false), { timeout: TEST_TIMEOUT });
+      expect(mockSupabase.rpc).toHaveBeenCalledWith(
+        'data_file_reference_list',
+        expect.objectContaining({
+          p_table_name: 'core_events',
+          p_record_id: 'event-123'
+        })
+      );
+    }, TEST_TIMEOUT);
+
+    it('sets fileReferences and fileUrls in multiple files mode', async () => {
+      const fileIds = [{ id: 'file-1' }, { id: 'file-2' }];
+      const fromRows = [
+        {
+          id: 'file-1',
+          file_path: 'path/to/file1.png',
+          is_public: true,
+          file_metadata: { category: FileCategory.EVENT_LOGOS },
+          table_name: 'core_events',
+          record_id: 'event-123',
+          organisation_id: VALID_ORG_ID,
+          app_id: '',
+          created_at: '2024-01-01T00:00:00Z',
+          updated_at: '2024-01-01T00:00:00Z',
+          created_by: null
+        },
+        {
+          id: 'file-2',
+          file_path: 'path/to/file2.png',
+          is_public: true,
+          file_metadata: { category: FileCategory.GENERAL_DOCUMENTS },
+          table_name: 'core_events',
+          record_id: 'event-123',
+          organisation_id: VALID_ORG_ID,
+          app_id: '',
+          created_at: '2024-01-01T00:00:00Z',
+          updated_at: '2024-01-01T00:00:00Z',
+          created_by: null
+        }
+      ];
+
+      const fromBuilder = {
+        select: vi.fn().mockReturnThis(),
+        in: vi.fn().mockReturnThis(),
+        eq: vi.fn().mockResolvedValue({ data: fromRows, error: null })
+      };
+      const supabaseForTest = {
+        ...mockSupabase,
+        rpc: vi.fn().mockImplementation((name: string) => {
+          if (name === 'data_file_reference_list') return Promise.resolve({ data: fileIds, error: null });
+          return Promise.resolve({ data: [], error: null });
+        }),
+        from: vi.fn(() => fromBuilder)
+      } as unknown as SupabaseClient<Database>;
+
+      const { result } = renderHook(() =>
+        usePublicFileDisplay('core_events', 'event-123', VALID_ORG_ID, undefined, {
+          supabase: supabaseForTest,
+          enableCache: false
+        })
+      );
+
+      await waitFor(() => expect(result.current.isLoading).toBe(false), { timeout: TEST_TIMEOUT });
+      expect(result.current.error).toBeNull(); // If hook threw, error would be set
+      expect(result.current.fileReferences.length).toBe(2);
+      expect(result.current.fileCount).toBe(2);
+      expect(result.current.fileUrl).toBeNull(); // Multiple files mode
+      expect(result.current.fileReference).toBeNull(); // Multiple files mode
+    }, TEST_TIMEOUT);
+  });
+
+  describe('Organisation ID Edge Cases', () => {
+    it('handles undefined organisation_id (searches both user and org scoped)', async () => {
+      (mockSupabase.rpc as any).mockResolvedValueOnce({
+        data: [],
+        error: null
+      });
+
+      const { result } = renderHook(() =>
+        usePublicFileDisplay('core_events', 'event-123', undefined, FileCategory.EVENT_LOGOS, {
+          supabase: mockSupabase
+        })
+      );
+
+      await waitFor(() => expect(result.current.isLoading).toBe(false), { timeout: TEST_TIMEOUT });
+      expect(mockSupabase.rpc).toHaveBeenCalledWith(
+        'data_file_reference_by_category_list',
+        expect.objectContaining({
+          p_organisation_id: undefined
+        })
+      );
+    }, TEST_TIMEOUT);
+
+    it('handles null organisation_id explicitly (normalised to undefined for RPC)', async () => {
+      (mockSupabase.rpc as any).mockResolvedValueOnce({
+        data: [],
+        error: null
+      });
+
+      const { result } = renderHook(() =>
+        usePublicFileDisplay('core_events', 'event-123', null, FileCategory.EVENT_LOGOS, {
+          supabase: mockSupabase
+        })
+      );
+
+      await waitFor(() => expect(result.current.isLoading).toBe(false), { timeout: TEST_TIMEOUT });
+      expect(mockSupabase.rpc).toHaveBeenCalledWith(
+        'data_file_reference_by_category_list',
+        expect.objectContaining({
+          p_organisation_id: undefined
+        })
+      );
+    }, TEST_TIMEOUT);
+
+    it('handles invalid organisation_id format', async () => {
+      (mockSupabase.rpc as any).mockResolvedValueOnce({
+        data: [],
+        error: null
+      });
+
+      const { result } = renderHook(() =>
+        usePublicFileDisplay('core_events', 'event-123', 'invalid-uuid', FileCategory.EVENT_LOGOS, {
+          supabase: mockSupabase
+        })
+      );
+
+      await waitFor(() => expect(result.current.isLoading).toBe(false), { timeout: TEST_TIMEOUT });
+      // Should still attempt to fetch (database will handle validation)
+      expect(mockSupabase.rpc).toHaveBeenCalled();
+    }, TEST_TIMEOUT);
+  });
+
+  describe('RPC Error Handling', () => {
+    it('handles RPC function errors in single file mode', async () => {
+      (mockSupabase.rpc as any).mockResolvedValueOnce({
+        data: null,
+        error: { message: 'RPC function error', code: 'PGRST500' }
+      });
+
+      const { result } = renderHook(() =>
+        usePublicFileDisplay('core_events', 'event-123', VALID_ORG_ID, FileCategory.EVENT_LOGOS, {
+          supabase: mockSupabase
+        })
+      );
+
+      await waitFor(() => expect(result.current.isLoading).toBe(false), { timeout: TEST_TIMEOUT });
+      expect(result.current.error).toBeDefined();
+      expect(result.current.error?.message).toContain('RPC function error');
+    }, TEST_TIMEOUT);
+
+    it('handles RPC function errors in multiple files mode', async () => {
+      (mockSupabase.rpc as any).mockResolvedValueOnce({
+        data: null,
+        error: { message: 'RPC function error', code: 'PGRST500' }
+      });
+
+      const { result } = renderHook(() =>
+        usePublicFileDisplay('core_events', 'event-123', VALID_ORG_ID, undefined, {
+          supabase: mockSupabase
+        })
+      );
+
+      await waitFor(() => expect(result.current.isLoading).toBe(false), { timeout: TEST_TIMEOUT });
+      expect(result.current.error).toBeDefined();
+      expect(result.current.error?.message).toContain('RPC function error');
+    }, TEST_TIMEOUT);
+  });
+
+  describe('Cache Behavior', () => {
+    it('uses cached data when available and not expired', async () => {
+      const fileData = {
+        id: 'file-1',
+        file_path: 'path/to/file.png',
+        file_metadata: { category: FileCategory.EVENT_LOGOS },
+        is_public: true,
+        created_at: '2024-01-01T00:00:00Z'
+      };
+
+      (mockSupabase.rpc as any).mockResolvedValueOnce({
+        data: [fileData],
+        error: null
+      });
+
+      // First call
+      const { result: result1 } = renderHook(() =>
+        usePublicFileDisplay('core_events', 'event-123', VALID_ORG_ID, FileCategory.EVENT_LOGOS, {
+          supabase: mockSupabase,
+          cacheTtl: 60000 // Long TTL
+        })
+      );
+
+      await waitFor(() => expect(result1.current.isLoading).toBe(false), { timeout: TEST_TIMEOUT });
+
+      // Second call - should use cache
+      const { result: result2 } = renderHook(() =>
+        usePublicFileDisplay('core_events', 'event-123', VALID_ORG_ID, FileCategory.EVENT_LOGOS, {
+          supabase: mockSupabase,
+          cacheTtl: 60000
+        })
+      );
+
+      // Should use cache (only one RPC call)
+      expect(mockSupabase.rpc).toHaveBeenCalledTimes(1);
+      expect(result2.current.fileReference).toBeDefined();
+    }, TEST_TIMEOUT);
+
+    it('bypasses cache when enableCache is false', async () => {
+      const fileData = {
+        id: 'file-1',
+        file_path: 'path/to/file.png',
+        file_metadata: { category: FileCategory.EVENT_LOGOS },
+        is_public: true,
+        created_at: '2024-01-01T00:00:00Z'
+      };
+
+      (mockSupabase.rpc as any).mockResolvedValue({
+        data: [fileData],
+        error: null
+      });
+
+      const { result } = renderHook(() =>
+        usePublicFileDisplay('core_events', 'event-123', VALID_ORG_ID, FileCategory.EVENT_LOGOS, {
+          supabase: mockSupabase,
+          enableCache: false
+        })
+      );
+
+      await waitFor(() => expect(result.current.isLoading).toBe(false), { timeout: TEST_TIMEOUT });
+
+      // Should call RPC (cache disabled)
+      expect(mockSupabase.rpc).toHaveBeenCalled();
+    }, TEST_TIMEOUT);
+  });
+
+  describe('File Reference Transformation', () => {
+    it('transforms RPC response to FileReference correctly', async () => {
+      const fileData = {
+        id: 'file-1',
+        file_path: 'path/to/file.png',
+        file_metadata: { 
+          category: FileCategory.EVENT_LOGOS,
+          fileName: 'logo.png',
+          fileType: 'png'
+        },
+        is_public: true,
+        created_at: '2024-01-01T00:00:00Z'
+      };
+
+      (mockSupabase.rpc as any).mockResolvedValueOnce({
+        data: [fileData],
+        error: null
+      });
+
+      const { result } = renderHook(() =>
+        usePublicFileDisplay('core_events', 'event-123', VALID_ORG_ID, FileCategory.EVENT_LOGOS, {
+          supabase: mockSupabase
+        })
+      );
+
+      await waitFor(() => expect(result.current.isLoading).toBe(false), { timeout: TEST_TIMEOUT });
+      expect(result.current.fileReference).toBeDefined();
+      expect(result.current.fileReference?.id).toBe('file-1');
+      expect(result.current.fileReference?.file_metadata.category).toBe(FileCategory.EVENT_LOGOS);
+    }, TEST_TIMEOUT);
+
+    it('extracts file name and type from file_path when not in metadata', async () => {
+      const fileData = {
+        id: 'file-1',
+        file_path: 'path/to/logo.png',
+        file_metadata: { category: FileCategory.EVENT_LOGOS },
+        is_public: true,
+        created_at: '2024-01-01T00:00:00Z'
+      };
+
+      (mockSupabase.rpc as any).mockResolvedValueOnce({
+        data: [fileData],
+        error: null
+      });
+
+      const { result } = renderHook(() =>
+        usePublicFileDisplay('core_events', 'event-123', VALID_ORG_ID, FileCategory.EVENT_LOGOS, {
+          supabase: mockSupabase
+        })
+      );
+
+      await waitFor(() => expect(result.current.isLoading).toBe(false), { timeout: TEST_TIMEOUT });
+      expect(result.current.fileReference).toBeDefined();
+      expect(result.current.fileReference?.file_metadata.fileName).toBe('logo.png');
+      expect(result.current.fileReference?.file_metadata.fileType).toBe('png');
+    }, TEST_TIMEOUT);
+  });
+
+  describe('Public Files Filtering', () => {
+    it('only returns public files', async () => {
+      const fileIds = [{ id: 'file-1' }, { id: 'file-2' }];
+      // .eq('is_public', true) returns only public rows
+      const fromRows = [
+        {
+          id: 'file-1',
+          file_path: 'path/to/file1.png',
+          is_public: true,
+          file_metadata: {},
+          table_name: 'core_events',
+          record_id: 'event-123',
+          organisation_id: VALID_ORG_ID,
+          app_id: '',
+          created_at: '2024-01-01T00:00:00Z',
+          updated_at: '2024-01-01T00:00:00Z',
+          created_by: null
+        }
+      ];
+
+      const fromBuilder = {
+        select: vi.fn().mockReturnThis(),
+        in: vi.fn().mockReturnThis(),
+        eq: vi.fn().mockResolvedValue({ data: fromRows, error: null })
+      };
+      const supabaseForTest = {
+        ...mockSupabase,
+        rpc: vi.fn().mockImplementation((name: string) => {
+          if (name === 'data_file_reference_list') return Promise.resolve({ data: fileIds, error: null });
+          return Promise.resolve({ data: [], error: null });
+        }),
+        from: vi.fn(() => fromBuilder)
+      } as unknown as SupabaseClient<Database>;
+
+      const { result } = renderHook(() =>
+        usePublicFileDisplay('core_events', 'event-123', VALID_ORG_ID, undefined, {
+          supabase: supabaseForTest,
+          enableCache: false
+        })
+      );
+
+      await waitFor(() => expect(result.current.isLoading).toBe(false), { timeout: TEST_TIMEOUT });
+      expect(result.current.fileReferences.length).toBe(1);
+      expect(result.current.fileCount).toBe(1);
+      expect(result.current.fileReferences[0].id).toBe('file-1');
+    }, TEST_TIMEOUT);
+  });
+
+  describe('Empty Results', () => {
+    it('handles empty file list gracefully', async () => {
+      (mockSupabase.rpc as any).mockResolvedValueOnce({
+        data: [],
+        error: null
+      });
+
+      const { result } = renderHook(() =>
+        usePublicFileDisplay('core_events', 'event-123', VALID_ORG_ID, FileCategory.EVENT_LOGOS, {
+          supabase: mockSupabase
+        })
+      );
+
+      await waitFor(() => expect(result.current.isLoading).toBe(false), { timeout: TEST_TIMEOUT });
+      expect(result.current.fileUrl).toBeNull();
+      expect(result.current.fileReference).toBeNull();
+      expect(result.current.fileReferences).toEqual([]);
+      expect(result.current.fileCount).toBe(0);
+    }, TEST_TIMEOUT);
+
+    it('caches empty results', async () => {
+      (mockSupabase.rpc as any).mockResolvedValueOnce({
+        data: [],
+        error: null
+      });
+
+      const { result } = renderHook(() =>
+        usePublicFileDisplay('core_events', 'event-123', VALID_ORG_ID, FileCategory.EVENT_LOGOS, {
+          supabase: mockSupabase
+        })
+      );
+
+      await waitFor(() => expect(result.current.isLoading).toBe(false), { timeout: TEST_TIMEOUT });
+
+      // Second call should use cache
+      const { result: result2 } = renderHook(() =>
+        usePublicFileDisplay('core_events', 'event-123', VALID_ORG_ID, FileCategory.EVENT_LOGOS, {
+          supabase: mockSupabase
+        })
+      );
+
+      // Should use cache (only one RPC call)
+      expect(mockSupabase.rpc).toHaveBeenCalledTimes(1);
+      expect(result2.current.fileCount).toBe(0);
+    }, TEST_TIMEOUT);
+  });
+
+  describe('Parameter Changes', () => {
+    it('refetches when table_name changes', async () => {
+      (mockSupabase.rpc as any).mockResolvedValue({ data: [], error: null });
+
+      const { result, rerender } = renderHook(
+        ({ tableName }) => usePublicFileDisplay(tableName, 'event-123', VALID_ORG_ID, FileCategory.EVENT_LOGOS, {
+          supabase: mockSupabase
+        }),
+        { initialProps: { tableName: 'core_events' } }
+      );
+
+      await waitFor(() => expect(result.current.isLoading).toBe(false), { timeout: TEST_TIMEOUT });
+
+      rerender({ tableName: 'core_organisations' });
+
+      await waitFor(() => expect(mockSupabase.rpc).toHaveBeenCalledTimes(2), { timeout: TEST_TIMEOUT });
+    }, TEST_TIMEOUT);
+
+    it('refetches when record_id changes', async () => {
+      (mockSupabase.rpc as any).mockResolvedValue({ data: [], error: null });
+
+      const { result, rerender } = renderHook(
+        ({ recordId }) => usePublicFileDisplay('core_events', recordId, VALID_ORG_ID, FileCategory.EVENT_LOGOS, {
+          supabase: mockSupabase
+        }),
+        { initialProps: { recordId: 'event-1' } }
+      );
+
+      await waitFor(() => expect(result.current.isLoading).toBe(false), { timeout: TEST_TIMEOUT });
+
+      rerender({ recordId: 'event-2' });
+
+      await waitFor(() => expect(mockSupabase.rpc).toHaveBeenCalledTimes(2), { timeout: TEST_TIMEOUT });
+    }, TEST_TIMEOUT);
+
+    it('refetches when category changes', async () => {
+      (mockSupabase.rpc as any).mockResolvedValue({ data: [], error: null });
+
+      const { result, rerender } = renderHook(
+        ({ category }) => usePublicFileDisplay('core_events', 'event-123', VALID_ORG_ID, category, {
+          supabase: mockSupabase
+        }),
+        { initialProps: { category: FileCategory.EVENT_LOGOS } }
+      );
+
+      await waitFor(() => expect(result.current.isLoading).toBe(false), { timeout: TEST_TIMEOUT });
+
+      rerender({ category: FileCategory.GENERAL_DOCUMENTS });
+
+      await waitFor(() => expect(mockSupabase.rpc).toHaveBeenCalledTimes(2), { timeout: TEST_TIMEOUT });
+    }, TEST_TIMEOUT);
+  });
+});