@jmruthers/pace-core 0.5.189 → 0.5.190

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

@@ -1,703 +0,0 @@
-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_ANON_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');
-    });
-  });
-});