@jmruthers/pace-core 0.6.10 → 0.6.12

package/src/services/EventService.test.ts

@@ -0,0 +1,1250 @@
+/**
+ * @file EventService Unit Tests
+ * @package @jmruthers/pace-core
+ * @module Services
+ * @since 0.1.0
+ *
+ * Unit tests for EventService class.
+ * Tests event management, selection, and persistence operations.
+ */
+
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { EventService } from './EventService';
+import { Event } from '../types/event';
+import { assertOrganisationId } from '../types/core';
+
+// Don't mock the logger - it now works in test mode
+// We'll spy on the Logger class methods in beforeEach to verify calls
+import { Logger } from '../utils/core/logger';
+
+let mockLoggerFunctions: {
+  debug: ReturnType<typeof vi.spyOn>;
+  error: ReturnType<typeof vi.spyOn>;
+  warn: ReturnType<typeof vi.spyOn>;
+  info: ReturnType<typeof vi.spyOn>;
+};
+
+// Mock secureStorage - use vi.hoisted so methods are proper spies (same path as EventService imports)
+const mockSetItem = vi.hoisted(() => vi.fn().mockResolvedValue(undefined));
+const mockGetItem = vi.hoisted(() => vi.fn().mockResolvedValue(null));
+const mockRemoveItem = vi.hoisted(() => vi.fn().mockResolvedValue(undefined));
+vi.mock('../utils/security/secureStorage', () => ({
+  secureStorage: {
+    setItem: mockSetItem,
+    getItem: mockGetItem,
+    removeItem: mockRemoveItem,
+  },
+}));
+
+// Reference to mocked secureStorage for test assertions (matches vi.mock above)
+const mockSecureStorage = {
+  setItem: mockSetItem,
+  getItem: mockGetItem,
+  removeItem: mockRemoveItem,
+};
+
+// Mock RBAC API (same path as EventService imports)
+vi.mock('../rbac/api', async () => {
+  const actual = await vi.importActual('../rbac/api');
+  return {
+    ...actual,
+    isSuperAdmin: vi.fn().mockResolvedValue({ ok: true, data: false }),
+  };
+});
+
+// Mock Supabase client
+const createMockSupabaseClient = () => ({
+  rpc: vi.fn(),
+});
+
+// Mock user and session
+const mockUser = {
+  id: 'user-1',
+  email: 'test@example.com'
+};
+
+const mockSession = {
+  access_token: 'token',
+  user: mockUser
+};
+
+const mockOrganisation = {
+  id: 'org-1',
+  display_name: 'Test Organisation'
+};
+
+const mockSetSelectedEventId = vi.fn();
+
+// Raw RPC response data (what comes from database)
+const mockEventRpcData = {
+  event_id: 'event-1',
+  event_name: 'Test Event',
+  event_code: 'test-event',
+  event_date: '2025-01-01T00:00:00Z',
+  event_venue: 'Test Venue',
+  event_participants: 100,
+  event_colours: '#FF0000',
+  organisation_id: 'org-1',
+  is_visible: true
+};
+
+const mockEvent2RpcData = {
+  event_id: 'event-2',
+  event_name: 'Future Event',
+  event_code: 'future-event',
+  event_date: '2025-12-31T00:00:00Z',
+  event_venue: 'Future Venue',
+  event_participants: 200,
+  event_colours: '#00FF00',
+  organisation_id: 'org-1',
+  is_visible: true
+};
+
+// Transformed Event objects (what EventService returns after transformation)
+const mockEvent: Event = {
+  id: 'event-1',
+  event_id: 'event-1',
+  event_name: 'Test Event',
+  event_code: 'test-event',
+  event_date: '2025-01-01T00:00:00Z',
+  event_venue: 'Test Venue',
+  event_participants: 100,
+  event_colours: '#FF0000',
+  event_logo: '',
+  organisation_id: assertOrganisationId('org-1'),
+  is_visible: true,
+  created_at: expect.any(String),
+  updated_at: expect.any(String)
+};
+
+const mockEvent2: Event = {
+  id: 'event-2',
+  event_id: 'event-2',
+  event_name: 'Future Event',
+  event_code: 'future-event',
+  event_date: '2025-12-31T00:00:00Z',
+  event_venue: 'Future Venue',
+  event_participants: 200,
+  event_colours: '#00FF00',
+  event_logo: '',
+  organisation_id: assertOrganisationId('org-1'),
+  is_visible: true,
+  created_at: expect.any(String),
+  updated_at: expect.any(String)
+};
+
+describe('EventService', () => {
+  let mockSupabase: ReturnType<typeof createMockSupabaseClient>;
+  let eventService: EventService;
+
+  beforeEach(() => {
+    // Spy on Logger methods to verify calls (logger now works in test mode)
+    mockLoggerFunctions = {
+      debug: vi.spyOn(Logger, 'debug'),
+      error: vi.spyOn(Logger, 'error'),
+      warn: vi.spyOn(Logger, 'warn'),
+      info: vi.spyOn(Logger, 'info'),
+    };
+    
+    vi.clearAllMocks();
+    mockSupabase = createMockSupabaseClient();
+    eventService = new EventService(
+      mockSupabase as any,
+      mockUser,
+      mockSession,
+      'test-app',
+      mockOrganisation,
+      mockSetSelectedEventId
+    );
+  });
+
+  afterEach(() => {
+    eventService.cleanup();
+    // Restore spies
+    mockLoggerFunctions.debug.mockRestore();
+    mockLoggerFunctions.error.mockRestore();
+    mockLoggerFunctions.warn.mockRestore();
+    mockLoggerFunctions.info.mockRestore();
+    vi.clearAllMocks();
+    // Clear localStorage
+    localStorage.clear();
+    sessionStorage.clear();
+  });
+
+  describe('Initialization', () => {
+    it('should initialize with default state', () => {
+      expect(eventService.getEvents()).toEqual([]);
+      expect(eventService.getSelectedEvent()).toBeNull();
+      expect(eventService.isLoading()).toBe(false);
+      expect(eventService.getError()).toBeNull();
+    });
+
+    it('should fetch events on initialization', async () => {
+      mockSupabase.rpc.mockResolvedValue({
+        data: [mockEventRpcData, mockEvent2RpcData],
+        error: null
+      });
+
+      await eventService.initialize();
+
+      // For org-required apps: uses selectedOrganisation.id
+      // For event-required apps: uses selectedEvent.organisation_id or null for super admins
+      expect(mockSupabase.rpc).toHaveBeenCalledWith('data_user_events_get', {
+        p_user_id: mockUser.id,
+        p_organisation_id: mockOrganisation.id, // Org-required app uses selectedOrganisation
+        p_app_name: 'test-app'
+      });
+
+      expect(eventService.getEvents()).toHaveLength(2);
+      expect(eventService.isLoading()).toBe(false);
+    });
+
+    it('should fetch events with null organisation for super admin', async () => {
+      // Skip this test if RBAC API is not properly mocked
+      // The RBAC API mock is set up at the module level, so we can't easily override it here
+      // This test verifies the super admin path exists, but the actual behavior depends on the mock setup
+      mockSupabase.rpc.mockResolvedValue({
+        data: [mockEventRpcData, mockEvent2RpcData],
+        error: null
+      });
+
+      await eventService.initialize();
+
+      // Verify RPC was called (super admin logic is tested in edge-cases file)
+      expect(mockSupabase.rpc).toHaveBeenCalled();
+    });
+
+    it('should use selectedEvent organisation_id when event is already selected', async () => {
+      mockSupabase.rpc.mockResolvedValue({
+        data: [mockEventRpcData],
+        error: null
+      });
+
+      // Set event first
+      eventService.setSelectedEvent(mockEvent);
+
+      // Now initialize (should use event's organisation)
+      await eventService.initialize();
+
+      expect(mockSupabase.rpc).toHaveBeenCalledWith('data_user_events_get', {
+        p_user_id: mockUser.id,
+        p_organisation_id: mockEvent.organisation_id,
+        p_app_name: 'test-app'
+      });
+    });
+
+    it('should sort events by date descending', async () => {
+      const oldEvent = {
+        ...mockEventRpcData,
+        event_id: 'event-old',
+        event_date: '2020-01-01T00:00:00Z'
+      };
+      const newEvent = {
+        ...mockEventRpcData,
+        event_id: 'event-new',
+        event_date: '2025-12-31T00:00:00Z'
+      };
+
+      mockSupabase.rpc.mockResolvedValue({
+        data: [oldEvent, newEvent],
+        error: null
+      });
+
+      await eventService.initialize();
+
+      const events = eventService.getEvents();
+      expect(events[0].event_id).toBe('event-new'); // Newest first
+      expect(events[1].event_id).toBe('event-old');
+    });
+
+    it('should handle events with null dates in sorting', async () => {
+      const eventWithDate = {
+        ...mockEventRpcData,
+        event_id: 'event-with-date',
+        event_date: '2025-01-01T00:00:00Z'
+      };
+      const eventWithoutDate = {
+        ...mockEventRpcData,
+        event_id: 'event-no-date',
+        event_date: null
+      };
+
+      mockSupabase.rpc.mockResolvedValue({
+        data: [eventWithoutDate, eventWithDate],
+        error: null
+      });
+
+      await eventService.initialize();
+
+      const events = eventService.getEvents();
+      // Events with dates should come first
+      expect(events[0].event_id).toBe('event-with-date');
+      expect(events[1].event_id).toBe('event-no-date');
+    });
+
+    it('should clear selected event if it no longer exists in events list', async () => {
+      mockSupabase.rpc.mockResolvedValue({
+        data: [mockEventRpcData],
+        error: null
+      });
+
+      await eventService.initialize();
+      eventService.setSelectedEvent(mockEvent);
+      expect(eventService.getSelectedEvent()?.event_id).toBe('event-1');
+
+      // Clear auto-selection flag to prevent auto-selection
+      (eventService as any).userClearedEventRef = true;
+      (eventService as any).hasAutoSelectedRef = false;
+
+      // Now fetch events without the selected event
+      mockSupabase.rpc.mockResolvedValue({
+        data: [mockEvent2RpcData], // Different event
+        error: null
+      });
+
+      await eventService.refreshEvents();
+
+      // Selected event should be cleared since it's not in the new list
+      // (unless auto-selection happens, which we prevented)
+      const selectedEvent = eventService.getSelectedEvent();
+      if (selectedEvent) {
+        // If auto-selection happened, it should be the new event
+        expect(selectedEvent.event_id).toBe('event-2');
+      } else {
+        // Otherwise, it should be null
+        expect(selectedEvent).toBeNull();
+      }
+    });
+
+    it('should handle missing dependencies gracefully', async () => {
+      const serviceWithoutUser = new EventService(
+        mockSupabase as any,
+        null,
+        null,
+        'test-app',
+        null,
+        mockSetSelectedEventId
+      );
+
+      await serviceWithoutUser.initialize();
+
+      expect(serviceWithoutUser.getEvents()).toEqual([]);
+      expect(serviceWithoutUser.isLoading()).toBe(false);
+    });
+  });
+
+  describe('Event Operations', () => {
+    beforeEach(async () => {
+      mockSupabase.rpc.mockResolvedValue({
+        data: [mockEventRpcData, mockEvent2RpcData],
+        error: null
+      });
+
+      await eventService.initialize();
+    });
+
+    it('should set selected event', () => {
+      eventService.setSelectedEvent(mockEvent);
+
+      expect(eventService.getSelectedEvent()).toEqual(mockEvent);
+      expect(mockSetSelectedEventId).toHaveBeenCalledWith('event-1');
+    });
+
+    it('should clear selected event', () => {
+      eventService.setSelectedEvent(mockEvent);
+      expect(eventService.getSelectedEvent()).toEqual(mockEvent);
+
+      eventService.setSelectedEvent(null);
+
+      expect(eventService.getSelectedEvent()).toBeNull();
+      expect(mockSetSelectedEventId).toHaveBeenCalledWith(null);
+    });
+
+    it('should allow selecting event from any organisation (no validation)', () => {
+      // Clear any auto-selected event first
+      eventService.setSelectedEvent(null);
+      
+      const eventFromDifferentOrg: Event = {
+        ...mockEvent,
+        organisation_id: 'org-2'
+      };
+
+      eventService.setSelectedEvent(eventFromDifferentOrg);
+
+      // Should allow selection - org validation removed (org derived from event for event-required apps)
+      expect(eventService.getSelectedEvent()).toEqual(eventFromDifferentOrg);
+    });
+
+    it('should refresh events', async () => {
+      // Clear the mock call count from the beforeEach initialization
+      vi.clearAllMocks();
+      
+      const newEventRpcData = {
+        ...mockEventRpcData,
+        event_id: 'event-3',
+        event_name: 'New Event'
+      };
+      mockSupabase.rpc.mockResolvedValue({
+        data: [mockEventRpcData, mockEvent2RpcData, newEventRpcData],
+        error: null
+      });
+
+      await eventService.refreshEvents();
+
+      expect(eventService.getEvents()).toHaveLength(3);
+      expect(mockSupabase.rpc).toHaveBeenCalledTimes(1); // Only the refresh call
+    });
+  });
+
+  describe('Event Selection Helpers', () => {
+    beforeEach(async () => {
+      // Set up mock data before creating service
+      mockSupabase.rpc.mockResolvedValue({
+        data: [mockEventRpcData, mockEvent2RpcData],
+        error: null
+      });
+
+      // Create a fresh service instance with the mock data
+      const testEventService = new EventService(
+        mockSupabase as any,
+        mockUser,
+        mockSession,
+        'test-app',
+        mockOrganisation,
+        mockSetSelectedEventId
+      );
+
+      await testEventService.initialize();
+      
+      // Replace the main eventService with our test instance
+      eventService = testEventService;
+    });
+
+    it('should get next event by date', () => {
+      const nextEvent = eventService.getNextEventByDate();
+      expect(nextEvent).toEqual(mockEvent2); // Future event should be selected
+    });
+
+    it('should return most recent past event when no future events', async () => {
+      const pastEvent1RpcData = {
+        ...mockEventRpcData,
+        event_id: 'event-past-1',
+        event_date: '2020-01-01T00:00:00Z'
+      };
+      const pastEvent2RpcData = {
+        ...mockEventRpcData,
+        event_id: 'event-past-2',
+        event_date: '2021-06-15T00:00:00Z' // More recent past event
+      };
+
+      mockSupabase.rpc.mockResolvedValue({
+        data: [pastEvent1RpcData, pastEvent2RpcData],
+        error: null
+      });
+
+      const service = new EventService(
+        mockSupabase as any,
+        mockUser,
+        mockSession,
+        'test-app',
+        mockOrganisation,
+        mockSetSelectedEventId
+      );
+
+      await service.initialize();
+
+      const nextEvent = service.getNextEventByDate();
+      // Should return the most recent past event (pastEvent2)
+      expect(nextEvent).not.toBeNull();
+      expect(nextEvent?.event_id).toBe('event-past-2');
+    });
+
+    it('should persist event selection', async () => {
+      await eventService.persistEventSelection('event-1');
+
+      expect(mockSecureStorage.setItem).toHaveBeenCalledWith(
+        expect.stringContaining('pace-core-selected-event'),
+        'event-1',
+        { encrypt: true }
+      );
+    });
+
+    it('should clear event selection', async () => {
+      eventService.setSelectedEvent(mockEvent);
+      await eventService.clearEventSelection();
+
+      expect(mockSecureStorage.removeItem).toHaveBeenCalledWith(
+        expect.stringContaining('pace-core-selected-event')
+      );
+      expect(eventService.getSelectedEvent()).toBeNull();
+    });
+
+    it('should load persisted event', async () => {
+      // Set up persisted event in secureStorage
+      mockSecureStorage.getItem.mockResolvedValueOnce('event-1');
+
+      const service = new EventService(
+        mockSupabase as any,
+        mockUser,
+        mockSession,
+        'test-app',
+        mockOrganisation,
+        mockSetSelectedEventId
+      );
+
+      mockSupabase.rpc.mockResolvedValue({
+        data: [mockEventRpcData, mockEvent2RpcData],
+        error: null
+      });
+
+      // Initialize will auto-select an event (mockEvent2), but loadPersistedEvent should override it
+      await service.initialize();
+      
+      // Restore the persisted event ID in secureStorage before calling loadPersistedEvent
+      mockSecureStorage.getItem.mockResolvedValueOnce('event-1');
+      
+      // Now loadPersistedEvent should find and load the persisted event
+      const loaded = await service.loadPersistedEvent(service.getEvents());
+      
+      expect(loaded).toBe(true);
+      expect(service.getSelectedEvent()).toEqual(mockEvent);
+      expect(service.getSelectedEvent()?.event_id).toBe('event-1');
+    });
+
+    it('should handle invalid persisted event', async () => {
+      // Set up invalid persisted event in secureStorage
+      mockSecureStorage.getItem.mockResolvedValueOnce('invalid-event');
+
+      const service = new EventService(
+        mockSupabase as any,
+        mockUser,
+        mockSession,
+        'test-app',
+        mockOrganisation,
+        mockSetSelectedEventId
+      );
+
+      mockSupabase.rpc.mockResolvedValue({
+        data: [mockEventRpcData, mockEvent2RpcData],
+        error: null
+      });
+
+      await service.initialize();
+
+      // The service should have auto-selected an event despite the invalid persisted event
+      // because the persisted event was invalid and userClearedEventRef is false
+      expect(service.getSelectedEvent()).not.toBeNull();
+      
+      // The auto-selected event should be persisted (replacing the invalid one)
+      expect(mockSecureStorage.setItem).toHaveBeenCalledWith(
+        expect.stringContaining('pace-core-selected-event'),
+        'event-2',
+        { encrypt: true }
+      );
+    });
+  });
+
+  describe('State Management', () => {
+    it('should notify subscribers when state changes', async () => {
+      mockSupabase.rpc.mockResolvedValue({
+        data: [mockEventRpcData],
+        error: null
+      });
+
+      const subscriber = vi.fn();
+      const unsubscribe = eventService.subscribe(subscriber);
+
+      await eventService.initialize();
+
+      expect(subscriber).toHaveBeenCalled();
+
+      unsubscribe();
+    });
+
+    it('should cleanup subscriptions on cleanup', () => {
+      const subscriber = vi.fn();
+      eventService.subscribe(subscriber);
+
+      eventService.cleanup();
+
+      // After cleanup, new state changes shouldn't notify subscribers
+      eventService.setSelectedEvent(mockEvent);
+
+      expect(subscriber).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should handle RPC errors gracefully', async () => {
+      mockSupabase.rpc.mockResolvedValue({
+        data: null,
+        error: { message: 'RPC error' }
+      });
+
+      await eventService.initialize();
+
+      expect(eventService.getError()).toBeDefined();
+      expect(eventService.getError()?.message).toBe('RPC error');
+      expect(eventService.getEvents()).toEqual([]);
+    });
+
+    it('should handle network errors', async () => {
+      mockSupabase.rpc.mockRejectedValue(new Error('Network error'));
+
+      await eventService.initialize();
+
+      expect(eventService.getError()).toBeDefined();
+      expect(eventService.getError()?.message).toBe('Network error');
+    });
+
+    it('should handle missing event data gracefully', async () => {
+      mockSupabase.rpc.mockResolvedValue({
+        data: null,
+        error: null
+      });
+
+      await eventService.initialize();
+
+      expect(eventService.getEvents()).toEqual([]);
+      expect(eventService.getError()).toBeNull();
+    });
+  });
+
+  describe('Auto-selection', () => {
+    it('should auto-select next event when no event is selected', async () => {
+      // Set up mock data before creating service
+      mockSupabase.rpc.mockResolvedValue({
+        data: [mockEventRpcData, mockEvent2RpcData],
+        error: null
+      });
+
+      // Create a fresh service instance with the mock data
+      const testEventService = new EventService(
+        mockSupabase as any,
+        mockUser,
+        mockSession,
+        'test-app',
+        mockOrganisation,
+        mockSetSelectedEventId
+      );
+
+      await testEventService.initialize();
+
+      // Should auto-select the future event
+      expect(testEventService.getSelectedEvent()).toEqual(mockEvent2);
+      expect(mockSetSelectedEventId).toHaveBeenCalledWith('event-2');
+    });
+
+    it('should not auto-select when user has cleared event', async () => {
+      // Set up mock data before calling initialize
+      mockSupabase.rpc.mockResolvedValue({
+        data: [mockEventRpcData, mockEvent2RpcData],
+        error: null
+      });
+
+      await eventService.initialize();
+
+      // Clear the event
+      eventService.setSelectedEvent(null);
+
+      // Refresh events
+      mockSupabase.rpc.mockResolvedValue({
+        data: [mockEventRpcData, mockEvent2RpcData],
+        error: null
+      });
+
+      await eventService.refreshEvents();
+
+      // Should not auto-select after user cleared
+      expect(eventService.getSelectedEvent()).toBeNull();
+    });
+  });
+
+  describe('Persistence', () => {
+    it('should persist event selection across sessions', async () => {
+      mockSupabase.rpc.mockResolvedValue({
+        data: [mockEventRpcData, mockEvent2RpcData],
+        error: null
+      });
+
+      await eventService.initialize();
+
+      eventService.setSelectedEvent(mockEvent);
+
+      // Check persistence - wait for async persistEventSelection call
+      await new Promise(resolve => setTimeout(resolve, 10));
+      expect(mockSecureStorage.setItem).toHaveBeenCalledWith(
+        expect.stringContaining('pace-core-selected-event'),
+        'event-1',
+        { encrypt: true }
+      );
+    });
+
+    it('should restore persisted event on initialization', async () => {
+      // Set up persisted event in secureStorage
+      mockSecureStorage.getItem.mockResolvedValue('event-1');
+
+      mockSupabase.rpc.mockResolvedValue({
+        data: [mockEventRpcData, mockEvent2RpcData],
+        error: null
+      });
+
+      const service = new EventService(
+        mockSupabase as any,
+        mockUser,
+        mockSession,
+        'test-app',
+        mockOrganisation,
+        mockSetSelectedEventId
+      );
+
+      await service.initialize();
+
+      // After initialize(), fetchEvents(true) is called which skips loading persisted events
+      // but still auto-selects, which may have overwritten the storage
+      // Restore the persisted event ID in secureStorage and then load it
+      mockSecureStorage.getItem.mockResolvedValueOnce('event-1');
+      
+      const loaded = await service.loadPersistedEvent(service.getEvents());
+      
+      expect(loaded).toBe(true);
+      expect(service.getSelectedEvent()).toEqual(mockEvent);
+      expect(service.getSelectedEvent()?.event_id).toBe('event-1');
+    });
+  });
+
+  describe('Dependency Updates', () => {
+    it('should update dependencies when organisation changes', async () => {
+      const newOrganisation = { id: 'org-2', display_name: 'New Organisation' };
+
+      await eventService.updateDependencies(
+        mockSupabase as any,
+        mockUser,
+        mockSession,
+        'test-app',
+        newOrganisation,
+        mockSetSelectedEventId
+      );
+
+      // Should reset initialization when organisation changes
+      expect(eventService.getEvents()).toBeDefined();
+    });
+
+    it('should preserve event when organisation first becomes available', async () => {
+      mockSupabase.rpc.mockResolvedValue({
+        data: [mockEventRpcData],
+        error: null
+      });
+
+      // Start without organisation
+      const serviceWithoutOrg = new EventService(
+        mockSupabase as any,
+        mockUser,
+        mockSession,
+        'test-app',
+        null,
+        mockSetSelectedEventId
+      );
+
+      await serviceWithoutOrg.initialize();
+      serviceWithoutOrg.setSelectedEvent(mockEvent);
+
+      // Now set organisation (first time)
+      await serviceWithoutOrg.updateDependencies(
+        mockSupabase as any,
+        mockUser,
+        mockSession,
+        'test-app',
+        mockOrganisation,
+        mockSetSelectedEventId
+      );
+
+      // Event should be preserved when org is first set
+      expect(serviceWithoutOrg.getSelectedEvent()).toEqual(mockEvent);
+
+      serviceWithoutOrg.cleanup();
+    });
+
+    it('should clear events when switching between different organisations', async () => {
+      mockSupabase.rpc.mockResolvedValue({
+        data: [mockEventRpcData],
+        error: null
+      });
+
+      await eventService.initialize();
+      eventService.setSelectedEvent(mockEvent);
+
+      const newOrganisation = { id: 'org-2', display_name: 'New Organisation' };
+
+      await eventService.updateDependencies(
+        mockSupabase as any,
+        mockUser,
+        mockSession,
+        'test-app',
+        newOrganisation,
+        mockSetSelectedEventId
+      );
+
+      // Events should be cleared when switching organisations
+      expect(eventService.getEvents()).toEqual([]);
+      expect(eventService.getSelectedEvent()).toBeNull();
+    });
+
+    it('should clear events when switching to different organisation', async () => {
+      mockSupabase.rpc.mockResolvedValue({
+        data: [mockEventRpcData],
+        error: null
+      });
+
+      await eventService.initialize();
+      eventService.setSelectedEvent(mockEvent);
+
+      const newOrganisation = { id: 'org-2', display_name: 'New Organisation' };
+
+      await eventService.updateDependencies(
+        mockSupabase as any,
+        mockUser,
+        mockSession,
+        'test-app',
+        newOrganisation,
+        mockSetSelectedEventId
+      );
+
+      // Events should be cleared when switching organisations
+      expect(eventService.getEvents()).toEqual([]);
+      expect(eventService.getSelectedEvent()).toBeNull();
+    });
+
+    it('should clear event selection when user changes', async () => {
+      mockSupabase.rpc.mockResolvedValue({
+        data: [mockEventRpcData],
+        error: null
+      });
+
+      await eventService.initialize();
+      eventService.setSelectedEvent(mockEvent);
+
+      const newUser = { id: 'user-2', email: 'new@example.com' };
+      const newSession = { access_token: 'new-token', user: newUser };
+
+      await eventService.updateDependencies(
+        mockSupabase as any,
+        newUser,
+        newSession,
+        'test-app',
+        mockOrganisation,
+        mockSetSelectedEventId
+      );
+
+      // Event selection should be cleared for previous user
+      expect(mockSecureStorage.removeItem).toHaveBeenCalled();
+    });
+
+    it('should clear event selection when user logs out', async () => {
+      mockSupabase.rpc.mockResolvedValue({
+        data: [mockEventRpcData],
+        error: null
+      });
+
+      await eventService.initialize();
+      eventService.setSelectedEvent(mockEvent);
+
+      await eventService.updateDependencies(
+        mockSupabase as any,
+        null,
+        null,
+        'test-app',
+        mockOrganisation,
+        mockSetSelectedEventId
+      );
+
+      // Event should be cleared on logout
+      expect(eventService.getSelectedEvent()).toBeNull();
+      expect(mockSetSelectedEventId).toHaveBeenCalledWith(null);
+    });
+
+    it('should reset initialization flags when user changes', async () => {
+      mockSupabase.rpc.mockResolvedValue({
+        data: [mockEventRpcData],
+        error: null
+      });
+
+      await eventService.initialize();
+      
+      const newUser = { id: 'user-2', email: 'new@example.com' };
+      const newSession = { access_token: 'new-token', user: newUser };
+
+      await eventService.updateDependencies(
+        mockSupabase as any,
+        newUser,
+        newSession,
+        'test-app',
+        mockOrganisation,
+        mockSetSelectedEventId
+      );
+
+      // Should allow re-initialization
+      expect((eventService as any).isInitializedRef).toBe(false);
+      expect((eventService as any).isFetchingRef).toBe(false);
+    });
+
+    it('should reset userClearedEventRef when new user logs in', async () => {
+      mockSupabase.rpc.mockResolvedValue({
+        data: [mockEventRpcData],
+        error: null
+      });
+
+      await eventService.initialize();
+      eventService.setSelectedEvent(null); // User clears event
+      
+      expect((eventService as any).userClearedEventRef).toBe(true);
+
+      const newUser = { id: 'user-2', email: 'new@example.com' };
+      const newSession = { access_token: 'new-token', user: newUser };
+
+      await eventService.updateDependencies(
+        mockSupabase as any,
+        newUser,
+        newSession,
+        'test-app',
+        mockOrganisation,
+        mockSetSelectedEventId
+      );
+
+      // Should reset flag for new user
+      expect((eventService as any).userClearedEventRef).toBe(false);
+    });
+  });
+
+  describe('Event Persistence', () => {
+    it('should restore persisted event', async () => {
+      mockSecureStorage.getItem.mockResolvedValue('event-1');
+
+      mockSupabase.rpc.mockResolvedValue({
+        data: [mockEventRpcData, mockEvent2RpcData],
+        error: null
+      });
+
+      const service = new EventService(
+        mockSupabase as any,
+        mockUser,
+        mockSession,
+        'test-app',
+        mockOrganisation,
+        mockSetSelectedEventId
+      );
+
+      await service.initialize();
+
+      const restored = await service.restorePersistedEvent();
+
+      expect(restored).toBe(true);
+      expect(service.getSelectedEvent()).toEqual(mockEvent);
+    });
+
+    it('should return false when restoring persisted event if events not loaded', async () => {
+      const service = new EventService(
+        mockSupabase as any,
+        mockUser,
+        mockSession,
+        'test-app',
+        mockOrganisation,
+        mockSetSelectedEventId
+      );
+
+      // Don't initialize, so events are empty
+      const restored = await service.restorePersistedEvent();
+
+      expect(restored).toBe(false);
+    });
+
+    it('should clear event selection for specific user', async () => {
+      await eventService.clearEventSelectionForUser('user-1');
+
+      expect(mockSecureStorage.removeItem).toHaveBeenCalledWith(
+        expect.stringContaining('pace-core-selected-event-user-1')
+      );
+    });
+
+    it('should handle clearing event selection for null user', async () => {
+      await eventService.clearEventSelectionForUser(null);
+
+      // Should not throw error
+      expect(mockSecureStorage.removeItem).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('Event Colours Parsing', () => {
+    it('should parse event colours from string JSON', () => {
+      const eventWithStringColours: Event = {
+        ...mockEvent,
+        event_colours: JSON.stringify({
+          main: { '500': '#FF0000' },
+          sec: { '500': '#00FF00' },
+          acc: { '500': '#0000FF' }
+        })
+      };
+
+      // The parseAndNormalizeEventColours is private, but we can test it indirectly
+      // by checking if setSelectedEvent handles it correctly
+      eventService.setSelectedEvent(eventWithStringColours);
+
+      expect(eventService.getSelectedEvent()).toEqual(eventWithStringColours);
+    });
+
+    it('should parse event colours with ev-* keys', () => {
+      const eventWithEvKeys: Event = {
+        ...mockEvent,
+        event_colours: {
+          'ev-main': { '500': '#FF0000' },
+          'ev-sec': { '500': '#00FF00' },
+          'ev-acc': { '500': '#0000FF' }
+        }
+      };
+
+      eventService.setSelectedEvent(eventWithEvKeys);
+
+      expect(eventService.getSelectedEvent()).toEqual(eventWithEvKeys);
+    });
+
+    it('should handle invalid event colours gracefully', () => {
+      const eventWithInvalidColours: Event = {
+        ...mockEvent,
+        event_colours: 'invalid-json'
+      };
+
+      // Should not throw error
+      eventService.setSelectedEvent(eventWithInvalidColours);
+
+      expect(eventService.getSelectedEvent()).toEqual(eventWithInvalidColours);
+    });
+
+    it('should handle null event colours', () => {
+      const eventWithNullColours: Event = {
+        ...mockEvent,
+        event_colours: null as any
+      };
+
+      eventService.setSelectedEvent(eventWithNullColours);
+
+      expect(eventService.getSelectedEvent()).toEqual(eventWithNullColours);
+    });
+  });
+
+  describe('Next Event Selection', () => {
+    it('should return null when no events provided', () => {
+      const nextEvent = eventService.getNextEventByDate([]);
+
+      expect(nextEvent).toBeNull();
+    });
+
+    it('should return most recent past event when all events are in the past', () => {
+      const pastEvent1: Event = {
+        ...mockEvent,
+        event_id: 'event-past-1',
+        event_date: '2020-01-01T00:00:00Z'
+      };
+      const pastEvent2: Event = {
+        ...mockEvent,
+        event_id: 'event-past-2',
+        event_date: '2022-03-20T00:00:00Z' // More recent past event
+      };
+
+      const nextEvent = eventService.getNextEventByDate([pastEvent1, pastEvent2]);
+
+      // Should return the most recent past event (pastEvent2)
+      expect(nextEvent).not.toBeNull();
+      expect(nextEvent?.event_id).toBe('event-past-2');
+    });
+
+    it('should select event on today\'s date', () => {
+      const today = new Date();
+      const todayEvent: Event = {
+        ...mockEvent,
+        event_date: today.toISOString()
+      };
+
+      const nextEvent = eventService.getNextEventByDate([todayEvent]);
+
+      expect(nextEvent).toEqual(todayEvent);
+    });
+
+    it('should select earliest future event when multiple future events exist', () => {
+      // Create events with dates far in the future to ensure they're both considered future events
+      const today = new Date();
+      const futureDate1 = new Date(today.getTime() + 200 * 24 * 60 * 60 * 1000); // 200 days from now
+      const futureDate2 = new Date(today.getTime() + 100 * 24 * 60 * 60 * 1000); // 100 days from now (earlier)
+      
+      const futureEvent1: Event = {
+        id: 'event-1',
+        event_id: 'event-1',
+        event_name: 'Later Event',
+        event_date: futureDate1.toISOString(),
+        event_venue: 'Venue',
+        event_participants: 100,
+        event_colours: '#FF0000',
+        event_logo: '',
+        organisation_id: assertOrganisationId('org-1'),
+        is_visible: true,
+        name: 'Later Event',
+        start_date: futureDate1.toISOString()
+      };
+
+      const futureEvent2: Event = {
+        id: 'event-2',
+        event_id: 'event-2',
+        event_name: 'Earlier Event',
+        event_date: futureDate2.toISOString(),
+        event_venue: 'Venue',
+        event_participants: 100,
+        event_colours: '#00FF00',
+        event_logo: '',
+        organisation_id: assertOrganisationId('org-1'),
+        is_visible: true,
+        name: 'Earlier Event',
+        start_date: futureDate2.toISOString()
+      };
+
+      const nextEvent = eventService.getNextEventByDate([futureEvent1, futureEvent2]);
+
+      // Should select the earlier event (event-2, 100 days from now)
+      expect(nextEvent?.event_id).toBe('event-2');
+      expect(nextEvent?.event_date).toBe(futureDate2.toISOString());
+    });
+
+    it('should prefer future events over past events when both exist', () => {
+      const today = new Date();
+      const pastDate = new Date(today.getTime() - 30 * 24 * 60 * 60 * 1000); // 30 days ago
+      const futureDate = new Date(today.getTime() + 30 * 24 * 60 * 60 * 1000); // 30 days from now
+
+      const pastEvent: Event = {
+        ...mockEvent,
+        event_id: 'event-past',
+        event_date: pastDate.toISOString()
+      };
+
+      const futureEvent: Event = {
+        ...mockEvent,
+        event_id: 'event-future',
+        event_date: futureDate.toISOString()
+      };
+
+      const nextEvent = eventService.getNextEventByDate([pastEvent, futureEvent]);
+
+      // Should prefer future event even if past event is more recent
+      expect(nextEvent).not.toBeNull();
+      expect(nextEvent?.event_id).toBe('event-future');
+    });
+
+    it('should filter out events without dates', () => {
+      const eventWithoutDate: Event = {
+        ...mockEvent,
+        event_date: null as any
+      };
+
+      const nextEvent = eventService.getNextEventByDate([eventWithoutDate]);
+
+      expect(nextEvent).toBeNull();
+    });
+  });
+
+  describe('Auto-selection Logic', () => {
+    it('should auto-select next event when no persisted event exists', async () => {
+      mockSecureStorage.getItem.mockResolvedValue(null);
+
+      mockSupabase.rpc.mockResolvedValue({
+        data: [mockEventRpcData, mockEvent2RpcData],
+        error: null
+      });
+
+      const service = new EventService(
+        mockSupabase as any,
+        mockUser,
+        mockSession,
+        'test-app',
+        mockOrganisation,
+        mockSetSelectedEventId
+      );
+
+      await service.initialize();
+
+      // Should auto-select the future event
+      expect(service.getSelectedEvent()).not.toBeNull();
+    });
+
+    it('should not auto-select when user has explicitly cleared event', async () => {
+      mockSupabase.rpc.mockResolvedValue({
+        data: [mockEventRpcData, mockEvent2RpcData],
+        error: null
+      });
+
+      await eventService.initialize();
+
+      // Clear the event (this sets userClearedEventRef)
+      eventService.setSelectedEvent(null);
+
+      // Refresh events
+      await eventService.refreshEvents();
+
+      // Should not auto-select after user cleared
+      expect(eventService.getSelectedEvent()).toBeNull();
+    });
+  });
+
+  describe('Storage Cleanup', () => {
+    it('should clean up old storage keys on initialization', async () => {
+      // Set old storage keys
+      sessionStorage.setItem('pace-core-selected-event', 'old-event');
+      localStorage.setItem('pace-core-selected-event', 'old-event');
+      localStorage.setItem('_sec_pace-core-selected-event', 'old-encrypted');
+
+      mockSupabase.rpc.mockResolvedValue({
+        data: [mockEventRpcData],
+        error: null
+      });
+
+      await eventService.initialize();
+
+      // Old keys should be removed
+      expect(sessionStorage.getItem('pace-core-selected-event')).toBeNull();
+      expect(localStorage.getItem('pace-core-selected-event')).toBeNull();
+      expect(localStorage.getItem('_sec_pace-core-selected-event')).toBeNull();
+    });
+  });
+
+  describe('Event Selection', () => {
+    it('should allow selecting event without organisation validation', () => {
+      vi.clearAllMocks();
+
+      const eventFromDifferentOrg: Event = {
+        ...mockEvent,
+        organisation_id: 'org-2'
+      };
+
+      // Should not throw error - validation removed (org derived from event for event-required apps)
+      eventService.setSelectedEvent(eventFromDifferentOrg);
+
+      // Event should be selected successfully
+      expect(eventService.getSelectedEvent()).toEqual(eventFromDifferentOrg);
+      // No error should be logged
+      expect(mockLoggerFunctions.error).not.toHaveBeenCalled();
+    });
+
+    it('should allow selecting event when organisation is null (event-required apps)', () => {
+      const serviceWithoutOrg = new EventService(
+        mockSupabase as any,
+        mockUser,
+        mockSession,
+        'test-app',
+        null,
+        mockSetSelectedEventId
+      );
+
+      // Should not throw error - org is derived from event for event-required apps
+      serviceWithoutOrg.setSelectedEvent(mockEvent);
+
+      // Event should be selected successfully
+      expect(serviceWithoutOrg.getSelectedEvent()).toEqual(mockEvent);
+    });
+  });
+});