@jmruthers/pace-core 0.6.9 → 0.6.11

package/src/utils/context/sessionTracking.test.ts

@@ -0,0 +1,354 @@
+/**
+ * @file Session Tracking Tests
+ * @package @jmruthers/pace-core
+ * @module Utils/Context
+ * @since 0.1.0
+ *
+ * Comprehensive tests for session tracking utility covering:
+ * - Event switch tracking
+ * - Session expiration tracking
+ * - App ID resolution
+ * - Error handling
+ * - Edge cases
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { useSessionTracking } from './sessionTracking';
+
+// Following testing standards: use timeout parameter to prevent hanging
+const TEST_TIMEOUT = 10000; // 10 seconds per test
+
+// Mock the logger
+vi.mock('../core/logger', () => ({
+  createLogger: vi.fn(() => ({
+    warn: vi.fn(),
+    error: vi.fn()
+  }))
+}));
+
+describe('Session Tracking', () => {
+  let mockSupabase: any;
+  let mockAuth: any;
+  let mockFrom: any;
+  let mockRpc: any;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    mockFrom = {
+      select: vi.fn().mockReturnThis(),
+      eq: vi.fn().mockReturnThis(),
+      single: vi.fn().mockResolvedValue({
+        data: { id: 'app-123' },
+        error: null
+      })
+    };
+
+    mockRpc = vi.fn().mockResolvedValue({ error: null });
+
+    mockAuth = {
+      getUser: vi.fn().mockResolvedValue({
+        data: { user: { id: 'user-123' } },
+        error: null
+      })
+    };
+
+    mockSupabase = {
+      from: vi.fn(() => mockFrom),
+      rpc: mockRpc,
+      auth: mockAuth
+    };
+  });
+
+  describe('useSessionTracking', () => {
+    it('returns tracking functions', () => {
+      const result = useSessionTracking(mockSupabase);
+      
+      expect(result).toHaveProperty('trackEventSwitch');
+      expect(result).toHaveProperty('trackSessionExpired');
+      expect(typeof result.trackEventSwitch).toBe('function');
+      expect(typeof result.trackSessionExpired).toBe('function');
+    }, TEST_TIMEOUT);
+
+    it('works without app name', () => {
+      const result = useSessionTracking(mockSupabase);
+      
+      expect(result.trackEventSwitch).toBeDefined();
+      expect(result.trackSessionExpired).toBeDefined();
+    }, TEST_TIMEOUT);
+
+    it('works with app name', () => {
+      const result = useSessionTracking(mockSupabase, 'MY_APP');
+      
+      expect(result.trackEventSwitch).toBeDefined();
+      expect(result.trackSessionExpired).toBeDefined();
+    }, TEST_TIMEOUT);
+  });
+
+  describe('trackEventSwitch', () => {
+    it('tracks event switch successfully', async () => {
+      const { trackEventSwitch } = useSessionTracking(mockSupabase, 'MY_APP');
+
+      await trackEventSwitch('event-123');
+
+      expect(mockAuth.getUser).toHaveBeenCalled();
+      expect(mockSupabase.from).toHaveBeenCalledWith('rbac_apps');
+      expect(mockFrom.eq).toHaveBeenCalledWith('name', 'MY_APP');
+      expect(mockFrom.eq).toHaveBeenCalledWith('is_active', true);
+      expect(mockRpc).toHaveBeenCalledWith('rbac_session_track', {
+        p_user_id: 'user-123',
+        p_session_type: 'event_switch',
+        p_event_id: 'event-123',
+        p_app_id: 'app-123',
+        p_ip_address: undefined,
+        p_user_agent: undefined
+      });
+    }, TEST_TIMEOUT);
+
+    it('tracks event switch without app name', async () => {
+      const { trackEventSwitch } = useSessionTracking(mockSupabase);
+
+      await trackEventSwitch('event-123');
+
+      expect(mockAuth.getUser).toHaveBeenCalled();
+      expect(mockRpc).toHaveBeenCalledWith('rbac_session_track', {
+        p_user_id: 'user-123',
+        p_session_type: 'event_switch',
+        p_event_id: 'event-123',
+        p_app_id: undefined,
+        p_ip_address: undefined,
+        p_user_agent: undefined
+      });
+    }, TEST_TIMEOUT);
+
+    it('handles missing user gracefully', async () => {
+      mockAuth.getUser.mockResolvedValue({
+        data: { user: null },
+        error: null
+      });
+
+      const { trackEventSwitch } = useSessionTracking(mockSupabase, 'MY_APP');
+
+      await trackEventSwitch('event-123');
+
+      expect(mockRpc).not.toHaveBeenCalled();
+    }, TEST_TIMEOUT);
+
+    it('handles app not found gracefully', async () => {
+      mockFrom.single.mockResolvedValue({
+        data: null,
+        error: { message: 'Not found' }
+      });
+
+      const { trackEventSwitch } = useSessionTracking(mockSupabase, 'NONEXISTENT_APP');
+
+      await trackEventSwitch('event-123');
+
+      expect(mockRpc).toHaveBeenCalledWith('rbac_session_track', expect.objectContaining({
+        p_app_id: undefined
+      }));
+    }, TEST_TIMEOUT);
+
+    it('handles app resolution errors gracefully', async () => {
+      mockFrom.single.mockRejectedValue(new Error('Database error'));
+
+      const { trackEventSwitch } = useSessionTracking(mockSupabase, 'MY_APP');
+
+      await trackEventSwitch('event-123');
+
+      expect(mockRpc).toHaveBeenCalledWith('rbac_session_track', expect.objectContaining({
+        p_app_id: undefined
+      }));
+    }, TEST_TIMEOUT);
+
+    it('handles RPC errors gracefully', async () => {
+      mockRpc.mockResolvedValue({ error: { message: 'RPC error' } });
+
+      const { trackEventSwitch } = useSessionTracking(mockSupabase, 'MY_APP');
+
+      await expect(trackEventSwitch('event-123')).resolves.not.toThrow();
+    }, TEST_TIMEOUT);
+
+    it('handles RPC exceptions gracefully', async () => {
+      mockRpc.mockRejectedValue(new Error('Network error'));
+
+      const { trackEventSwitch } = useSessionTracking(mockSupabase, 'MY_APP');
+
+      await expect(trackEventSwitch('event-123')).resolves.not.toThrow();
+    }, TEST_TIMEOUT);
+
+    it('handles getUser errors gracefully', async () => {
+      mockAuth.getUser.mockResolvedValue({
+        data: { user: null },
+        error: { message: 'Auth error' }
+      });
+
+      const { trackEventSwitch } = useSessionTracking(mockSupabase, 'MY_APP');
+
+      await trackEventSwitch('event-123');
+
+      expect(mockRpc).not.toHaveBeenCalled();
+    }, TEST_TIMEOUT);
+  });
+
+  describe('trackSessionExpired', () => {
+    it('tracks session expiration successfully', async () => {
+      const { trackSessionExpired } = useSessionTracking(mockSupabase, 'MY_APP');
+
+      await trackSessionExpired();
+
+      expect(mockAuth.getUser).toHaveBeenCalled();
+      expect(mockRpc).toHaveBeenCalledWith('rbac_session_track', {
+        p_user_id: 'user-123',
+        p_session_type: 'session_expired',
+        p_event_id: undefined,
+        p_app_id: 'app-123',
+        p_ip_address: undefined,
+        p_user_agent: undefined
+      });
+    }, TEST_TIMEOUT);
+
+    it('tracks session expiration without app name', async () => {
+      const { trackSessionExpired } = useSessionTracking(mockSupabase);
+
+      await trackSessionExpired();
+
+      expect(mockAuth.getUser).toHaveBeenCalled();
+      expect(mockRpc).toHaveBeenCalledWith('rbac_session_track', {
+        p_user_id: 'user-123',
+        p_session_type: 'session_expired',
+        p_event_id: undefined,
+        p_app_id: undefined,
+        p_ip_address: undefined,
+        p_user_agent: undefined
+      });
+    }, TEST_TIMEOUT);
+
+    it('handles missing user gracefully', async () => {
+      mockAuth.getUser.mockResolvedValue({
+        data: { user: null },
+        error: null
+      });
+
+      const { trackSessionExpired } = useSessionTracking(mockSupabase, 'MY_APP');
+
+      await trackSessionExpired();
+
+      expect(mockRpc).not.toHaveBeenCalled();
+    }, TEST_TIMEOUT);
+
+    it('handles app not found gracefully', async () => {
+      mockFrom.single.mockResolvedValue({
+        data: null,
+        error: { message: 'Not found' }
+      });
+
+      const { trackSessionExpired } = useSessionTracking(mockSupabase, 'NONEXISTENT_APP');
+
+      await trackSessionExpired();
+
+      expect(mockRpc).toHaveBeenCalledWith('rbac_session_track', expect.objectContaining({
+        p_app_id: undefined
+      }));
+    }, TEST_TIMEOUT);
+
+    it('handles RPC errors gracefully', async () => {
+      mockRpc.mockResolvedValue({ error: { message: 'RPC error' } });
+
+      const { trackSessionExpired } = useSessionTracking(mockSupabase, 'MY_APP');
+
+      await expect(trackSessionExpired()).resolves.not.toThrow();
+    }, TEST_TIMEOUT);
+
+    it('handles RPC exceptions gracefully', async () => {
+      mockRpc.mockRejectedValue(new Error('Network error'));
+
+      const { trackSessionExpired } = useSessionTracking(mockSupabase, 'MY_APP');
+
+      await expect(trackSessionExpired()).resolves.not.toThrow();
+    }, TEST_TIMEOUT);
+  });
+
+  describe('App ID Resolution', () => {
+    it('resolves app ID for active app', async () => {
+      const { trackEventSwitch } = useSessionTracking(mockSupabase, 'MY_APP');
+
+      await trackEventSwitch('event-123');
+
+      expect(mockSupabase.from).toHaveBeenCalledWith('rbac_apps');
+      expect(mockFrom.select).toHaveBeenCalledWith('id');
+      expect(mockFrom.eq).toHaveBeenCalledWith('name', 'MY_APP');
+      expect(mockFrom.eq).toHaveBeenCalledWith('is_active', true);
+    }, TEST_TIMEOUT);
+
+    it('handles inactive app', async () => {
+      mockFrom.single.mockResolvedValue({
+        data: null,
+        error: { message: 'App not active' }
+      });
+
+      const { trackEventSwitch } = useSessionTracking(mockSupabase, 'INACTIVE_APP');
+
+      await trackEventSwitch('event-123');
+
+      expect(mockRpc).toHaveBeenCalledWith('rbac_session_track', expect.objectContaining({
+        p_app_id: undefined
+      }));
+    }, TEST_TIMEOUT);
+
+    it('caches app ID resolution within same tracking instance', async () => {
+      const { trackEventSwitch } = useSessionTracking(mockSupabase, 'MY_APP');
+
+      await trackEventSwitch('event-1');
+      await trackEventSwitch('event-2');
+
+      // Should resolve app ID once per call (no caching in current implementation)
+      expect(mockFrom.single).toHaveBeenCalledTimes(2);
+    }, TEST_TIMEOUT);
+  });
+
+  describe('Edge Cases', () => {
+    it('handles empty event ID', async () => {
+      const { trackEventSwitch } = useSessionTracking(mockSupabase, 'MY_APP');
+
+      await trackEventSwitch('');
+
+      expect(mockRpc).toHaveBeenCalledWith('rbac_session_track', expect.objectContaining({
+        p_event_id: ''
+      }));
+    }, TEST_TIMEOUT);
+
+    it('handles very long event ID', async () => {
+      const longEventId = 'e'.repeat(1000);
+      const { trackEventSwitch } = useSessionTracking(mockSupabase, 'MY_APP');
+
+      await trackEventSwitch(longEventId);
+
+      expect(mockRpc).toHaveBeenCalledWith('rbac_session_track', expect.objectContaining({
+        p_event_id: longEventId
+      }));
+    }, TEST_TIMEOUT);
+
+    it('handles special characters in event ID', async () => {
+      const { trackEventSwitch } = useSessionTracking(mockSupabase, 'MY_APP');
+
+      await trackEventSwitch('event-123@domain.com');
+
+      expect(mockRpc).toHaveBeenCalledWith('rbac_session_track', expect.objectContaining({
+        p_event_id: 'event-123@domain.com'
+      }));
+    }, TEST_TIMEOUT);
+
+    it('handles rapid consecutive calls', async () => {
+      const { trackEventSwitch } = useSessionTracking(mockSupabase, 'MY_APP');
+
+      const promises = Array.from({ length: 10 }, (_, i) => 
+        trackEventSwitch(`event-${i}`)
+      );
+
+      await Promise.all(promises);
+
+      expect(mockRpc).toHaveBeenCalledTimes(10);
+    }, TEST_TIMEOUT);
+  });
+});

package/src/utils/core/cn.test.ts

@@ -0,0 +1,66 @@
+/**
+ * @file Unit Tests for cn Utility
+ * @package @jmruthers/pace-core
+ * @module Utils/Core
+ * @since 1.0.0
+ */
+
+import { describe, it, expect } from 'vitest';
+import { cn } from './cn';
+
+describe('cn utility', () => {
+  describe('Class merging', () => {
+    it('merges class names correctly', () => {
+      expect(cn('foo', 'bar')).toBe('foo bar');
+      expect(cn('foo', 'bar', 'baz')).toBe('foo bar baz');
+    });
+
+    it('handles conditional classes', () => {
+      expect(cn('foo', true && 'bar', false && 'baz')).toBe('foo bar');
+      expect(cn('foo', false && 'bar', true && 'baz')).toBe('foo baz');
+    });
+
+    it('handles arrays of classes', () => {
+      expect(cn(['foo', 'bar'], 'baz')).toBe('foo bar baz');
+      expect(cn('foo', ['bar', 'baz'])).toBe('foo bar baz');
+    });
+
+    it('handles objects with boolean values', () => {
+      expect(cn({ foo: true, bar: false, baz: true })).toBe('foo baz');
+      expect(cn({ foo: false, bar: true })).toBe('bar');
+    });
+
+    it('handles undefined and null values', () => {
+      expect(cn('foo', undefined, 'bar', null, 'baz')).toBe('foo bar baz');
+      expect(cn(undefined, null)).toBe('');
+    });
+
+    it('handles empty strings', () => {
+      expect(cn('foo', '', 'bar')).toBe('foo bar');
+      expect(cn('', '')).toBe('');
+    });
+
+    it('merges Tailwind classes correctly', () => {
+      const result1 = cn('px-2 py-1', 'px-4');
+      expect(result1).toContain('px-4');
+      expect(result1).toContain('py-1');
+      expect(result1).not.toContain('px-2');
+      
+      expect(cn('bg-acc-500', 'bg-main-500')).toBe('bg-main-500');
+    });
+
+    it('handles complex combinations', () => {
+      expect(cn('foo', { bar: true, baz: false }, ['qux', 'quux'], 'corge')).toBe('foo bar qux quux corge');
+    });
+
+    it('handles no arguments', () => {
+      expect(cn()).toBe('');
+    });
+
+    it('handles single argument', () => {
+      expect(cn('foo')).toBe('foo');
+      expect(cn({ foo: true })).toBe('foo');
+      expect(cn(['foo', 'bar'])).toBe('foo bar');
+    });
+  });
+});

