@jmruthers/pace-core 0.5.3 → 0.5.5

package/src/utils/__tests__/sessionTracking.unit.test.ts

@@ -0,0 +1,356 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import type { SupabaseClient } from '@supabase/supabase-js';
+
+describe('sessionTracking', () => {
+  let consoleSpy: {
+    log: ReturnType<typeof vi.spyOn>;
+    warn: ReturnType<typeof vi.spyOn>;
+    error: ReturnType<typeof vi.spyOn>;
+  };
+  let mockSupabase: SupabaseClient;
+  let trackingFunctions: any;
+
+  beforeEach(() => {
+    // Mock console methods before each test
+    consoleSpy = {
+      log: vi.spyOn(console, 'log').mockImplementation(() => {}),
+      warn: vi.spyOn(console, 'warn').mockImplementation(() => {}),
+      error: vi.spyOn(console, 'error').mockImplementation(() => {})
+    };
+    
+    // Create a mock Supabase client
+    mockSupabase = {
+      rpc: vi.fn(),
+      auth: {
+        getUser: vi.fn()
+      }
+    } as unknown as SupabaseClient;
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('trackLogin', () => {
+    it('should track login successfully', async () => {
+      const mockUser = { id: 'user-123', email: 'test@example.com' };
+      const mockGetUser = vi.fn().mockResolvedValue({ data: { user: mockUser } });
+      const mockRpc = vi.fn().mockResolvedValue({ error: null });
+      
+      mockSupabase.auth.getUser = mockGetUser;
+      mockSupabase.rpc = mockRpc;
+
+      // Import the module after setting up mocks
+      vi.resetModules();
+      const { useSessionTracking } = await import('../sessionTracking');
+      trackingFunctions = useSessionTracking(mockSupabase, 'test-app');
+
+      await trackingFunctions.trackLogin('event-123');
+
+      expect(mockGetUser).toHaveBeenCalled();
+      expect(mockRpc).toHaveBeenCalledWith('track_user_session', {
+        p_session_type: 'login',
+        p_event_id: 'event-123',
+        p_app_id: undefined
+      });
+      expect(consoleSpy.log).toHaveBeenCalledWith('Login session tracked successfully');
+    });
+
+    it('should track login without event ID', async () => {
+      const mockUser = { id: 'user-123', email: 'test@example.com' };
+      const mockGetUser = vi.fn().mockResolvedValue({ data: { user: mockUser } });
+      const mockRpc = vi.fn().mockResolvedValue({ error: null });
+      
+      mockSupabase.auth.getUser = mockGetUser;
+      mockSupabase.rpc = mockRpc;
+
+      vi.resetModules();
+      const { useSessionTracking } = await import('../sessionTracking');
+      trackingFunctions = useSessionTracking(mockSupabase, 'test-app');
+
+      await trackingFunctions.trackLogin();
+
+      expect(mockRpc).toHaveBeenCalledWith('track_user_session', {
+        p_session_type: 'login',
+        p_event_id: undefined,
+        p_app_id: undefined
+      });
+    });
+
+    it('should handle no authenticated user', async () => {
+      const mockGetUser = vi.fn().mockResolvedValue({ data: { user: null } });
+      mockSupabase.auth.getUser = mockGetUser;
+
+      vi.resetModules();
+      const { useSessionTracking } = await import('../sessionTracking');
+      trackingFunctions = useSessionTracking(mockSupabase, 'test-app');
+
+      await trackingFunctions.trackLogin();
+
+      expect(consoleSpy.warn).toHaveBeenCalledWith('No authenticated user found for session tracking');
+    });
+
+    it('should handle tracking error', async () => {
+      const mockUser = { id: 'user-123', email: 'test@example.com' };
+      const mockGetUser = vi.fn().mockResolvedValue({ data: { user: mockUser } });
+      const mockRpc = vi.fn().mockResolvedValue({ error: { message: 'Database error' } });
+      
+      mockSupabase.auth.getUser = mockGetUser;
+      mockSupabase.rpc = mockRpc;
+
+      vi.resetModules();
+      const { useSessionTracking } = await import('../sessionTracking');
+      trackingFunctions = useSessionTracking(mockSupabase, 'test-app');
+
+      await trackingFunctions.trackLogin();
+
+      expect(consoleSpy.error).toHaveBeenCalledWith('Failed to track login session:', { message: 'Database error' });
+    });
+
+    it('should handle unexpected errors', async () => {
+      const mockGetUser = vi.fn().mockRejectedValue(new Error('Auth error'));
+      mockSupabase.auth.getUser = mockGetUser;
+
+      vi.resetModules();
+      const { useSessionTracking } = await import('../sessionTracking');
+      trackingFunctions = useSessionTracking(mockSupabase, 'test-app');
+
+      await trackingFunctions.trackLogin();
+
+      expect(consoleSpy.error).toHaveBeenCalledWith('Failed to track login:', expect.any(Error));
+    });
+  });
+
+  describe('trackEventSwitch', () => {
+    it('should track event switch successfully', async () => {
+      const mockUser = { id: 'user-123', email: 'test@example.com' };
+      const mockGetUser = vi.fn().mockResolvedValue({ data: { user: mockUser } });
+      const mockRpc = vi.fn().mockResolvedValue({ error: null });
+      
+      mockSupabase.auth.getUser = mockGetUser;
+      mockSupabase.rpc = mockRpc;
+
+      vi.resetModules();
+      const { useSessionTracking } = await import('../sessionTracking');
+      trackingFunctions = useSessionTracking(mockSupabase, 'test-app');
+
+      await trackingFunctions.trackEventSwitch('event-456');
+
+      expect(mockRpc).toHaveBeenCalledWith('track_user_session', {
+        p_session_type: 'event_switch',
+        p_event_id: 'event-456',
+        p_app_id: undefined
+      });
+      expect(consoleSpy.log).toHaveBeenCalledWith('Event switch session tracked successfully');
+    });
+
+    it('should handle no authenticated user', async () => {
+      const mockGetUser = vi.fn().mockResolvedValue({ data: { user: null } });
+      mockSupabase.auth.getUser = mockGetUser;
+
+      vi.resetModules();
+      const { useSessionTracking } = await import('../sessionTracking');
+      trackingFunctions = useSessionTracking(mockSupabase, 'test-app');
+
+      await trackingFunctions.trackEventSwitch('event-456');
+
+      expect(consoleSpy.warn).toHaveBeenCalledWith('No authenticated user found for session tracking');
+    });
+
+    it('should handle tracking error', async () => {
+      const mockUser = { id: 'user-123', email: 'test@example.com' };
+      const mockGetUser = vi.fn().mockResolvedValue({ data: { user: mockUser } });
+      const mockRpc = vi.fn().mockResolvedValue({ error: { message: 'Database error' } });
+      
+      mockSupabase.auth.getUser = mockGetUser;
+      mockSupabase.rpc = mockRpc;
+
+      vi.resetModules();
+      const { useSessionTracking } = await import('../sessionTracking');
+      trackingFunctions = useSessionTracking(mockSupabase, 'test-app');
+
+      await trackingFunctions.trackEventSwitch('event-456');
+
+      expect(consoleSpy.error).toHaveBeenCalledWith('Failed to track event switch session:', { message: 'Database error' });
+    });
+
+    it('should handle unexpected errors', async () => {
+      const mockGetUser = vi.fn().mockRejectedValue(new Error('Auth error'));
+      mockSupabase.auth.getUser = mockGetUser;
+
+      vi.resetModules();
+      const { useSessionTracking } = await import('../sessionTracking');
+      trackingFunctions = useSessionTracking(mockSupabase, 'test-app');
+
+      await trackingFunctions.trackEventSwitch('event-456');
+
+      expect(consoleSpy.error).toHaveBeenCalledWith('Failed to track event switch:', expect.any(Error));
+    });
+  });
+
+  describe('trackLogout', () => {
+    it('should track logout successfully', async () => {
+      const mockUser = { id: 'user-123', email: 'test@example.com' };
+      const mockGetUser = vi.fn().mockResolvedValue({ data: { user: mockUser } });
+      const mockRpc = vi.fn().mockResolvedValue({ error: null });
+      
+      mockSupabase.auth.getUser = mockGetUser;
+      mockSupabase.rpc = mockRpc;
+
+      vi.resetModules();
+      const { useSessionTracking } = await import('../sessionTracking');
+      trackingFunctions = useSessionTracking(mockSupabase, 'test-app');
+
+      await trackingFunctions.trackLogout();
+
+      expect(mockRpc).toHaveBeenCalledWith('track_user_session', {
+        p_session_type: 'logout',
+        p_app_id: undefined
+      });
+      expect(consoleSpy.log).toHaveBeenCalledWith('Logout session tracked successfully');
+    });
+
+    it('should handle no authenticated user', async () => {
+      const mockGetUser = vi.fn().mockResolvedValue({ data: { user: null } });
+      mockSupabase.auth.getUser = mockGetUser;
+
+      vi.resetModules();
+      const { useSessionTracking } = await import('../sessionTracking');
+      trackingFunctions = useSessionTracking(mockSupabase, 'test-app');
+
+      await trackingFunctions.trackLogout();
+
+      expect(consoleSpy.warn).toHaveBeenCalledWith('No authenticated user found for session tracking');
+    });
+
+    it('should handle tracking error', async () => {
+      const mockUser = { id: 'user-123', email: 'test@example.com' };
+      const mockGetUser = vi.fn().mockResolvedValue({ data: { user: mockUser } });
+      const mockRpc = vi.fn().mockResolvedValue({ error: { message: 'Database error' } });
+      
+      mockSupabase.auth.getUser = mockGetUser;
+      mockSupabase.rpc = mockRpc;
+
+      vi.resetModules();
+      const { useSessionTracking } = await import('../sessionTracking');
+      trackingFunctions = useSessionTracking(mockSupabase, 'test-app');
+
+      await trackingFunctions.trackLogout();
+
+      expect(consoleSpy.error).toHaveBeenCalledWith('Failed to track logout session:', { message: 'Database error' });
+    });
+
+    it('should handle unexpected errors', async () => {
+      const mockGetUser = vi.fn().mockRejectedValue(new Error('Auth error'));
+      mockSupabase.auth.getUser = mockGetUser;
+
+      vi.resetModules();
+      const { useSessionTracking } = await import('../sessionTracking');
+      trackingFunctions = useSessionTracking(mockSupabase, 'test-app');
+
+      await trackingFunctions.trackLogout();
+
+      expect(consoleSpy.error).toHaveBeenCalledWith('Failed to track logout:', expect.any(Error));
+    });
+  });
+
+  describe('trackSessionExpired', () => {
+    it('should track session expiration successfully', async () => {
+      const mockUser = { id: 'user-123', email: 'test@example.com' };
+      const mockGetUser = vi.fn().mockResolvedValue({ data: { user: mockUser } });
+      const mockRpc = vi.fn().mockResolvedValue({ error: null });
+      
+      mockSupabase.auth.getUser = mockGetUser;
+      mockSupabase.rpc = mockRpc;
+
+      vi.resetModules();
+      const { useSessionTracking } = await import('../sessionTracking');
+      trackingFunctions = useSessionTracking(mockSupabase, 'test-app');
+
+      await trackingFunctions.trackSessionExpired();
+
+      expect(mockRpc).toHaveBeenCalledWith('track_user_session', {
+        p_session_type: 'session_expired',
+        p_app_id: undefined
+      });
+      expect(consoleSpy.log).toHaveBeenCalledWith('Session expiration tracked successfully');
+    });
+
+    it('should handle no authenticated user', async () => {
+      const mockGetUser = vi.fn().mockResolvedValue({ data: { user: null } });
+      mockSupabase.auth.getUser = mockGetUser;
+
+      vi.resetModules();
+      const { useSessionTracking } = await import('../sessionTracking');
+      trackingFunctions = useSessionTracking(mockSupabase, 'test-app');
+
+      await trackingFunctions.trackSessionExpired();
+
+      expect(consoleSpy.warn).toHaveBeenCalledWith('No authenticated user found for session tracking');
+    });
+
+    it('should handle tracking error', async () => {
+      const mockUser = { id: 'user-123', email: 'test@example.com' };
+      const mockGetUser = vi.fn().mockResolvedValue({ data: { user: mockUser } });
+      const mockRpc = vi.fn().mockResolvedValue({ error: { message: 'Database error' } });
+      
+      mockSupabase.auth.getUser = mockGetUser;
+      mockSupabase.rpc = mockRpc;
+
+      vi.resetModules();
+      const { useSessionTracking } = await import('../sessionTracking');
+      trackingFunctions = useSessionTracking(mockSupabase, 'test-app');
+
+      await trackingFunctions.trackSessionExpired();
+
+      expect(consoleSpy.error).toHaveBeenCalledWith('Failed to track session expiration:', { message: 'Database error' });
+    });
+
+    it('should handle unexpected errors', async () => {
+      const mockGetUser = vi.fn().mockRejectedValue(new Error('Auth error'));
+      mockSupabase.auth.getUser = mockGetUser;
+
+      vi.resetModules();
+      const { useSessionTracking } = await import('../sessionTracking');
+      trackingFunctions = useSessionTracking(mockSupabase, 'test-app');
+
+      await trackingFunctions.trackSessionExpired();
+
+      expect(consoleSpy.error).toHaveBeenCalledWith('Failed to track session expiration:', expect.any(Error));
+    });
+  });
+
+  describe('useSessionTracking without app name', () => {
+    it('should work without app name parameter', async () => {
+      vi.resetModules();
+      const { useSessionTracking } = await import('../sessionTracking');
+      const trackingWithoutApp = useSessionTracking(mockSupabase);
+      
+      expect(trackingWithoutApp).toHaveProperty('trackLogin');
+      expect(trackingWithoutApp).toHaveProperty('trackEventSwitch');
+      expect(trackingWithoutApp).toHaveProperty('trackLogout');
+      expect(trackingWithoutApp).toHaveProperty('trackSessionExpired');
+    });
+
+    it('should pass undefined app name to tracking calls', async () => {
+      const mockUser = { id: 'user-123', email: 'test@example.com' };
+      const mockGetUser = vi.fn().mockResolvedValue({ data: { user: mockUser } });
+      const mockRpc = vi.fn().mockResolvedValue({ error: null });
+      
+      mockSupabase.auth.getUser = mockGetUser;
+      mockSupabase.rpc = mockRpc;
+
+      vi.resetModules();
+      const { useSessionTracking } = await import('../sessionTracking');
+      const trackingWithoutApp = useSessionTracking(mockSupabase);
+
+      await trackingWithoutApp.trackLogin();
+
+      expect(mockRpc).toHaveBeenCalledWith('track_user_session', {
+        p_session_type: 'login',
+        p_event_id: undefined,
+        p_app_name: undefined
+      });
+    });
+  });
+}); 

package/src/utils/__tests__/validation.unit.test.ts

@@ -0,0 +1,84 @@
+
+import { describe, it, expect } from 'vitest';
+import {
+  isValidEmail,
+  isEmpty,
+  isStrongPassword,
+  isValidUrl,
+  isValidDate,
+  isWithinRange,
+  matchesPattern
+} from '../validation';
+
+describe('validation utilities', () => {
+  describe('isValidEmail', () => {
+    it('validates correct emails', () => {
+      expect(isValidEmail('test@example.com')).toBe(true);
+      expect(isValidEmail('user.name+tag@domain.co')).toBe(true);
+    });
+    it('invalidates incorrect emails', () => {
+      expect(isValidEmail('not-an-email')).toBe(false);
+      expect(isValidEmail('user@.com')).toBe(false);
+    });
+  });
+
+  describe('isEmpty', () => {
+    it('returns true for null, undefined, or whitespace', () => {
+      expect(isEmpty(null)).toBe(true);
+      expect(isEmpty(undefined)).toBe(true);
+      expect(isEmpty('   ')).toBe(true);
+    });
+    it('returns false for non-empty strings', () => {
+      expect(isEmpty('hello')).toBe(false);
+    });
+  });
+
+  describe('isStrongPassword', () => {
+    it('validates strong passwords', () => {
+      expect(isStrongPassword('Abcdefg1')).toBe(true);
+    });
+    it('invalidates weak passwords', () => {
+      expect(isStrongPassword('abcdefg')).toBe(false);
+      expect(isStrongPassword('ABCDEFG1')).toBe(false);
+      expect(isStrongPassword('abc1')).toBe(false);
+    });
+  });
+
+  describe('isValidUrl', () => {
+    it('validates correct URLs', () => {
+      expect(isValidUrl('https://example.com')).toBe(true);
+      expect(isValidUrl('http://localhost:3000')).toBe(true);
+    });
+    it('invalidates incorrect URLs', () => {
+      expect(isValidUrl('not-a-url')).toBe(false);
+    });
+  });
+
+  describe('isValidDate', () => {
+    it('validates correct date strings', () => {
+      expect(isValidDate('2023-01-01')).toBe(true);
+    });
+    it('invalidates incorrect date strings', () => {
+      expect(isValidDate('not-a-date')).toBe(false);
+    });
+  });
+
+  describe('isWithinRange', () => {
+    it('returns true if value is within range', () => {
+      expect(isWithinRange(5, 1, 10)).toBe(true);
+    });
+    it('returns false if value is outside range', () => {
+      expect(isWithinRange(0, 1, 10)).toBe(false);
+      expect(isWithinRange(11, 1, 10)).toBe(false);
+    });
+  });
+
+  describe('matchesPattern', () => {
+    it('returns true if value matches pattern', () => {
+      expect(matchesPattern('abc123', /^[a-z]+\d+$/)).toBe(true);
+    });
+    it('returns false if value does not match pattern', () => {
+      expect(matchesPattern('123abc', /^[a-z]+\d+$/)).toBe(false);
+    });
+  });
+});