@onlineapps/error-handler-core 1.0.0

package/tests/unit/ErrorClassifier.test.js

@@ -0,0 +1,82 @@
+/**
+ * ErrorClassifier Unit Tests
+ */
+
+const { ErrorClassifier, ErrorTypes } = require('../../src/ErrorClassifier');
+
+describe('ErrorClassifier @unit', () => {
+  let classifier;
+  
+  beforeEach(() => {
+    classifier = new ErrorClassifier();
+  });
+  
+  describe('classify', () => {
+    test('should classify ECONNREFUSED as TRANSIENT', () => {
+      const error = new Error('Connection refused');
+      error.code = 'ECONNREFUSED';
+      
+      expect(classifier.classify(error)).toBe(ErrorTypes.TRANSIENT);
+    });
+    
+    test('should classify HTTP 404 as BUSINESS', () => {
+      const error = new Error('Not Found');
+      error.statusCode = 404;
+      
+      expect(classifier.classify(error)).toBe(ErrorTypes.BUSINESS);
+    });
+    
+    test('should classify timeout message as TIMEOUT', () => {
+      const error = new Error('Operation timeout');
+      
+      expect(classifier.classify(error)).toBe(ErrorTypes.TIMEOUT);
+    });
+    
+    test('should classify explicit type', () => {
+      const error = new Error('Custom error');
+      error.type = 'BUSINESS';
+      
+      expect(classifier.classify(error)).toBe(ErrorTypes.BUSINESS);
+    });
+    
+    test('should return UNKNOWN for unclassified error', () => {
+      const error = new Error('Some random error');
+      
+      expect(classifier.classify(error)).toBe(ErrorTypes.UNKNOWN);
+    });
+    
+    test('should handle null error', () => {
+      expect(classifier.classify(null)).toBe(ErrorTypes.UNKNOWN);
+    });
+  });
+  
+  describe('shouldRetry', () => {
+    test('should retry TRANSIENT errors', () => {
+      const error = new Error('Connection refused');
+      error.code = 'ECONNREFUSED';
+      
+      expect(classifier.shouldRetry(error, 0, 3)).toBe(true);
+    });
+    
+    test('should not retry after max attempts', () => {
+      const error = new Error('Connection refused');
+      error.code = 'ECONNREFUSED';
+      
+      expect(classifier.shouldRetry(error, 3, 3)).toBe(false);
+    });
+    
+    test('should not retry BUSINESS errors', () => {
+      const error = new Error('Not Found');
+      error.statusCode = 404;
+      
+      expect(classifier.shouldRetry(error, 0, 3)).toBe(false);
+    });
+    
+    test('should retry TIMEOUT errors', () => {
+      const error = new Error('Operation timeout');
+      
+      expect(classifier.shouldRetry(error, 0, 3)).toBe(true);
+    });
+  });
+});
+

package/tests/unit/ErrorHandlerCore.test.js

