@jmruthers/pace-core 0.6.4 → 0.6.6

package/src/hooks/__tests__/usePublicEvent.simple.test.ts

@@ -14,25 +14,26 @@ vi.mock('../../components/PublicLayout/PublicPageProvider', () => ({
   }))
 }));
 
-// Mock Supabase client
+// Mock Supabase client with proper query builder chain
+// usePublicEvent uses: .from('core_events').select(...).eq(...).eq(...).not(...).limit(1).single()
+const createMockQueryBuilder = (mockData: any = null, mockError: any = null) => {
+  const builder: any = {
+    select: vi.fn().mockReturnThis(),
+    eq: vi.fn().mockReturnThis(),
+    not: vi.fn().mockReturnThis(),
+    limit: vi.fn().mockReturnThis(),
+    single: vi.fn().mockResolvedValue({ data: mockData, error: mockError }),
+    maybeSingle: vi.fn().mockResolvedValue({ data: mockData, error: mockError })
+  };
+  return builder;
+};
+
 const mockSupabaseClient = {
-  rpc: vi.fn(),
-  from: vi.fn(() => ({
-    select: vi.fn(() => ({
-      eq: vi.fn(() => ({
-        eq: vi.fn(() => ({
-          not: vi.fn(() => ({
-            limit: vi.fn(() => ({
-              single: vi.fn()
-            }))
-          }))
-        }))
-      }))
-    }))
-  }))
+  rpc: vi.fn().mockResolvedValue({ data: null, error: null }),
+  from: vi.fn(() => createMockQueryBuilder())
 };
 
-// Mock createClient
+// Mock createClient to return our mock client
 vi.mock('@supabase/supabase-js', () => ({
   createClient: vi.fn(() => mockSupabaseClient)
 }));
@@ -118,16 +119,30 @@ describe('usePublicEvent - Simple Tests', () => {
         event_logo: null
       };
 
-      mockSupabaseClient.rpc.mockResolvedValueOnce({
-        data: [mockEventData],
-        error: null
-      });
+      // usePublicEvent uses: .from('core_events').select(...).eq(...).eq(...).not(...).limit(1).single()
+      const mockQueryBuilder = {
+        select: vi.fn().mockReturnThis(),
+        eq: vi.fn().mockReturnThis(),
+        not: vi.fn().mockReturnThis(),
+        limit: vi.fn().mockReturnThis(),
+        single: vi.fn().mockResolvedValue({ 
+          data: {
+            ...mockEventData,
+            event_code: 'test-event',
+            is_visible: true,
+            created_at: '2024-01-01T00:00:00Z',
+            updated_at: '2024-01-01T00:00:00Z'
+          }, 
+          error: null 
+        })
+      };
+      mockSupabaseClient.from.mockReturnValue(mockQueryBuilder);
 
       const { result } = renderHook(() => usePublicEvent('test-event'));
 
       await waitFor(() => {
         expect(result.current.isLoading).toBe(false);
-      });
+      }, { timeout: 2000 });
 
       expect(result.current.event).toEqual({
         id: '123',
@@ -198,22 +213,30 @@ describe('usePublicEvent - Simple Tests', () => {
         event_logo: null
       };
 
-      mockSupabaseClient.rpc.mockResolvedValueOnce({
-        data: [mockEventData],
-        error: null
+      // usePublicEvent makes TWO queries: core_events + core_file_references (logo)
+      const mockEventQueryBuilder = createMockQueryBuilder({
+        ...mockEventData,
+        event_code: 'test-event',
+        is_visible: true,
+        created_at: '2024-01-01T00:00:00Z',
+        updated_at: '2024-01-01T00:00:00Z'
       });
+      const mockLogoQueryBuilder = createMockQueryBuilder(null, null);
+      mockSupabaseClient.from
+        .mockReturnValueOnce(mockEventQueryBuilder)
+        .mockReturnValueOnce(mockLogoQueryBuilder);
 
       const { result, rerender } = renderHook(() => usePublicEvent('test-event'));
 
       await waitFor(() => {
         expect(result.current.isLoading).toBe(false);
-      });
+      }, { timeout: 2000 });
 
       // Rerender with same event code - should use cache
       rerender();
       
-      // Should not call RPC again
-      expect(mockSupabaseClient.rpc).toHaveBeenCalledTimes(1);
+      // Should not call query again (cached) - but initial call was 2 (event + logo)
+      expect(mockSupabaseClient.from).toHaveBeenCalledTimes(2);
     });
   });
 
