@jmruthers/pace-core 0.5.75 → 0.5.77

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

@@ -95,7 +95,7 @@ describe('EventService', () => {
     it('should initialize with default state', () => {
       expect(eventService.getEvents()).toEqual([]);
       expect(eventService.getSelectedEvent()).toBeNull();
-      expect(eventService.isLoading()).toBe(true);
+      expect(eventService.isLoading()).toBe(false);
       expect(eventService.getError()).toBeNull();
     });
 

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

@@ -0,0 +1,411 @@
+/**
+ * @file InactivityService Lifecycle Tests
+ * @package @jmruthers/pace-core
+ * @module Services/__tests__
+ * @since 1.0.0
+ *
+ * Additional lifecycle tests for InactivityService covering:
+ * - Activity tracking edge cases
+ * - Cleanup and disposal logic
+ * - Timer management scenarios
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { InactivityService } from '../InactivityService';
+
+// Mock Supabase client
+const createMockSupabaseClient = () => ({
+  auth: {
+    signOut: vi.fn()
+  }
+});
+
+const mockUser = {
+  id: 'user-1',
+  email: 'test@example.com'
+};
+
+const mockSession = {
+  access_token: 'token',
+  refresh_token: 'refresh',
+  expires_at: 1234567890,
+  user: mockUser
+};
+
+vi.mock('../../hooks/useInactivityTracker', () => ({
+  useInactivityTracker: vi.fn(() => ({
+    startTracking: vi.fn(),
+    stopTracking: vi.fn(),
+    isTracking: true
+  }))
+}));
+
+describe('InactivityService Lifecycle Tests', () => {
+  let mockSupabase: ReturnType<typeof createMockSupabaseClient>;
+  let inactivityService: InactivityService;
+  let mockOnIdleLogout: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+    mockSupabase = createMockSupabaseClient();
+    mockOnIdleLogout = vi.fn();
+    
+    inactivityService = new InactivityService(
+      mockSupabase as any,
+      mockUser,
+      mockSession,
+      300000, // 5 minutes
+      60000,  // 1 minute warning
+      mockOnIdleLogout,
+      false
+    );
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    inactivityService.cleanup();
+    vi.clearAllMocks();
+  });
+
+  describe('Timer Management', () => {
+    it('tracks inactivity with correct timeout duration', () => {
+      expect(inactivityService.getTimeRemaining()).toBe(300000);
+    });
+
+    it('updates inactivity timer on user activity', () => {
+      const initialTime = inactivityService.getInactivityTimeRemaining();
+      
+      // Simulate some activity
+      inactivityService['resetInactivityTimer']?.();
+      
+      // Time should be reset (in reality this calls internal reset)
+      expect(typeof inactivityService.getTimeRemaining).toBe('function');
+    });
+
+    it('handles multiple rapid activity events', () => {
+      // Simulate rapid activity
+      for (let i = 0; i < 10; i++) {
+        inactivityService['resetInactivityTimer']?.();
+      }
+      
+      // Should not crash or create memory leaks
+      expect(inactivityService.getTimeRemaining()).toBeDefined();
+    });
+
+    it('clears all timers on cleanup', () => {
+      inactivityService.cleanup();
+      
+      // Should not throw or leak timers
+      expect(() => inactivityService.getTimeRemaining()).not.toThrow();
+      expect(() => inactivityService.cleanup()).not.toThrow();
+    });
+  });
+
+  describe('Warning State Management', () => {
+    it('should not show warning initially', () => {
+      expect(inactivityService.getShowInactivityWarning()).toBe(false);
+    });
+
+    it('tracks warning state separately from idle state', () => {
+      expect(inactivityService.getShowWarning()).toBeDefined();
+      expect(inactivityService.getIsIdle()).toBeDefined();
+      
+      // Initial state should be false
+      expect(inactivityService.getShowWarning()).toBe(false);
+      expect(inactivityService.getIsIdle()).toBe(false);
+    });
+
+    it('handles warning state transitions', () => {
+      const showWarning = inactivityService.getShowWarning();
+      expect(typeof showWarning).toBe('boolean');
+      
+      // State should be gettable
+      expect(inactivityService.getShowWarning()).toBeDefined();
+    });
+  });
+
+  describe('Activity Tracking', () => {
+    it('tracks user activity state', () => {
+      expect(inactivityService.getIsIdle()).toBe(false);
+    });
+
+    it('provides activity time remaining', () => {
+      const timeRemaining = inactivityService.getInactivityTimeRemaining();
+      expect(typeof timeRemaining).toBe('number');
+      expect(timeRemaining).toBeGreaterThanOrEqual(0);
+    });
+
+    it('handles concurrent activity tracking', () => {
+      // Multiple rapid state checks should not fail
+      for (let i = 0; i < 20; i++) {
+        expect(() => inactivityService.getIsIdle()).not.toThrow();
+        expect(() => inactivityService.getInactivityTimeRemaining()).not.toThrow();
+      }
+    });
+  });
+
+  describe('Cleanup and Disposal', () => {
+    it('cleanup can be called multiple times safely', () => {
+      inactivityService.cleanup();
+      inactivityService.cleanup();
+      inactivityService.cleanup();
+      
+      // Should not throw
+      expect(() => inactivityService.getTimeRemaining()).not.toThrow();
+    });
+
+    it('cleanup clears internal state', () => {
+      // Get initial state
+      const initialTimeRemaining = inactivityService.getTimeRemaining();
+      
+      // Cleanup
+      inactivityService.cleanup();
+      
+      // Should still be accessible (properties remain)
+      expect(typeof inactivityService.getTimeRemaining()).toBe('number');
+    });
+
+    it('handles cleanup with no user', () => {
+      const serviceWithoutUser = new InactivityService(
+        mockSupabase as any,
+        null,
+        null,
+        300000,
+        60000,
+        mockOnIdleLogout,
+        false
+      );
+      
+      expect(() => serviceWithoutUser.cleanup()).not.toThrow();
+    });
+
+    it('handles cleanup with no session', () => {
+      const serviceWithoutSession = new InactivityService(
+        mockSupabase as any,
+        mockUser,
+        null,
+        300000,
+        60000,
+        mockOnIdleLogout,
+        false
+      );
+      
+      expect(() => serviceWithoutSession.cleanup()).not.toThrow();
+    });
+  });
+
+  describe('Configuration Handling', () => {
+    it('handles zero timeout gracefully', () => {
+      const zeroTimeoutService = new InactivityService(
+        mockSupabase as any,
+        mockUser,
+        mockSession,
+        0, // Zero timeout
+        0, // Zero warning
+        mockOnIdleLogout,
+        false
+      );
+      
+      expect(zeroTimeoutService.getTimeRemaining()).toBe(0);
+      zeroTimeoutService.cleanup();
+    });
+
+    it('handles negative timeout gracefully', () => {
+      const negativeTimeoutService = new InactivityService(
+        mockSupabase as any,
+        mockUser,
+        mockSession,
+        -1000, // Negative timeout
+        60000,
+        mockOnIdleLogout,
+        false
+      );
+      
+      expect(negativeTimeoutService.getTimeRemaining()).toBeDefined();
+      negativeTimeoutService.cleanup();
+    });
+
+    it('handles very large timeout values', () => {
+      const largeTimeoutService = new InactivityService(
+        mockSupabase as any,
+        mockUser,
+        mockSession,
+        24 * 60 * 60 * 1000, // 24 hours
+        60000,
+        mockOnIdleLogout,
+        false
+      );
+      
+      expect(largeTimeoutService.getTimeRemaining()).toBe(24 * 60 * 60 * 1000);
+      largeTimeoutService.cleanup();
+    });
+  });
+
+  describe('State Query Methods', () => {
+    it('getTimeRemaining returns valid number', () => {
+      const time = inactivityService.getTimeRemaining();
+      expect(typeof time).toBe('number');
+      expect(time).toBeGreaterThanOrEqual(0);
+    });
+
+    it('getShowInactivityWarning returns boolean', () => {
+      const showWarning = inactivityService.getShowInactivityWarning();
+      expect(typeof showWarning).toBe('boolean');
+    });
+
+    it('getInactivityTimeRemaining returns number', () => {
+      const timeRemaining = inactivityService.getInactivityTimeRemaining();
+      expect(typeof timeRemaining).toBe('number');
+    });
+
+    it('getIsIdle returns boolean', () => {
+      const isIdle = inactivityService.getIsIdle();
+      expect(typeof isIdle).toBe('boolean');
+    });
+
+    it('getShowWarning returns boolean', () => {
+      const showWarning = inactivityService.getShowWarning();
+      expect(typeof showWarning).toBe('boolean');
+    });
+
+    it('getIsTracking returns boolean', () => {
+      const isTracking = inactivityService.getIsTracking();
+      expect(typeof isTracking).toBe('boolean');
+    });
+  });
+
+  describe('Multiple Instance Management', () => {
+    it('handles multiple service instances independently', () => {
+      const service1 = new InactivityService(
+        mockSupabase as any,
+        mockUser,
+        mockSession,
+        300000,
+        60000,
+        mockOnIdleLogout,
+        false
+      );
+      
+      const service2 = new InactivityService(
+        mockSupabase as any,
+        mockUser,
+        mockSession,
+        600000,
+        120000,
+        mockOnIdleLogout,
+        false
+      );
+      
+      expect(service1.getTimeRemaining()).toBe(300000);
+      expect(service2.getTimeRemaining()).toBe(600000);
+      
+      service1.cleanup();
+      service2.cleanup();
+    });
+
+    it('cleanup does not affect other instances', () => {
+      const service1 = new InactivityService(
+        mockSupabase as any,
+        mockUser,
+        mockSession,
+        300000,
+        60000,
+        mockOnIdleLogout,
+        false
+      );
+      
+      const service2 = new InactivityService(
+        mockSupabase as any,
+        mockUser,
+        mockSession,
+        600000,
+        120000,
+        mockOnIdleLogout,
+        false
+      );
+      
+      service1.cleanup();
+      
+      // Service2 should still be functional
+      expect(service2.getTimeRemaining()).toBe(600000);
+      
+      service2.cleanup();
+    });
+  });
+
+  describe('Edge Cases', () => {
+    it('handles rapid init/cleanup cycles', () => {
+      for (let i = 0; i < 10; i++) {
+        const service = new InactivityService(
+          mockSupabase as any,
+          mockUser,
+          mockSession,
+          300000,
+          60000,
+          mockOnIdleLogout,
+          false
+        );
+        
+        expect(service.getTimeRemaining()).toBe(300000);
+        service.cleanup();
+      }
+    });
+
+    it('handles missing Supabase client', () => {
+      const service = new InactivityService(
+        null as any,
+        mockUser,
+        mockSession,
+        300000,
+        60000,
+        mockOnIdleLogout,
+        false
+      );
+      
+      expect(() => service.getTimeRemaining()).not.toThrow();
+      expect(() => service.cleanup()).not.toThrow();
+    });
+
+    it('handles disabled inactivity tracking', () => {
+      const disabledService = new InactivityService(
+        mockSupabase as any,
+        mockUser,
+        mockSession,
+        300000,
+        60000,
+        mockOnIdleLogout,
+        true // dangerouslyDisableInactivity
+      );
+      
+      expect(disabledService.getIsTracking()).toBe(false);
+      disabledService.cleanup();
+    });
+  });
+
+  describe('State Persistence', () => {
+    it('maintains state across method calls', () => {
+      const initialTime = inactivityService.getTimeRemaining();
+      const initialShowWarning = inactivityService.getShowWarning();
+      
+      // Multiple calls should return consistent values
+      expect(inactivityService.getTimeRemaining()).toBe(initialTime);
+      expect(inactivityService.getShowWarning()).toBe(initialShowWarning);
+    });
+
+    it('provides consistent state reading', () => {
+      const states = [];
+      
+      for (let i = 0; i < 10; i++) {
+        states.push({
+          timeRemaining: inactivityService.getTimeRemaining(),
+          showWarning: inactivityService.getShowWarning(),
+          isIdle: inactivityService.getIsIdle()
+        });
+      }
+      
+      // All calls should return same state (or reasonable transitions)
+      expect(states.length).toBe(10);
+    });
+  });
+});
+