@jmruthers/pace-core 0.6.10 → 0.6.12

package/src/services/__tests__/EventService.test.ts

@@ -1,1018 +0,0 @@
-/**
- * @file EventService Unit Tests
- * @package @jmruthers/pace-core
- * @module Services/__tests__
- * @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 - must be defined inline in vi.mock due to hoisting
-vi.mock('../../utils/security/secureStorage', () => {
-  const mockSecureStorage = {
-    setItem: vi.fn().mockResolvedValue(undefined),
-    getItem: vi.fn().mockResolvedValue(null),
-    removeItem: vi.fn().mockResolvedValue(undefined),
-  };
-  return {
-    secureStorage: mockSecureStorage,
-  };
-});
-
-// Get reference to mocked secureStorage for test assertions
-import { secureStorage } from '../../utils/security/secureStorage';
-const mockSecureStorage = secureStorage as any;
-
-// Mock RBAC API (scope is now page-level only, no app-level config needed)
-vi.mock('../../rbac/api', async () => {
-  const actual = await vi.importActual('../../rbac/api');
-  return {
-    ...actual,
-    isSuperAdmin: vi.fn().mockResolvedValue(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 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 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);
-    });
-  });
-
-  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);
-    });
-  });
-});