@@ -0,0 +1,183 @@
+/**
+ * ErrorHandlerCore Unit Tests
+ */
+
+const ErrorHandlerCore = require('../../src/ErrorHandlerCore');
+const { ErrorTypes } = require('../../src/ErrorClassifier');
+
+describe('ErrorHandlerCore @unit', () => {
+  let errorHandler;
+  let mockMonitoring;
+  
+  beforeEach(() => {
+    mockMonitoring = {
+      logger: {
+        error: jest.fn(),
+        warn: jest.fn(),
+        info: jest.fn()
+      },
+      // Fallback for conn-base-monitoring wrapper
+      error: jest.fn(),
+      warn: jest.fn(),
+      info: jest.fn()
+    };
+    
+    errorHandler = new ErrorHandlerCore({
+      serviceName: 'test-service',
+      serviceVersion: '1.0.0',
+      environment: 'test',
+      monitoring: mockMonitoring,
+      handling: {
+        maxRetries: 3,
+        retryDelay: 100
+      }
+    });
+  });
+  
+  describe('constructor', () => {
+    test('should throw if serviceName missing', () => {
+      expect(() => {
+        new ErrorHandlerCore({
+          monitoring: mockMonitoring
+        });
+      }).toThrow('serviceName is required');
+    });
+    
+    test('should throw if monitoring missing', () => {
+      expect(() => {
+        new ErrorHandlerCore({
+          serviceName: 'test'
+        });
+      }).toThrow('monitoring instance is required');
+    });
+    
+    test('should initialize with valid config', () => {
+      expect(errorHandler.serviceName).toBe('test-service');
+      expect(errorHandler.classifier).toBeDefined();
+      expect(errorHandler.retryHandler).toBeDefined();
+    });
+  });
+  
+  describe('logError', () => {
+    test('should log error via monitoring', async () => {
+      const error = new Error('Test error');
+      
+      const result = await errorHandler.logError({
+        moduleName: 'TestModule',
+        operation: 'testOperation',
+        error: error
+      });
+      
+      expect(mockMonitoring.logger.error).toHaveBeenCalled();
+      expect(result).toHaveProperty('timestamp');
+      expect(result).toHaveProperty('error');
+      expect(result.error.type).toBeDefined();
+    });
+    
+    test('should handle monitoring failure gracefully', async () => {
+      // Mock logger.error to throw
+      mockMonitoring.logger.error.mockImplementation(() => {
+        throw new Error('Monitoring failed');
+      });
+      
+      const consoleSpy = jest.spyOn(console, 'error').mockImplementation();
+      
+      const error = new Error('Test error');
+      await errorHandler.logError({
+        moduleName: 'TestModule',
+        operation: 'testOperation',
+        error: error
+      });
+      
+      expect(consoleSpy).toHaveBeenCalled();
+      consoleSpy.mockRestore();
+    });
+  });
+  
+  describe('handleError', () => {
+    test('should classify and log error', async () => {
+      const error = new Error('Connection refused');
+      error.code = 'ECONNREFUSED';
+      
+      const result = await errorHandler.handleError({
+        moduleName: 'TestModule',
+        operation: 'testOperation',
+        error: error
+      });
+      
+      expect(result.errorType).toBe(ErrorTypes.TRANSIENT);
+      expect(result.action).toBe('retry');
+      expect(result.shouldRetry).toBe(true);
+      expect(mockMonitoring.logger.error).toHaveBeenCalled();
+    });
+    
+    test('should route to DLQ for BUSINESS errors', async () => {
+      const error = new Error('Not Found');
+      error.statusCode = 404;
+      
+      // Mock MQ client for DLQ
+      const mockMQClient = {
+        publish: jest.fn().mockResolvedValue()
+      };
+      
+      errorHandler.dlqRouter.mqClient = mockMQClient;
+      
+      const result = await errorHandler.handleError({
+        moduleName: 'TestModule',
+        operation: 'testOperation',
+        error: error,
+        context: {
+          message: { id: 'msg-123' },
+          queue: 'test.queue'
+        }
+      });
+      
+      expect(result.errorType).toBe(ErrorTypes.BUSINESS);
+      expect(result.action).toBe('dlq');
+      expect(mockMQClient.publish).toHaveBeenCalled();
+    });
+    
+    test('should throw for FATAL errors', async () => {
+      const error = new Error('Fatal error');
+      error.type = 'FATAL';
+      
+      const result = await errorHandler.handleError({
+        moduleName: 'TestModule',
+        operation: 'testOperation',
+        error: error
+      });
+      
+      expect(result.errorType).toBe(ErrorTypes.FATAL);
+      expect(result.action).toBe('throw');
+    });
+  });
+  
+  describe('executeWithRetry', () => {
+    test('should retry on failure', async () => {
+      const fn = jest.fn()
+        .mockRejectedValueOnce(new Error('Fail 1'))
+        .mockResolvedValue('success');
+      
+      const result = await errorHandler.executeWithRetry({
+        moduleName: 'TestModule',
+        operation: 'testOperation',
+        fn: fn
+      });
+      
+      expect(result).toBe('success');
+      expect(fn).toHaveBeenCalledTimes(2);
+      expect(mockMonitoring.logger.error).toHaveBeenCalled(); // Logs retry attempt
+    });
+  });
+  
+  describe('registerCompensation', () => {
+    test('should register compensation handler', () => {
+      const handler = jest.fn().mockResolvedValue();
+      
+      errorHandler.registerCompensation('test-operation', handler);
+      
+      expect(errorHandler.compensation.hasHandler('test-operation')).toBe(true);
+    });
+  });
+});
+

package/tests/unit/RetryHandler.test.js

