@jmruthers/pace-core 0.5.118 → 0.5.119

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

@@ -0,0 +1,249 @@
+/**
+ * @file useEvents Hook Unit Tests
+ * @package @jmruthers/pace-core
+ * @module Hooks/__tests__/useEvents
+ * @since 0.1.0
+ * 
+ * Comprehensive tests for the useEvents hook covering all critical functionality.
+ */
+
+import { renderHook, act } from '@testing-library/react';
+import { vi, describe, it, expect, beforeEach } from 'vitest';
+import { useEvents } from '../useEvents';
+import { Event } from '../../types/unified';
+
+// Mock useEventService
+const mockEventService = {
+  getEvents: vi.fn(() => []),
+  getSelectedEvent: vi.fn(() => null),
+  isLoading: vi.fn(() => false),
+  getError: vi.fn(() => null),
+  setSelectedEvent: vi.fn(),
+  refreshEvents: vi.fn().mockResolvedValue(undefined),
+  subscribe: vi.fn(() => vi.fn()), // Returns unsubscribe function
+};
+
+vi.mock('../services/useEventService', () => ({
+  useEventService: vi.fn(() => mockEventService),
+}));
+
+describe('useEvents', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockEventService.getEvents.mockReturnValue([]);
+    mockEventService.getSelectedEvent.mockReturnValue(null);
+    mockEventService.isLoading.mockReturnValue(false);
+    mockEventService.getError.mockReturnValue(null);
+    mockEventService.refreshEvents.mockResolvedValue(undefined);
+  });
+
+  describe('Initialization', () => {
+    it('returns event context with default values', () => {
+      const { result } = renderHook(() => useEvents());
+
+      expect(result.current.events).toEqual([]);
+      expect(result.current.selectedEvent).toBeNull();
+      expect(result.current.isLoading).toBe(false);
+      expect(result.current.error).toBeNull();
+      expect(typeof result.current.setSelectedEvent).toBe('function');
+      expect(typeof result.current.refreshEvents).toBe('function');
+    });
+
+    it('calls useEventService to get event service', () => {
+      const { useEventService } = require('../services/useEventService');
+      
+      renderHook(() => useEvents());
+
+      expect(useEventService).toHaveBeenCalled();
+    });
+  });
+
+  describe('Event State Access', () => {
+    it('returns events from event service', () => {
+      const mockEvents: Event[] = [
+        {
+          id: 'event-1',
+          event_id: 'event-1',
+          event_name: 'Test Event 1',
+          event_date: '2025-01-01T00:00:00Z',
+          event_venue: 'Test Venue',
+          event_participants: 100,
+          event_colours: '#FF0000',
+          event_logo: '',
+          organisation_id: 'org-1',
+          is_visible: true,
+          name: 'Test Event 1',
+          start_date: '2025-01-01T00:00:00Z',
+        },
+        {
+          id: 'event-2',
+          event_id: 'event-2',
+          event_name: 'Test Event 2',
+          event_date: '2025-02-01T00:00:00Z',
+          event_venue: 'Test Venue 2',
+          event_participants: 200,
+          event_colours: '#00FF00',
+          event_logo: '',
+          organisation_id: 'org-1',
+          is_visible: true,
+          name: 'Test Event 2',
+          start_date: '2025-02-01T00:00:00Z',
+        },
+      ];
+
+      mockEventService.getEvents.mockReturnValue(mockEvents);
+
+      const { result } = renderHook(() => useEvents());
+
+      expect(result.current.events).toEqual(mockEvents);
+      expect(result.current.events).toHaveLength(2);
+    });
+
+    it('returns selected event from event service', () => {
+      const mockSelectedEvent: Event = {
+        id: 'event-1',
+        event_id: 'event-1',
+        event_name: 'Selected Event',
+        event_date: '2025-01-01T00:00:00Z',
+        event_venue: 'Test Venue',
+        event_participants: 100,
+        event_colours: '#FF0000',
+        event_logo: '',
+        organisation_id: 'org-1',
+        is_visible: true,
+        name: 'Selected Event',
+        start_date: '2025-01-01T00:00:00Z',
+      };
+
+      mockEventService.getSelectedEvent.mockReturnValue(mockSelectedEvent);
+
+      const { result } = renderHook(() => useEvents());
+
+      expect(result.current.selectedEvent).toEqual(mockSelectedEvent);
+    });
+
+    it('returns loading state from event service', () => {
+      mockEventService.isLoading.mockReturnValue(true);
+
+      const { result } = renderHook(() => useEvents());
+
+      expect(result.current.isLoading).toBe(true);
+    });
+
+    it('returns error from event service', () => {
+      const mockError = new Error('Failed to load events');
+      mockEventService.getError.mockReturnValue(mockError);
+
+      const { result } = renderHook(() => useEvents());
+
+      expect(result.current.error).toEqual(mockError);
+    });
+  });
+
+  describe('Event Selection', () => {
+    it('calls setSelectedEvent on event service when setSelectedEvent is called', () => {
+      const mockEvent: Event = {
+        id: 'event-1',
+        event_id: 'event-1',
+        event_name: 'Test Event',
+        event_date: '2025-01-01T00:00:00Z',
+        event_venue: 'Test Venue',
+        event_participants: 100,
+        event_colours: '#FF0000',
+        event_logo: '',
+        organisation_id: 'org-1',
+        is_visible: true,
+        name: 'Test Event',
+        start_date: '2025-01-01T00:00:00Z',
+      };
+
+      const { result } = renderHook(() => useEvents());
+
+      act(() => {
+        result.current.setSelectedEvent(mockEvent);
+      });
+
+      expect(mockEventService.setSelectedEvent).toHaveBeenCalledWith(mockEvent);
+      expect(mockEventService.setSelectedEvent).toHaveBeenCalledTimes(1);
+    });
+
+    it('calls setSelectedEvent with null when clearing selection', () => {
+      const { result } = renderHook(() => useEvents());
+
+      act(() => {
+        result.current.setSelectedEvent(null);
+      });
+
+      expect(mockEventService.setSelectedEvent).toHaveBeenCalledWith(null);
+      expect(mockEventService.setSelectedEvent).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('Event Refresh', () => {
+    it('calls refreshEvents on event service when refreshEvents is called', async () => {
+      const { result } = renderHook(() => useEvents());
+
+      await act(async () => {
+        await result.current.refreshEvents();
+      });
+
+      expect(mockEventService.refreshEvents).toHaveBeenCalledTimes(1);
+    });
+
+    it('handles refreshEvents promise resolution', async () => {
+      mockEventService.refreshEvents.mockResolvedValue(undefined);
+
+      const { result } = renderHook(() => useEvents());
+
+      await act(async () => {
+        await expect(result.current.refreshEvents()).resolves.toBeUndefined();
+      });
+    });
+
+    it('handles refreshEvents promise rejection', async () => {
+      const mockError = new Error('Refresh failed');
+      mockEventService.refreshEvents.mockRejectedValue(mockError);
+
+      const { result } = renderHook(() => useEvents());
+
+      await act(async () => {
+        await expect(result.current.refreshEvents()).rejects.toThrow('Refresh failed');
+      });
+    });
+  });
+
+  describe('Reactive Updates', () => {
+    it('updates when event service state changes', () => {
+      const mockEvents: Event[] = [
+        {
+          id: 'event-1',
+          event_id: 'event-1',
+          event_name: 'Test Event',
+          event_date: '2025-01-01T00:00:00Z',
+          event_venue: 'Test Venue',
+          event_participants: 100,
+          event_colours: '#FF0000',
+          event_logo: '',
+          organisation_id: 'org-1',
+          is_visible: true,
+          name: 'Test Event',
+          start_date: '2025-01-01T00:00:00Z',
+        },
+      ];
+
+      const { result, rerender } = renderHook(() => useEvents());
+
+      // Initial state
+      expect(result.current.events).toEqual([]);
+
+      // Update mock and rerender
+      mockEventService.getEvents.mockReturnValue(mockEvents);
+      rerender();
+
+      // Note: In real usage, the subscription would trigger updates
+      // This test verifies the hook structure
+      expect(mockEventService.getEvents).toHaveBeenCalled();
+    });
+  });
+});
+