@jmruthers/pace-core 0.6.9 → 0.6.11

package/src/services/InactivityService.test.ts

@@ -0,0 +1,829 @@
+/**
+ * @file InactivityService Unit Tests
+ * @package @jmruthers/pace-core
+ * @module Services
+ * @since 0.1.0
+ *
+ * Unit tests for InactivityService class.
+ * Tests inactivity tracking, warnings, and logout operations.
+ */
+
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { InactivityService } from './InactivityService';
+
+// 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 Supabase client
+const createMockSupabaseClient = () => ({
+  auth: {
+    signOut: vi.fn()
+  }
+});
+
+// Mock user and session
+const mockUser = {
+  id: 'user-1',
+  email: 'test@example.com'
+};
+
+const mockSession = {
+  access_token: 'token',
+  user: mockUser
+};
+
+// Mock the useInactivityTracker hook
+vi.mock('../../hooks/useInactivityTracker', () => ({
+  useInactivityTracker: vi.fn(() => ({
+    isIdle: false,
+    timeRemaining: 0,
+    showWarning: false,
+    resetActivity: vi.fn(),
+    startTracking: vi.fn(),
+    stopTracking: vi.fn(),
+    isTracking: false
+  }))
+}));
+
+describe('InactivityService', () => {
+  let mockSupabase: ReturnType<typeof createMockSupabaseClient>;
+  let inactivityService: InactivityService;
+  let mockOnIdleLogout: ReturnType<typeof vi.fn>;
+
+  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'),
+    };
+    
+    mockSupabase = createMockSupabaseClient();
+    mockOnIdleLogout = vi.fn();
+    
+    inactivityService = new InactivityService(
+      mockSupabase as any,
+      mockUser,
+      mockSession,
+      300000, // 5 minutes
+      60000,  // 1 minute warning
+      mockOnIdleLogout,
+      false
+    );
+  });
+
+  afterEach(() => {
+    inactivityService.cleanup();
+    // Restore spies
+    mockLoggerFunctions.debug.mockRestore();
+    mockLoggerFunctions.error.mockRestore();
+    mockLoggerFunctions.warn.mockRestore();
+    mockLoggerFunctions.info.mockRestore();
+    vi.clearAllMocks();
+  });
+
+  describe('Initialization', () => {
+    it('should initialize with default state', () => {
+      expect(inactivityService.getShowInactivityWarning()).toBe(false);
+      expect(inactivityService.getInactivityTimeRemaining()).toBe(0);
+      expect(inactivityService.getIsIdle()).toBe(false);
+      expect(inactivityService.getTimeRemaining()).toBe(300000);
+      expect(inactivityService.getShowWarning()).toBe(false);
+      expect(inactivityService.getIsTracking()).toBe(false);
+    });
+
+    it('should setup inactivity tracker on initialization', () => {
+      // The service should be tracking if user and session are available
+      expect(inactivityService.getIsTracking()).toBe(false); // Initially false until setup completes
+    });
+
+    it('should handle missing user gracefully', () => {
+      const serviceWithoutUser = new InactivityService(
+        mockSupabase as any,
+        null,
+        null,
+        300000,
+        60000,
+        mockOnIdleLogout,
+        false
+      );
+
+      expect(serviceWithoutUser.getIsTracking()).toBe(false);
+    });
+
+    it('should handle missing session gracefully', () => {
+      const serviceWithoutSession = new InactivityService(
+        mockSupabase as any,
+        mockUser,
+        null,
+        300000,
+        60000,
+        mockOnIdleLogout,
+        false
+      );
+
+      expect(serviceWithoutSession.getIsTracking()).toBe(false);
+    });
+  });
+
+  describe('Activity Management', () => {
+    it('should reset activity', () => {
+      // Set some state first
+      inactivityService.setShowInactivityWarning(true);
+      inactivityService.setInactivityTimeRemaining(30);
+      inactivityService.setIsIdle(true);
+      inactivityService.setTimeRemaining(10000);
+      inactivityService.setShowWarning(true);
+
+      inactivityService.resetActivity();
+
+      expect(inactivityService.getShowInactivityWarning()).toBe(false);
+      expect(inactivityService.getInactivityTimeRemaining()).toBe(0);
+      expect(inactivityService.getIsIdle()).toBe(false);
+      expect(inactivityService.getTimeRemaining()).toBe(300000);
+      expect(inactivityService.getShowWarning()).toBe(false);
+    });
+
+    it('should not notify when resetActivity does not change state', () => {
+      const subscriber = vi.fn();
+      inactivityService.subscribe(subscriber);
+      
+      // Reset when already in default state
+      inactivityService.resetActivity();
+      
+      // Should not notify if state didn't change
+      const callCount = subscriber.mock.calls.length;
+      
+      // Reset again - should not notify
+      inactivityService.resetActivity();
+      
+      // Call count should remain the same (or only increase if state actually changed)
+      expect(subscriber.mock.calls.length).toBeGreaterThanOrEqual(callCount);
+      
+      inactivityService.cleanup();
+    });
+
+    it('should reset activity when inactivityTracker exists', async () => {
+      await inactivityService.initialize();
+      inactivityService.startTracking();
+      
+      // Set some state
+      inactivityService.setShowInactivityWarning(true);
+      inactivityService.setIsIdle(true);
+      
+      inactivityService.resetActivity();
+      
+      expect(inactivityService.getShowInactivityWarning()).toBe(false);
+      expect(inactivityService.getIsIdle()).toBe(false);
+    });
+
+    it('should start tracking', () => {
+      inactivityService.startTracking();
+
+      expect(inactivityService.getIsTracking()).toBe(true);
+      expect(inactivityService.getShowInactivityWarning()).toBe(false);
+      expect(inactivityService.getInactivityTimeRemaining()).toBe(0);
+    });
+
+    it('should stop tracking', () => {
+      inactivityService.startTracking();
+      expect(inactivityService.getIsTracking()).toBe(true);
+
+      inactivityService.stopTracking();
+
+      expect(inactivityService.getIsTracking()).toBe(false);
+    });
+  });
+
+  describe('Idle Logout', () => {
+    it('should handle idle logout successfully', async () => {
+      mockSupabase.auth.signOut.mockResolvedValue({ error: null });
+
+      await inactivityService.handleIdleLogout();
+
+      expect(inactivityService.getShowInactivityWarning()).toBe(false);
+      expect(inactivityService.getInactivityTimeRemaining()).toBe(0);
+      expect(inactivityService.getIsTracking()).toBe(false);
+      expect(mockSupabase.auth.signOut).toHaveBeenCalled();
+      expect(mockOnIdleLogout).toHaveBeenCalledWith('inactivity');
+    });
+
+    it('should handle idle logout with error', async () => {
+      const error = new Error('Sign out failed');
+      mockSupabase.auth.signOut.mockRejectedValue(error);
+
+      await inactivityService.handleIdleLogout();
+
+      expect(inactivityService.getShowInactivityWarning()).toBe(false);
+      expect(inactivityService.getInactivityTimeRemaining()).toBe(0);
+      expect(inactivityService.getIsTracking()).toBe(false);
+      expect(mockSupabase.auth.signOut).toHaveBeenCalled();
+      expect(mockOnIdleLogout).toHaveBeenCalledWith('inactivity');
+    });
+
+    it('should handle sessionStorage clearing on idle logout', async () => {
+      // Verify that handleIdleLogout completes successfully
+      // The sessionStorage.clear() call is wrapped in try-catch, so it won't throw
+      mockSupabase.auth.signOut.mockResolvedValue({ error: null });
+
+      await expect(inactivityService.handleIdleLogout()).resolves.toBeUndefined();
+      expect(mockOnIdleLogout).toHaveBeenCalledWith('inactivity');
+    });
+
+    it('should handle sessionStorage clearing error gracefully', async () => {
+      // Mock sessionStorage to throw error
+      const originalClear = sessionStorage.clear;
+      sessionStorage.clear = vi.fn(() => {
+        throw new Error('Storage error');
+      });
+      
+      mockSupabase.auth.signOut.mockResolvedValue({ error: null });
+
+      // Should not throw error even if sessionStorage.clear fails
+      await expect(inactivityService.handleIdleLogout()).resolves.toBeUndefined();
+      expect(mockOnIdleLogout).toHaveBeenCalledWith('inactivity');
+      
+      // Restore original
+      sessionStorage.clear = originalClear;
+    });
+
+    it('should handle manual sign out', async () => {
+      mockSupabase.auth.signOut.mockResolvedValue({ error: null });
+
+      await inactivityService.handleSignOutNow();
+
+      expect(inactivityService.getShowInactivityWarning()).toBe(false);
+      expect(inactivityService.getInactivityTimeRemaining()).toBe(0);
+      expect(inactivityService.getIsTracking()).toBe(false);
+      expect(mockSupabase.auth.signOut).toHaveBeenCalled();
+      expect(mockOnIdleLogout).toHaveBeenCalledWith('inactivity');
+    });
+
+    it('should handle manual sign out with error', async () => {
+      const error = new Error('Sign out failed');
+      mockSupabase.auth.signOut.mockRejectedValue(error);
+
+      await inactivityService.handleSignOutNow();
+
+      expect(inactivityService.getShowInactivityWarning()).toBe(false);
+      expect(inactivityService.getInactivityTimeRemaining()).toBe(0);
+      expect(inactivityService.getIsTracking()).toBe(false);
+      expect(mockSupabase.auth.signOut).toHaveBeenCalled();
+      expect(mockOnIdleLogout).toHaveBeenCalledWith('inactivity');
+    });
+
+    it('should handle sessionStorage clearing on manual sign out', async () => {
+      // Verify that handleSignOutNow completes successfully
+      mockSupabase.auth.signOut.mockResolvedValue({ error: null });
+
+      await expect(inactivityService.handleSignOutNow()).resolves.toBeUndefined();
+      expect(mockOnIdleLogout).toHaveBeenCalledWith('inactivity');
+    });
+
+    it('should handle sessionStorage clearing error on manual sign out gracefully', async () => {
+      // Mock sessionStorage to throw error
+      const originalClear = sessionStorage.clear;
+      sessionStorage.clear = vi.fn(() => {
+        throw new Error('Storage error');
+      });
+      
+      mockSupabase.auth.signOut.mockResolvedValue({ error: null });
+
+      // Should not throw error even if sessionStorage.clear fails
+      await expect(inactivityService.handleSignOutNow()).resolves.toBeUndefined();
+      expect(mockOnIdleLogout).toHaveBeenCalledWith('inactivity');
+      
+      // Restore original
+      sessionStorage.clear = originalClear;
+    });
+  });
+
+  describe('Stay Signed In', () => {
+    it('should handle stay signed in', () => {
+      // Set some warning state
+      inactivityService.setShowInactivityWarning(true);
+      inactivityService.setInactivityTimeRemaining(30);
+
+      inactivityService.handleStaySignedIn();
+
+      expect(inactivityService.getShowInactivityWarning()).toBe(false);
+      expect(inactivityService.getInactivityTimeRemaining()).toBe(0);
+      expect(inactivityService.getIsIdle()).toBe(false);
+      expect(inactivityService.getTimeRemaining()).toBe(300000);
+      expect(inactivityService.getShowWarning()).toBe(false);
+    });
+  });
+
+  describe('Warning Management', () => {
+    it('should trigger warning', () => {
+      inactivityService.triggerWarning(120000); // 2 minutes remaining
+
+      expect(inactivityService.getShowInactivityWarning()).toBe(true);
+      expect(inactivityService.getInactivityTimeRemaining()).toBe(120); // Converted to seconds
+      expect(inactivityService.getShowWarning()).toBe(true);
+    });
+
+    it('should trigger idle', async () => {
+      mockSupabase.auth.signOut.mockResolvedValue({ error: null });
+
+      inactivityService.triggerIdle();
+
+      expect(inactivityService.getIsIdle()).toBe(true);
+      expect(mockSupabase.auth.signOut).toHaveBeenCalled();
+      
+      // Wait for the async handleIdleLogout to complete
+      await new Promise(resolve => setTimeout(resolve, 0));
+      expect(mockOnIdleLogout).toHaveBeenCalledWith('inactivity');
+    });
+  });
+
+  describe('State Management', () => {
+    it('should notify subscribers when state changes', () => {
+      const subscriber = vi.fn();
+      const unsubscribe = inactivityService.subscribe(subscriber);
+
+      inactivityService.setShowInactivityWarning(true);
+
+      expect(subscriber).toHaveBeenCalled();
+
+      unsubscribe();
+    });
+
+    it('should cleanup subscriptions on cleanup', () => {
+      const subscriber = vi.fn();
+      inactivityService.subscribe(subscriber);
+
+      inactivityService.cleanup();
+
+      // After cleanup, new state changes shouldn't notify subscribers
+      inactivityService.setShowInactivityWarning(true);
+
+      expect(subscriber).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('Configuration', () => {
+    it('should respect dangerouslyDisableInactivity flag', () => {
+      const disabledService = new InactivityService(
+        mockSupabase as any,
+        mockUser,
+        mockSession,
+        300000,
+        60000,
+        mockOnIdleLogout,
+        true // dangerouslyDisableInactivity = true
+      );
+
+      expect(disabledService.getIsTracking()).toBe(false);
+    });
+
+    it('should handle different timeout configurations', () => {
+      const customService = new InactivityService(
+        mockSupabase as any,
+        mockUser,
+        mockSession,
+        600000, // 10 minutes
+        120000, // 2 minutes warning
+        mockOnIdleLogout,
+        false
+      );
+
+      expect(customService.getTimeRemaining()).toBe(600000);
+    });
+
+    it('should handle missing onIdleLogout callback', () => {
+      const serviceWithoutCallback = new InactivityService(
+        mockSupabase as any,
+        mockUser,
+        mockSession,
+        300000,
+        60000,
+        undefined, // No callback
+        false
+      );
+
+      // Should not throw error
+      expect(serviceWithoutCallback.getIsTracking()).toBe(false);
+    });
+  });
+
+  describe('Environment Handling', () => {
+    it('should handle production environment', () => {
+      // Mock production environment
+      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,
+        false
+      );
+
+      expect(service.getIsTracking()).toBe(false); // Initially false until setup completes
+
+      // Restore original mode
+      (import.meta.env as any).MODE = originalMode;
+    });
+
+    it('should handle development environment', () => {
+      // Mock development environment
+      const originalMode = import.meta.env.MODE;
+      (import.meta.env as any).MODE = 'development';
+
+      const service = new InactivityService(
+        mockSupabase as any,
+        mockUser,
+        mockSession,
+        300000,
+        60000,
+        mockOnIdleLogout,
+        false
+      );
+
+      expect(service.getIsTracking()).toBe(false); // Initially false until setup completes
+
+      // Restore original mode
+      (import.meta.env as any).MODE = originalMode;
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should handle sign out errors gracefully', async () => {
+      const error = new Error('Network error');
+      mockSupabase.auth.signOut.mockRejectedValue(error);
+
+      // Should not throw error
+      await expect(inactivityService.handleIdleLogout()).resolves.toBeUndefined();
+      await expect(inactivityService.handleSignOutNow()).resolves.toBeUndefined();
+    });
+
+    it('should handle missing Supabase client', async () => {
+      const serviceWithoutSupabase = new InactivityService(
+        null as any,
+        mockUser,
+        mockSession,
+        300000,
+        60000,
+        mockOnIdleLogout,
+        false
+      );
+
+      // Should not throw error
+      await expect(serviceWithoutSupabase.handleIdleLogout()).resolves.toBeUndefined();
+      await expect(serviceWithoutSupabase.handleSignOutNow()).resolves.toBeUndefined();
+    });
+  });
+
+  describe('Timer Management', () => {
+    it('should handle timer cleanup on service cleanup', () => {
+      inactivityService.startTracking();
+      expect(inactivityService.getIsTracking()).toBe(true);
+
+      inactivityService.cleanup();
+
+      // After cleanup, tracking should be stopped
+      expect(inactivityService.getIsTracking()).toBe(false);
+    });
+
+    it('should handle multiple cleanup calls', () => {
+      inactivityService.startTracking();
+      expect(inactivityService.getIsTracking()).toBe(true);
+
+      inactivityService.cleanup();
+      inactivityService.cleanup(); // Second cleanup call
+
+      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();
+    });
+
+    it('should update idleTimeoutMs when provided', () => {
+      const newSupabase = createMockSupabaseClient();
+      
+      inactivityService.updateDependencies(
+        newSupabase as any,
+        mockUser,
+        mockSession,
+        600000 // 10 minutes
+      );
+
+      // Time remaining should reflect new timeout
+      inactivityService.resetActivity();
+      expect(inactivityService.getTimeRemaining()).toBe(600000);
+    });
+
+    it('should update warnBeforeMs when provided', () => {
+      const newSupabase = createMockSupabaseClient();
+      
+      inactivityService.updateDependencies(
+        newSupabase as any,
+        mockUser,
+        mockSession,
+        undefined,
+        120000 // 2 minutes warning
+      );
+
+      // Should not throw error
+      expect(inactivityService.getIsTracking()).toBeDefined();
+    });
+
+    it('should update onIdleLogout callback when provided', () => {
+      const newSupabase = createMockSupabaseClient();
+      const newOnIdleLogout = vi.fn();
+      
+      inactivityService.updateDependencies(
+        newSupabase as any,
+        mockUser,
+        mockSession,
+        undefined,
+        undefined,
+        newOnIdleLogout
+      );
+
+      // 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-expect-error - deleting global.window for test environment
+      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 () => {
+      vi.clearAllMocks();
+      const originalMode = import.meta.env.MODE;
+      const originalWindow = global.window;
+      
+      // Ensure window is defined for the test
+      if (typeof global.window === 'undefined') {
+        (global as any).window = {};
+      }
+      
+      (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(mockLoggerFunctions.warn).toHaveBeenCalledWith(
+        'InactivityService',
+        'Inactivity feature enabled in production'
+      );
+
+      (import.meta.env as any).MODE = originalMode;
+      if (originalWindow === undefined) {
+        delete (global as any).window;
+      }
+      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();
+    });
+
+    it('should handle multiple activity events with throttling', async () => {
+      vi.useFakeTimers();
+      await inactivityService.initialize();
+
+      // Simulate rapid activity events
+      const events = ['mousedown', 'mousemove', 'keypress', 'scroll', 'touchstart', 'click'];
+      events.forEach(eventType => {
+        const event = new Event(eventType, { bubbles: true });
+        document.dispatchEvent(event);
+      });
+
+      // Advance timers to allow throttling to complete
+      vi.advanceTimersByTime(1100);
+
+      // Should handle all events without crashing
+      expect(inactivityService.getIsTracking()).toBeDefined();
+
+      vi.useRealTimers();
+    });
+
+    it('should throttle activity detection to once per second', async () => {
+      vi.useFakeTimers();
+      await inactivityService.initialize();
+
+      const initialTime = inactivityService.getTimeRemaining();
+
+      // Fire multiple events rapidly
+      for (let i = 0; i < 10; i++) {
+        const event = new MouseEvent('mousedown', { bubbles: true });
+        document.dispatchEvent(event);
+      }
+
+      // Advance time by less than 1 second - should not reset yet
+      vi.advanceTimersByTime(500);
+      expect(inactivityService.getTimeRemaining()).toBe(initialTime);
+
+      // Advance past 1 second - should reset
+      vi.advanceTimersByTime(600);
+      // Time should be reset (or at least different)
+      expect(inactivityService.getTimeRemaining()).toBeDefined();
+
+      vi.useRealTimers();
+    });
+  });
+
+  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);
+    });
+  });
+});