@jmruthers/pace-core 0.5.190 → 0.5.193

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

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

package/src/hooks/__tests__/useSecureDataAccess.unit.test.tsx

@@ -5,7 +5,7 @@ import { useUnifiedAuth } from '../../providers';
 import { useOrganisations } from '../../hooks/useOrganisations';
 import { testDataGenerators } from '../../__tests__/helpers/test-utils';
 import { useResolvedScope } from '../../rbac/hooks/useResolvedScope';
-import { useSuperAdminBypass } from '../../rbac/hooks/useSuperAdminBypass';
+import { useOrganisationSecurity } from '../useOrganisationSecurity';
 
 // Mock dependencies
 vi.mock('../../providers', () => ({
@@ -28,8 +28,8 @@ vi.mock('../../rbac/hooks/useResolvedScope', () => ({
   useResolvedScope: vi.fn(),
 }));
 
-vi.mock('../../rbac/hooks/useSuperAdminBypass', () => ({
-  useSuperAdminBypass: vi.fn(),
+vi.mock('../useOrganisationSecurity', () => ({
+  useOrganisationSecurity: vi.fn(),
 }));
 
 const mockUseUnifiedAuth = {
@@ -114,10 +114,17 @@ describe('useSecureDataAccess', () => {
       isLoading: false,
       error: null,
     });
-    // Default mock for useSuperAdminBypass - not super admin
-    vi.mocked(useSuperAdminBypass).mockReturnValue({
-      isSuperAdmin: false,
-    });
+    // Default mock for useOrganisationSecurity - not super admin
+    vi.mocked(useOrganisationSecurity).mockReturnValue({
+      superAdminContext: { isSuperAdmin: false, hasGlobalAccess: false, canManageAllOrganisations: false },
+      validateOrganisationAccess: vi.fn(),
+      hasMinimumRole: vi.fn(),
+      canAccessChildOrganisations: vi.fn(),
+      checkPermission: vi.fn(),
+      getPermissions: vi.fn(),
+      logOrganisationAccess: vi.fn(),
+      canManageOrganisation: vi.fn(),
+    } as any);
   });
 
   describe('validateContext', () => {
@@ -400,7 +407,7 @@ describe('useSecureDataAccess', () => {
 
       const { result } = renderHook(() => useSecureDataAccess());
 
-      const data = await result.current.secureUpdate('event', { name: 'Updated' }, { id: 1 });
+      const data = await result.current.secureUpdate('core_events', { name: 'Updated' }, { id: 1 });
 
       expect(data).toEqual([{ id: 1, name: 'Updated', organisation_id: 'org-123' }]);
     });
@@ -421,7 +428,7 @@ describe('useSecureDataAccess', () => {
 
       const { result } = renderHook(() => useSecureDataAccess());
 
-      await expect(result.current.secureUpdate('event', { name: 'Updated' }, { id: 1 })).rejects.toThrow('Update failed');
+      await expect(result.current.secureUpdate('core_events', { name: 'Updated' }, { id: 1 })).rejects.toThrow('Update failed');
     });
 
     it('should return empty array when no data updated', async () => {
@@ -440,7 +447,7 @@ describe('useSecureDataAccess', () => {
 
       const { result } = renderHook(() => useSecureDataAccess());
 
-      const data = await result.current.secureUpdate('event', { name: 'Updated' }, { id: 1 });
+      const data = await result.current.secureUpdate('core_events', { name: 'Updated' }, { id: 1 });
 
       expect(data).toEqual([]);
     });
@@ -461,9 +468,9 @@ describe('useSecureDataAccess', () => {
 
       const { result } = renderHook(() => useSecureDataAccess());
 
-      await result.current.secureDelete('event', { id: 1 });
+      await result.current.secureDelete('core_events', { id: 1 });
 
-      expect(mockSupabase.from).toHaveBeenCalledWith('event');
+      expect(mockSupabase.from).toHaveBeenCalledWith('core_events');
     });
 
     it('should handle delete errors', async () => {
@@ -480,7 +487,8 @@ describe('useSecureDataAccess', () => {
 
       const { result } = renderHook(() => useSecureDataAccess());
 
-      await expect(result.current.secureDelete('event', { id: 1 })).rejects.toThrow('Delete failed');
+      // The implementation throws the error, so the promise should reject
+      await expect(result.current.secureDelete('core_events', { id: 1 })).rejects.toThrow('Delete failed');
     });
   });
 
@@ -605,12 +613,12 @@ describe('useSecureDataAccess', () => {
       const { result } = renderHook(() => useSecureDataAccess());
 
       // Verify the actual behavior: secure update works correctly
-      const updateResult = await result.current.secureUpdate('event', { name: 'Updated' }, { id: 1 });
+      const updateResult = await result.current.secureUpdate('core_events', { name: 'Updated' }, { id: 1 });
 
       // Test the actual functionality: update executes and returns results
       expect(updateResult).toEqual([{ id: 1, name: 'Updated' }]);
       // Verify security: organisation filter is applied
-      expect(mockSupabase.from).toHaveBeenCalledWith('event');
+      expect(mockSupabase.from).toHaveBeenCalledWith('core_events');
       // Verify the operation completed successfully (organisation filter is applied internally)
 
       consoleSpy.mockRestore();