@jmruthers/pace-core 0.5.87 → 0.5.89

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

@@ -1,583 +0,0 @@
-import React from 'react';
-import { renderHook, waitFor, act } 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()
-            }))
-          }))
-        }))
-      }))
-    }))
-  }))
-};
-
-// Helper to create table query mocks
-const createTableQueryMock = () => ({
-  data: null,
-  error: null,
-  mockResolvedValueOnce: vi.fn(),
-  mockResolvedValue: vi.fn()
-});
-
-// Helper to create a complete table query chain
-const createTableQueryChain = (finalResult: any) => {
-  const mockChain = {
-    select: vi.fn().mockReturnThis(),
-    eq: vi.fn().mockReturnThis(),
-    not: vi.fn().mockReturnThis(),
-    limit: vi.fn().mockReturnThis(),
-    single: vi.fn().mockResolvedValue(finalResult)
-  };
-  return mockChain;
-};
-
-// Mock createClient
-vi.mock('@supabase/supabase-js', () => ({
-  createClient: vi.fn(() => mockSupabaseClient)
-}));
-
-// Mock environment variables
-const originalEnv = import.meta.env;
-
-describe('usePublicEvent', () => {
-  beforeEach(() => {
-    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
-    });
-
-    // Re-establish mock implementations after clearAllMocks
-    mockSupabaseClient.rpc.mockImplementation(() => 
-      Promise.resolve({
-        data: null,
-        error: null
-      })
-    );
-    
-    // Ensure the mock is properly configured
-    expect(mockSupabaseClient.rpc).toBeDefined();
-  });
-
-  afterEach(() => {
-    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);
-      }, { interval: 10 });
-
-      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),
-        name: 'Test Event',
-        start_date: '2024-01-01'
-      });
-      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);
-      }, { interval: 10 });
-
-      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);
-      }, { interval: 10 });
-
-      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'
-      };
-
-      mockSupabaseClient.rpc.mockResolvedValueOnce({
-        data: [mockEventData],
-        error: null
-      });
-
-      const { result, rerender } = renderHook(() => usePublicEvent('test-event'));
-
-      await waitFor(() => {
-        expect(result.current.isLoading).toBe(false);
-      }, { interval: 10 });
-
-      // Rerender with same event code - should use cache
-      rerender();
-      
-      // Should not call RPC again
-      expect(mockSupabaseClient.rpc).toHaveBeenCalledTimes(1);
-    });
-
-    it('should respect cache TTL', 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'
-      };
-
-      mockSupabaseClient.rpc.mockResolvedValueOnce({
-        data: [mockEventData],
-        error: null
-      });
-
-      const { result } = renderHook(() => usePublicEvent('test-event', { cacheTtl: 100 }));
-
-      await waitFor(() => {
-        expect(result.current.isLoading).toBe(false);
-      }, { interval: 10 });
-
-      // Wait for cache to expire
-      await new Promise(resolve => setTimeout(resolve, 150));
-
-      // Rerender should fetch again
-      const { result: result2 } = renderHook(() => usePublicEvent('test-event', { cacheTtl: 100 }));
-      
-      await waitFor(() => {
-        expect(result2.current.isLoading).toBe(false);
-      }, { interval: 10 });
-
-      expect(mockSupabaseClient.rpc).toHaveBeenCalledTimes(2);
-    });
-
-    it('should disable caching when requested', 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
-      };
-
-      // Clear any existing cache
-      const { clearPublicEventCache } = await import('../public/usePublicEvent');
-      clearPublicEventCache();
-
-      // Use mockImplementation to handle multiple calls
-      let callCount = 0;
-      mockSupabaseClient.rpc.mockImplementation(() => {
-        callCount++;
-        return Promise.resolve({
-          data: [mockEventData],
-          error: null
-        });
-      });
-
-      const { result, rerender } = renderHook(
-        ({ eventCode }) => usePublicEvent(eventCode, { enableCache: false }),
-        { initialProps: { eventCode: 'test-event' } }
-      );
-
-      await waitFor(() => {
-        expect(result.current.isLoading).toBe(false);
-      }, { interval: 10 });
-
-      // Change the event code to force a new fetch
-      rerender({ eventCode: 'test-event-2' });
-      
-      await waitFor(() => {
-        expect(result.current.isLoading).toBe(false);
-      }, { interval: 10 });
-
-      expect(callCount).toBe(2);
-    });
-  });
-
-  describe('Error Handling', () => {
-    it('should handle RPC errors', async () => {
-      // Mock the RPC call to return an error object
-      const testError = { message: 'Database error', details: 'Test error details', hint: null, code: 'TEST_ERROR' };
-      mockSupabaseClient.rpc.mockImplementation(() => 
-        Promise.resolve({
-          data: null,
-          error: testError
-        })
-      );
-
-      const { result } = renderHook(() => usePublicEvent('test-event'));
-
-      await waitFor(() => {
-        expect(result.current.isLoading).toBe(false);
-      }, { interval: 10 });
-
-      expect(result.current.error).toBeInstanceOf(Error);
-      expect(result.current.error?.message).toBe('Database error');
-      expect(result.current.event).toBe(null);
-      
-      // Verify the mock was called
-      expect(mockSupabaseClient.rpc).toHaveBeenCalledWith('get_public_event_by_code', {
-        event_code_param: 'test-event'
-      });
-    });
-
-    it('should handle missing Supabase client', async () => {
-      // Mock the PublicPageProvider to return null environment
-      const mockUsePublicPageContext = vi.mocked(usePublicPageContext);
-      mockUsePublicPageContext.mockReturnValueOnce({
-        environment: {
-          supabaseUrl: '',
-          supabaseKey: ''
-        }
-      });
-
-      // Mock createClient to return null when environment is empty
-      const { createClient } = await import('@supabase/supabase-js');
-      vi.mocked(createClient).mockReturnValueOnce(null as any);
-
-      const { result } = renderHook(() => usePublicEvent('test-event'));
-
-      await waitFor(() => {
-        expect(result.current.isLoading).toBe(false);
-      }, { interval: 10 });
-
-      expect(result.current.error).toBeInstanceOf(Error);
-      expect(result.current.error?.message).toContain('Invalid event code or Supabase client not available');
-      expect(result.current.event).toBe(null);
-    });
-  });
-
-  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);
-      }, { interval: 10 });
-
-      expect(result.current.event).toBeTruthy();
-    });
-  });
-
-  describe('Refetch Functionality', () => {
-    it('should refetch 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'
-      };
-
-      mockSupabaseClient.rpc.mockResolvedValue({
-        data: [mockEventData],
-        error: null
-      });
-
-      const { result } = renderHook(() => usePublicEvent('test-event'));
-
-      await waitFor(() => {
-        expect(result.current.isLoading).toBe(false);
-      }, { interval: 10 });
-
-      // Call refetch
-      await act(async () => {
-        await result.current.refetch();
-      });
-
-      expect(mockSupabaseClient.rpc).toHaveBeenCalledTimes(2);
-    });
-
-    it('should clear cache 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'
-      };
-
-      mockSupabaseClient.rpc.mockResolvedValue({
-        data: [mockEventData],
-        error: null
-      });
-
-      const { result } = renderHook(() => usePublicEvent('test-event'));
-
-      await waitFor(() => {
-        expect(result.current.isLoading).toBe(false);
-      }, { interval: 10 });
-
-      // Call refetch
-      await act(async () => {
-        await result.current.refetch();
-      });
-
-      // Should call RPC again (cache was cleared)
-      expect(mockSupabaseClient.rpc).toHaveBeenCalledTimes(2);
-    });
-  });
-
-  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('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);
-      }, { interval: 10 });
-
-      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);
-      }, { interval: 10 });
-
-      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);
-      }, { interval: 10 });
-
-      expect(result.current.event).toBe(null);
-      expect(result.current.error).toEqual(new Error('Event not found'));
-    });
-  });
-});