@@ -0,0 +1,81 @@
+/**
+ * RetryHandler Unit Tests
+ */
+
+const RetryHandler = require('../../src/RetryHandler');
+
+describe('RetryHandler @unit', () => {
+  let retryHandler;
+  
+  beforeEach(() => {
+    retryHandler = new RetryHandler({
+      maxRetries: 3,
+      retryDelay: 1000,
+      retryMultiplier: 2
+    });
+  });
+  
+  describe('calculateBackoff', () => {
+    test('should calculate exponential backoff', () => {
+      expect(retryHandler.calculateBackoff(1)).toBe(1000);
+      expect(retryHandler.calculateBackoff(2)).toBe(2000);
+      expect(retryHandler.calculateBackoff(3)).toBe(4000);
+      expect(retryHandler.calculateBackoff(4)).toBe(8000);
+    });
+    
+    test('should cap at maxRetryDelay', () => {
+      const handler = new RetryHandler({
+        maxRetryDelay: 5000
+      });
+      
+      expect(handler.calculateBackoff(10)).toBe(5000);
+    });
+  });
+  
+  describe('executeWithRetry', () => {
+    test('should succeed on first attempt', async () => {
+      const fn = jest.fn().mockResolvedValue('success');
+      
+      const result = await retryHandler.executeWithRetry(fn);
+      
+      expect(result).toBe('success');
+      expect(fn).toHaveBeenCalledTimes(1);
+    });
+    
+    test('should retry on failure', async () => {
+      const fn = jest.fn()
+        .mockRejectedValueOnce(new Error('Fail 1'))
+        .mockRejectedValueOnce(new Error('Fail 2'))
+        .mockResolvedValue('success');
+      
+      const result = await retryHandler.executeWithRetry(fn);
+      
+      expect(result).toBe('success');
+      expect(fn).toHaveBeenCalledTimes(3);
+    });
+    
+    test('should throw after max retries', async () => {
+      const error = new Error('Always fails');
+      const fn = jest.fn().mockRejectedValue(error);
+      
+      await expect(retryHandler.executeWithRetry(fn)).rejects.toThrow('Always fails');
+      expect(fn).toHaveBeenCalledTimes(3);
+    });
+    
+    test('should call onRetry callback', async () => {
+      const onRetry = jest.fn();
+      const fn = jest.fn()
+        .mockRejectedValueOnce(new Error('Fail'))
+        .mockResolvedValue('success');
+      
+      await retryHandler.executeWithRetry(fn, { onRetry });
+      
+      expect(onRetry).toHaveBeenCalledWith(
+        expect.any(Error),
+        1,
+        1000
+      );
+    });
+  });
+});
+

package/tests/unit/UnifiedLogSchema.test.js

@@ -0,0 +1,75 @@
+/**
+ * UnifiedLogSchema Unit Tests
+ */
+
+const UnifiedLogSchema = require('../../src/UnifiedLogSchema');
+
+describe('UnifiedLogSchema @unit', () => {
+  let schema;
+  
+  beforeEach(() => {
+    schema = new UnifiedLogSchema();
+  });
+  
+  describe('create', () => {
+    test('should create unified log entry', () => {
+      const error = new Error('Test error');
+      error.code = 'ETIMEDOUT';
+      
+      const logEntry = schema.create({
+        moduleName: 'TestModule',
+        operation: 'testOperation',
+        error: error,
+        context: { userId: 123 },
+        serviceName: 'test-service',
+        serviceVersion: '1.0.0',
+        environment: 'test',
+        errorType: 'TRANSIENT'
+      });
+      
+      expect(logEntry).toHaveProperty('timestamp');
+      expect(logEntry).toHaveProperty('serviceName', 'test-service');
+      expect(logEntry).toHaveProperty('moduleName', 'TestModule');
+      expect(logEntry).toHaveProperty('operation', 'testOperation');
+      expect(logEntry).toHaveProperty('error');
+      expect(logEntry.error).toHaveProperty('message', 'Test error');
+      expect(logEntry.error).toHaveProperty('code', 'ETIMEDOUT');
+      expect(logEntry.error).toHaveProperty('type', 'TRANSIENT');
+      expect(logEntry).toHaveProperty('context');
+      expect(logEntry.context).toHaveProperty('userId', 123);
+      expect(logEntry).toHaveProperty('metadata');
+      expect(logEntry.metadata).toHaveProperty('severity');
+      expect(logEntry.metadata).toHaveProperty('environment', 'test');
+    });
+    
+    test('should determine severity from error type', () => {
+      const error = new Error('Fatal error');
+      
+      const logEntry = schema.create({
+        moduleName: 'TestModule',
+        operation: 'testOperation',
+        error: error,
+        serviceName: 'test-service',
+        errorType: 'FATAL'
+      });
+      
+      expect(logEntry.metadata.severity).toBe('fatal');
+    });
+    
+    test('should handle missing optional fields', () => {
+      const error = new Error('Test error');
+      
+      const logEntry = schema.create({
+        moduleName: 'TestModule',
+        operation: 'testOperation',
+        error: error,
+        serviceName: 'test-service'
+      });
+      
+      expect(logEntry).toHaveProperty('timestamp');
+      expect(logEntry.serviceName).toBe('test-service');
+      expect(logEntry.error.type).toBe('UNKNOWN');
+    });
+  });
+});
+