@energica-city/shared-amplify-utils
Version:
Shared utilities for AWS Amplify projects
304 lines • 46.9 kB
JavaScript
"use strict";
// @ts-nocheck
const mockLogger = {
log: vi.fn(),
error: vi.fn(),
info: vi.fn(),
warn: vi.fn(),
};
vi.mock('../log', () => ({
logger: mockLogger,
}));
vi.mock('@log', () => ({
logger: mockLogger,
}));
describe('Error Utility', () => {
beforeEach(() => {
vi.clearAllMocks();
vi.resetModules();
});
afterEach(() => {
vi.clearAllMocks();
vi.resetModules();
});
describe('throwError', () => {
it('should throw error with simple message', async () => {
const { throwError } = await import('./error');
expect(() => throwError('Simple error message')).toThrow('Simple error message');
expect(mockLogger.error).toHaveBeenCalledWith('Simple error message', {
errorType: 'undefined',
stack: expect.any(String),
});
});
it('should throw error with message and Error object', async () => {
const { throwError } = await import('./error');
const originalError = new Error('Database connection failed');
expect(() => throwError('User creation failed', originalError)).toThrow('User creation failed: Database connection failed');
expect(mockLogger.error).toHaveBeenCalledWith('User creation failed: Database connection failed', {
originalError: {
name: 'Error',
message: 'Database connection failed',
stack: expect.any(String),
},
errorType: 'object',
stack: expect.any(String),
});
});
it('should throw error with message and string error', async () => {
const { throwError } = await import('./error');
expect(() => throwError('Operation failed', 'Network timeout')).toThrow('Operation failed: Network timeout');
expect(mockLogger.error).toHaveBeenCalledWith('Operation failed: Network timeout', {
originalError: 'Network timeout',
errorType: 'string',
stack: expect.any(String),
});
});
it('should throw error with message and context object', async () => {
const { throwError } = await import('./error');
const context = {
userId: '123',
operation: 'create',
additionalInfo: 'test',
};
expect(() => throwError('Context error', context)).toThrow('Context error');
expect(mockLogger.error).toHaveBeenCalledWith('Context error', {
userId: '123',
operation: 'create',
additionalInfo: 'test',
errorType: 'object',
stack: expect.any(String),
});
});
it('should throw error with message and primitive value', async () => {
const { throwError } = await import('./error');
expect(() => throwError('Number error', 404)).toThrow('Number error: 404');
expect(mockLogger.error).toHaveBeenCalledWith('Number error: 404', {
originalError: 404,
errorType: 'number',
stack: expect.any(String),
});
});
it('should throw error with Error object only', async () => {
const { throwError } = await import('./error');
const error = new Error('Direct error');
expect(() => throwError(error)).toThrow('Direct error');
expect(mockLogger.error).toHaveBeenCalledWith('Direct error', {
originalError: {
name: 'Error',
message: 'Direct error',
stack: expect.any(String),
},
errorType: 'object',
stack: expect.any(String),
});
});
it('should throw error with array of errors', async () => {
const { throwError } = await import('./error');
const errors = [
new Error('First error'),
{ message: 'Second error' },
'Third error',
];
expect(() => throwError(errors)).toThrow('Multiple errors occurred: First error; Second error; Third error');
expect(mockLogger.error).toHaveBeenCalledWith('Multiple errors occurred: First error; Second error; Third error', {
errors,
errorType: 'object',
stack: expect.any(String),
});
});
it('should handle single error in array', async () => {
const { throwError } = await import('./error');
const errors = [new Error('Single error')];
expect(() => throwError(errors)).toThrow('Single error');
expect(mockLogger.error).toHaveBeenCalledWith('Single error', {
errors,
errorType: 'object',
stack: expect.any(String),
});
});
it('should handle empty array', async () => {
const { throwError } = await import('./error');
const errors = [];
expect(() => throwError(errors)).toThrow('Unknown error occurred');
expect(mockLogger.error).toHaveBeenCalledWith('Unknown error occurred', {
errors,
errorType: 'object',
stack: expect.any(String),
});
});
it('should handle unknown object with message property', async () => {
const { throwError } = await import('./error');
const unknownError = { message: 'Custom error', code: 500 };
expect(() => throwError(unknownError)).toThrow('Custom error');
expect(mockLogger.error).toHaveBeenCalledWith('Custom error', {
originalError: unknownError,
errorType: 'object',
stack: expect.any(String),
});
});
it('should handle unknown object without message property', async () => {
const { throwError } = await import('./error');
const unknownError = { code: 500, status: 'failed' };
expect(() => throwError(unknownError)).toThrow('Unexpected error: [object Object]');
expect(mockLogger.error).toHaveBeenCalledWith('Unexpected error: [object Object]', {
originalError: unknownError,
errorType: 'object',
stack: expect.any(String),
});
});
it('should preserve original stack trace when available', async () => {
const { throwError } = await import('./error');
const originalError = new Error('Original error');
originalError.stack = 'Original stack trace\n at someFunction';
try {
throwError('Wrapped error', originalError);
}
catch (error) {
expect(error.stack).toContain('Wrapped error: Original error');
expect(error.stack).toContain('Caused by: Original stack trace');
}
});
it('should handle null and undefined values', async () => {
const { throwError } = await import('./error');
expect(() => throwError('Null error', null)).toThrow('Null error: null');
expect(() => throwError('Undefined error', undefined)).toThrow('Undefined error');
});
});
describe('extractErrorMessage', () => {
it('should extract message from Error object', async () => {
const { extractErrorMessage } = await import('./error');
const error = new Error('Test error message');
const result = extractErrorMessage(error);
expect(result).toBe('Test error message');
});
it('should return string as-is', async () => {
const { extractErrorMessage } = await import('./error');
const result = extractErrorMessage('String error');
expect(result).toBe('String error');
});
it('should extract message from object with message property', async () => {
const { extractErrorMessage } = await import('./error');
const error = { message: 'Object error message', code: 404 };
const result = extractErrorMessage(error);
expect(result).toBe('Object error message');
});
it('should handle array of errors', async () => {
const { extractErrorMessage } = await import('./error');
const errors = [
new Error('First error'),
'Second error',
{ message: 'Third error' },
];
const result = extractErrorMessage(errors);
expect(result).toBe('First error; Second error; Third error');
});
it('should convert unknown types to string', async () => {
const { extractErrorMessage } = await import('./error');
expect(extractErrorMessage(404)).toBe('404');
expect(extractErrorMessage(true)).toBe('true');
expect(extractErrorMessage(null)).toBe('null');
expect(extractErrorMessage(undefined)).toBe('undefined');
});
it('should handle complex objects', async () => {
const { extractErrorMessage } = await import('./error');
const complexObject = { code: 500, details: { reason: 'timeout' } };
const result = extractErrorMessage(complexObject);
expect(result).toBe('[object Object]');
});
it('should handle empty array', async () => {
const { extractErrorMessage } = await import('./error');
const result = extractErrorMessage([]);
expect(result).toBe('');
});
it('should handle nested arrays', async () => {
const { extractErrorMessage } = await import('./error');
const nestedErrors = [
'Error 1',
['Nested error 1', 'Nested error 2'],
new Error('Error 2'),
];
const result = extractErrorMessage(nestedErrors);
expect(result).toBe('Error 1; Nested error 1; Nested error 2; Error 2');
});
});
describe('createErrorContext', () => {
it('should create error context object', async () => {
const { createErrorContext } = await import('./error');
const context = {
userId: '123',
operation: 'create',
endpoint: '/api/users',
};
const result = createErrorContext(context);
expect(result).toEqual({
userId: '123',
operation: 'create',
endpoint: '/api/users',
});
});
it('should handle empty context', async () => {
const { createErrorContext } = await import('./error');
const result = createErrorContext({});
expect(result).toEqual({});
});
it('should handle various data types in context', async () => {
const { createErrorContext } = await import('./error');
const context = {
stringValue: 'test',
numberValue: 42,
booleanValue: true,
arrayValue: [1, 2, 3],
objectValue: { nested: 'value' },
nullValue: null,
undefinedValue: undefined,
};
const result = createErrorContext(context);
expect(result).toEqual({
stringValue: 'test',
numberValue: 42,
booleanValue: true,
arrayValue: [1, 2, 3],
objectValue: { nested: 'value' },
nullValue: null,
});
});
});
describe('integration tests', () => {
it('should work with typical QueryFactory error pattern', async () => {
const { throwError } = await import('./error');
const dbError = new Error('Connection timeout');
expect(() => throwError('User could not be created', dbError)).toThrow('User could not be created: Connection timeout');
expect(mockLogger.error).toHaveBeenCalledWith('User could not be created: Connection timeout', expect.objectContaining({
originalError: expect.objectContaining({
name: 'Error',
message: 'Connection timeout',
}),
errorType: 'object',
stack: expect.any(String),
}));
});
it('should work with GraphQL errors array pattern', async () => {
const { throwError } = await import('./error');
const graphqlErrors = [
{ message: 'Field validation failed' },
{ message: 'Permission denied' },
];
expect(() => throwError(graphqlErrors)).toThrow('Multiple errors occurred: Field validation failed; Permission denied');
});
it('should work with context-based error pattern', async () => {
const { throwError, createErrorContext } = await import('./error');
const context = createErrorContext({
userId: 'user-123',
operation: 'delete',
resource: 'Calendar',
});
expect(() => throwError('Resource deletion failed', context)).toThrow('Resource deletion failed');
expect(mockLogger.error).toHaveBeenCalledWith('Resource deletion failed', expect.objectContaining({
userId: 'user-123',
operation: 'delete',
resource: 'Calendar',
}));
});
});
});
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"error.test.js","sourceRoot":"","sources":["../../error/error.test.ts"],"names":[],"mappings":"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","sourcesContent":["// @ts-nocheck\nconst mockLogger = {\n  log: vi.fn(),\n  error: vi.fn(),\n  info: vi.fn(),\n  warn: vi.fn(),\n};\n\nvi.mock('../log', () => ({\n  logger: mockLogger,\n}));\n\nvi.mock('@log', () => ({\n  logger: mockLogger,\n}));\n\ndescribe('Error Utility', () => {\n  beforeEach(() => {\n    vi.clearAllMocks();\n    vi.resetModules();\n  });\n\n  afterEach(() => {\n    vi.clearAllMocks();\n    vi.resetModules();\n  });\n\n  describe('throwError', () => {\n    it('should throw error with simple message', async () => {\n      const { throwError } = await import('./error');\n\n      expect(() => throwError('Simple error message')).toThrow(\n        'Simple error message',\n      );\n      expect(mockLogger.error).toHaveBeenCalledWith('Simple error message', {\n        errorType: 'undefined',\n        stack: expect.any(String),\n      });\n    });\n\n    it('should throw error with message and Error object', async () => {\n      const { throwError } = await import('./error');\n      const originalError = new Error('Database connection failed');\n\n      expect(() => throwError('User creation failed', originalError)).toThrow(\n        'User creation failed: Database connection failed',\n      );\n\n      expect(mockLogger.error).toHaveBeenCalledWith(\n        'User creation failed: Database connection failed',\n        {\n          originalError: {\n            name: 'Error',\n            message: 'Database connection failed',\n            stack: expect.any(String),\n          },\n          errorType: 'object',\n          stack: expect.any(String),\n        },\n      );\n    });\n\n    it('should throw error with message and string error', async () => {\n      const { throwError } = await import('./error');\n\n      expect(() => throwError('Operation failed', 'Network timeout')).toThrow(\n        'Operation failed: Network timeout',\n      );\n\n      expect(mockLogger.error).toHaveBeenCalledWith(\n        'Operation failed: Network timeout',\n        {\n          originalError: 'Network timeout',\n          errorType: 'string',\n          stack: expect.any(String),\n        },\n      );\n    });\n\n    it('should throw error with message and context object', async () => {\n      const { throwError } = await import('./error');\n      const context = {\n        userId: '123',\n        operation: 'create',\n        additionalInfo: 'test',\n      };\n\n      expect(() => throwError('Context error', context)).toThrow(\n        'Context error',\n      );\n\n      expect(mockLogger.error).toHaveBeenCalledWith('Context error', {\n        userId: '123',\n        operation: 'create',\n        additionalInfo: 'test',\n        errorType: 'object',\n        stack: expect.any(String),\n      });\n    });\n\n    it('should throw error with message and primitive value', async () => {\n      const { throwError } = await import('./error');\n\n      expect(() => throwError('Number error', 404)).toThrow(\n        'Number error: 404',\n      );\n\n      expect(mockLogger.error).toHaveBeenCalledWith('Number error: 404', {\n        originalError: 404,\n        errorType: 'number',\n        stack: expect.any(String),\n      });\n    });\n\n    it('should throw error with Error object only', async () => {\n      const { throwError } = await import('./error');\n      const error = new Error('Direct error');\n\n      expect(() => throwError(error)).toThrow('Direct error');\n\n      expect(mockLogger.error).toHaveBeenCalledWith('Direct error', {\n        originalError: {\n          name: 'Error',\n          message: 'Direct error',\n          stack: expect.any(String),\n        },\n        errorType: 'object',\n        stack: expect.any(String),\n      });\n    });\n\n    it('should throw error with array of errors', async () => {\n      const { throwError } = await import('./error');\n      const errors = [\n        new Error('First error'),\n        { message: 'Second error' },\n        'Third error',\n      ];\n\n      expect(() => throwError(errors)).toThrow(\n        'Multiple errors occurred: First error; Second error; Third error',\n      );\n\n      expect(mockLogger.error).toHaveBeenCalledWith(\n        'Multiple errors occurred: First error; Second error; Third error',\n        {\n          errors,\n          errorType: 'object',\n          stack: expect.any(String),\n        },\n      );\n    });\n\n    it('should handle single error in array', async () => {\n      const { throwError } = await import('./error');\n      const errors = [new Error('Single error')];\n\n      expect(() => throwError(errors)).toThrow('Single error');\n\n      expect(mockLogger.error).toHaveBeenCalledWith('Single error', {\n        errors,\n        errorType: 'object',\n        stack: expect.any(String),\n      });\n    });\n\n    it('should handle empty array', async () => {\n      const { throwError } = await import('./error');\n      const errors = [];\n\n      expect(() => throwError(errors)).toThrow('Unknown error occurred');\n\n      expect(mockLogger.error).toHaveBeenCalledWith('Unknown error occurred', {\n        errors,\n        errorType: 'object',\n        stack: expect.any(String),\n      });\n    });\n\n    it('should handle unknown object with message property', async () => {\n      const { throwError } = await import('./error');\n      const unknownError = { message: 'Custom error', code: 500 };\n\n      expect(() => throwError(unknownError)).toThrow('Custom error');\n\n      expect(mockLogger.error).toHaveBeenCalledWith('Custom error', {\n        originalError: unknownError,\n        errorType: 'object',\n        stack: expect.any(String),\n      });\n    });\n\n    it('should handle unknown object without message property', async () => {\n      const { throwError } = await import('./error');\n      const unknownError = { code: 500, status: 'failed' };\n\n      expect(() => throwError(unknownError)).toThrow(\n        'Unexpected error: [object Object]',\n      );\n\n      expect(mockLogger.error).toHaveBeenCalledWith(\n        'Unexpected error: [object Object]',\n        {\n          originalError: unknownError,\n          errorType: 'object',\n          stack: expect.any(String),\n        },\n      );\n    });\n\n    it('should preserve original stack trace when available', async () => {\n      const { throwError } = await import('./error');\n      const originalError = new Error('Original error');\n      originalError.stack = 'Original stack trace\\n  at someFunction';\n\n      try {\n        throwError('Wrapped error', originalError);\n      } catch (error) {\n        expect(error.stack).toContain('Wrapped error: Original error');\n        expect(error.stack).toContain('Caused by: Original stack trace');\n      }\n    });\n\n    it('should handle null and undefined values', async () => {\n      const { throwError } = await import('./error');\n\n      expect(() => throwError('Null error', null)).toThrow('Null error: null');\n\n      expect(() => throwError('Undefined error', undefined)).toThrow(\n        'Undefined error',\n      );\n    });\n  });\n\n  describe('extractErrorMessage', () => {\n    it('should extract message from Error object', async () => {\n      const { extractErrorMessage } = await import('./error');\n      const error = new Error('Test error message');\n\n      const result = extractErrorMessage(error);\n\n      expect(result).toBe('Test error message');\n    });\n\n    it('should return string as-is', async () => {\n      const { extractErrorMessage } = await import('./error');\n\n      const result = extractErrorMessage('String error');\n\n      expect(result).toBe('String error');\n    });\n\n    it('should extract message from object with message property', async () => {\n      const { extractErrorMessage } = await import('./error');\n      const error = { message: 'Object error message', code: 404 };\n\n      const result = extractErrorMessage(error);\n\n      expect(result).toBe('Object error message');\n    });\n\n    it('should handle array of errors', async () => {\n      const { extractErrorMessage } = await import('./error');\n      const errors = [\n        new Error('First error'),\n        'Second error',\n        { message: 'Third error' },\n      ];\n\n      const result = extractErrorMessage(errors);\n\n      expect(result).toBe('First error; Second error; Third error');\n    });\n\n    it('should convert unknown types to string', async () => {\n      const { extractErrorMessage } = await import('./error');\n\n      expect(extractErrorMessage(404)).toBe('404');\n      expect(extractErrorMessage(true)).toBe('true');\n      expect(extractErrorMessage(null)).toBe('null');\n      expect(extractErrorMessage(undefined)).toBe('undefined');\n    });\n\n    it('should handle complex objects', async () => {\n      const { extractErrorMessage } = await import('./error');\n      const complexObject = { code: 500, details: { reason: 'timeout' } };\n\n      const result = extractErrorMessage(complexObject);\n\n      expect(result).toBe('[object Object]');\n    });\n\n    it('should handle empty array', async () => {\n      const { extractErrorMessage } = await import('./error');\n\n      const result = extractErrorMessage([]);\n\n      expect(result).toBe('');\n    });\n\n    it('should handle nested arrays', async () => {\n      const { extractErrorMessage } = await import('./error');\n      const nestedErrors = [\n        'Error 1',\n        ['Nested error 1', 'Nested error 2'],\n        new Error('Error 2'),\n      ];\n\n      const result = extractErrorMessage(nestedErrors);\n\n      expect(result).toBe('Error 1; Nested error 1; Nested error 2; Error 2');\n    });\n  });\n\n  describe('createErrorContext', () => {\n    it('should create error context object', async () => {\n      const { createErrorContext } = await import('./error');\n      const context = {\n        userId: '123',\n        operation: 'create',\n        endpoint: '/api/users',\n      };\n\n      const result = createErrorContext(context);\n\n      expect(result).toEqual({\n        userId: '123',\n        operation: 'create',\n        endpoint: '/api/users',\n      });\n    });\n\n    it('should handle empty context', async () => {\n      const { createErrorContext } = await import('./error');\n\n      const result = createErrorContext({});\n\n      expect(result).toEqual({});\n    });\n\n    it('should handle various data types in context', async () => {\n      const { createErrorContext } = await import('./error');\n      const context = {\n        stringValue: 'test',\n        numberValue: 42,\n        booleanValue: true,\n        arrayValue: [1, 2, 3],\n        objectValue: { nested: 'value' },\n        nullValue: null,\n        undefinedValue: undefined,\n      };\n\n      const result = createErrorContext(context);\n\n      expect(result).toEqual({\n        stringValue: 'test',\n        numberValue: 42,\n        booleanValue: true,\n        arrayValue: [1, 2, 3],\n        objectValue: { nested: 'value' },\n        nullValue: null,\n      });\n    });\n  });\n\n  describe('integration tests', () => {\n    it('should work with typical QueryFactory error pattern', async () => {\n      const { throwError } = await import('./error');\n      const dbError = new Error('Connection timeout');\n\n      expect(() => throwError('User could not be created', dbError)).toThrow(\n        'User could not be created: Connection timeout',\n      );\n\n      expect(mockLogger.error).toHaveBeenCalledWith(\n        'User could not be created: Connection timeout',\n        expect.objectContaining({\n          originalError: expect.objectContaining({\n            name: 'Error',\n            message: 'Connection timeout',\n          }),\n          errorType: 'object',\n          stack: expect.any(String),\n        }),\n      );\n    });\n\n    it('should work with GraphQL errors array pattern', async () => {\n      const { throwError } = await import('./error');\n      const graphqlErrors = [\n        { message: 'Field validation failed' },\n        { message: 'Permission denied' },\n      ];\n\n      expect(() => throwError(graphqlErrors)).toThrow(\n        'Multiple errors occurred: Field validation failed; Permission denied',\n      );\n    });\n\n    it('should work with context-based error pattern', async () => {\n      const { throwError, createErrorContext } = await import('./error');\n      const context = createErrorContext({\n        userId: 'user-123',\n        operation: 'delete',\n        resource: 'Calendar',\n      });\n\n      expect(() => throwError('Resource deletion failed', context)).toThrow(\n        'Resource deletion failed',\n      );\n\n      expect(mockLogger.error).toHaveBeenCalledWith(\n        'Resource deletion failed',\n        expect.objectContaining({\n          userId: 'user-123',\n          operation: 'delete',\n          resource: 'Calendar',\n        }),\n      );\n    });\n  });\n});\n"]}