@jmruthers/pace-core 0.5.67 → 0.5.69

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

@@ -0,0 +1,403 @@
+/**
+ * @file InactivityService Unit Tests
+ * @package @jmruthers/pace-core
+ * @module Services/__tests__
+ * @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';
+
+// 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(() => {
+    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();
+    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 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 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');
+    });
+  });
+
+  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);
+    });
+  });
+});