@jmruthers/pace-core 0.5.118 → 0.5.120

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

@@ -522,4 +522,394 @@ describe('EventService', () => {
       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: [mockEvent],
+        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: [mockEvent],
+        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: [mockEvent],
+        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: [mockEvent, mockEvent2],
+        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 null when all events are in the past', () => {
+      const pastEvent: Event = {
+        ...mockEvent,
+        event_date: '2020-01-01T00:00:00Z'
+      };
+
+      const nextEvent = eventService.getNextEventByDate([pastEvent]);
+
+      expect(nextEvent).toBeNull();
+    });
+
+    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: '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: '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 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: [mockEvent, mockEvent2],
+        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: [mockEvent, mockEvent2],
+        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: [mockEvent],
+        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 Validation', () => {
+    it('should handle validation error gracefully', () => {
+      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+      const eventFromDifferentOrg: Event = {
+        ...mockEvent,
+        organisation_id: 'org-2'
+      };
+
+      // Should not throw error
+      eventService.setSelectedEvent(eventFromDifferentOrg);
+
+      expect(consoleErrorSpy).toHaveBeenCalled();
+      consoleErrorSpy.mockRestore();
+    });
+
+    it('should handle missing organisation during validation', () => {
+      const serviceWithoutOrg = new EventService(
+        mockSupabase as any,
+        mockUser,
+        mockSession,
+        'test-app',
+        null,
+        mockSetSelectedEventId
+      );
+
+      // Should not throw error
+      serviceWithoutOrg.setSelectedEvent(mockEvent);
+
+      // When organisation is null, validation is skipped (only validates when organisation exists)
+      // So the event can still be selected
+      expect(serviceWithoutOrg.getSelectedEvent()).toEqual(mockEvent);
+    });
+  });
 });

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

@@ -400,4 +400,221 @@ describe('InactivityService', () => {
       expect(inactivityService.getIsTracking()).toBe(false);
     });
   });
