@jmruthers/pace-core 0.5.68 → 0.5.69

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

@@ -0,0 +1,435 @@
+import React from 'react';
+import { renderHook, waitFor } from '@testing-library/react';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { 
+  usePublicRouteParams, 
+  usePublicEventCode, 
+  generatePublicRoutePath, 
+  extractEventCodeFromPath 
+} from '../public/usePublicRouteParams';
+import { usePublicEvent } from '../public/usePublicEvent';
+
+// Mock React Router
+const mockParams = {};
+const mockLocation = { pathname: '/public/event/test-event' };
+
+vi.mock('react-router-dom', () => ({
+  useParams: () => mockParams,
+  useLocation: () => mockLocation
+}));
+
+// Mock usePublicEvent
+vi.mock('../public/usePublicEvent', () => ({
+  usePublicEvent: vi.fn(() => ({
+    event: null,
+    isLoading: false,
+    error: null,
+    refetch: vi.fn()
+  }))
+}));
+
+describe('usePublicRouteParams', () => {
+  beforeEach(() => {
+    // Clear mockParams for each test
+    Object.keys(mockParams).forEach(key => delete (mockParams as any)[key]);
+  });
+  
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('Basic Functionality', () => {
+    it('should extract event code from URL parameters', () => {
+      mockParams.eventCode = 'test-event';
+
+      const { result } = renderHook(() => usePublicRouteParams());
+
+      expect(result.current.eventCode).toBe('test-event');
+    });
+
+    it('should handle missing event code parameter', () => {
+      // No eventCode in params
+
+      const { result } = renderHook(() => usePublicRouteParams());
+
+      expect(result.current.eventCode).toBe(null);
+    });
+
+    it('should validate event code format', () => {
+      mockParams.eventCode = 'invalid@code!';
+
+      const { result } = renderHook(() => usePublicRouteParams());
+
+      expect(result.current.eventCode).toBe(null);
+      expect(result.current.error).toEqual(new Error('Invalid event code format: invalid@code!'));
+    });
+
+    it('should accept valid event code formats', () => {
+      const validCodes = [
+        'test-event',
+        'test_event',
+        'test123',
+        'TEST-EVENT',
+        'test-event-123',
+        'a1b2c3'
+      ];
+
+      validCodes.forEach(code => {
+        mockParams.eventCode = code;
+        const { result } = renderHook(() => usePublicRouteParams());
+        expect(result.current.eventCode).toBe(code);
+      });
+    });
+
+    it('should reject invalid event code formats', () => {
+      const invalidCodes = [
+        'ab', // too short
+        'a'.repeat(51), // too long
+        'test@event', // invalid character
+        'test event', // space
+        'test.event', // dot
+        'test/event', // slash
+        'test\\event', // backslash
+        '', // empty
+        '   ', // whitespace only
+        'test-event-', // trailing hyphen
+        '-test-event', // leading hyphen
+        'test--event', // double hyphen
+        'test__event' // double underscore
+      ];
+
+      invalidCodes.forEach(code => {
+        mockParams.eventCode = code;
+        const { result } = renderHook(() => usePublicRouteParams());
+        expect(result.current.eventCode).toBe(null);
+        if (code.length > 0) {
+          expect(result.current.error).toEqual(new Error(`Invalid event code format: ${code}`));
+        }
+      });
+    });
+  });
+
+  describe('Event Data Fetching', () => {
+    it('should fetch event data when fetchEventData is true', async () => {
+      mockParams.eventCode = 'test-event';
+      
+      const mockEvent = {
+        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: '2024-01-01T00:00:00Z',
+        updated_at: '2024-01-01T00:00:00Z',
+        name: 'Test Event',
+        start_date: '2024-01-01'
+      };
+
+      (usePublicEvent as any).mockReturnValue({
+        event: mockEvent,
+        isLoading: false,
+        error: null,
+        refetch: vi.fn()
+      });
+
+      const { result } = renderHook(() => usePublicRouteParams({ fetchEventData: true }));
+
+      expect(result.current.event).toEqual(mockEvent);
+      expect(result.current.eventId).toBe('123');
+      expect(result.current.isLoading).toBe(false);
+      expect(result.current.error).toBe(null);
+    });
+
+    it('should not fetch event data when fetchEventData is false', () => {
+      mockParams.eventCode = 'test-event';
+
+      const { result } = renderHook(() => usePublicRouteParams({ fetchEventData: false }));
+
+      expect(result.current.event).toBe(null);
+      expect(result.current.eventId).toBe(null);
+      expect(result.current.isLoading).toBe(false);
+      // Note: usePublicEvent might still be called for validation, but the event data should not be used
+    });
+
+    it('should handle event loading state', () => {
+      mockParams.eventCode = 'test-event';
+
+      (usePublicEvent as any).mockReturnValue({
+        event: null,
+        isLoading: true,
+        error: null,
+        refetch: vi.fn()
+      });
+
+      const { result } = renderHook(() => usePublicRouteParams({ fetchEventData: true }));
+
+      expect(result.current.isLoading).toBe(true);
+      expect(result.current.event).toBe(null);
+    });
+
+    it('should handle event error state', () => {
+      mockParams.eventCode = 'test-event';
+
+      (usePublicEvent as any).mockReturnValue({
+        event: null,
+        isLoading: false,
+        error: new Error('Event not found'),
+        refetch: vi.fn()
+      });
+
+      const { result } = renderHook(() => usePublicRouteParams({ fetchEventData: true }));
+
+      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 event code validation error', () => {
+      mockParams.eventCode = 'invalid@code!';
+
+      const { result } = renderHook(() => usePublicRouteParams({ fetchEventData: true }));
+
+      expect(result.current.isLoading).toBe(false);
+      expect(result.current.event).toBe(null);
+      expect(result.current.error).toEqual(new Error('Invalid event code format: invalid@code!'));
+    });
+  });
+
+  describe('Custom Configuration', () => {
+    it('should use custom event code parameter name', () => {
+      mockParams.customEventCode = 'test-event';
+
+      const { result } = renderHook(() => 
+        usePublicRouteParams({ eventCodeParam: 'customEventCode' })
+      );
+
+      expect(result.current.eventCode).toBe('test-event');
+    });
+
+    it('should disable event code validation when requested', () => {
+      mockParams.eventCode = 'invalid@code!';
+
+      const { result } = renderHook(() => 
+        usePublicRouteParams({ validateEventCode: false })
+      );
+
+      expect(result.current.eventCode).toBe('invalid@code!');
+      expect(result.current.error).toBe(null);
+    });
+
+    it('should pass correct options to usePublicEvent', () => {
+      mockParams.eventCode = 'test-event';
+
+      (usePublicEvent as any).mockReturnValue({
+        event: null,
+        isLoading: false,
+        error: null,
+        refetch: vi.fn()
+      });
+
+      renderHook(() => usePublicRouteParams({ fetchEventData: true }));
+
+      expect(usePublicEvent).toHaveBeenCalledWith('test-event', {
+        enableCache: true,
+        cacheTtl: 5 * 60 * 1000 // 5 minutes
+      });
+    });
+  });
+
+  describe('Refetch Functionality', () => {
+    it('should provide refetch function', async () => {
+      mockParams.eventCode = 'test-event';
+      
+      const mockRefetch = vi.fn();
+      (usePublicEvent as any).mockReturnValue({
+        event: null,
+        isLoading: false,
+        error: null,
+        refetch: mockRefetch
+      });
+
+      const { result } = renderHook(() => usePublicRouteParams({ fetchEventData: true }));
+
+      await result.current.refetch();
+
+      expect(mockRefetch).toHaveBeenCalled();
+    });
+
+    it('should not refetch when fetchEventData is false', async () => {
+      mockParams.eventCode = 'test-event';
+
+      const { result } = renderHook(() => usePublicRouteParams({ fetchEventData: false }));
+
+      await result.current.refetch();
+
+      // Should not throw or call any refetch function
+      expect(result.current.refetch).toBeDefined();
+    });
+  });
+
+  describe('Logging', () => {
+    it('should log route access for debugging', () => {
+      const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+      mockParams.eventCode = 'test-event';
+      
+      const mockEvent = {
+        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: '2024-01-01T00:00:00Z',
+        updated_at: '2024-01-01T00:00:00Z',
+        name: 'Test Event',
+        start_date: '2024-01-01'
+      };
+
+      (usePublicEvent as any).mockReturnValue({
+        event: mockEvent,
+        isLoading: false,
+        error: null,
+        refetch: vi.fn()
+      });
+
+      renderHook(() => usePublicRouteParams({ fetchEventData: true }));
+
+      expect(consoleSpy).toHaveBeenCalledWith('[usePublicRouteParams] Public route accessed:', {
+        eventCode: 'test-event',
+        eventId: '123',
+        eventName: 'Test Event',
+        path: '/public/event/test-event'
+      });
+
+      consoleSpy.mockRestore();
+    });
+  });
+
+  describe('usePublicEventCode', () => {
+    it('should extract event code without fetching data', () => {
+      mockParams.eventCode = 'test-event';
+
+      const { result } = renderHook(() => usePublicEventCode());
+
+      expect(result.current.eventCode).toBe('test-event');
+      expect(result.current.error).toBe(null);
+    });
+
+    it('should handle missing event code', () => {
+      // No eventCode in params
+
+      const { result } = renderHook(() => usePublicEventCode());
+
+      expect(result.current.eventCode).toBe(null);
+      expect(result.current.error).toEqual(new Error("Event code parameter 'eventCode' not found or invalid"));
+    });
+
+    it('should handle invalid event code format', () => {
+      mockParams.eventCode = 'invalid@code!';
+
+      const { result } = renderHook(() => usePublicEventCode());
+
+      expect(result.current.eventCode).toBe(null);
+      expect(result.current.error).toEqual(new Error("Event code parameter 'eventCode' not found or invalid"));
+    });
+
+    it('should use custom parameter name', () => {
+      mockParams.customEventCode = 'test-event';
+
+      const { result } = renderHook(() => usePublicEventCode('customEventCode'));
+
+      expect(result.current.eventCode).toBe('test-event');
+      expect(result.current.error).toBe(null);
+    });
+  });
+
+  describe('Utility Functions', () => {
+    describe('generatePublicRoutePath', () => {
+      it('should generate correct route path', () => {
+        expect(generatePublicRoutePath('test-event')).toBe('/public/event/test-event/index');
+        expect(generatePublicRoutePath('test-event', 'details')).toBe('/public/event/test-event/details');
+        expect(generatePublicRoutePath('test-event', 'registration')).toBe('/public/event/test-event/registration');
+      });
+
+      it('should throw error for invalid event code', () => {
+        expect(() => generatePublicRoutePath('invalid@code!')).toThrow('Invalid event code for route generation');
+        expect(() => generatePublicRoutePath('ab')).toThrow('Invalid event code for route generation');
+        expect(() => generatePublicRoutePath('')).toThrow('Invalid event code for route generation');
+      });
+    });
+
+    describe('extractEventCodeFromPath', () => {
+      it('should extract event code from valid paths', () => {
+        expect(extractEventCodeFromPath('/public/event/test-event')).toBe('test-event');
+        expect(extractEventCodeFromPath('/public/event/test-event/')).toBe('test-event');
+        expect(extractEventCodeFromPath('/public/event/test-event/details')).toBe('test-event');
+        expect(extractEventCodeFromPath('/public/event/test-event/details/step1')).toBe('test-event');
+        expect(extractEventCodeFromPath('/public/event/test-event-123')).toBe('test-event-123');
+        expect(extractEventCodeFromPath('/public/event/test_event')).toBe('test_event');
+        expect(extractEventCodeFromPath('/public/event/test123')).toBe('test123');
+      });
+
+      it('should return null for invalid paths', () => {
+        expect(extractEventCodeFromPath('/public/event/')).toBe(null);
+        expect(extractEventCodeFromPath('/public/event/ab')).toBe(null); // too short
+        expect(extractEventCodeFromPath('/public/event/test@event')).toBe(null); // invalid character
+        expect(extractEventCodeFromPath('/public/event/test event')).toBe(null); // space
+        expect(extractEventCodeFromPath('/public/event/')).toBe(null);
+        expect(extractEventCodeFromPath('/public/event')).toBe(null);
+        expect(extractEventCodeFromPath('/public/')).toBe(null);
+        expect(extractEventCodeFromPath('/')).toBe(null);
+        expect(extractEventCodeFromPath('')).toBe(null);
+        expect(extractEventCodeFromPath('/other/path')).toBe(null);
+        expect(extractEventCodeFromPath('/public/event/')).toBe(null);
+      });
+    });
+  });
+
+  describe('Edge Cases', () => {
+    it('should handle rapid parameter changes', () => {
+      // Test that the hook works with different parameter values
+      mockParams.eventCode = 'event1';
+      
+      const { result } = renderHook(() => usePublicRouteParams());
+
+      expect(result.current.eventCode).toBe('event1');
+      expect(result.current.error).toBe(null);
+    });
+
+    it('should handle undefined parameters', () => {
+      mockParams.eventCode = undefined;
+
+      const { result } = renderHook(() => usePublicRouteParams());
+
+      expect(result.current.eventCode).toBe(null);
+    });
+
+    it('should handle null parameters', () => {
+      mockParams.eventCode = null;
+
+      const { result } = renderHook(() => usePublicRouteParams());
+
+      expect(result.current.eventCode).toBe(null);
+    });
+
+    it('should handle empty string parameters', () => {
+      mockParams.eventCode = '';
+
+      const { result } = renderHook(() => usePublicRouteParams());
+
+      expect(result.current.eventCode).toBe(null);
+    });
+  });
+});

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

