@jmruthers/pace-core 0.5.190 → 0.5.193

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

@@ -0,0 +1,703 @@
+import React from 'react';
+import { renderHook, waitFor } from '@testing-library/react';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { usePublicEvent, clearPublicEventCache, getPublicEventCacheStats } from '../public/usePublicEvent';
+import { usePublicPageContext } from '../../components/PublicLayout/PublicPageProvider';
+
+// Mock the PublicPageProvider
+vi.mock('../../components/PublicLayout/PublicPageProvider', () => ({
+  usePublicPageContext: vi.fn(() => ({
+    environment: {
+      supabaseUrl: 'https://test.supabase.co',
+      supabaseKey: 'test-anon-key'
+    }
+  }))
+}));
+
+// Mock Supabase client
+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()
+            }))
+          }))
+        }))
+      }))
+    }))
+  }))
+};
+
+// Mock createClient
+vi.mock('@supabase/supabase-js', () => ({
+  createClient: vi.fn(() => mockSupabaseClient)
+}));
+
+// Mock environment variables
+const originalEnv = import.meta.env;
+
+describe('usePublicEvent - Simple Tests', () => {
+  let originalMode: string | undefined;
+
+  beforeEach(() => {
+    // Ensure logger is enabled by setting MODE to development
+    originalMode = import.meta.env.MODE;
+    (import.meta.env as any).MODE = 'development';
+    
+    import('../../utils/core/logger').then(({ Logger, LogLevel }) => {
+      Logger.configure({
+        level: LogLevel.DEBUG,
+        includeTimestamp: false,
+        includeComponent: true,
+      });
+    });
+    
+    vi.clearAllMocks();
+    clearPublicEventCache();
+    
+    // Reset environment
+    Object.defineProperty(import.meta, 'env', {
+      value: {
+        VITE_SUPABASE_URL: 'https://test.supabase.co',
+        VITE_SUPABASE_ANON_KEY: 'test-anon-key'
+      },
+      writable: true
+    });
+
+    // Mock window object
+    Object.defineProperty(window, 'location', {
+      value: { href: 'https://test.com' },
+      writable: true
+    });
+  });
+
+  afterEach(() => {
+    // Restore original mode
+    if (originalMode !== undefined) {
+      (import.meta.env as any).MODE = originalMode;
+    }
+    vi.clearAllMocks();
+    clearPublicEventCache();
+    Object.defineProperty(import.meta, 'env', {
+      value: originalEnv,
+      writable: true
+    });
+  });
+
+  describe('Basic Functionality', () => {
+    it('should initialize with loading state', () => {
+      const { result } = renderHook(() => usePublicEvent('test-event'));
+
+      expect(result.current.isLoading).toBe(true);
+      expect(result.current.event).toBe(null);
+      expect(result.current.error).toBe(null);
+    });
+
+    it('should fetch event data successfully via RPC', async () => {
+      const mockEventData = {
+        event_id: '123',
+        event_name: 'Test Event',
+        event_date: '2024-01-01',
+        event_venue: 'Test Venue',
+        event_participants: 100,
+        event_colours: { primary: '#000000' },
+        organisation_id: 'org-123',
+        event_days: 1,
+        event_typicalunit: 'km',
+        event_rounddown: false,
+        event_youthmultiplier: 1.0,
+        event_catering_email: 'test@example.com',
+        event_news: 'Test news',
+        event_billing: 'Test billing',
+        event_footer: 'Test footer',
+        event_email: 'event@example.com',
+        event_logo: null
+      };
+
+      mockSupabaseClient.rpc.mockResolvedValueOnce({
+        data: [mockEventData],
+        error: null
+      });
+
+      const { result } = renderHook(() => usePublicEvent('test-event'));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
+
+      expect(result.current.event).toEqual({
+        id: '123',
+        event_id: '123',
+        event_name: 'Test Event',
+        event_code: 'test-event',
+        event_date: '2024-01-01',
+        event_venue: 'Test Venue',
+        event_participants: 100,
+        event_logo: null,
+        event_colours: { primary: '#000000' },
+        organisation_id: 'org-123',
+        is_visible: true,
+        created_at: expect.any(String),
+        updated_at: expect.any(String)
+      });
+      expect(result.current.error).toBe(null);
+    });
+
+    it('should handle event not found', async () => {
+      mockSupabaseClient.rpc.mockResolvedValueOnce({
+        data: [],
+        error: null
+      });
+
+      const { result } = renderHook(() => usePublicEvent('nonexistent-event'));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
+
+      expect(result.current.event).toBe(null);
+      expect(result.current.error).toEqual(new Error('Event not found'));
+    });
+
+    it('should handle invalid event code', async () => {
+      const { result } = renderHook(() => usePublicEvent(''));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
+
+      expect(result.current.event).toBe(null);
+      expect(result.current.error).toBeInstanceOf(Error);
+      expect(result.current.error?.message).toContain('Invalid event code or Supabase client not available');
+    });
+  });
+
+  describe('Caching', () => {
+    it('should cache event data', async () => {
+      const mockEventData = {
+        event_id: '123',
+        event_name: 'Test Event',
+        event_date: '2024-01-01',
+        event_venue: 'Test Venue',
+        event_participants: 100,
+        event_colours: { primary: '#000000' },
+        organisation_id: 'org-123',
+        event_days: 1,
+        event_typicalunit: 'km',
+        event_rounddown: false,
+        event_youthmultiplier: 1.0,
+        event_catering_email: 'test@example.com',
+        event_news: 'Test news',
+        event_billing: 'Test billing',
+        event_footer: 'Test footer',
+        event_email: 'event@example.com',
+        event_logo: null
+      };
+
+      mockSupabaseClient.rpc.mockResolvedValueOnce({
+        data: [mockEventData],
+        error: null
+      });
+
+      const { result, rerender } = renderHook(() => usePublicEvent('test-event'));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
+
+      // Rerender with same event code - should use cache
+      rerender();
+      
+      // Should not call RPC again
+      expect(mockSupabaseClient.rpc).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('Provider Context Integration', () => {
+    it('should use PublicPageContext when available', async () => {
+      const mockContext = {
+        environment: {
+          supabaseUrl: 'https://context.supabase.co',
+          supabaseKey: 'context-anon-key'
+        }
+      };
+
+      vi.mocked(usePublicPageContext).mockReturnValue(mockContext);
+
+      const mockEventData = {
+        event_id: '123',
+        event_name: 'Test Event',
+        event_date: '2024-01-01',
+        event_venue: 'Test Venue',
+        event_participants: 100,
+        event_colours: { primary: '#000000' },
+        organisation_id: 'org-123',
+        event_days: 1,
+        event_typicalunit: 'km',
+        event_rounddown: false,
+        event_youthmultiplier: 1.0,
+        event_catering_email: 'test@example.com',
+        event_news: 'Test news',
+        event_billing: 'Test billing',
+        event_footer: 'Test footer',
+        event_email: 'event@example.com',
+        event_logo: null
+      };
+
+      mockSupabaseClient.rpc.mockResolvedValueOnce({
+        data: [mockEventData],
+        error: null
+      });
+
+      const { result } = renderHook(() => usePublicEvent('test-event'));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
+
+      expect(result.current.event).toBeTruthy();
+    });
+  });
+
+  describe('Cache Management Utilities', () => {
+    it('should clear public event cache', () => {
+      // Add some data to cache
+      const stats = getPublicEventCacheStats();
+      expect(stats.size).toBe(0);
+
+      // Clear cache
+      clearPublicEventCache();
+      
+      const statsAfter = getPublicEventCacheStats();
+      expect(statsAfter.size).toBe(0);
+    });
+
+    it('should get cache statistics', () => {
+      const stats = getPublicEventCacheStats();
+      expect(stats).toEqual({
+        size: 0,
+        keys: []
+      });
+    });
+  });
+
+  describe('Refetch Functionality', () => {
+    it('refetches data when refetch is called', async () => {
+      const mockEventData = {
+        event_id: '123',
+        event_name: 'Test Event',
+        event_date: '2024-01-01',
+        event_venue: 'Test Venue',
+        event_participants: 100,
+        event_colours: { primary: '#000000' },
+        organisation_id: 'org-123',
+        event_days: 1,
+        event_typicalunit: 'km',
+        event_rounddown: false,
+        event_youthmultiplier: 1.0,
+        event_catering_email: 'test@example.com',
+        event_news: 'Test news',
+        event_billing: 'Test billing',
+        event_footer: 'Test footer',
+        event_email: 'event@example.com',
+        event_logo: null
+      };
+
+      mockSupabaseClient.rpc.mockResolvedValue({
+        data: [mockEventData],
+        error: null
+      });
+
+      const { result } = renderHook(() => usePublicEvent('test-event', { enableCache: true }));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
+
+      const firstCallCount = mockSupabaseClient.rpc.mock.calls.length;
+
+      // Update mock to return different data
+      const updatedEventData = { ...mockEventData, event_name: 'Updated Event' };
+      mockSupabaseClient.rpc.mockResolvedValue({
+        data: [updatedEventData],
+        error: null
+      });
+
+      await result.current.refetch();
+
+      await waitFor(() => {
+        expect(result.current.event?.event_name).toBe('Updated Event');
+      }, { timeout: 2000 });
+
+      // Should have made another call
+      expect(mockSupabaseClient.rpc.mock.calls.length).toBeGreaterThan(firstCallCount);
+    });
+
+    it('clears cache before refetching', async () => {
+      const mockEventData = {
+        event_id: '123',
+        event_name: 'Test Event',
+        event_date: '2024-01-01',
+        event_venue: 'Test Venue',
+        event_participants: 100,
+        event_colours: { primary: '#000000' },
+        organisation_id: 'org-123',
+        event_days: 1,
+        event_typicalunit: 'km',
+        event_rounddown: false,
+        event_youthmultiplier: 1.0,
+        event_catering_email: 'test@example.com',
+        event_news: 'Test news',
+        event_billing: 'Test billing',
+        event_footer: 'Test footer',
+        event_email: 'event@example.com',
+        event_logo: null
+      };
+
+      mockSupabaseClient.rpc.mockResolvedValue({
+        data: [mockEventData],
+        error: null
+      });
+
+      const { result } = renderHook(() => usePublicEvent('test-event', { enableCache: true }));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
+
+      // Verify cache exists
+      const statsBefore = getPublicEventCacheStats();
+      expect(statsBefore.size).toBeGreaterThan(0);
+
+      await result.current.refetch();
+
+      // Cache should be cleared and then repopulated
+      await waitFor(() => {
+        expect(result.current.event).toBeDefined();
+      }, { timeout: 2000 });
+    });
+  });
+
+  describe('Caching Options', () => {
+    it('respects cacheTtl option', async () => {
+      const mockEventData = {
+        event_id: '123',
+        event_name: 'Test Event',
+        event_date: '2024-01-01',
+        event_venue: 'Test Venue',
+        event_participants: 100,
+        event_colours: { primary: '#000000' },
+        organisation_id: 'org-123',
+        event_days: 1,
+        event_typicalunit: 'km',
+        event_rounddown: false,
+        event_youthmultiplier: 1.0,
+        event_catering_email: 'test@example.com',
+        event_news: 'Test news',
+        event_billing: 'Test billing',
+        event_footer: 'Test footer',
+        event_email: 'event@example.com',
+        event_logo: null
+      };
+
+      mockSupabaseClient.rpc.mockResolvedValue({
+        data: [mockEventData],
+        error: null
+      });
+
+      const { result } = renderHook(() => usePublicEvent('test-event', {
+        enableCache: true,
+        cacheTtl: 1000 // 1 second
+      }));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
+
+      expect(result.current.event).toBeTruthy();
+    });
+
+    it('disables caching when enableCache is false', async () => {
+      const mockEventData = {
+        event_id: '123',
+        event_name: 'Test Event',
+        event_date: '2024-01-01',
+        event_venue: 'Test Venue',
+        event_participants: 100,
+        event_colours: { primary: '#000000' },
+        organisation_id: 'org-123',
+        event_days: 1,
+        event_typicalunit: 'km',
+        event_rounddown: false,
+        event_youthmultiplier: 1.0,
+        event_catering_email: 'test@example.com',
+        event_news: 'Test news',
+        event_billing: 'Test billing',
+        event_footer: 'Test footer',
+        event_email: 'event@example.com',
+        event_logo: null
+      };
+
+      mockSupabaseClient.rpc.mockResolvedValue({
+        data: [mockEventData],
+        error: null
+      });
+
+      const { result, rerender } = renderHook(() => usePublicEvent('test-event', {
+        enableCache: false
+      }));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
+
+      const firstCallCount = mockSupabaseClient.rpc.mock.calls.length;
+
+      // Rerender - should make another call since caching is disabled
+      rerender();
+
+      await waitFor(() => {
+        expect(result.current.event).toBeTruthy();
+      }, { timeout: 2000 });
+    });
+  });
+
+  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
+      });
+
+      const { result } = renderHook(() => usePublicEvent('test-event'));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      }, { timeout: 2000 });
+
+      expect(result.current.error).toBeInstanceOf(Error);
+      expect(result.current.error?.message).toBe('Permission denied');
+      expect(result.current.event).toBe(null);
+    });
+
+    it('handles exceptions during event fetch', async () => {
+      const error = new Error('Network timeout');
+      // Mock RPC to reject, and table access to also fail
+      mockSupabaseClient.rpc.mockRejectedValue(error);
+      mockSupabaseClient.from.mockReturnValue({
+        select: vi.fn().mockReturnThis(),
+        eq: vi.fn().mockReturnThis(),
+        not: vi.fn().mockReturnThis(),
+        limit: vi.fn().mockReturnThis(),
+        single: vi.fn().mockRejectedValue(error)
+      });
+
+      const { result } = renderHook(() => usePublicEvent('test-event'));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      }, { timeout: 2000 });
+
+      expect(result.current.error).toBeInstanceOf(Error);
+      expect(result.current.error?.message).toBe('Network timeout');
+      expect(result.current.event).toBe(null);
+    });
+
+    it('handles non-Error exceptions', async () => {
+      const stringError = 'String error';
+      // Mock RPC to reject, and table access to also fail
+      mockSupabaseClient.rpc.mockRejectedValue(stringError);
+      mockSupabaseClient.from.mockReturnValue({
+        select: vi.fn().mockReturnThis(),
+        eq: vi.fn().mockReturnThis(),
+        not: vi.fn().mockReturnThis(),
+        limit: vi.fn().mockReturnThis(),
+        single: vi.fn().mockRejectedValue(stringError)
+      });
+
+      const { result } = renderHook(() => usePublicEvent('test-event'));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      }, { timeout: 2000 });
+
+      expect(result.current.error).toBeInstanceOf(Error);
+      expect(result.current.error?.message).toBe('Unknown error occurred');
+    });
+  });
+
+  describe('Parameter Changes', () => {
+    it('refetches when eventCode changes', async () => {
+      const mockEventData1 = {
+        event_id: '123',
+        event_name: 'Event 1',
+        event_date: '2024-01-01',
+        event_venue: 'Venue 1',
+        event_participants: 100,
+        event_colours: { primary: '#000000' },
+        organisation_id: 'org-123',
+        event_days: 1,
+        event_typicalunit: 'km',
+        event_rounddown: false,
+        event_youthmultiplier: 1.0,
+        event_catering_email: 'test@example.com',
+        event_news: 'Test news',
+        event_billing: 'Test billing',
+        event_footer: 'Test footer',
+        event_email: 'event@example.com',
+        event_logo: null
+      };
+
+      const mockEventData2 = {
+        ...mockEventData1,
+        event_id: '456',
+        event_name: 'Event 2'
+      };
+
+      mockSupabaseClient.rpc
+        .mockResolvedValueOnce({
+          data: [mockEventData1],
+          error: null
+        })
+        .mockResolvedValueOnce({
+          data: [mockEventData2],
+          error: null
+        });
+
+      const { result, rerender } = renderHook(
+        ({ eventCode }) => usePublicEvent(eventCode),
+        { initialProps: { eventCode: 'event-1' } }
+      );
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      }, { timeout: 2000 });
+
+      expect(result.current.event?.event_name).toBe('Event 1');
+
+      rerender({ eventCode: 'event-2' });
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      }, { timeout: 2000 });
+
+      expect(result.current.event?.event_name).toBe('Event 2');
+    });
+  });
+
+  describe('Edge Cases', () => {
+    it('should handle null event data from RPC', async () => {
+      mockSupabaseClient.rpc.mockResolvedValueOnce({
+        data: null,
+        error: null
+      });
+
+      const { result } = renderHook(() => usePublicEvent('test-event'));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      }, { timeout: 2000 });
+
+      expect(result.current.event).toBe(null);
+      expect(result.current.error).toEqual(new Error('Event not found'));
+    });
+
+    it('should handle empty event data array from RPC', async () => {
+      mockSupabaseClient.rpc.mockResolvedValueOnce({
+        data: [],
+        error: null
+      });
+
+      const { result } = renderHook(() => usePublicEvent('test-event'));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      }, { timeout: 2000 });
+
+      expect(result.current.event).toBe(null);
+      expect(result.current.error).toEqual(new Error('Event not found'));
+    });
+
+    it('should handle undefined event data from RPC', async () => {
+      mockSupabaseClient.rpc.mockResolvedValueOnce({
+        data: [undefined],
+        error: null
+      });
+
+      const { result } = renderHook(() => usePublicEvent('test-event'));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      }, { timeout: 2000 });
+
+      expect(result.current.event).toBe(null);
+      expect(result.current.error).toEqual(new Error('Event not found'));
+    });
+
+    it('handles missing Supabase environment variables', async () => {
+      // Mock usePublicPageContext to return null environment
+      vi.mocked(usePublicPageContext).mockReturnValue({
+        environment: {
+          supabaseUrl: null,
+          supabaseKey: null
+        }
+      } as any);
+
+      // Mock environment variables to be undefined
+      Object.defineProperty(import.meta, 'env', {
+        value: {},
+        writable: true
+      });
+
+      const consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+      const { result } = renderHook(() => usePublicEvent('test-event'));
+
+      await waitFor(() => {
+        expect(consoleWarnSpy).toHaveBeenCalledWith(
+          expect.stringContaining('[WARN] [usePublicEvent] Missing Supabase environment variables. Please ensure VITE_SUPABASE_URL and VITE_SUPABASE_PUBLISHABLE_KEY are set in your environment.')
+        );
+      }, { timeout: 2000 });
+
+      // Should still initialize but with error
+      expect(result.current.isLoading).toBe(false);
+      expect(result.current.error).toBeInstanceOf(Error);
+      expect(result.current.error?.message).toContain('Invalid event code or Supabase client not available');
+
+      consoleWarnSpy.mockRestore();
+    });
+
+    it('handles server-side rendering (window undefined)', () => {
+      // Test that the hook handles missing window by checking the implementation
+      // The hook checks `typeof window === 'undefined'` and returns null supabase client
+      // We can't actually delete window in the test environment as React needs it
+      // Instead, we test the behavior when supabase client is null (which happens when window is undefined)
+      
+      // Mock usePublicPageContext to return null environment
+      vi.mocked(usePublicPageContext).mockReturnValue({
+        environment: {
+          supabaseUrl: null,
+          supabaseKey: null
+        }
+      } as any);
+
+      // Mock environment variables to be undefined
+      Object.defineProperty(import.meta, 'env', {
+        value: {},
+        writable: true
+      });
+
+      const { result } = renderHook(() => usePublicEvent('test-event'));
+
+      // When supabase client is null (as it would be in SSR), the hook should handle it gracefully
+      expect(result.current.isLoading).toBe(false);
+      expect(result.current.error).toBeInstanceOf(Error);
+      expect(result.current.error?.message).toContain('Invalid event code or Supabase client not available');
+    });
+  });
+});