@jmruthers/pace-core 0.2.4

package/src/hooks/__tests__/useInactivityTracker.unit.test.ts

@@ -0,0 +1,385 @@
+/**
+ * @file useInactivityTracker Tests
+ * @package @jmruthers/pace-core
+ * @module Hooks/useInactivityTracker
+ * @since 0.1.0
+ */
+
+import { renderHook, act, waitFor } from '@testing-library/react';
+import { vi } from 'vitest';
+import { useInactivityTracker } from '../useInactivityTracker';
+
+// Mock timers will be set up in each test
+
+// Mock localStorage
+const localStorageMock = {
+  getItem: vi.fn(),
+  setItem: vi.fn(),
+  removeItem: vi.fn(),
+  clear: vi.fn(),
+};
+Object.defineProperty(window, 'localStorage', {
+  value: localStorageMock,
+});
+
+// Mock BroadcastChannel
+const mockBroadcastChannel = {
+  postMessage: vi.fn(),
+  close: vi.fn(),
+  onmessage: null as any,
+};
+Object.defineProperty(window, 'BroadcastChannel', {
+  value: vi.fn(() => mockBroadcastChannel),
+});
+
+// Mock document event listeners
+const mockAddEventListener = vi.fn();
+const mockRemoveEventListener = vi.fn();
+Object.defineProperty(document, 'addEventListener', {
+  value: mockAddEventListener,
+});
+Object.defineProperty(document, 'removeEventListener', {
+  value: mockRemoveEventListener,
+});
+
+describe('useInactivityTracker', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.clearAllTimers();
+    vi.useFakeTimers();
+    localStorageMock.getItem.mockReturnValue(null);
+    localStorageMock.setItem.mockImplementation(() => {});
+    localStorageMock.removeItem.mockImplementation(() => {});
+    localStorageMock.clear.mockImplementation(() => {});
+    mockAddEventListener.mockImplementation(() => {});
+    mockRemoveEventListener.mockImplementation(() => {});
+    mockBroadcastChannel.postMessage.mockImplementation(() => {});
+    mockBroadcastChannel.close.mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    vi.runOnlyPendingTimers();
+    vi.useRealTimers();
+  });
+
+  it('initializes with default values', () => {
+    const { result } = renderHook(() => useInactivityTracker({ enabled: false }));
+    
+    expect(result.current.isIdle).toBe(false);
+    expect(result.current.timeRemaining).toBe(30 * 60 * 1000); // 30 minutes
+    expect(result.current.showWarning).toBe(false);
+    expect(result.current.isTracking).toBe(false);
+  });
+
+  it('starts tracking when enabled', () => {
+    const { result } = renderHook(() => 
+      useInactivityTracker({ enabled: true })
+    );
+    
+    act(() => {
+      result.current.startTracking();
+    });
+    
+    expect(result.current.isTracking).toBe(true);
+    expect(mockAddEventListener).toHaveBeenCalled();
+  });
+
+  it('stops tracking when disabled', () => {
+    const { result } = renderHook(() => 
+      useInactivityTracker({ enabled: false })
+    );
+    
+    act(() => {
+      result.current.startTracking();
+    });
+    
+    expect(result.current.isTracking).toBe(false);
+  });
+
+  it('calls onIdle after timeout', () => {
+    const onIdle = vi.fn();
+    const { result } = renderHook(() => 
+      useInactivityTracker({ 
+        enabled: true,
+        idleTimeoutMs: 1000,
+        onIdle 
+      })
+    );
+    
+    act(() => {
+      result.current.startTracking();
+    });
+    
+    // Fast-forward time to trigger idle
+    act(() => {
+      vi.advanceTimersByTime(1000);
+    });
+    
+    expect(onIdle).toHaveBeenCalled();
+    expect(result.current.isIdle).toBe(true);
+  });
+
+  it('calls onWarning before idle timeout', () => {
+    const onWarning = vi.fn();
+    const { result } = renderHook(() => 
+      useInactivityTracker({ 
+        enabled: true,
+        idleTimeoutMs: 2000,
+        warnBeforeMs: 1000,
+        onWarning 
+      })
+    );
+    
+    act(() => {
+      result.current.startTracking();
+    });
+    
+    // Fast-forward to warning time
+    act(() => {
+      vi.advanceTimersByTime(1000);
+    });
+    
+    expect(onWarning).toHaveBeenCalled();
+    expect(result.current.showWarning).toBe(true);
+  });
+
+  it('calls onActivity when user becomes active', () => {
+    const onActivity = vi.fn();
+    const { result } = renderHook(() => 
+      useInactivityTracker({ 
+        enabled: true,
+        onActivity 
+      })
+    );
+    
+    act(() => {
+      result.current.startTracking();
+    });
+    
+    act(() => {
+      result.current.resetActivity();
+    });
+    
+    expect(onActivity).toHaveBeenCalled();
+  });
+
+  it('resets activity timer when resetActivity is called', () => {
+    const { result } = renderHook(() => 
+      useInactivityTracker({ 
+        enabled: true,
+        idleTimeoutMs: 2000,
+        warnBeforeMs: 1000
+      })
+    );
+    
+    act(() => {
+      result.current.startTracking();
+    });
+    
+    // Advance time partially
+    act(() => {
+      vi.advanceTimersByTime(500);
+    });
+    
+    // Reset activity
+    act(() => {
+      result.current.resetActivity();
+    });
+    
+    expect(result.current.timeRemaining).toBe(2000);
+    expect(result.current.showWarning).toBe(false);
+  });
+
+  it('updates time remaining during countdown', () => {
+    const { result } = renderHook(() => 
+      useInactivityTracker({ 
+        enabled: true,
+        idleTimeoutMs: 2000
+      })
+    );
+    
+    act(() => {
+      result.current.startTracking();
+    });
+    
+    // Advance time by 1000ms to trigger countdown interval
+    act(() => {
+      vi.advanceTimersByTime(1000);
+    });
+    
+    expect(result.current.timeRemaining).toBe(1000);
+  });
+
+  it('persists activity time to localStorage', () => {
+    const { result } = renderHook(() => 
+      useInactivityTracker({ 
+        enabled: true,
+        storageKey: 'test-inactivity'
+      })
+    );
+    
+    act(() => {
+      result.current.startTracking();
+    });
+    
+    expect(localStorageMock.setItem).toHaveBeenCalledWith(
+      'test-inactivity',
+      expect.any(String)
+    );
+  });
+
+  it('loads persisted activity time from localStorage', () => {
+    const pastTime = Date.now() - 1000; // 1 second ago
+    localStorageMock.getItem.mockReturnValue(pastTime.toString());
+    
+    const { result } = renderHook(() => 
+      useInactivityTracker({ 
+        enabled: true,
+        idleTimeoutMs: 2000,
+        storageKey: 'test-inactivity'
+      })
+    );
+    
+    act(() => {
+      result.current.startTracking();
+    });
+    
+    // Advance time to trigger countdown interval
+    act(() => {
+      vi.advanceTimersByTime(1000);
+    });
+    
+    expect(result.current.timeRemaining).toBe(1000); // Should be 1 second remaining
+  });
+
+  it('handles invalid persisted time gracefully', () => {
+    localStorageMock.getItem.mockReturnValue('invalid');
+    
+    const { result } = renderHook(() => 
+      useInactivityTracker({ 
+        enabled: true,
+        idleTimeoutMs: 2000
+      })
+    );
+    
+    act(() => {
+      result.current.startTracking();
+    });
+    
+    expect(result.current.timeRemaining).toBe(2000); // Should use full timeout
+  });
+
+  it('broadcasts activity to other tabs', () => {
+    const { result } = renderHook(() => 
+      useInactivityTracker({ 
+        enabled: true,
+        channelName: 'test-channel'
+      })
+    );
+    
+    act(() => {
+      result.current.startTracking();
+    });
+    
+    expect(mockBroadcastChannel.postMessage).toHaveBeenCalledWith({
+      type: 'activity',
+      timestamp: expect.any(Number)
+    });
+  });
+
+  it('handles broadcast channel messages from other tabs', () => {
+    const { result } = renderHook(() => 
+      useInactivityTracker({ 
+        enabled: true,
+        channelName: 'test-channel'
+      })
+    );
+    
+    act(() => {
+      result.current.startTracking();
+    });
+    
+    // Simulate message from another tab
+    const otherTabTime = Date.now() - 500;
+    act(() => {
+      if (mockBroadcastChannel.onmessage) {
+        mockBroadcastChannel.onmessage({
+          data: { type: 'activity', timestamp: otherTabTime }
+        });
+      }
+    });
+    
+    // Advance time to trigger countdown interval
+    act(() => {
+      vi.advanceTimersByTime(1000);
+    });
+    
+    expect(result.current.timeRemaining).toBe(30 * 60 * 1000 - 1000);
+  });
+
+  it('cleans up timers and listeners on unmount', () => {
+    const { result, unmount } = renderHook(() => 
+      useInactivityTracker({ enabled: true })
+    );
+    
+    act(() => {
+      result.current.startTracking();
+    });
+    
+    unmount();
+    
+    expect(mockRemoveEventListener).toHaveBeenCalled();
+    expect(mockBroadcastChannel.close).toHaveBeenCalled();
+  });
+
+  it('handles errors gracefully', () => {
+    // Mock localStorage to throw error
+    localStorageMock.setItem.mockImplementation(() => {
+      throw new Error('Storage error');
+    });
+    
+    const consoleSpy = vi.spyOn(console, 'warn').mockImplementation();
+    
+    const { result } = renderHook(() => 
+      useInactivityTracker({ enabled: true })
+    );
+    
+    act(() => {
+      result.current.startTracking();
+    });
+    
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Failed to persist activity time'),
+      expect.any(Error)
+    );
+    
+    consoleSpy.mockRestore();
+  });
+
+  it('throttles event handling', () => {
+    const onActivity = vi.fn();
+    const { result } = renderHook(() => 
+      useInactivityTracker({ 
+        enabled: true,
+        onActivity 
+      })
+    );
+    
+    act(() => {
+      result.current.startTracking();
+    });
+    
+    // Simulate multiple rapid events
+    act(() => {
+      // These would normally be triggered by event listeners
+      // but we'll call resetActivity directly to test the throttling
+      result.current.resetActivity();
+      result.current.resetActivity();
+      result.current.resetActivity();
+    });
+    
+    // resetActivity calls onActivity directly, so it should be called each time
+    // The throttling is applied to the event listeners, not resetActivity itself
+    expect(onActivity).toHaveBeenCalledTimes(3);
+  });
+});