package/src/utils/core/debugLogger.test.ts

@@ -0,0 +1,113 @@
+/**
+ * @file Unit Tests for DebugLogger Utility
+ * @package @jmruthers/pace-core
+ * @module Utils/Core
+ * @since 1.0.0
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { DebugLogger } from './debugLogger';
+
+describe('DebugLogger utility', () => {
+  let originalMode: string | undefined;
+  let consoleLogSpy: ReturnType<typeof vi.spyOn>;
+  let consoleInfoSpy: ReturnType<typeof vi.spyOn>;
+  let consoleWarnSpy: ReturnType<typeof vi.spyOn>;
+  let consoleErrorSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    originalMode = import.meta.env.MODE;
+    (import.meta.env as any).MODE = 'development';
+    
+    consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    consoleInfoSpy = vi.spyOn(console, 'info').mockImplementation(() => {});
+    consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    if (originalMode !== undefined) {
+      (import.meta.env as any).MODE = originalMode;
+    }
+    consoleLogSpy.mockRestore();
+    consoleInfoSpy.mockRestore();
+    consoleWarnSpy.mockRestore();
+    consoleErrorSpy.mockRestore();
+    vi.clearAllMocks();
+  });
+
+  describe('DebugLogger methods', () => {
+    it('logs debug messages in development mode', () => {
+      DebugLogger.log('TestComponent', 'Debug message', { data: 'test' });
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        '[TestComponent] Debug message',
+        { data: 'test' }
+      );
+    });
+
+    it('logs info messages in development mode', () => {
+      DebugLogger.info('TestComponent', 'Info message', { data: 'test' });
+      expect(consoleInfoSpy).toHaveBeenCalledWith(
+        '[TestComponent] Info message',
+        { data: 'test' }
+      );
+    });
+
+    it('logs warn messages always', () => {
+      DebugLogger.warn('TestComponent', 'Warn message', { data: 'test' });
+      expect(consoleWarnSpy).toHaveBeenCalledWith(
+        '[TestComponent] Warn message',
+        { data: 'test' }
+      );
+    });
+
+    it('logs error messages always', () => {
+      DebugLogger.error('TestComponent', 'Error message', { data: 'test' });
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        '[TestComponent] Error message',
+        { data: 'test' }
+      );
+    });
+
+    it('does not log debug or info in production mode', () => {
+      (import.meta.env as any).MODE = 'production';
+      
+      DebugLogger.log('TestComponent', 'Debug message');
+      DebugLogger.info('TestComponent', 'Info message');
+      DebugLogger.warn('TestComponent', 'Warn message');
+      DebugLogger.error('TestComponent', 'Error message');
+
+      expect(consoleLogSpy).not.toHaveBeenCalled();
+      expect(consoleInfoSpy).not.toHaveBeenCalled();
+      expect(consoleWarnSpy).toHaveBeenCalled();
+      expect(consoleErrorSpy).toHaveBeenCalled();
+    });
+
+    it('handles console method errors gracefully', () => {
+      consoleLogSpy.mockImplementation(() => {
+        throw new Error('Console error');
+      });
+      
+      expect(() => {
+        DebugLogger.log('TestComponent', 'Test message');
+      }).not.toThrow();
+    });
+
+    it('handles multiple arguments', () => {
+      DebugLogger.log('TestComponent', 'Message', 'arg1', 'arg2', { data: 'test' });
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        '[TestComponent] Message',
+        'arg1',
+        'arg2',
+        { data: 'test' }
+      );
+    });
+
+    it('handles empty component name', () => {
+      DebugLogger.log('', 'Test message');
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        '[] Test message'
+      );
+    });
+  });
+});

package/src/utils/core/debugLogger.ts

@@ -8,6 +8,9 @@
 /**
  * Debug logger that respects environment settings
  * Only logs in development mode to prevent production console spam
+ * 
+ * NOTE: This utility intentionally uses console methods for debugging purposes.
+ * It provides a lightweight alternative to the main logger for development-only logging.
  */
 export class DebugLogger {
   /**
@@ -20,11 +23,12 @@ export class DebugLogger {
   /**
    * Log debug information only in development mode
    */
-  static log(component: string, message: string, ...args: any[]): void {
+  static log(component: string, message: string, ...args: unknown[]): void {
     if (this.isDevelopment) {
       try {
+        // eslint-disable-next-line no-console -- Intentional: Debug logger uses console for development debugging
         console.log(`[${component}] ${message}`, ...args);
-      } catch (e) {
+      } catch (_e) {
         // Gracefully handle console method errors
       }
     }
@@ -33,10 +37,11 @@ export class DebugLogger {
   /**
    * Log error information (always logged)
    */
-  static error(component: string, message: string, ...args: any[]): void {
+  static error(component: string, message: string, ...args: unknown[]): void {
     try {
+      // eslint-disable-next-line no-console -- Intentional: Debug logger uses console for error logging
       console.error(`[${component}] ${message}`, ...args);
-    } catch (e) {
+    } catch (_e) {
       // Gracefully handle console method errors
     }
   }
@@ -44,10 +49,11 @@ export class DebugLogger {
   /**
    * Log warning information (always logged)
    */
-  static warn(component: string, message: string, ...args: any[]): void {
+  static warn(component: string, message: string, ...args: unknown[]): void {
     try {
+      // eslint-disable-next-line no-console -- Intentional: Debug logger uses console for warning logging
       console.warn(`[${component}] ${message}`, ...args);
-    } catch (e) {
+    } catch (_e) {
       // Gracefully handle console method errors
     }
   }
@@ -55,11 +61,12 @@ export class DebugLogger {
   /**
    * Log info information only in development mode
    */
-  static info(component: string, message: string, ...args: any[]): void {
+  static info(component: string, message: string, ...args: unknown[]): void {
     if (this.isDevelopment) {
       try {
+        // eslint-disable-next-line no-console -- Intentional: Debug logger uses console for development debugging
         console.info(`[${component}] ${message}`, ...args);
-      } catch (e) {
+      } catch (_e) {
         // Gracefully handle console method errors
       }
     }