+
+  describe('Dependency Updates', () => {
+    it('should update dependencies', () => {
+      const newUser = { id: 'user-2', email: 'new@example.com' };
+      const newSession = { access_token: 'new-token', user: newUser };
+      const newSupabase = createMockSupabaseClient();
+      const newOnIdleLogout = vi.fn();
+
+      inactivityService.updateDependencies(
+        newSupabase as any,
+        newUser,
+        newSession,
+        600000, // 10 minutes
+        120000, // 2 minutes warning
+        newOnIdleLogout
+      );
+
+      // Verify state was updated by checking if notifications occurred
+      const subscriber = vi.fn();
+      inactivityService.subscribe(subscriber);
+
+      inactivityService.setShowInactivityWarning(true);
+      expect(subscriber).toHaveBeenCalled();
+
+      inactivityService.cleanup();
+    });
+
+    it('should update dependencies with partial parameters', () => {
+      const newUser = { id: 'user-2', email: 'new@example.com' };
+      const newSession = { access_token: 'new-token', user: newUser };
+      const newSupabase = createMockSupabaseClient();
+
+      inactivityService.updateDependencies(
+        newSupabase as any,
+        newUser,
+        newSession
+        // Omit optional parameters
+      );
+
+      // Should not throw error
+      expect(inactivityService.getIsTracking()).toBeDefined();
+    });
+  });
+
+  describe('Initialization and Setup', () => {
+    it('should setup inactivity tracker on initialization when user and session available', async () => {
+      await inactivityService.initialize();
+
+      // After initialization, tracker should be set up if user and session are available
+      // The actual tracking state depends on setupEventHandlers being called
+      expect(inactivityService.getIsTracking()).toBeDefined();
+    });
+
+    it('should handle setupInactivityTracker failure gracefully', async () => {
+      // Mock the import to fail
+      vi.doMock('../../hooks/useInactivityTracker', () => {
+        throw new Error('Import failed');
+      });
+
+      const service = new InactivityService(
+        mockSupabase as any,
+        mockUser,
+        mockSession,
+        300000,
+        60000,
+        mockOnIdleLogout
+      );
+
+      // Should not throw error
+      await expect(service.initialize()).resolves.toBeUndefined();
+
+      service.cleanup();
+    });
+
+    it('should handle window undefined environment', async () => {
+      const originalWindow = global.window;
+      // @ts-ignore - for testing
+      delete global.window;
+
+      const service = new InactivityService(
+        mockSupabase as any,
+        mockUser,
+        mockSession,
+        300000,
+        60000,
+        mockOnIdleLogout
+      );
+
+      await service.initialize();
+
+      // Should handle gracefully without window
+      expect(service.getIsTracking()).toBeDefined();
+
+      global.window = originalWindow;
+      service.cleanup();
+    });
+
+    it('should log production warning when enabled', async () => {
+      const consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      const originalMode = import.meta.env.MODE;
+      (import.meta.env as any).MODE = 'production';
+
+      const service = new InactivityService(
+        mockSupabase as any,
+        mockUser,
+        mockSession,
+        300000,
+        60000,
+        mockOnIdleLogout
+      );
+
+      await service.initialize();
+
+      // Should log warning in production
+      expect(consoleWarnSpy).toHaveBeenCalledWith(
+        expect.stringContaining('[InactivityService] Inactivity feature enabled in production')
+      );
+
+      (import.meta.env as any).MODE = originalMode;
+      consoleWarnSpy.mockRestore();
+      service.cleanup();
+    });
+  });
+
+  describe('Event Handlers', () => {
+    it('should handle activity events and reset timers', async () => {
+      await inactivityService.initialize();
+
+      // Simulate activity event
+      const mousedownEvent = new MouseEvent('mousedown', { bubbles: true });
+      document.dispatchEvent(mousedownEvent);
+
+      // Activity should reset timers
+      // Note: In test environment, timers may not work exactly as in production
+      // but we can verify the event handlers are set up
+      expect(inactivityService.getIsTracking()).toBeDefined();
+    });
+
+    it('should cleanup event listeners on cleanup', async () => {
+      await inactivityService.initialize();
+
+      // Wait a bit to ensure event handlers are set up
+      await new Promise(resolve => setTimeout(resolve, 10));
+
+      const removeEventListenerSpy = vi.spyOn(document, 'removeEventListener');
+
+      inactivityService.cleanup();
+
+      // Should remove event listeners if they were added
+      // Note: In some test environments, event listeners may not be added if window is not properly set up
+      // The important thing is that cleanup doesn't throw an error
+      expect(() => inactivityService.cleanup()).not.toThrow();
+      removeEventListenerSpy.mockRestore();
+    });
+  });
+
+  describe('Edge Cases', () => {
+    it('should handle idle logout when onIdleLogout is null', async () => {
+      const serviceWithoutCallback = new InactivityService(
+        mockSupabase as any,
+        mockUser,
+        mockSession,
+        300000,
+        60000,
+        null as any
+      );
+
+      mockSupabase.auth.signOut.mockResolvedValue({ error: null });
+
+      // Should not throw error
+      await expect(serviceWithoutCallback.handleIdleLogout()).resolves.toBeUndefined();
+
+      serviceWithoutCallback.cleanup();
+    });
+
+    it('should handle idle logout when Supabase client is null', async () => {
+      const serviceWithoutSupabase = new InactivityService(
+        null as any,
+        mockUser,
+        mockSession,
+        300000,
+        60000,
+        mockOnIdleLogout
+      );
+
+      // Should not throw error
+      await expect(serviceWithoutSupabase.handleIdleLogout()).resolves.toBeUndefined();
+
+      serviceWithoutSupabase.cleanup();
+    });
+
+    it('should handle resetActivity when inactivityTracker exists', () => {
+      inactivityService.setIsTracking(true);
+      
+      // Reset should clear all state
+      inactivityService.resetActivity();
+
+      expect(inactivityService.getShowInactivityWarning()).toBe(false);
+      expect(inactivityService.getIsIdle()).toBe(false);
+      expect(inactivityService.getShowWarning()).toBe(false);
+    });
+
+    it('should handle startTracking when inactivityTracker exists', () => {
+      inactivityService.startTracking();
+
+      expect(inactivityService.getIsTracking()).toBe(true);
+    });
+
+    it('should handle stopTracking when inactivityTracker exists', () => {
+      inactivityService.startTracking();
+      expect(inactivityService.getIsTracking()).toBe(true);
+
+      inactivityService.stopTracking();
+
+      expect(inactivityService.getIsTracking()).toBe(false);
+    });
+  });
 });