@serve.zone/dcrouter 2.12.4

package/test/test.reputationmonitor.ts

@@ -0,0 +1,262 @@
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+import * as plugins from '../ts/plugins.js';
+import * as paths from '../ts/paths.js';
+import { SenderReputationMonitor } from '../ts/deliverability/classes.senderreputationmonitor.js';
+
+// Set NODE_ENV to test to prevent loading persisted data
+process.env.NODE_ENV = 'test';
+
+// Cleanup any temporary test data
+const cleanupTestData = () => {
+  const reputationDataPath = plugins.path.join(paths.dataDir, 'reputation');
+  if (plugins.fs.existsSync(reputationDataPath)) {
+    // Remove the directory recursively using fs instead of smartfile
+    plugins.fs.rmSync(reputationDataPath, { recursive: true, force: true });
+  }
+};
+
+// Helper to reset the singleton instance between tests
+const resetSingleton = () => {
+  // @ts-ignore - accessing private static field for testing
+  SenderReputationMonitor.instance = null;
+  
+  // Clean up any timeout to prevent race conditions
+  const activeSendReputationMonitors = Array.from(Object.values(global))
+    .filter((item: any) => item && typeof item === 'object' && item._idleTimeout)
+    .filter((item: any) => 
+      item._onTimeout && 
+      item._onTimeout.toString && 
+      item._onTimeout.toString().includes('updateAllDomainMetrics'));
+    
+  // Clear any active timeouts to prevent race conditions
+  activeSendReputationMonitors.forEach((timer: any) => {
+    clearTimeout(timer);
+  });
+};
+
+// Before running any tests
+tap.test('setup', async () => {
+  resetSingleton();
+  cleanupTestData();
+});
+
+// Test initialization of SenderReputationMonitor
+tap.test('should initialize SenderReputationMonitor with default settings', async () => {
+  resetSingleton();
+  const reputationMonitor = SenderReputationMonitor.getInstance();
+  
+  expect(reputationMonitor).toBeTruthy();
+  // Check if the object has the expected methods
+  expect(typeof reputationMonitor.recordSendEvent).toEqual('function');
+  expect(typeof reputationMonitor.getReputationData).toEqual('function');
+  expect(typeof reputationMonitor.getReputationSummary).toEqual('function');
+});
+
+// Test initialization with custom settings
+tap.test('should initialize SenderReputationMonitor with custom settings', async () => {
+  resetSingleton();
+  const reputationMonitor = SenderReputationMonitor.getInstance({
+    enabled: false, // Disable automatic updates to prevent race conditions
+    domains: ['example.com', 'test.com'],
+    updateFrequency: 12 * 60 * 60 * 1000, // 12 hours
+    alertThresholds: {
+      minReputationScore: 80,
+      maxComplaintRate: 0.05
+    }
+  });
+  
+  // Test adding domains
+  reputationMonitor.addDomain('newdomain.com');
+  
+  // Test retrieving reputation data
+  const data = reputationMonitor.getReputationData('example.com');
+  expect(data).toBeTruthy();
+  expect(data.domain).toEqual('example.com');
+});
+
+// Test recording and tracking send events
+tap.test('should record send events and update metrics', async () => {
+  resetSingleton();
+  const reputationMonitor = SenderReputationMonitor.getInstance({
+    enabled: false, // Disable automatic updates to prevent race conditions
+    domains: ['example.com']
+  });
+  
+  // Record a series of events
+  reputationMonitor.recordSendEvent('example.com', { type: 'sent', count: 100 });
+  reputationMonitor.recordSendEvent('example.com', { type: 'delivered', count: 95 });
+  reputationMonitor.recordSendEvent('example.com', { type: 'bounce', hardBounce: true, count: 3 });
+  reputationMonitor.recordSendEvent('example.com', { type: 'bounce', hardBounce: false, count: 2 });
+  reputationMonitor.recordSendEvent('example.com', { type: 'complaint', count: 1 });
+  
+  // Check metrics
+  const metrics = reputationMonitor.getReputationData('example.com');
+  
+  expect(metrics).toBeTruthy();
+  expect(metrics.volume.sent).toEqual(100);
+  expect(metrics.volume.delivered).toEqual(95);
+  expect(metrics.volume.hardBounces).toEqual(3);
+  expect(metrics.volume.softBounces).toEqual(2);
+  expect(metrics.complaints.total).toEqual(1);
+});
+
+// Test reputation score calculation
+tap.test('should calculate reputation scores correctly', async () => {
+  resetSingleton();
+  const reputationMonitor = SenderReputationMonitor.getInstance({
+    enabled: false, // Disable automatic updates to prevent race conditions
+    domains: ['high.com', 'medium.com', 'low.com']
+  });
+  
+  // Record events for different domains
+  reputationMonitor.recordSendEvent('high.com', { type: 'sent', count: 1000 });
+  reputationMonitor.recordSendEvent('high.com', { type: 'delivered', count: 990 });
+  reputationMonitor.recordSendEvent('high.com', { type: 'open', count: 500 });
+  
+  reputationMonitor.recordSendEvent('medium.com', { type: 'sent', count: 1000 });
+  reputationMonitor.recordSendEvent('medium.com', { type: 'delivered', count: 950 });
+  reputationMonitor.recordSendEvent('medium.com', { type: 'open', count: 300 });
+  
+  reputationMonitor.recordSendEvent('low.com', { type: 'sent', count: 1000 });
+  reputationMonitor.recordSendEvent('low.com', { type: 'delivered', count: 850 });
+  reputationMonitor.recordSendEvent('low.com', { type: 'open', count: 100 });
+  
+  // Get reputation summary
+  const summary = reputationMonitor.getReputationSummary();
+  expect(Array.isArray(summary)).toEqual(true);
+  expect(summary.length >= 3).toEqual(true);
+  
+  // Check that domains are included in the summary
+  const domains = summary.map(item => item.domain);
+  expect(domains.includes('high.com')).toEqual(true);
+  expect(domains.includes('medium.com')).toEqual(true);
+  expect(domains.includes('low.com')).toEqual(true);
+});
+
+// Test adding and removing domains
+tap.test('should add and remove domains for monitoring', async () => {
+  resetSingleton();
+  const reputationMonitor = SenderReputationMonitor.getInstance({
+    enabled: false, // Disable automatic updates to prevent race conditions
+    domains: ['example.com']
+  });
+  
+  // Add a new domain
+  reputationMonitor.addDomain('newdomain.com');
+  
+  // Record data for the new domain
+  reputationMonitor.recordSendEvent('newdomain.com', { type: 'sent', count: 50 });
+  
+  // Check that data was recorded for the new domain
+  const metrics = reputationMonitor.getReputationData('newdomain.com');
+  expect(metrics).toBeTruthy();
+  expect(metrics.volume.sent).toEqual(50);
+  
+  // Remove a domain
+  reputationMonitor.removeDomain('newdomain.com');
+  
+  // Check that data is no longer available
+  const removedMetrics = reputationMonitor.getReputationData('newdomain.com');
+  expect(removedMetrics === null).toEqual(true);
+});
+
+// Test handling open and click events
+tap.test('should track engagement metrics correctly', async () => {
+  resetSingleton();
+  const reputationMonitor = SenderReputationMonitor.getInstance({
+    enabled: false, // Disable automatic updates to prevent race conditions
+    domains: ['example.com']
+  });
+  
+  // Record basic sending metrics
+  reputationMonitor.recordSendEvent('example.com', { type: 'sent', count: 1000 });
+  reputationMonitor.recordSendEvent('example.com', { type: 'delivered', count: 950 });
+  
+  // Record engagement events
+  reputationMonitor.recordSendEvent('example.com', { type: 'open', count: 500 });
+  reputationMonitor.recordSendEvent('example.com', { type: 'click', count: 250 });
+  
+  // Check engagement metrics
+  const metrics = reputationMonitor.getReputationData('example.com');
+  expect(metrics).toBeTruthy();
+  expect(metrics.engagement.opens).toEqual(500);
+  expect(metrics.engagement.clicks).toEqual(250);
+  expect(typeof metrics.engagement.openRate).toEqual('number');
+  expect(typeof metrics.engagement.clickRate).toEqual('number');
+});
+
+// Test historical data tracking
+tap.test('should store historical reputation data', async () => {
+  resetSingleton();
+  const reputationMonitor = SenderReputationMonitor.getInstance({
+    enabled: false, // Disable automatic updates to prevent race conditions
+    domains: ['example.com']
+  });
+  
+  // Record events over multiple days
+  const today = new Date();
+  const todayStr = today.toISOString().split('T')[0];
+  
+  // Record data
+  reputationMonitor.recordSendEvent('example.com', { type: 'sent', count: 1000 });
+  reputationMonitor.recordSendEvent('example.com', { type: 'delivered', count: 950 });
+  
+  // Get metrics data
+  const metrics = reputationMonitor.getReputationData('example.com');
+  
+  // Check that historical data exists
+  expect(metrics.historical).toBeTruthy();
+  expect(metrics.historical.reputationScores).toBeTruthy();
+  
+  // Check that daily send volume is tracked
+  expect(metrics.volume.dailySendVolume).toBeTruthy();
+  expect(metrics.volume.dailySendVolume[todayStr]).toEqual(1000);
+});
+
+// Test event recording for different event types
+tap.test('should correctly handle different event types', async () => {
+  resetSingleton();
+  const reputationMonitor = SenderReputationMonitor.getInstance({
+    enabled: false, // Disable automatic updates to prevent race conditions
+    domains: ['example.com']
+  });
+  
+  // Record different types of events
+  reputationMonitor.recordSendEvent('example.com', { type: 'sent', count: 100 });
+  reputationMonitor.recordSendEvent('example.com', { type: 'delivered', count: 95 });
+  reputationMonitor.recordSendEvent('example.com', { type: 'bounce', hardBounce: true, count: 3 });
+  reputationMonitor.recordSendEvent('example.com', { type: 'bounce', hardBounce: false, count: 2 });
+  reputationMonitor.recordSendEvent('example.com', { type: 'complaint', receivingDomain: 'gmail.com', count: 1 });
+  reputationMonitor.recordSendEvent('example.com', { type: 'open', count: 50 });
+  reputationMonitor.recordSendEvent('example.com', { type: 'click', count: 25 });
+  
+  // Check metrics for different event types
+  const metrics = reputationMonitor.getReputationData('example.com');
+  
+  // Check volume metrics
+  expect(metrics.volume.sent).toEqual(100);
+  expect(metrics.volume.delivered).toEqual(95);
+  expect(metrics.volume.hardBounces).toEqual(3);
+  expect(metrics.volume.softBounces).toEqual(2);
+  
+  // Check complaint metrics
+  expect(metrics.complaints.total).toEqual(1);
+  expect(metrics.complaints.topDomains[0].domain).toEqual('gmail.com');
+  
+  // Check engagement metrics
+  expect(metrics.engagement.opens).toEqual(50);
+  expect(metrics.engagement.clicks).toEqual(25);
+});
+
+// After all tests, clean up
+tap.test('cleanup', async () => {
+  resetSingleton();
+  cleanupTestData();
+});
+
+tap.test('stop', async () => {
+  await tap.stopForcefully();
+});
+
+
+export default tap.start();