package/src/hooks/__tests__/useOrganisationPermissions.unit.test.tsx

@@ -0,0 +1,286 @@
+import { renderHook } from '@testing-library/react';
+import { vi, describe, it, expect, beforeEach } from 'vitest';
+import { useOrganisationPermissions } from '../useOrganisationPermissions';
+import { useOrganisations } from '../../providers/OrganisationProvider';
+
+// Mock dependencies
+vi.mock('../../providers/OrganisationProvider');
+
+const mockUseOrganisations = {
+  selectedOrganisation: null,
+  getUserRole: vi.fn(),
+  validateOrganisationAccess: vi.fn(),
+  ensureOrganisationContext: vi.fn()
+};
+
+describe('useOrganisationPermissions', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.mocked(useOrganisations).mockReturnValue(mockUseOrganisations as any);
+  });
+
+  describe('Basic functionality', () => {
+    it('should return default values when no organisation context', () => {
+      vi.mocked(mockUseOrganisations.ensureOrganisationContext).mockImplementation(() => {
+        throw new Error('No organisation context');
+      });
+
+      const { result } = renderHook(() => useOrganisationPermissions());
+
+      expect(result.current.userRole).toBe('no_access');
+      expect(result.current.hasOrganisationAccess).toBe(false);
+      expect(result.current.organisationId).toBe('');
+      expect(result.current.isOrgAdmin).toBe(false);
+      expect(result.current.isSuperAdmin).toBe(false);
+      expect(result.current.canModerate).toBe(false);
+      expect(result.current.canManageMembers).toBe(false);
+      expect(result.current.canManageSettings).toBe(false);
+      expect(result.current.canManageEvents).toBe(false);
+      expect(result.current.hasAdminPrivileges).toBe(false);
+    });
+
+    it('should return correct values when organisation context exists', () => {
+      const mockOrg = { id: 'org-123' };
+      vi.mocked(mockUseOrganisations.ensureOrganisationContext).mockReturnValue(mockOrg);
+      vi.mocked(mockUseOrganisations.getUserRole).mockReturnValue('org_admin');
+      vi.mocked(mockUseOrganisations.validateOrganisationAccess).mockReturnValue(true);
+
+      const { result } = renderHook(() => useOrganisationPermissions());
+
+      expect(result.current.organisationId).toBe('org-123');
+      expect(result.current.userRole).toBe('org_admin');
+      expect(result.current.hasOrganisationAccess).toBe(true);
+      expect(result.current.isOrgAdmin).toBe(true);
+      expect(result.current.hasAdminPrivileges).toBe(true);
+    });
+
+    it('should use provided organisation ID when passed', () => {
+      vi.mocked(mockUseOrganisations.getUserRole).mockReturnValue('member');
+      vi.mocked(mockUseOrganisations.validateOrganisationAccess).mockReturnValue(true);
+
+      const { result } = renderHook(() => useOrganisationPermissions('org-456'));
+
+      expect(result.current.organisationId).toBe('org-456');
+      expect(result.current.userRole).toBe('member');
+    });
+  });
+
+  describe('Role-based permissions', () => {
+    it('should handle member role correctly', () => {
+      const mockOrg = { id: 'org-123' };
+      vi.mocked(mockUseOrganisations.ensureOrganisationContext).mockReturnValue(mockOrg);
+      vi.mocked(mockUseOrganisations.getUserRole).mockReturnValue('member');
+      vi.mocked(mockUseOrganisations.validateOrganisationAccess).mockReturnValue(true);
+
+      const { result } = renderHook(() => useOrganisationPermissions());
+
+      expect(result.current.isOrgAdmin).toBe(false);
+      expect(result.current.isSuperAdmin).toBe(false);
+      expect(result.current.canModerate).toBe(false);
+      expect(result.current.canManageMembers).toBe(false);
+      expect(result.current.canManageSettings).toBe(false);
+      expect(result.current.canManageEvents).toBe(false);
+      expect(result.current.hasAdminPrivileges).toBe(false);
+    });
+
+    it('should handle leader role correctly', () => {
+      const mockOrg = { id: 'org-123' };
+      vi.mocked(mockUseOrganisations.ensureOrganisationContext).mockReturnValue(mockOrg);
+      vi.mocked(mockUseOrganisations.getUserRole).mockReturnValue('leader');
+      vi.mocked(mockUseOrganisations.validateOrganisationAccess).mockReturnValue(true);
+
+      const { result } = renderHook(() => useOrganisationPermissions());
+
+      expect(result.current.isOrgAdmin).toBe(false);
+      expect(result.current.isSuperAdmin).toBe(false);
+      expect(result.current.canModerate).toBe(true);
+      expect(result.current.canManageMembers).toBe(false);
+      expect(result.current.canManageSettings).toBe(false);
+      expect(result.current.canManageEvents).toBe(true);
+      expect(result.current.hasAdminPrivileges).toBe(false);
+    });
+
+
+
+    it('should handle org_admin role correctly', () => {
+      const mockOrg = { id: 'org-123' };
+      vi.mocked(mockUseOrganisations.ensureOrganisationContext).mockReturnValue(mockOrg);
+      vi.mocked(mockUseOrganisations.getUserRole).mockReturnValue('org_admin');
+      vi.mocked(mockUseOrganisations.validateOrganisationAccess).mockReturnValue(true);
+
+      const { result } = renderHook(() => useOrganisationPermissions());
+
+      expect(result.current.isOrgAdmin).toBe(true);
+      expect(result.current.isSuperAdmin).toBe(true);
+      expect(result.current.canModerate).toBe(true);
+      expect(result.current.canManageMembers).toBe(true);
+      expect(result.current.canManageSettings).toBe(true);
+      expect(result.current.canManageEvents).toBe(true);
+      expect(result.current.hasAdminPrivileges).toBe(true);
+    });
+
+
+  });
+
+  describe('Permission checking', () => {
+    it('should return false for permissions when no access', () => {
+      vi.mocked(mockUseOrganisations.validateOrganisationAccess).mockReturnValue(false);
+
+      const { result } = renderHook(() => useOrganisationPermissions());
+
+      expect(result.current.hasPermission('view_basic')).toBe(false);
+      expect(result.current.hasPermission('moderate_content')).toBe(false);
+      expect(result.current.hasPermission('manage_members')).toBe(false);
+    });
+
+    it('should return false for permissions when no role', () => {
+      const mockOrg = { id: 'org-123' };
+      vi.mocked(mockUseOrganisations.ensureOrganisationContext).mockReturnValue(mockOrg);
+      vi.mocked(mockUseOrganisations.getUserRole).mockReturnValue('no_access');
+      vi.mocked(mockUseOrganisations.validateOrganisationAccess).mockReturnValue(true);
+
+      const { result } = renderHook(() => useOrganisationPermissions());
+
+      expect(result.current.hasPermission('view_basic')).toBe(false);
+    });
+
+    it('should return correct permissions for member role', () => {
+      const mockOrg = { id: 'org-123' };
+      vi.mocked(mockUseOrganisations.ensureOrganisationContext).mockReturnValue(mockOrg);
+      vi.mocked(mockUseOrganisations.getUserRole).mockReturnValue('member');
+      vi.mocked(mockUseOrganisations.validateOrganisationAccess).mockReturnValue(true);
+
+      const { result } = renderHook(() => useOrganisationPermissions());
+
+      expect(result.current.hasPermission('view_basic')).toBe(true);
+      expect(result.current.hasPermission('view_details')).toBe(true);
+      expect(result.current.hasPermission('moderate_content')).toBe(false);
+      expect(result.current.hasPermission('manage_members')).toBe(false);
+    });
+
+    it('should return correct permissions for leader role', () => {
+      const mockOrg = { id: 'org-123' };
+      vi.mocked(mockUseOrganisations.ensureOrganisationContext).mockReturnValue(mockOrg);
+      vi.mocked(mockUseOrganisations.getUserRole).mockReturnValue('leader');
+      vi.mocked(mockUseOrganisations.validateOrganisationAccess).mockReturnValue(true);
+
+      const { result } = renderHook(() => useOrganisationPermissions());
+
+      expect(result.current.hasPermission('view_basic')).toBe(true);
+      expect(result.current.hasPermission('view_details')).toBe(true);
+      expect(result.current.hasPermission('moderate_content')).toBe(true);
+      expect(result.current.hasPermission('manage_events')).toBe(true);
+      expect(result.current.hasPermission('manage_members')).toBe(false);
+    });
+
+
+
+    it('should return correct permissions for org_admin role', () => {
+      const mockOrg = { id: 'org-123' };
+      vi.mocked(mockUseOrganisations.ensureOrganisationContext).mockReturnValue(mockOrg);
+      vi.mocked(mockUseOrganisations.getUserRole).mockReturnValue('org_admin');
+      vi.mocked(mockUseOrganisations.validateOrganisationAccess).mockReturnValue(true);
+
+      const { result } = renderHook(() => useOrganisationPermissions());
+
+      expect(result.current.hasPermission('view_basic')).toBe(true);
+      expect(result.current.hasPermission('moderate_content')).toBe(true);
+      expect(result.current.hasPermission('manage_members')).toBe(true);
+      expect(result.current.hasPermission('manage_events')).toBe(true);
+      expect(result.current.hasPermission('manage_settings')).toBe(true);
+    });
+
+
+
+    it('should return true for wildcard permission', () => {
+      const mockOrg = { id: 'org-123' };
+      vi.mocked(mockUseOrganisations.ensureOrganisationContext).mockReturnValue(mockOrg);
+      vi.mocked(mockUseOrganisations.getUserRole).mockReturnValue('member');
+      vi.mocked(mockUseOrganisations.validateOrganisationAccess).mockReturnValue(true);
+
+      const { result } = renderHook(() => useOrganisationPermissions());
+
+      expect(result.current.hasPermission('*')).toBe(true);
+    });
+  });
+
+  describe('getAllPermissions function', () => {
+    it('should return empty array when no access', () => {
+      vi.mocked(mockUseOrganisations.validateOrganisationAccess).mockReturnValue(false);
+
+      const { result } = renderHook(() => useOrganisationPermissions());
+
+      expect(result.current.getAllPermissions()).toEqual([]);
+    });
+
+    it('should return correct permissions for member role', () => {
+      const mockOrg = { id: 'org-123' };
+      vi.mocked(mockUseOrganisations.ensureOrganisationContext).mockReturnValue(mockOrg);
+      vi.mocked(mockUseOrganisations.getUserRole).mockReturnValue('member');
+      vi.mocked(mockUseOrganisations.validateOrganisationAccess).mockReturnValue(true);
+
+      const { result } = renderHook(() => useOrganisationPermissions());
+
+      expect(result.current.getAllPermissions()).toEqual(['view_basic', 'view_details']);
+    });
+
+    it('should return correct permissions for leader role', () => {
+      const mockOrg = { id: 'org-123' };
+      vi.mocked(mockUseOrganisations.ensureOrganisationContext).mockReturnValue(mockOrg);
+      vi.mocked(mockUseOrganisations.getUserRole).mockReturnValue('leader');
+      vi.mocked(mockUseOrganisations.validateOrganisationAccess).mockReturnValue(true);
+
+      const { result } = renderHook(() => useOrganisationPermissions());
+
+      expect(result.current.getAllPermissions()).toEqual(['view_basic', 'view_details', 'moderate_content', 'manage_events']);
+    });
+
+
+
+    it('should return correct permissions for org_admin role', () => {
+      const mockOrg = { id: 'org-123' };
+      vi.mocked(mockUseOrganisations.ensureOrganisationContext).mockReturnValue(mockOrg);
+      vi.mocked(mockUseOrganisations.getUserRole).mockReturnValue('org_admin');
+      vi.mocked(mockUseOrganisations.validateOrganisationAccess).mockReturnValue(true);
+
+      const { result } = renderHook(() => useOrganisationPermissions());
+
+      expect(result.current.getAllPermissions()).toEqual([
+        'view_basic',
+        'view_details',
+        'moderate_content',
+        'manage_events',
+        'manage_members',
+        'manage_settings'
+      ]);
+    });
+
+
+  });
+
+  describe('Edge cases', () => {
+    it('should handle unknown role gracefully', () => {
+      const mockOrg = { id: 'org-123' };
+      vi.mocked(mockUseOrganisations.ensureOrganisationContext).mockReturnValue(mockOrg);
+      vi.mocked(mockUseOrganisations.getUserRole).mockReturnValue('unknown_role');
+      vi.mocked(mockUseOrganisations.validateOrganisationAccess).mockReturnValue(true);
+
+      const { result } = renderHook(() => useOrganisationPermissions());
+
+      expect(result.current.hasPermission('view_basic')).toBe(false);
+      expect(result.current.getAllPermissions()).toEqual([]);
+    });
+
+    it('should handle organisation context error gracefully', () => {
+      vi.mocked(mockUseOrganisations.ensureOrganisationContext).mockImplementation(() => {
+        throw new Error('Organisation context error');
+      });
+
+      const { result } = renderHook(() => useOrganisationPermissions());
+
+      expect(result.current.organisationId).toBe('');
+      expect(result.current.userRole).toBe('no_access');
+      expect(result.current.hasOrganisationAccess).toBe(false);
+    });
+  });
+});