@jmruthers/pace-core 0.2.7 → 0.5.1

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

@@ -1,334 +0,0 @@
-/**
- * @file Secure Data Access Unit Tests
- * @package @jmruthers/pace-core
- * @module Utils/SecureDataAccess
- * @since 0.4.0
- */
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { createSecureDataAccess } from '../secureDataAccess';
-import type { SupabaseClient } from '@supabase/supabase-js';
-import { testDataGenerators } from '../../__tests__/shared';
-
-// Create a proper mock for Supabase query chain
-const createMockQuery = (returnData: any = null, returnError: any = null) => {
-  const mockQuery = {
-    select: vi.fn(() => mockQuery),
-    eq: vi.fn(() => mockQuery),
-    ne: vi.fn(() => mockQuery),
-    gt: vi.fn(() => mockQuery),
-    gte: vi.fn(() => mockQuery),
-    lt: vi.fn(() => mockQuery),
-    lte: vi.fn(() => mockQuery),
-    like: vi.fn(() => mockQuery),
-    ilike: vi.fn(() => mockQuery),
-    in: vi.fn(() => mockQuery),
-    not: vi.fn(() => mockQuery),
-    or: vi.fn(() => mockQuery),
-    and: vi.fn(() => mockQuery),
-    order: vi.fn(() => mockQuery),
-    limit: vi.fn(() => mockQuery),
-    offset: vi.fn(() => mockQuery),
-    single: vi.fn(() => mockQuery),
-    maybeSingle: vi.fn(() => mockQuery),
-    insert: vi.fn(() => mockQuery),
-    update: vi.fn(() => mockQuery),
-    delete: vi.fn(() => mockQuery),
-    then: vi.fn((callback: any) => Promise.resolve(callback({ data: returnData, error: returnError })))
-  };
-  return mockQuery;
-};
-
-// Mock Supabase client
-const mockSupabaseClient = {
-  from: vi.fn(() => createMockQuery())
-} as any;
-
-describe('Secure Data Access', () => {
-  let secureDataAccess: ReturnType<typeof createSecureDataAccess>;
-  const organisationId = 'org-123';
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    secureDataAccess = createSecureDataAccess(mockSupabaseClient, organisationId);
-  });
-
-  describe('createSecureDataAccess', () => {
-    it('should create secure data access instance', () => {
-      expect(secureDataAccess).toBeDefined();
-      expect(secureDataAccess.secureQuery).toBeDefined();
-      expect(secureDataAccess.secureSingleQuery).toBeDefined();
-      expect(secureDataAccess.secureInsert).toBeDefined();
-      expect(secureDataAccess.secureUpdate).toBeDefined();
-      expect(secureDataAccess.secureDelete).toBeDefined();
-    });
-
-    it('should create instance with super admin privileges', () => {
-      const superAdminAccess = createSecureDataAccess(mockSupabaseClient, organisationId, true);
-      expect(superAdminAccess).toBeDefined();
-    });
-  });
-
-  describe('validateOrganisationContext', () => {
-    it('should throw error for empty organisation ID', () => {
-      expect(() => {
-        secureDataAccess.validateOrganisationContext('');
-      }).toThrow('Organisation context is required for secure data access');
-    });
-
-    it('should throw error for null organisation ID', () => {
-      expect(() => {
-        secureDataAccess.validateOrganisationContext(null as any);
-      }).toThrow('Organisation context is required for secure data access');
-    });
-
-    it('should not throw error for valid organisation ID', () => {
-      expect(() => {
-        secureDataAccess.validateOrganisationContext('valid-org-id');
-      }).not.toThrow();
-    });
-
-    it('should throw error for non-super admin without organisation context', () => {
-      const nonSuperAdminAccess = createSecureDataAccess(mockSupabaseClient, '', false);
-      expect(() => {
-        nonSuperAdminAccess.validateOrganisationContext('');
-      }).toThrow('Organisation context is required for secure data access');
-    });
-  });
-
-  describe('secureQuery', () => {
-    it('should execute secure query with organisation filter', async () => {
-      const mockData = testDataGenerators.createUsers(1, { id: 1, name: 'Test', organisation_id: organisationId });
-      const mockQuery = createMockQuery(mockData);
-      mockSupabaseClient.from = vi.fn(() => mockQuery);
-
-      const options = {
-        table: 'event', // Use a table that has organisation_id
-        select: '*',
-        organisationId: organisationId,
-        filters: { name: 'Test' }
-      };
-
-      const result = await secureDataAccess.secureQuery(options);
-
-      expect(mockSupabaseClient.from).toHaveBeenCalledWith('event');
-      expect(mockQuery.select).toHaveBeenCalledWith('*');
-      expect(mockQuery.eq).toHaveBeenCalledWith('organisation_id', organisationId);
-      expect(mockQuery.eq).toHaveBeenCalledWith('name', 'Test');
-    });
-
-    it('should handle query errors gracefully', async () => {
-      const mockError = { message: 'Database error' };
-      const mockQuery = createMockQuery(null, mockError);
-      mockSupabaseClient.from = vi.fn(() => mockQuery);
-
-      const options = {
-        table: 'users',
-        select: '*',
-        organisationId: organisationId
-      };
-
-      await expect(secureDataAccess.secureQuery(options)).rejects.toThrow();
-    });
-  });
-
-  describe('secureSingleQuery', () => {
-    it('should execute single secure query', async () => {
-      const mockData = { id: 1, name: 'Test', organisation_id: organisationId };
-      const mockQuery = createMockQuery(mockData);
-      mockSupabaseClient.from = vi.fn(() => mockQuery);
-
-      const options = {
-        table: 'event', // Use a table that has organisation_id
-        select: '*',
-        organisationId: organisationId,
-        filters: { id: 1 }
-      };
-
-      const result = await secureDataAccess.secureSingleQuery(options);
-
-      expect(mockSupabaseClient.from).toHaveBeenCalledWith('event');
-      expect(mockQuery.single).toHaveBeenCalled();
-    });
-
-    it('should return null for no results', async () => {
-      const mockQuery = createMockQuery(null);
-      mockSupabaseClient.from = vi.fn(() => mockQuery);
-
-      const options = {
-        table: 'users',
-        select: '*',
-        organisationId: organisationId,
-        filters: { id: 999 }
-      };
-
-      const result = await secureDataAccess.secureSingleQuery(options);
-
-      expect(result).toBeNull();
-    });
-  });
-
-  describe('secureInsert', () => {
-    it('should insert data with organisation context', async () => {
-      const mockData = { id: 1, name: 'New User', organisation_id: organisationId };
-      const mockQuery = createMockQuery(mockData);
-      mockSupabaseClient.from = vi.fn(() => mockQuery);
-
-      const insertData = { name: 'New User' };
-
-      const result = await secureDataAccess.secureInsert('users', insertData, organisationId);
-
-      expect(mockSupabaseClient.from).toHaveBeenCalledWith('users');
-      expect(mockQuery.insert).toHaveBeenCalledWith({
-        ...insertData,
-        organisation_id: organisationId
-      });
-      expect(mockQuery.select).toHaveBeenCalled();
-      expect(mockQuery.single).toHaveBeenCalled();
-    });
-
-    it('should handle insert errors gracefully', async () => {
-      const mockError = { message: 'Insert failed' };
-      const mockQuery = createMockQuery(null, mockError);
-      mockSupabaseClient.from = vi.fn(() => mockQuery);
-
-      const insertData = { name: 'New User' };
-
-      await expect(secureDataAccess.secureInsert('users', insertData, organisationId)).rejects.toThrow();
-    });
-  });
-
-  describe('secureUpdate', () => {
-    it('should update data with organisation context', async () => {
-      const mockData = { id: 1, name: 'Updated User', organisation_id: organisationId };
-      const mockQuery = createMockQuery(mockData);
-      mockSupabaseClient.from = vi.fn(() => mockQuery);
-
-      const updateData = { name: 'Updated User' };
-      const filters = { id: 1 };
-
-      const result = await secureDataAccess.secureUpdate('users', updateData, filters, organisationId);
-
-      expect(mockSupabaseClient.from).toHaveBeenCalledWith('users');
-      expect(mockQuery.update).toHaveBeenCalledWith(updateData);
-      expect(mockQuery.eq).toHaveBeenCalledWith('id', 1);
-    });
-
-    it('should handle update errors gracefully', async () => {
-      const mockError = { message: 'Update failed' };
-      const mockQuery = createMockQuery(null, mockError);
-      mockSupabaseClient.from = vi.fn(() => mockQuery);
-
-      const updateData = { name: 'Updated User' };
-      const filters = { id: 1 };
-
-      await expect(secureDataAccess.secureUpdate('users', updateData, filters, organisationId)).rejects.toThrow();
-    });
-  });
-
-  describe('secureDelete', () => {
-    it('should delete data with organisation context', async () => {
-      const mockQuery = createMockQuery({ count: 1 });
-      mockSupabaseClient.from = vi.fn(() => mockQuery);
-
-      const filters = { id: 1 };
-
-      const result = await secureDataAccess.secureDelete('users', filters, organisationId);
-
-      expect(mockSupabaseClient.from).toHaveBeenCalledWith('users');
-      expect(mockQuery.delete).toHaveBeenCalled();
-      expect(mockQuery.eq).toHaveBeenCalledWith('id', 1);
-    });
-
-    it('should return true for successful deletion', async () => {
-      const mockQuery = createMockQuery({ count: 1 });
-      mockSupabaseClient.from = vi.fn(() => mockQuery);
-
-      const filters = { id: 1 };
-
-      const result = await secureDataAccess.secureDelete('users', filters, organisationId);
-
-      expect(result).toBe(true);
-    });
-
-    it('should return false for failed deletion', async () => {
-      const mockError = { message: 'Delete failed' };
-      const mockQuery = createMockQuery(null, mockError);
-      mockSupabaseClient.from = vi.fn(() => mockQuery);
-
-      const filters = { id: 1 };
-
-      await expect(secureDataAccess.secureDelete('users', filters, organisationId)).rejects.toThrow();
-    });
-  });
-
-  describe('queryByOrganisation', () => {
-    it('should query data by organisation', async () => {
-      const mockData = testDataGenerators.createUsers(1, { id: 1, name: 'Test', organisation_id: organisationId });
-      const mockQuery = createMockQuery(mockData);
-      mockSupabaseClient.from = vi.fn(() => mockQuery);
-
-      const result = await secureDataAccess.queryByOrganisation('users', '*', organisationId, { name: 'Test' });
-
-      expect(mockSupabaseClient.from).toHaveBeenCalledWith('users');
-      expect(mockQuery.eq).toHaveBeenCalledWith('name', 'Test');
-    });
-
-    it('should query without additional filters', async () => {
-      const mockData = testDataGenerators.createUsers(1, { id: 1, name: 'Test', organisation_id: organisationId });
-      const mockQuery = createMockQuery(mockData);
-      mockSupabaseClient.from = vi.fn(() => mockQuery);
-
-      const result = await secureDataAccess.queryByOrganisation('users', '*', organisationId);
-
-      expect(mockSupabaseClient.from).toHaveBeenCalledWith('users');
-    });
-  });
-
-  describe('Edge Cases', () => {
-    it('should handle undefined filters gracefully', async () => {
-      const mockData = testDataGenerators.createUsers(1, { id: 1, name: 'Test', organisation_id: organisationId });
-      const mockQuery = createMockQuery(mockData);
-      mockSupabaseClient.from = vi.fn(() => mockQuery);
-
-      const options = {
-        table: 'users',
-        select: '*',
-        organisationId: organisationId,
-        filters: undefined
-      };
-
-      await expect(secureDataAccess.secureQuery(options)).resolves.toBeDefined();
-    });
-
-    it('should handle null filters gracefully', async () => {
-      const mockData = testDataGenerators.createUsers(1, { id: 1, name: 'Test', organisation_id: organisationId });
-      const mockQuery = createMockQuery(mockData);
-      mockSupabaseClient.from = vi.fn(() => mockQuery);
-
-      const options = {
-        table: 'users',
-        select: '*',
-        organisationId: organisationId,
-        filters: undefined
-      };
-
-      await expect(secureDataAccess.secureQuery(options)).resolves.toBeDefined();
-    });
-
-    it('should handle empty filters object', async () => {
-      const mockData = testDataGenerators.createUsers(1, { id: 1, name: 'Test', organisation_id: organisationId });
-      const mockQuery = createMockQuery(mockData);
-      mockSupabaseClient.from = vi.fn(() => mockQuery);
-
-      const options = {
-        table: 'users',
-        select: '*',
-        organisationId: organisationId,
-        filters: {}
-      };
-
-      await expect(secureDataAccess.secureQuery(options)).resolves.toBeDefined();
-    });
-  });
-}); 

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