@@ -147,7 +147,7 @@ describe('useRBAC', () => {
         expect(result.current.globalRole).toBe('super_admin');
         expect(result.current.organisationRole).toBeNull();
         expect(result.current.eventAppRole).toBeNull();
-      }, { timeout: 3000 });
+      }, { interval: 10, timeout: 3000 });
     });
 
     it('detects organisation role from permissions', async () => {
@@ -168,7 +168,7 @@ describe('useRBAC', () => {
         expect(result.current.globalRole).toBeNull();
         expect(result.current.organisationRole).toBe('org_admin');
         expect(result.current.eventAppRole).toBeNull();
-      }, { timeout: 3000 });
+      }, { interval: 10, timeout: 3000 });
     });
 
     it('detects event app role from permissions', async () => {
@@ -190,7 +190,7 @@ describe('useRBAC', () => {
         expect(result.current.globalRole).toBeNull();
         expect(result.current.organisationRole).toBeNull();
         expect(result.current.eventAppRole).toBe('event_admin');
-      }, { timeout: 3000 });
+      }, { interval: 10, timeout: 3000 });
     });
 
     it('detects multiple roles from permissions', async () => {
@@ -224,7 +224,7 @@ describe('useRBAC', () => {
         expect(result.current.globalRole).toBe('super_admin');
         expect(result.current.organisationRole).toBe('org_admin');
         expect(result.current.eventAppRole).toBe('event_admin');
-      }, { timeout: 3000 });
+      }, { interval: 10, timeout: 3000 });
     });
 
     it('handles empty permissions array', async () => {
@@ -261,7 +261,7 @@ describe('useRBAC', () => {
 
       await waitFor(() => {
         expect(result.current.globalRole).toBe('super_admin');
-      }, { timeout: 3000 });
+      }, { interval: 10, timeout: 3000 });
 
       const hasPermission = await result.current.hasPermission('read', 'dashboard');
       expect(hasPermission).toBe(true);
@@ -298,7 +298,7 @@ describe('useRBAC', () => {
 
       await waitFor(() => {
         expect(result.current.organisationRole).toBe('org_admin');
-      }, { timeout: 3000 });
+      }, { interval: 10, timeout: 3000 });
 
       const hasPermission = await result.current.hasPermission('read', 'dashboard');
       expect(hasPermission).toBe(true);
@@ -343,7 +343,7 @@ describe('useRBAC', () => {
 
       await waitFor(() => {
         expect(result.current.organisationRole).toBe('org_admin');
-      }, { timeout: 3000 });
+      }, { interval: 10, timeout: 3000 });
 
       const hasPermission = await result.current.hasPermission('write', 'admin');
       expect(hasPermission).toBe(false);
@@ -382,7 +382,7 @@ describe('useRBAC', () => {
 
       await waitFor(() => {
         expect(result.current.organisationRole).toBe('org_admin');
-      }, { timeout: 3000 });
+      }, { interval: 10, timeout: 3000 });
 
       const hasPermission = await result.current.hasPermission('read', 'dashboard');
       expect(hasPermission).toBe(false);
@@ -421,7 +421,7 @@ describe('useRBAC', () => {
 
       await waitFor(() => {
         expect(result.current.organisationRole).toBe('org_admin');
-      }, { timeout: 3000 });
+      }, { interval: 10, timeout: 3000 });
 
       await result.current.hasPermission('read');
       
@@ -801,7 +801,7 @@ describe('useRBAC', () => {
 
       await waitFor(() => {
         expect(result.current.organisationRole).toBe('org_admin');
-      }, { timeout: 3000 });
+      }, { interval: 10, timeout: 3000 });
 
       // Change organisation
       mockUseOrganisations.mockReturnValue({