@@ -248,16 +271,24 @@ describe('usePublicEvent - Simple Tests', () => {
         event_logo: null
       };
 
-      mockSupabaseClient.rpc.mockResolvedValueOnce({
-        data: [mockEventData],
-        error: null
+      // usePublicEvent makes TWO queries: core_events + core_file_references (logo)
+      const mockEventQueryBuilder = createMockQueryBuilder({
+        ...mockEventData,
+        event_code: 'test-event',
+        is_visible: true,
+        created_at: '2024-01-01T00:00:00Z',
+        updated_at: '2024-01-01T00:00:00Z'
       });
+      const mockLogoQueryBuilder = createMockQueryBuilder(null, null);
+      mockSupabaseClient.from
+        .mockReturnValueOnce(mockEventQueryBuilder)
+        .mockReturnValueOnce(mockLogoQueryBuilder);
 
       const { result } = renderHook(() => usePublicEvent('test-event'));
 
       await waitFor(() => {
         expect(result.current.isLoading).toBe(false);
-      });
+      }, { timeout: 2000 });
 
       expect(result.current.event).toBeTruthy();
     });
@@ -307,25 +338,40 @@ describe('usePublicEvent - Simple Tests', () => {
         event_logo: null
       };
 
-      mockSupabaseClient.rpc.mockResolvedValue({
-        data: [mockEventData],
-        error: null
+      // usePublicEvent makes TWO queries: core_events + core_file_references (logo)
+      const mockEventQueryBuilder = createMockQueryBuilder({
+        ...mockEventData,
+        event_code: 'test-event',
+        is_visible: true,
+        created_at: '2024-01-01T00:00:00Z',
+        updated_at: '2024-01-01T00:00:00Z'
       });
+      const mockLogoQueryBuilder = createMockQueryBuilder(null, null);
+      mockSupabaseClient.from
+        .mockReturnValueOnce(mockEventQueryBuilder)
+        .mockReturnValueOnce(mockLogoQueryBuilder);
 
       const { result } = renderHook(() => usePublicEvent('test-event', { enableCache: true }));
 
       await waitFor(() => {
         expect(result.current.isLoading).toBe(false);
-      });
+      }, { timeout: 2000 });
 
-      const firstCallCount = mockSupabaseClient.rpc.mock.calls.length;
+      const firstCallCount = mockSupabaseClient.from.mock.calls.length;
 
       // Update mock to return different data
       const updatedEventData = { ...mockEventData, event_name: 'Updated Event' };
-      mockSupabaseClient.rpc.mockResolvedValue({
-        data: [updatedEventData],
-        error: null
+      const updatedEventQueryBuilder = createMockQueryBuilder({
+        ...updatedEventData,
+        event_code: 'test-event',
+        is_visible: true,
+        created_at: '2024-01-01T00:00:00Z',
+        updated_at: '2024-01-01T00:00:00Z'
       });
+      const updatedLogoQueryBuilder = createMockQueryBuilder(null, null);
+      mockSupabaseClient.from
+        .mockReturnValueOnce(updatedEventQueryBuilder)
+        .mockReturnValueOnce(updatedLogoQueryBuilder);
 
       await result.current.refetch();
 
@@ -334,7 +380,7 @@ describe('usePublicEvent - Simple Tests', () => {
       }, { timeout: 2000 });
 
       // Should have made another call
-      expect(mockSupabaseClient.rpc.mock.calls.length).toBeGreaterThan(firstCallCount);
+      expect(mockSupabaseClient.from.mock.calls.length).toBeGreaterThan(firstCallCount);
     });
 
     it('clears cache before refetching', async () => {
@@ -358,16 +404,24 @@ describe('usePublicEvent - Simple Tests', () => {
         event_logo: null
       };
 
-      mockSupabaseClient.rpc.mockResolvedValue({
-        data: [mockEventData],
-        error: null
+      // usePublicEvent makes TWO queries: core_events + core_file_references (logo)
+      const mockEventQueryBuilder = createMockQueryBuilder({
+        ...mockEventData,
+        event_code: 'test-event',
+        is_visible: true,
+        created_at: '2024-01-01T00:00:00Z',
+        updated_at: '2024-01-01T00:00:00Z'
       });
+      const mockLogoQueryBuilder = createMockQueryBuilder(null, null);
+      mockSupabaseClient.from
+        .mockReturnValueOnce(mockEventQueryBuilder)
+        .mockReturnValueOnce(mockLogoQueryBuilder);
 
       const { result } = renderHook(() => usePublicEvent('test-event', { enableCache: true }));
 
       await waitFor(() => {
         expect(result.current.isLoading).toBe(false);
-      });
+      }, { timeout: 2000 });
 
       // Verify cache exists
       const statsBefore = getPublicEventCacheStats();
@@ -404,10 +458,18 @@ describe('usePublicEvent - Simple Tests', () => {
         event_logo: null
       };
 
-      mockSupabaseClient.rpc.mockResolvedValue({
-        data: [mockEventData],
-        error: null
+      // usePublicEvent makes TWO queries: core_events + core_file_references (logo)
+      const mockEventQueryBuilder = createMockQueryBuilder({
+        ...mockEventData,
+        event_code: 'test-event',
+        is_visible: true,
+        created_at: '2024-01-01T00:00:00Z',
+        updated_at: '2024-01-01T00:00:00Z'
       });
+      const mockLogoQueryBuilder = createMockQueryBuilder(null, null);
+      mockSupabaseClient.from
+        .mockReturnValueOnce(mockEventQueryBuilder)
+        .mockReturnValueOnce(mockLogoQueryBuilder);
 
       const { result } = renderHook(() => usePublicEvent('test-event', {
         enableCache: true,
@@ -442,10 +504,18 @@ describe('usePublicEvent - Simple Tests', () => {
         event_logo: null
       };
 
-      mockSupabaseClient.rpc.mockResolvedValue({
-        data: [mockEventData],
-        error: null
+      // usePublicEvent makes TWO queries: core_events + core_file_references (logo)
+      const mockEventQueryBuilder = createMockQueryBuilder({
+        ...mockEventData,
+        event_code: 'test-event',
+        is_visible: true,
+        created_at: '2024-01-01T00:00:00Z',
+        updated_at: '2024-01-01T00:00:00Z'
       });
+      const mockLogoQueryBuilder = createMockQueryBuilder(null, null);
+      mockSupabaseClient.from
+        .mockReturnValueOnce(mockEventQueryBuilder)
+        .mockReturnValueOnce(mockLogoQueryBuilder);
 
       const { result, rerender } = renderHook(() => usePublicEvent('test-event', {
         enableCache: false
@@ -453,9 +523,9 @@ describe('usePublicEvent - Simple Tests', () => {
 
       await waitFor(() => {
         expect(result.current.isLoading).toBe(false);
-      });
+      }, { timeout: 2000 });
 
-      const firstCallCount = mockSupabaseClient.rpc.mock.calls.length;
+      const firstCallCount = mockSupabaseClient.from.mock.calls.length;
 
       // Rerender - should make another call since caching is disabled
       rerender();
@@ -467,12 +537,10 @@ describe('usePublicEvent - Simple Tests', () => {
   });
 
   describe('Error Handling', () => {
-    it('handles RPC errors that are not schema cache issues', async () => {
-      const rpcError = { message: 'Permission denied', code: 'PGRST301' };
-      mockSupabaseClient.rpc.mockResolvedValueOnce({
-        data: null,
-        error: rpcError
-      });
+    it('handles query errors that are not schema cache issues', async () => {
+      // usePublicEvent uses table query, not RPC
+      const mockQueryBuilder = createMockQueryBuilder(null, { message: 'Permission denied', code: 'PGRST301' });
+      mockSupabaseClient.from.mockReturnValue(mockQueryBuilder);
 
       const { result } = renderHook(() => usePublicEvent('test-event'));
 
@@ -559,15 +627,29 @@ describe('usePublicEvent - Simple Tests', () => {
         event_name: 'Event 2'
       };
 
-      mockSupabaseClient.rpc
-        .mockResolvedValueOnce({
-          data: [mockEventData1],
-          error: null
-        })
-        .mockResolvedValueOnce({
-          data: [mockEventData2],
-          error: null
-        });
+      // usePublicEvent makes TWO queries per event: core_events + core_file_references (logo)
+      const mockEventQueryBuilder1 = createMockQueryBuilder({
+        ...mockEventData1,
+        event_code: 'event-1',
+        is_visible: true,
+        created_at: '2024-01-01T00:00:00Z',
+        updated_at: '2024-01-01T00:00:00Z'
+      });
+      const mockLogoQueryBuilder1 = createMockQueryBuilder(null, null);
+      const mockEventQueryBuilder2 = createMockQueryBuilder({
+        ...mockEventData2,
+        event_code: 'event-2',
+        is_visible: true,
+        created_at: '2024-01-01T00:00:00Z',
+        updated_at: '2024-01-01T00:00:00Z'
+      });
+      const mockLogoQueryBuilder2 = createMockQueryBuilder(null, null);
+      
+      mockSupabaseClient.from
+        .mockReturnValueOnce(mockEventQueryBuilder1) // Event 1: event query
+        .mockReturnValueOnce(mockLogoQueryBuilder1)  // Event 1: logo query
+        .mockReturnValueOnce(mockEventQueryBuilder2) // Event 2: event query
+        .mockReturnValueOnce(mockLogoQueryBuilder2); // Event 2: logo query
 
       const { result, rerender } = renderHook(
         ({ eventCode }) => usePublicEvent(eventCode),