@@ -1,377 +0,0 @@
-/**
- * @file Secure Errors Unit Tests
- * @package @jmruthers/pace-core
- * @module Utils/SecureErrors
- * @since 0.4.0
- */
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { 
-  SecureError, 
-  createSecureError, 
-  convertToAuthError, 
-  isSecureError, 
-  sanitizeError, 
-  generateRequestId, 
-  logSecurityEvent 
-} from '../secureErrors';
-import { AuthErrorCode } from '../../types/unified';
-
-describe('Secure Errors', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    vi.spyOn(console, 'warn').mockImplementation(() => {});
-  });
-
-  describe('SecureError', () => {
-    it('should create a SecureError with all properties', () => {
-      const error = new SecureError(
-        'Test error message',
-        AuthErrorCode.INVALID_CREDENTIALS,
-        400,
-        'User-friendly message'
-      );
-
-      expect(error.message).toBe('Test error message');
-      expect(error.code).toBe(AuthErrorCode.INVALID_CREDENTIALS);
-      expect(error.statusCode).toBe(400);
-      expect(error.userMessage).toBe('User-friendly message');
-      expect(error.name).toBe('SecureError');
-    });
-
-    it('should create a SecureError with default status code', () => {
-      const error = new SecureError(
-        'Test error message',
-        AuthErrorCode.INVALID_CREDENTIALS
-      );
-
-      expect(error.statusCode).toBe(500);
-    });
-
-    it('should create a SecureError with default user message', () => {
-      const error = new SecureError(
-        'Test error message',
-        AuthErrorCode.INVALID_CREDENTIALS
-      );
-
-      expect(error.userMessage).toBe('Test error message');
-    });
-
-    it('should be an instance of Error', () => {
-      const error = new SecureError(
-        'Test error message',
-        AuthErrorCode.INVALID_CREDENTIALS
-      );
-
-      expect(error).toBeInstanceOf(Error);
-      expect(error).toBeInstanceOf(SecureError);
-    });
-
-    it('should have correct stack trace', () => {
-      const error = new SecureError(
-        'Test error message',
-        AuthErrorCode.INVALID_CREDENTIALS
-      );
-
-      expect(error.stack).toBeDefined();
-      expect(typeof error.stack).toBe('string');
-    });
-  });
-
-  describe('createSecureError', () => {
-    it('should create a SecureError with all parameters', () => {
-      const error = createSecureError(
-        'Test error message',
-        AuthErrorCode.INVALID_CREDENTIALS,
-        400,
-        'User-friendly message'
-      );
-
-      expect(error).toBeInstanceOf(SecureError);
-      expect(error.message).toBe('Test error message');
-      expect(error.code).toBe(AuthErrorCode.INVALID_CREDENTIALS);
-      expect(error.statusCode).toBe(400);
-      expect(error.userMessage).toBe('User-friendly message');
-    });
-
-    it('should create a SecureError with default parameters', () => {
-      const error = createSecureError(
-        'Test error message',
-        AuthErrorCode.INVALID_CREDENTIALS
-      );
-
-      expect(error).toBeInstanceOf(SecureError);
-      expect(error.statusCode).toBe(500);
-      expect(error.userMessage).toBe('Test error message');
-    });
-
-    it('should create different SecureError instances', () => {
-      const error1 = createSecureError('Error 1', AuthErrorCode.INVALID_CREDENTIALS);
-      const error2 = createSecureError('Error 2', AuthErrorCode.WEAK_PASSWORD);
-
-      expect(error1).not.toBe(error2);
-      expect(error1.message).toBe('Error 1');
-      expect(error2.message).toBe('Error 2');
-    });
-  });
-
-  describe('convertToAuthError', () => {
-    it('should convert SecureError to AuthError', () => {
-      const secureError = new SecureError(
-        'Test error message',
-        AuthErrorCode.INVALID_CREDENTIALS,
-        400,
-        'User-friendly message'
-      );
-
-      const authError = convertToAuthError(secureError);
-
-      expect(authError.message).toBe('Test error message');
-      expect(authError.code).toBe(AuthErrorCode.INVALID_CREDENTIALS);
-      expect(authError.user_message).toBe('User-friendly message');
-      expect(authError.__isAuthError).toBe(true);
-      expect(authError.name).toBe('AuthError');
-      expect(authError.timestamp).toBeDefined();
-    });
-
-    it('should convert regular Error to AuthError', () => {
-      const regularError = new Error('Regular error message');
-
-      const authError = convertToAuthError(regularError);
-
-      expect(authError.message).toBe('Regular error message');
-      expect(authError.code).toBe(AuthErrorCode.UNKNOWN_ERROR);
-      expect(authError.user_message).toBe('Regular error message');
-      expect(authError.__isAuthError).toBe(true);
-      expect(authError.name).toBe('AuthError');
-      expect(authError.timestamp).toBeDefined();
-    });
-
-    it('should convert unknown error to AuthError', () => {
-      const unknownError = 'String error';
-
-      const authError = convertToAuthError(unknownError);
-
-      expect(authError.message).toBe('Unknown error occurred');
-      expect(authError.code).toBe(AuthErrorCode.UNKNOWN_ERROR);
-      expect(authError.user_message).toBe('Unknown error occurred');
-      expect(authError.__isAuthError).toBe(true);
-      expect(authError.name).toBe('AuthError');
-      expect(authError.timestamp).toBeDefined();
-    });
-
-    it('should convert null to AuthError', () => {
-      const authError = convertToAuthError(null);
-
-      expect(authError.message).toBe('Unknown error occurred');
-      expect(authError.code).toBe(AuthErrorCode.UNKNOWN_ERROR);
-      expect(authError.__isAuthError).toBe(true);
-    });
-
-    it('should convert undefined to AuthError', () => {
-      const authError = convertToAuthError(undefined);
-
-      expect(authError.message).toBe('Unknown error occurred');
-      expect(authError.code).toBe(AuthErrorCode.UNKNOWN_ERROR);
-      expect(authError.__isAuthError).toBe(true);
-    });
-
-    it('should preserve timestamp when converting', () => {
-      const secureError = new SecureError('Test', AuthErrorCode.INVALID_CREDENTIALS);
-      const authError = convertToAuthError(secureError);
-
-      expect(authError.timestamp).toBeGreaterThan(0);
-      expect(typeof authError.timestamp).toBe('number');
-    });
-  });
-
-  describe('isSecureError', () => {
-    it('should return true for SecureError instances', () => {
-      const secureError = new SecureError(
-        'Test error message',
-        AuthErrorCode.INVALID_CREDENTIALS
-      );
-
-      expect(isSecureError(secureError)).toBe(true);
-    });
-
-    it('should return false for regular Error instances', () => {
-      const regularError = new Error('Regular error message');
-
-      expect(isSecureError(regularError)).toBe(false);
-    });
-
-    it('should return false for non-error objects', () => {
-      expect(isSecureError('string')).toBe(false);
-      expect(isSecureError(123)).toBe(false);
-      expect(isSecureError({})).toBe(false);
-      expect(isSecureError(null)).toBe(false);
-      expect(isSecureError(undefined)).toBe(false);
-    });
-
-    it('should return false for objects with similar structure', () => {
-      const fakeError = {
-        message: 'Test',
-        code: AuthErrorCode.INVALID_CREDENTIALS,
-        statusCode: 400,
-        userMessage: 'Test'
-      };
-
-      expect(isSecureError(fakeError)).toBe(false);
-    });
-  });
-
-  describe('sanitizeError', () => {
-    it('should sanitize SecureError', () => {
-      const secureError = new SecureError(
-        'Test error message',
-        AuthErrorCode.INVALID_CREDENTIALS,
-        400,
-        'User-friendly message'
-      );
-
-      const sanitized = sanitizeError(secureError);
-
-      expect(sanitized).toBeInstanceOf(Object);
-      expect(sanitized.__isAuthError).toBe(true);
-      expect(sanitized.code).toBe(AuthErrorCode.INVALID_CREDENTIALS);
-    });
-
-    it('should sanitize regular Error', () => {
-      const regularError = new Error('Regular error message');
-
-      const sanitized = sanitizeError(regularError);
-
-      expect(sanitized).toBeInstanceOf(Object);
-      expect(sanitized.__isAuthError).toBe(true);
-      expect(sanitized.code).toBe(AuthErrorCode.UNKNOWN_ERROR);
-    });
-
-    it('should sanitize unknown error', () => {
-      const sanitized = sanitizeError('Unknown error');
-
-      expect(sanitized).toBeInstanceOf(Object);
-      expect(sanitized.__isAuthError).toBe(true);
-      expect(sanitized.code).toBe(AuthErrorCode.UNKNOWN_ERROR);
-    });
-  });
-
-  describe('generateRequestId', () => {
-    it('should generate a request ID with correct format', () => {
-      const requestId = generateRequestId();
-
-      expect(requestId).toMatch(/^req_\d+_[a-z0-9]{9}$/);
-    });
-
-    it('should generate unique request IDs', () => {
-      const requestId1 = generateRequestId();
-      const requestId2 = generateRequestId();
-
-      expect(requestId1).not.toBe(requestId2);
-    });
-
-    it('should generate request IDs with timestamp', () => {
-      const before = Date.now();
-      const requestId = generateRequestId();
-      const after = Date.now();
-
-      const timestamp = parseInt(requestId.split('_')[1]);
-      expect(timestamp).toBeGreaterThanOrEqual(before);
-      expect(timestamp).toBeLessThanOrEqual(after);
-    });
-
-    it('should generate request IDs with random suffix', () => {
-      const requestId = generateRequestId();
-      const parts = requestId.split('_');
-
-      expect(parts).toHaveLength(3);
-      expect(parts[0]).toBe('req');
-      expect(parts[2]).toHaveLength(9);
-      expect(parts[2]).toMatch(/^[a-z0-9]+$/);
-    });
-  });
-
-  describe('logSecurityEvent', () => {
-    it('should log security events', () => {
-      const consoleSpy = vi.spyOn(console, 'warn');
-
-      logSecurityEvent('Test security event');
-
-      expect(consoleSpy).toHaveBeenCalledWith(
-        '[SECURITY] Test security event',
-        undefined
-      );
-    });
-
-    it('should log security events with details', () => {
-      const consoleSpy = vi.spyOn(console, 'warn');
-      const details = { userId: 'user-123', action: 'login_attempt' };
-
-      logSecurityEvent('Test security event', details);
-
-      expect(consoleSpy).toHaveBeenCalledWith(
-        '[SECURITY] Test security event',
-        details
-      );
-    });
-
-    it('should handle multiple security events', () => {
-      const consoleSpy = vi.spyOn(console, 'warn');
-
-      logSecurityEvent('Event 1');
-      logSecurityEvent('Event 2', { detail: 'test' });
-
-      expect(consoleSpy).toHaveBeenCalledTimes(2);
-    });
-
-    it('should handle null and undefined details', () => {
-      const consoleSpy = vi.spyOn(console, 'warn');
-
-      logSecurityEvent('Event with null details', null);
-      logSecurityEvent('Event with undefined details', undefined);
-
-      expect(consoleSpy).toHaveBeenCalledTimes(2);
-      expect(consoleSpy).toHaveBeenCalledWith(
-        '[SECURITY] Event with null details',
-        null
-      );
-      expect(consoleSpy).toHaveBeenCalledWith(
-        '[SECURITY] Event with undefined details',
-        undefined
-      );
-    });
-  });
-
-  describe('Integration Tests', () => {
-    it('should handle error conversion chain', () => {
-      const secureError = new SecureError(
-        'Original error',
-        AuthErrorCode.INVALID_CREDENTIALS,
-        400,
-        'User message'
-      );
-
-      const authError = convertToAuthError(secureError);
-      const sanitized = sanitizeError(authError);
-
-      expect(isSecureError(secureError)).toBe(true);
-      expect(authError.__isAuthError).toBe(true);
-      expect(sanitized.__isAuthError).toBe(true);
-    });
-
-    it('should handle error creation and conversion', () => {
-      const error = createSecureError(
-        'Test error',
-        AuthErrorCode.WEAK_PASSWORD,
-        422,
-        'Password is too weak'
-      );
-
-      const converted = convertToAuthError(error);
-
-      expect(error).toBeInstanceOf(SecureError);
-      expect(converted.code).toBe(AuthErrorCode.WEAK_PASSWORD);
-      expect(converted.user_message).toBe('Password is too weak');
-    });
-  });
-});