@jmruthers/pace-core 0.6.9 → 0.6.11

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

@@ -1,443 +0,0 @@
-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 = [
-        'a', // too short (1 character)
-        '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()
-      });
-
-      // Verify the actual behavior: route params are extracted correctly
-      const { result } = renderHook(() => usePublicRouteParams({ fetchEventData: true }));
-
-      // Test the actual functionality: event data is fetched and returned
-      expect(result.current.eventCode).toBe('test-event');
-      expect(result.current.eventId).toBe('123');
-      expect(result.current.event).toEqual(mockEvent);
-      expect(result.current.isLoading).toBe(false);
-      expect(result.current.error).toBeNull();
-
-      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');
-        // 2-character codes are now valid
-        expect(generatePublicRoutePath('GG')).toBe('/public/event/GG/index');
-        expect(generatePublicRoutePath('ab', 'page')).toBe('/public/event/ab/page');
-      });
-
-      it('should throw error for invalid event code', () => {
-        expect(() => generatePublicRoutePath('invalid@code!')).toThrow('Invalid event code for route generation');
-        expect(() => generatePublicRoutePath('a')).toThrow('Invalid event code for route generation'); // too short (1 character)
-        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');
-        // 2-character codes are now valid
-        expect(extractEventCodeFromPath('/public/event/ab')).toBe('ab');
-        expect(extractEventCodeFromPath('/public/event/GG')).toBe('GG');
-        expect(extractEventCodeFromPath('/public/event/A1')).toBe('A1');
-      });
-
-      it('should return null for invalid paths', () => {
-        expect(extractEventCodeFromPath('/public/event/')).toBe(null);
-        expect(extractEventCodeFromPath('/public/event/a')).toBe(null); // too short (1 character)
-        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__/useQueryCache.test.ts

@@ -1,144 +0,0 @@
-import { renderHook, act } from '@testing-library/react';
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { SupabaseClient } from '@supabase/supabase-js';
-import { useQueryCache, queryCacheHelpers } from '../useQueryCache';
-
-vi.mock('../../utils/core/logger', () => ({
-  createLogger: () => ({
-    debug: vi.fn(),
-    error: vi.fn(),
-  }),
-}));
-
-describe('useQueryCache', () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-    vi.setSystemTime(0);
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-    vi.clearAllMocks();
-  });
-
-  const supabase = {} as SupabaseClient<any>;
-
-  it('caches query results and returns cached data', async () => {
-    const fetchFn = vi.fn().mockResolvedValue({ id: 1 });
-    const { result } = renderHook(() => useQueryCache(supabase));
-
-    const first = await result.current.getCachedQuery('table', 'id', '1', fetchFn, { ttl: 5 });
-    const second = await result.current.getCachedQuery('table', 'id', '1', fetchFn, { ttl: 5 });
-
-    expect(first).toEqual({ id: 1 });
-    expect(second).toEqual(first);
-    expect(fetchFn).toHaveBeenCalledTimes(1);
-
-    act(() => {
-      result.current.clearCache();
-    });
-  });
-
-  it('invalidates cache entries explicitly', async () => {
-    const fetchFn = vi.fn().mockResolvedValue({ id: 2 });
-    const { result } = renderHook(() => useQueryCache());
-
-    await result.current.getCachedQuery('table', 'id', '2', fetchFn);
-    act(() => {
-      result.current.invalidateQuery('table', 'id', '2');
-    });
-    await result.current.getCachedQuery('table', 'id', '2', fetchFn);
-
-    expect(fetchFn).toHaveBeenCalledTimes(2);
-
-    act(() => {
-      result.current.clearCache();
-    });
-  });
-
-  it('expires cache entries after ttl', async () => {
-    const fetchFn = vi.fn().mockResolvedValue('value');
-    const { result } = renderHook(() => useQueryCache());
-
-    await result.current.getCachedQuery('table', 'key', 'val', fetchFn, { ttl: 1 });
-
-    vi.setSystemTime(2000); // advance past ttl
-    await result.current.getCachedQuery('table', 'key', 'val', fetchFn, { ttl: 1 });
-
-    expect(fetchFn).toHaveBeenCalledTimes(2);
-
-    act(() => {
-      result.current.clearCache();
-    });
-  });
-
-  it('deduplicates in-flight requests', async () => {
-    let resolveFn: (value: string) => void;
-    const fetchPromise = new Promise<string>(resolve => {
-      resolveFn = resolve;
-    });
-    const fetchFn = vi.fn(() => fetchPromise);
-    const { result } = renderHook(() => useQueryCache());
-
-    const firstPromise = result.current.getCachedQuery('table', 'id', '3', fetchFn);
-    const secondPromise = result.current.getCachedQuery('table', 'id', '3', fetchFn);
-
-    expect(fetchFn).toHaveBeenCalledTimes(1);
-
-    resolveFn!('done');
-
-    await expect(firstPromise).resolves.toBe('done');
-    await expect(secondPromise).resolves.toBe('done');
-
-    act(() => {
-      result.current.clearCache();
-    });
-  });
-
-  it('bypasses cache when disabled', async () => {
-    const fetchFn = vi.fn().mockResolvedValue('fresh');
-    const { result } = renderHook(() => useQueryCache());
-
-    await result.current.getCachedQuery('table', 'id', '4', fetchFn, { enabled: false });
-    await result.current.getCachedQuery('table', 'id', '4', fetchFn, { enabled: false });
-
-    expect(fetchFn).toHaveBeenCalledTimes(2);
-  });
-});
-
-describe('queryCacheHelpers', () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-    vi.setSystemTime(0);
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-    vi.clearAllMocks();
-  });
-
-  it('caches helper queries and reuses promises for in-flight requests', async () => {
-    let resolveFn: (value: string) => void;
-    const promise = new Promise<string>(resolve => {
-      resolveFn = resolve;
-    });
-    const fetchFn = vi.fn(() => promise);
-    const supabase = {} as SupabaseClient<any>;
-
-    const firstPromise = queryCacheHelpers.pacePersonByUserId(supabase, 'user', fetchFn);
-    const secondPromise = queryCacheHelpers.pacePersonByUserId(supabase, 'user', fetchFn);
-
-    expect(fetchFn).toHaveBeenCalledTimes(1);
-
-    resolveFn!('person');
-
-    await expect(firstPromise).resolves.toBe('person');
-    await expect(secondPromise).resolves.toBe('person');
-
-    // Subsequent call should return cached data immediately
-    const cached = await queryCacheHelpers.pacePersonByUserId(supabase, 'user', fetchFn);
-    expect(cached).toBe('person');
-    expect(fetchFn).toHaveBeenCalledTimes(1);
-  });
-});
-