@serve.zone/dcrouter 2.12.4

package/test/test.errors.ts

@@ -0,0 +1,408 @@
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+import * as errors from '../ts/errors/index.js';
+import {
+  PlatformError, 
+  ValidationError,
+  NetworkError,
+  ResourceError,
+  OperationError
+} from '../ts/errors/base.errors.js';
+import {
+  ErrorSeverity,
+  ErrorCategory,
+  ErrorRecoverability
+} from '../ts/errors/error.codes.js';
+import {
+  EmailServiceError,
+  EmailTemplateError,
+  EmailValidationError,
+  EmailSendError,
+  EmailReceiveError
+} from '../ts/errors/email.errors.js';
+import {
+  MtaConnectionError,
+  MtaAuthenticationError,
+  MtaDeliveryError,
+  MtaConfigurationError
+} from '../ts/errors/mta.errors.js';
+import {
+  ErrorHandler
+} from '../ts/errors/error-handler.js';
+
+// Test base error classes
+tap.test('Base error classes should set properties correctly', async () => {
+  const message = 'Test error message';
+  const code = 'TEST_ERROR_CODE';
+  const context = {
+    component: 'TestComponent',
+    operation: 'testOperation',
+    data: { foo: 'bar' }
+  };
+
+  // Test PlatformError
+  const platformError = new PlatformError(
+    message,
+    code,
+    ErrorSeverity.MEDIUM,
+    ErrorCategory.OPERATION,
+    ErrorRecoverability.MAYBE_RECOVERABLE,
+    context
+  );
+
+  expect(platformError.message).toEqual(message);
+  expect(platformError.code).toEqual(code);
+  expect(platformError.severity).toEqual(ErrorSeverity.MEDIUM);
+  expect(platformError.category).toEqual(ErrorCategory.OPERATION);
+  expect(platformError.recoverability).toEqual(ErrorRecoverability.MAYBE_RECOVERABLE);
+  expect(platformError.context?.component).toEqual(context.component);
+  expect(platformError.context?.operation).toEqual(context.operation);
+  expect(platformError.context?.data?.foo).toEqual('bar');
+  expect(platformError.name).toEqual('PlatformError');
+
+  // Test ValidationError
+  const validationError = new ValidationError(message, code, context);
+  expect(validationError.category).toEqual(ErrorCategory.VALIDATION);
+  expect(validationError.severity).toEqual(ErrorSeverity.LOW);
+
+  // Test NetworkError
+  const networkError = new NetworkError(message, code, context);
+  expect(networkError.category).toEqual(ErrorCategory.CONNECTIVITY);
+  expect(networkError.severity).toEqual(ErrorSeverity.MEDIUM);
+  expect(networkError.recoverability).toEqual(ErrorRecoverability.MAYBE_RECOVERABLE);
+
+  // Test ResourceError
+  const resourceError = new ResourceError(message, code, context);
+  expect(resourceError.category).toEqual(ErrorCategory.RESOURCE);
+});
+
+// Test 7: Error withRetry() method
+tap.test('PlatformError withRetry creates new instance with retry info', async () => {
+  const originalError = new EmailSendError('Send failed', {
+    data: { someData: true }
+  });
+  
+  const retryError = originalError.withRetry(3, 1, 1000);
+  
+  // Verify it's a new instance
+  expect(retryError === originalError).toEqual(false);
+  expect(retryError).toBeInstanceOf(EmailSendError);
+  
+  // Verify original data is preserved
+  expect(retryError.context?.data?.someData).toEqual(true);
+  
+  // Verify retry info is added
+  expect(retryError.context?.retry?.maxRetries).toEqual(3);
+  expect(retryError.context?.retry?.currentRetry).toEqual(1);
+  expect(retryError.context?.retry?.retryDelay).toEqual(1000);
+  expect(retryError.context?.retry?.nextRetryAt).toBeTypeofNumber();
+});
+
+// Test email error classes
+tap.test('Email error classes should be properly constructed', async () => {
+  try {
+    // Test EmailServiceError
+    const emailServiceError = new EmailServiceError('Email service error', {
+      component: 'EmailService',
+      operation: 'sendEmail'
+    });
+    expect(emailServiceError.code).toEqual('EMAIL_SERVICE_ERROR');
+    expect(emailServiceError.name).toEqual('EmailServiceError');
+
+  // Test EmailTemplateError
+  const templateError = new EmailTemplateError('Template not found: welcome_email', {
+    data: { templateId: 'welcome_email' }
+  });
+  expect(templateError.code).toEqual('EMAIL_TEMPLATE_ERROR');
+  expect(templateError.context.data?.templateId).toEqual('welcome_email');
+
+  // Test EmailSendError with permanent flag
+  const permanentError = EmailSendError.permanent(
+    'Invalid recipient: user@example.com',
+    { data: { details: 'DNS not found', recipient: 'user@example.com' } }
+  );
+  expect(permanentError.code).toEqual('EMAIL_SEND_ERROR');
+  expect(permanentError.isPermanent()).toEqual(true);
+  expect(permanentError.context.data?.permanent).toEqual(true);
+
+  // Test EmailSendError with temporary flag and retry
+  const tempError = EmailSendError.temporary(
+    'Server busy',
+    3,
+    0,
+    1000,
+    { data: { server: 'smtp.example.com' } }
+  );
+  expect(tempError.isPermanent()).toEqual(false);
+  expect(tempError.context.data?.permanent).toEqual(false);
+  expect(tempError.context.retry?.maxRetries).toEqual(3);
+  expect(tempError.shouldRetry()).toEqual(true);
+  } catch (error) {
+    console.error('Test failed with error:', error);
+    throw error;
+  }
+});
+
+// Test MTA error classes
+tap.test('MTA error classes should be properly constructed', async () => {
+  try {
+    // Test MtaConnectionError
+    const dnsError = MtaConnectionError.dnsError('mail.example.com', new Error('DNS lookup failed'));
+    expect(dnsError.code).toEqual('MTA_CONNECTION_ERROR');
+    expect(dnsError.category).toEqual(ErrorCategory.CONNECTIVITY);
+    expect(dnsError.context.data?.hostname).toEqual('mail.example.com');
+
+  // Test MtaTimeoutError via MtaConnectionError.timeout
+  const timeoutError = MtaConnectionError.timeout('mail.example.com', 25, 30000);
+  expect(timeoutError.code).toEqual('MTA_CONNECTION_ERROR');
+  expect(timeoutError.context.data?.timeout).toEqual(30000);
+
+  // Test MtaAuthenticationError
+  const authError = MtaAuthenticationError.invalidCredentials('mail.example.com', 'user@example.com');
+  expect(authError.code).toEqual('MTA_AUTHENTICATION_ERROR');
+  expect(authError.category).toEqual(ErrorCategory.AUTHENTICATION);
+  expect(authError.context.data?.username).toEqual('user@example.com');
+
+  // Test MtaDeliveryError
+  const permDeliveryError = MtaDeliveryError.permanent(
+    'User unknown',
+    'nonexistent@example.com',
+    '550',
+    '550 5.1.1 User unknown',
+    {}
+  );
+  expect(permDeliveryError.code).toEqual('MTA_DELIVERY_ERROR');
+  expect(permDeliveryError.isPermanent()).toEqual(true);
+  expect(permDeliveryError.getRecipientAddress()).toEqual('nonexistent@example.com');
+  expect(permDeliveryError.getStatusCode()).toEqual('550');
+
+  // Test temporary delivery error with retry
+  const tempDeliveryError = MtaDeliveryError.temporary(
+    'Mailbox temporarily unavailable',
+    'user@example.com',
+    '450',
+    '450 4.2.1 Mailbox temporarily unavailable',
+    3,
+    1,
+    5000
+  );
+  expect(tempDeliveryError.isPermanent()).toEqual(false);
+  expect(tempDeliveryError.shouldRetry()).toEqual(true);
+  expect(tempDeliveryError.context.retry?.currentRetry).toEqual(1);
+  expect(tempDeliveryError.context.retry?.maxRetries).toEqual(3);
+  } catch (error) {
+    console.error('MTA test failed with error:', error);
+    throw error;
+  }
+});
+
+// Test error handler utility
+tap.test('ErrorHandler should properly handle and format errors', async () => {
+  // Configure error handler
+  ErrorHandler.configure({
+    logErrors: false, // Disable for testing
+    includeStacksInProd: false,
+    retry: {
+      maxAttempts: 5,
+      baseDelay: 100,
+      maxDelay: 1000,
+      backoffFactor: 2
+    }
+  });
+
+  // Test converting regular Error to PlatformError
+  const regularError = new Error('Something went wrong');
+  const platformError = ErrorHandler.toPlatformError(
+    regularError,
+    'PLATFORM_OPERATION_ERROR',
+    { component: 'TestHandler' }
+  );
+
+  expect(platformError).toBeInstanceOf(PlatformError);
+  expect(platformError.code).toEqual('PLATFORM_OPERATION_ERROR');
+  expect(platformError.context?.component).toEqual('TestHandler');
+
+  // Test formatting error for API response
+  const formattedError = ErrorHandler.formatErrorForResponse(platformError, true);
+  expect(formattedError.code).toEqual('PLATFORM_OPERATION_ERROR');
+  expect(formattedError.message).toEqual('An unexpected error occurred.');
+  expect(formattedError.details?.rawMessage).toEqual('Something went wrong');
+
+  // Test executing a function with error handling
+  let executed = false;
+  try {
+    await ErrorHandler.execute(async () => {
+      executed = true;
+      throw new Error('Execution failed');
+    }, 'TEST_EXECUTION_ERROR', { operation: 'testExecution' });
+  } catch (error) {
+    expect(error).toBeInstanceOf(PlatformError);
+    expect(error.code).toEqual('TEST_EXECUTION_ERROR');
+    expect(error.context.operation).toEqual('testExecution');
+  }
+  expect(executed).toEqual(true);
+
+  // Test executeWithRetry successful after retries
+  let attempts = 0;
+  const result = await ErrorHandler.executeWithRetry(
+    async () => {
+      attempts++;
+      if (attempts < 3) {
+        throw new Error('Temporary failure');
+      }
+      return 'success';
+    },
+    'TEST_RETRY_ERROR',
+    {
+      maxAttempts: 5,
+      baseDelay: 10, // Use small delay for tests
+      retryableErrorPatterns: [/Temporary failure/], // Add pattern to make error retryable
+      onRetry: (error, attempt, delay) => {
+        expect(error).toBeInstanceOf(PlatformError);
+        expect(attempt).toBeGreaterThan(0);
+        expect(delay).toBeGreaterThan(0);
+      }
+    }
+  );
+
+  expect(result).toEqual('success');
+  expect(attempts).toEqual(3);
+
+  // Test executeWithRetry that fails after max attempts
+  attempts = 0;
+  try {
+    await ErrorHandler.executeWithRetry(
+      async () => {
+        attempts++;
+        throw new Error('Persistent failure');
+      },
+      'TEST_RETRY_ERROR',
+      {
+        maxAttempts: 3,
+        baseDelay: 10,
+        retryableErrorPatterns: [/Persistent failure/] // Make error retryable so it tries all attempts
+      }
+    );
+  } catch (error) {
+    expect(error).toBeInstanceOf(PlatformError);
+    expect(attempts).toEqual(3);
+  }
+});
+
+// Test retry utilities
+tap.test('Error retry utilities should work correctly', async () => {
+  let attempts = 0;
+  const start = Date.now();
+
+  try {
+    await errors.retry(
+      async () => {
+        attempts++;
+        if (attempts < 3) {
+          throw new Error('Temporary error');
+        }
+        return 'success';
+      },
+      {
+        maxRetries: 5,
+        initialDelay: 20,
+        backoffFactor: 1.5,
+        retryableErrors: [/Temporary/]
+      }
+    );
+  } catch (e) {
+    // Should not reach here
+    expect(false).toEqual(true);
+  }
+
+  expect(attempts).toEqual(3);
+
+  // Test retry with non-retryable error
+  attempts = 0;
+  try {
+    await errors.retry(
+      async () => {
+        attempts++;
+        throw new Error('Critical error');
+      },
+      {
+        maxRetries: 3,
+        initialDelay: 10,
+        retryableErrors: [/Temporary/] // Won't match "Critical"
+      }
+    );
+  } catch (error) {
+    expect(error.message).toEqual('Critical error');
+    expect(attempts).toEqual(1); // Should only attempt once
+  }
+});
+
+// Helper function that will reject first n times, then resolve
+interface FlakyFunction {
+  (failTimes: number, result?: any): Promise<any>;
+  counter: number;
+  reset: () => void;
+}
+
+const flaky: FlakyFunction = Object.assign(
+  async function (failTimes: number, result: any = 'success'): Promise<any> {
+    if (flaky.counter < failTimes) {
+      flaky.counter++;
+      throw new Error(`Flaky failure ${flaky.counter}`);
+    }
+    return result;
+  },
+  {
+    counter: 0,
+    reset: () => { flaky.counter = 0; }
+  }
+);
+
+// Test error wrapping and retry combination
+tap.test('Error handling can be combined with retry for robust operations', async () => {
+  // Reset counter for the test
+  flaky.reset();
+
+  // Create a wrapped version of the flaky function
+  const wrapped = errors.withErrorHandling(
+    () => flaky(2, 'wrapped success'),
+    'TEST_WRAPPED_ERROR',
+    { component: 'TestComponent' }
+  );
+
+  // Execute with retry
+  const result = await errors.retry(
+    wrapped,
+    {
+      maxRetries: 3,
+      initialDelay: 10,
+      retryableErrors: [/Flaky failure/]
+    }
+  );
+  expect(result).toEqual('wrapped success');
+  expect(flaky.counter).toEqual(2);
+
+  // Reset and test failure case
+  flaky.reset();
+  
+  try {
+    await errors.retry(
+      () => flaky(5, 'never reached'),
+      {
+        maxRetries: 2, // Only retry twice, but we need 5 attempts to succeed
+        initialDelay: 10,
+        retryableErrors: [/Flaky failure/] // Add pattern to make it retry
+      }
+    );
+    // Should not reach here
+    expect(false).toEqual(true);
+  } catch (error) {
+    expect(error.message).toContain('Flaky failure');
+    expect(flaky.counter).toEqual(3); // Initial + 2 retries = 3 attempts
+  }
+});
+
+tap.test('stop', async () => {
+  await tap.stopForcefully();
+});
+
+export default tap.start();