package/test/test.smartmail.ts

@@ -0,0 +1,248 @@
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+import * as plugins from '../ts/plugins.js';
+import * as paths from '../ts/paths.js';
+
+// Import the components we want to test
+import { EmailValidator } from '../ts/mail/core/classes.emailvalidator.js';
+import { TemplateManager } from '../ts/mail/core/classes.templatemanager.js';
+import { Email } from '../ts/mail/core/classes.email.js';
+
+// Ensure test directories exist
+paths.ensureDirectories();
+
+tap.test('EmailValidator - should validate email formats correctly', async (tools) => {
+  const validator = new EmailValidator();
+  
+  // Test valid email formats
+  expect(validator.isValidFormat('user@example.com')).toEqual(true);
+  expect(validator.isValidFormat('firstname.lastname@example.com')).toEqual(true);
+  expect(validator.isValidFormat('user+tag@example.com')).toEqual(true);
+  
+  // Test invalid email formats
+  expect(validator.isValidFormat('user@')).toEqual(false);
+  expect(validator.isValidFormat('@example.com')).toEqual(false);
+  expect(validator.isValidFormat('user@example')).toEqual(false);
+  expect(validator.isValidFormat('user.example.com')).toEqual(false);
+});
+
+tap.test('EmailValidator - should perform comprehensive validation', async (tools) => {
+  const validator = new EmailValidator();
+  
+  // Test basic validation (syntax-only)
+  const basicResult = await validator.validate('user@example.com', { checkSyntaxOnly: true });
+  expect(basicResult.isValid).toEqual(true);
+  expect(basicResult.details.formatValid).toEqual(true);
+  
+  // We can't reliably test MX validation in all environments, but the function should run
+  const mxResult = await validator.validate('user@example.com', { checkMx: true });
+  expect(typeof mxResult.isValid).toEqual('boolean');
+  expect(typeof mxResult.hasMx).toEqual('boolean');
+});
+
+tap.test('EmailValidator - should detect invalid emails', async (tools) => {
+  const validator = new EmailValidator();
+  
+  const invalidResult = await validator.validate('invalid@@example.com', { checkSyntaxOnly: true });
+  expect(invalidResult.isValid).toEqual(false);
+  expect(invalidResult.details.formatValid).toEqual(false);
+});
+
+tap.test('TemplateManager - should register and retrieve templates', async (tools) => {
+  const templateManager = new TemplateManager({
+    from: 'test@example.com'
+  });
+  
+  // Register a custom template
+  templateManager.registerTemplate({
+    id: 'test-template',
+    name: 'Test Template',
+    description: 'A test template',
+    from: 'test@example.com',
+    subject: 'Test Subject: {{name}}',
+    bodyHtml: '<p>Hello, {{name}}!</p>',
+    bodyText: 'Hello, {{name}}!',
+    category: 'test'
+  });
+  
+  // Get the template back
+  const template = templateManager.getTemplate('test-template');
+  expect(template).toBeTruthy();
+  expect(template.id).toEqual('test-template');
+  expect(template.subject).toEqual('Test Subject: {{name}}');
+  
+  // List templates
+  const templates = templateManager.listTemplates();
+  expect(templates.length > 0).toEqual(true);
+  expect(templates.some(t => t.id === 'test-template')).toEqual(true);
+});
+
+tap.test('TemplateManager - should create email from template', async (tools) => {
+  const templateManager = new TemplateManager({
+    from: 'test@example.com'
+  });
+  
+  // Register a template
+  templateManager.registerTemplate({
+    id: 'welcome-test',
+    name: 'Welcome Test',
+    description: 'A welcome test template',
+    from: 'welcome@example.com',
+    subject: 'Welcome, {{name}}!',
+    bodyHtml: '<p>Hello, {{name}}! Welcome to our service.</p>',
+    bodyText: 'Hello, {{name}}! Welcome to our service.',
+    category: 'test'
+  });
+  
+  // Create email from template
+  const email = await templateManager.createEmail('welcome-test', {
+    name: 'John Doe'
+  });
+  
+  expect(email).toBeTruthy();
+  expect(email.from).toEqual('welcome@example.com');
+  expect(email.getSubjectWithVariables()).toEqual('Welcome, John Doe!');
+  expect(email.getHtmlWithVariables()?.indexOf('Hello, John Doe!') > -1).toEqual(true);
+});
+
+tap.test('Email - should handle template variables', async (tools) => {
+  // Create email with variables
+  const email = new Email({
+    from: 'sender@example.com',
+    to: 'recipient@example.com',
+    subject: 'Hello {{name}}!',
+    text: 'Welcome, {{name}}! Your order #{{orderId}} has been processed.',
+    html: '<p>Welcome, <strong>{{name}}</strong>! Your order #{{orderId}} has been processed.</p>',
+    variables: {
+      name: 'John Doe',
+      orderId: '12345'
+    }
+  });
+  
+  // Test variable substitution
+  expect(email.getSubjectWithVariables()).toEqual('Hello John Doe!');
+  expect(email.getTextWithVariables()).toEqual('Welcome, John Doe! Your order #12345 has been processed.');
+  expect(email.getHtmlWithVariables().indexOf('<strong>John Doe</strong>') > -1).toEqual(true);
+  
+  // Test with additional variables
+  const additionalVars = {
+    name: 'Jane Smith', // Override existing variable
+    status: 'shipped'   // Add new variable
+  };
+  
+  expect(email.getSubjectWithVariables(additionalVars)).toEqual('Hello Jane Smith!');
+  
+  // Add a new variable
+  email.setVariable('trackingNumber', 'TRK123456');
+  expect(email.getTextWithVariables().indexOf('12345') > -1).toEqual(true);
+  
+  // Update multiple variables at once
+  email.setVariables({
+    orderId: '67890',
+    status: 'delivered'
+  });
+  
+  expect(email.getTextWithVariables().indexOf('67890') > -1).toEqual(true);
+});
+
+tap.test('Email and Smartmail compatibility - should convert between formats', async (tools) => {
+  // Create a Smartmail instance
+  const smartmail = new plugins.smartmail.Smartmail({
+    from: 'smartmail@example.com',
+    subject: 'Test Subject',
+    body: '<p>This is a test email.</p>',
+    creationObjectRef: {
+      orderId: '12345'
+    }
+  });
+  
+  // Add recipient and attachment
+  smartmail.addRecipient('recipient@example.com');
+  
+  const attachment = await plugins.smartfile.SmartFile.fromString(
+    'test.txt',
+    'This is a test attachment',
+    'utf8',
+  );
+  
+  smartmail.addAttachment(attachment);
+  
+  // Convert to Email
+  const resolvedSmartmail = await smartmail;
+  const email = Email.fromSmartmail(resolvedSmartmail);
+  
+  // Verify first conversion (Smartmail to Email)
+  expect(email.from).toEqual('smartmail@example.com');
+  expect(email.to.indexOf('recipient@example.com') > -1).toEqual(true);
+  expect(email.subject).toEqual('Test Subject');
+  expect(email.html?.indexOf('This is a test email') > -1).toEqual(true);
+  expect(email.attachments.length).toEqual(1);
+  
+  // Convert back to Smartmail
+  const convertedSmartmail = await email.toSmartmail();
+  
+  // Verify second conversion (Email back to Smartmail) with simplified assertions
+  expect(convertedSmartmail.options.from).toEqual('smartmail@example.com');
+  expect(Array.isArray(convertedSmartmail.options.to)).toEqual(true);
+  expect(convertedSmartmail.options.to.length).toEqual(1);
+  expect(convertedSmartmail.getSubject()).toEqual('Test Subject');
+  expect(convertedSmartmail.getBody(true).indexOf('This is a test email') > -1).toEqual(true);
+  expect(convertedSmartmail.attachments.length).toEqual(1);
+});
+
+tap.test('Email - should validate email addresses', async (tools) => {
+  // Attempt to create an email with invalid addresses
+  let errorThrown = false;
+  
+  try {
+    const email = new Email({
+      from: 'invalid-email',
+      to: 'recipient@example.com',
+      subject: 'Test',
+      text: 'Test'
+    });
+  } catch (error) {
+    errorThrown = true;
+    expect(error.message.indexOf('Invalid sender email address') > -1).toEqual(true);
+  }
+  
+  expect(errorThrown).toEqual(true);
+  
+  // Attempt with invalid recipient
+  errorThrown = false;
+  
+  try {
+    const email = new Email({
+      from: 'sender@example.com',
+      to: 'invalid-recipient',
+      subject: 'Test',
+      text: 'Test'
+    });
+  } catch (error) {
+    errorThrown = true;
+    expect(error.message.indexOf('Invalid recipient email address') > -1).toEqual(true);
+  }
+  
+  expect(errorThrown).toEqual(true);
+  
+  // Valid email should not throw
+  let validEmail: Email;
+  try {
+    validEmail = new Email({
+      from: 'sender@example.com',
+      to: 'recipient@example.com',
+      subject: 'Test',
+      text: 'Test'
+    });
+    
+    expect(validEmail).toBeTruthy();
+    expect(validEmail.from).toEqual('sender@example.com');
+  } catch (error) {
+    expect(error === undefined).toEqual(true); // This should not happen
+  }
+});
+
+tap.test('stop', async () => {
+  tap.stopForcefully();
+})
+
+export default tap.start();

package/test/test.smtp.client.compatibility.ts

@@ -0,0 +1,154 @@
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+import { smtpClientMod } from '../ts/mail/delivery/index.js';
+import type { ISmtpClientOptions, SmtpClient } from '../ts/mail/delivery/smtpclient/index.js';
+import { Email } from '../ts/mail/core/classes.email.js';
+
+/**
+ * Compatibility tests for the legacy SMTP client facade
+ */
+
+tap.test('verify backward compatibility - client creation', async () => {
+  // Create test configuration
+  const options: ISmtpClientOptions = {
+    host: 'smtp.example.com',
+    port: 587,
+    secure: false,
+    connectionTimeout: 10000,
+    domain: 'test.example.com'
+  };
+  
+  // Create SMTP client instance using legacy constructor
+  const smtpClient = smtpClientMod.createSmtpClient(options);
+  
+  // Verify instance was created correctly
+  expect(smtpClient).toBeTruthy();
+  expect(smtpClient.isConnected()).toBeFalsy(); // Should start disconnected
+});
+
+tap.test('verify backward compatibility - methods exist', async () => {
+  const options: ISmtpClientOptions = {
+    host: 'smtp.example.com',
+    port: 587,
+    secure: false
+  };
+  
+  const smtpClient = smtpClientMod.createSmtpClient(options);
+  
+  // Verify all expected methods exist
+  expect(typeof smtpClient.sendMail === 'function').toBeTruthy();
+  expect(typeof smtpClient.verify === 'function').toBeTruthy();
+  expect(typeof smtpClient.isConnected === 'function').toBeTruthy();
+  expect(typeof smtpClient.getPoolStatus === 'function').toBeTruthy();
+  expect(typeof smtpClient.updateOptions === 'function').toBeTruthy();
+  expect(typeof smtpClient.close === 'function').toBeTruthy();
+  expect(typeof smtpClient.on === 'function').toBeTruthy();
+  expect(typeof smtpClient.off === 'function').toBeTruthy();
+  expect(typeof smtpClient.emit === 'function').toBeTruthy();
+});
+
+tap.test('verify backward compatibility - options update', async () => {
+  const options: ISmtpClientOptions = {
+    host: 'smtp.example.com',
+    port: 587,
+    secure: false
+  };
+  
+  const smtpClient = smtpClientMod.createSmtpClient(options);
+  
+  // Test option updates don't throw
+  expect(() => smtpClient.updateOptions({
+    host: 'new-smtp.example.com',
+    port: 465,
+    secure: true
+  })).not.toThrow();
+  
+  expect(() => smtpClient.updateOptions({
+    debug: true,
+    connectionTimeout: 5000
+  })).not.toThrow();
+});
+
+tap.test('verify backward compatibility - connection failure handling', async () => {
+  const options: ISmtpClientOptions = {
+    host: 'nonexistent.invalid.domain',
+    port: 587,
+    secure: false,
+    connectionTimeout: 1000 // Short timeout for faster test
+  };
+  
+  const smtpClient = smtpClientMod.createSmtpClient(options);
+  
+  // verify() should return false for invalid hosts
+  const isValid = await smtpClient.verify();
+  expect(isValid).toBeFalsy();
+  
+  // sendMail should fail gracefully for invalid hosts
+  const email = new Email({
+    from: 'test@example.com',
+    to: 'recipient@example.com',
+    subject: 'Test Email',
+    text: 'This is a test email'
+  });
+  
+  try {
+    const result = await smtpClient.sendMail(email);
+    expect(result.success).toBeFalsy();
+    expect(result.error).toBeTruthy();
+  } catch (error) {
+    // Connection errors are expected for invalid domains
+    expect(error).toBeTruthy();
+  }
+});
+
+tap.test('verify backward compatibility - pool status', async () => {
+  const options: ISmtpClientOptions = {
+    host: 'smtp.example.com',
+    port: 587,
+    secure: false,
+    pool: true,
+    maxConnections: 5
+  };
+  
+  const smtpClient = smtpClientMod.createSmtpClient(options);
+  
+  // Get pool status
+  const status = smtpClient.getPoolStatus();
+  expect(status).toBeTruthy();
+  expect(typeof status.total === 'number').toBeTruthy();
+  expect(typeof status.active === 'number').toBeTruthy();
+  expect(typeof status.idle === 'number').toBeTruthy();
+  expect(typeof status.pending === 'number').toBeTruthy();
+  
+  // Initially should have no connections
+  expect(status.total).toEqual(0);
+  expect(status.active).toEqual(0);
+  expect(status.idle).toEqual(0);
+  expect(status.pending).toEqual(0);
+});
+
+tap.test('verify backward compatibility - event handling', async () => {
+  const options: ISmtpClientOptions = {
+    host: 'smtp.example.com',
+    port: 587,
+    secure: false
+  };
+  
+  const smtpClient = smtpClientMod.createSmtpClient(options);
+  
+  // Test event listener methods don't throw
+  const testListener = () => {};
+  
+  expect(() => smtpClient.on('test', testListener)).not.toThrow();
+  expect(() => smtpClient.off('test', testListener)).not.toThrow();
+  expect(() => smtpClient.emit('test')).not.toThrow();
+});
+
+tap.test('clean up after compatibility tests', async () => {
+  // No-op - just to make sure everything is cleaned up properly
+});
+
+tap.test('stop', async () => {
+  await tap.stopForcefully();
+});
+
+export default tap.start();