@serve.zone/dcrouter 2.12.4

package/test/test.smtp.client.ts

@@ -0,0 +1,191 @@
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+import * as plugins from '../ts/plugins.js';
+import * as paths from '../ts/paths.js';
+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';
+
+/**
+ * Tests for the SMTP client class
+ */
+tap.test('verify SMTP client initialization', 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
+  const smtpClient = smtpClientMod.createSmtpClient(options);
+  
+  // Verify instance was created correctly
+  expect(smtpClient).toBeTruthy();
+  expect(smtpClient.isConnected()).toBeFalsy(); // Should start disconnected
+});
+
+tap.test('test SMTP client configuration update', async () => {
+  // Create test configuration
+  const options: ISmtpClientOptions = {
+    host: 'smtp.example.com',
+    port: 587,
+    secure: false
+  };
+  
+  // Create SMTP client instance
+  const smtpClient = smtpClientMod.createSmtpClient(options);
+  
+  // Update configuration
+  smtpClient.updateOptions({
+    host: 'new-smtp.example.com',
+    port: 465,
+    secure: true
+  });
+  
+  // Can't directly test private fields, but we can verify it doesn't throw
+  expect(() => smtpClient.updateOptions({
+    tls: {
+      rejectUnauthorized: false
+    }
+  })).not.toThrow();
+});
+
+// Mocked SMTP server for testing
+class MockSmtpServer {
+  private responses: Map<string, string>;
+  
+  constructor() {
+    this.responses = new Map();
+    
+    // Default responses
+    this.responses.set('connect', '220 smtp.example.com ESMTP ready');
+    this.responses.set('EHLO', '250-smtp.example.com\r\n250-PIPELINING\r\n250-SIZE 10240000\r\n250-STARTTLS\r\n250-AUTH PLAIN LOGIN\r\n250 HELP');
+    this.responses.set('MAIL FROM', '250 OK');
+    this.responses.set('RCPT TO', '250 OK');
+    this.responses.set('DATA', '354 Start mail input; end with <CRLF>.<CRLF>');
+    this.responses.set('data content', '250 OK: message accepted');
+    this.responses.set('QUIT', '221 Bye');
+  }
+  
+  public setResponse(command: string, response: string): void {
+    this.responses.set(command, response);
+  }
+  
+  public getResponse(command: string): string {
+    if (command.startsWith('MAIL FROM')) {
+      return this.responses.get('MAIL FROM') || '250 OK';
+    } else if (command.startsWith('RCPT TO')) {
+      return this.responses.get('RCPT TO') || '250 OK';
+    } else if (command.startsWith('EHLO') || command.startsWith('HELO')) {
+      return this.responses.get('EHLO') || '250 OK';
+    } else if (command === 'DATA') {
+      return this.responses.get('DATA') || '354 Start mail input; end with <CRLF>.<CRLF>';
+    } else if (command.includes('Content-Type')) {
+      return this.responses.get('data content') || '250 OK: message accepted';
+    } else if (command === 'QUIT') {
+      return this.responses.get('QUIT') || '221 Bye';
+    }
+    
+    return this.responses.get(command) || '250 OK';
+  }
+}
+
+/**
+ * This test validates the SMTP client public interface
+ */
+tap.test('verify SMTP client email delivery functionality with mock', async () => {
+  // Create a test email
+  const testEmail = new Email({
+    from: 'sender@example.com',
+    to: ['recipient@example.com'],
+    subject: 'Test Email',
+    text: 'This is a test email'
+  });
+  
+  // Create SMTP client options
+  const options: ISmtpClientOptions = {
+    host: 'smtp.example.com',
+    port: 587,
+    secure: false,
+    domain: 'test.example.com',
+    auth: {
+      user: 'testuser',
+      pass: 'testpass'
+    }
+  };
+  
+  // Create SMTP client instance
+  const smtpClient = smtpClientMod.createSmtpClient(options);
+  
+  // Test public methods exist and have correct signatures
+  expect(typeof smtpClient.sendMail).toEqual('function');
+  expect(typeof smtpClient.verify).toEqual('function');
+  expect(typeof smtpClient.isConnected).toEqual('function');
+  expect(typeof smtpClient.getPoolStatus).toEqual('function');
+  expect(typeof smtpClient.updateOptions).toEqual('function');
+  expect(typeof smtpClient.close).toEqual('function');
+  
+  // Test connection status before any operation
+  expect(smtpClient.isConnected()).toBeFalsy();
+  
+  // Test pool status
+  const poolStatus = smtpClient.getPoolStatus();
+  expect(poolStatus).toBeTruthy();
+  expect(typeof poolStatus.active).toEqual('number');
+  expect(typeof poolStatus.idle).toEqual('number');
+  expect(typeof poolStatus.total).toEqual('number');
+  
+  // Since we can't connect to a real server, we'll skip the actual send test
+  // and just verify the client was created correctly
+  expect(smtpClient).toBeTruthy();
+});
+
+tap.test('test SMTP client error handling with mock', async () => {
+  // Create SMTP client instance
+  const smtpClient = smtpClientMod.createSmtpClient({
+    host: 'smtp.example.com',
+    port: 587,
+    secure: false
+  });
+  
+  // Test with valid email (Email class might allow any string)
+  const testEmail = new Email({
+    from: 'sender@example.com',
+    to: ['recipient@example.com'],
+    subject: 'Test Email',
+    text: 'This is a test email'
+  });
+  
+  // Test event listener methods
+  const mockListener = () => {};
+  smtpClient.on('test-event', mockListener);
+  smtpClient.off('test-event', mockListener);
+  
+  // Test update options
+  smtpClient.updateOptions({
+    auth: {
+      user: 'newuser',
+      pass: 'newpass'
+    }
+  });
+  
+  // Verify client is still functional
+  expect(smtpClient.isConnected()).toBeFalsy();
+  
+  // Test close on a non-connected client
+  await smtpClient.close();
+  expect(smtpClient.isConnected()).toBeFalsy();
+});
+
+// Final clean-up test
+tap.test('clean up after tests', async () => {
+  // No-op - just to make sure everything is cleaned up properly
+});
+
+tap.test('stop', async () => {
+  await tap.stopForcefully();
+});
+
+export default tap.start();

package/test/test.smtp.server.ts

@@ -0,0 +1,180 @@
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+import * as plugins from '../ts/plugins.js';
+import * as paths from '../ts/paths.js';
+import { createSmtpServer } from '../ts/mail/delivery/smtpserver/index.js';
+import { UnifiedEmailServer } from '../ts/mail/routing/classes.unified.email.server.js';
+import { Email } from '../ts/mail/core/classes.email.js';
+import type { ISmtpServerOptions } from '../ts/mail/delivery/interfaces.js';
+
+/**
+ * Tests for the SMTP server class
+ */
+tap.test('verify SMTP server initialization', async () => {
+  // Mock email server
+  const mockEmailServer = {
+    processEmailByMode: async () => new Email({
+      from: 'test@example.com',
+      to: 'recipient@example.com',
+      subject: 'Test Email',
+      text: 'This is a test email'
+    })
+  } as any;
+
+  // Create test configuration
+  const options: ISmtpServerOptions = {
+    port: 2525, // Use a high port for testing
+    hostname: 'test.example.com',
+    key: '-----BEGIN RSA PRIVATE KEY-----\nMIIEpAIBAAKCAQEAxzYIwlfnr7AK2v6E+c2oYD7nAIXIIvDuvVvZ8R9kyxXIzTXB\nj5D1AgntqKS3bFR1XT8hCVeXjuLKPBvXbhVjG15gXlXxpNiFi1ZcphJvs4zB/Vh7\nZv2ALt3anSIwsJ2rZA/R/GqdJPkHvYf/GMTDLw0YllR0YOevErnRIIM5S58Lj2nT\nCr5v5hK1Gl9mWwRkFQKkWVl2UXt/JX6C7Z6UyJXMZSnoG0Kw6GQje41K5r0Zdzrh\nrGfmb9wSDUn9sZGX6il+oMiYz7UgQkPEzGUZEJxKJwxy8ZgPdSgbvYq4WwPwbBUJ\nlpw0gt5i6HOS7CphRama+zAf5LvfSLoLXSP5JwIDAQABAoIBAQC8C5Ge6wS4LuH9\ntbZFPwjdGHXL+QT2fOFxPBrE7PkeY8UXD7G5Yei6iqqCxJh8nhLQ3DoayhZM69hO\nePOV1Z/LDERCnGel15WKQ1QJ1HZ+JQXnfQrE1Mi9QrXO5bVFtnXIr0mZ+AzwoUmn\nK5fYCvaL3xDZPDzOYL5kZG2hQKgbywGKZoQx16G0dSEhlAHbK9z6XmPRrbUKGzB8\nqV7QGbL7BUTQs5JW/8LpkYr5C0q5THtUVb9mHNR3jPf9WTPQ0D3lxcbLS4PQ8jQ/\nL/GcuHGmsXhe2Unw3w2wpuJKPeHKz4rBNIvaSjIZl9/dIKM88JYQTiIGKErxsC0e\nkczQMp6BAoGBAO0zUN8H7ynXGNNtK/tJo0lI3qg1ZKgr+0CU2L5eU8Bn1oJ1JkCI\nWD3p36NdECx5tGexm9U6MN+HzKYUjnQ6LKzbHQGLZqzF5IL5axXgCn8w4BM+6Ixm\ny8kQgsTKlKRMXIn8RZCmXNnc7v0FhBgpDxPmm7ZUuOPrInd8Ph4mEsePAoGBANb4\n3/izAHnLEp3/sTOZpfWBnDcvEHCG7/JAX0TDRW1FpXiTHpvDV1j3XU3EvLl7WRJ1\nB+B8h/Z6kQtUUxQ3I+zxuQIkQYI8qPu+xhQ8gb5AIO5CMX09+xKUgYjQtm7kYs7W\nL0LD9u3hkGsJk2wfVvMJKb3OSIHeTwRzFCzGX995AoGADkLB8eu/FKAIfwRPCHVE\nsfwMtqjkj2XJ9FeNcRQ5g/Tf8OGnCGEzBwXb05wJVrXUgXp4dBaqYTdAKj8uLEvd\nmi9t/LzR+33cGUdAQHItxcKbsMv00TyNRQUvZFZ7ZEY8aBkv5uZfvJHZ5iQ8C7+g\nHGXNfVGXGPutz/KN6X25CLECgYEAjVLK0MkXzLxCYJRDIhB1TpQVXjpxYUP2Vxls\nSSxfeYqkJPgNvYiHee33xQ8+TP1y9WzkWh+g2AbGmwTuKKL6CvQS9gKVvqqaFB7y\nKrkR13MTPJKvHHdQYKGQqQGgHKh0kGFCC0+PoVwtYs/XU1KpZCE16nNgXrOvTYNN\nHxESa+kCgYB7WOcawTp3WdKP8JbolxIfxax7Kd4QkZhY7dEb4JxBBYXXXpv/NHE9\npcJw4eKDyY+QE2AHPu3+fQYzXopaaTGRpB+ynEfYfD2hW+HnOWfWu/lFJbiwBn/S\nwRsYzSWiLtNplKNFRrsSoMWlh8GOTUpZ7FMLXWhE4rE9NskQBbYq8g==\n-----END RSA PRIVATE KEY-----',
+    cert: '-----BEGIN CERTIFICATE-----\nMIIDazCCAlOgAwIBAgIUcmAewXEYwtzbZmZAJ5inMogKSbowDQYJKoZIhvcNAQEL\nBQAwRTELMAkGA1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoM\nGEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDAeFw0yNDAyMjAwODM4MzRaFw0yNTAy\nMTkwODM4MzRaMEUxCzAJBgNVBAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEw\nHwYDVQQKDBhJbnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQwggEiMA0GCSqGSIb3DQEB\nAQUAA4IBDwAwggEKAoIBAQDHNgjCV+evsAra/oT5zahgPucAhcgi8O69W9nxH2TL\nFcjNNcGPkPUCCe2opLdsVHVdPyEJV5eO4so8G9duFWMbXmBeVfGk2IWLVlymEm+z\njMH9WHtm/YAu3dqdIjCwnatED9H8ap0k+Qd9h/8YxMMvDRiWVHRg568SudEggzlL\nnwuPadMKvm/mErUaX2ZbBGQVAqRZWXZRe38lfoLtnpTIlcxlKegbQrDoZCN7jUrm\nvRl3OuGsZ+Zv3BINSf2xkZfqKX6gyJjPtSBCQ8TMZRkQnEonDHLxmA91KBu9irhb\nA/BsFQmWnDSC3mLoc5LsKmFFqZr7MB/ku99IugtdI/knAgMBAAGjUzBRMB0GA1Ud\nDgQWBBQryyWLuN22OqU1r9HIt2tMLBk42DAfBgNVHSMEGDAWgBQryyWLuN22OqU1\nr9HIt2tMLBk42DAPBgNVHRMBAf8EBTADAQH/MA0GCSqGSIb3DQEBCwUAA4IBAQAe\nCeXQZlXJ2xLnDoOoKY3BpodErNmAwygGYxwDCU0xPbpUMPrQhLI80JlZmfy58gT/\n0ZbULS+srShfEsFnBLmzWLGXDvA/IKCQyTmCQwbPeELGXF6h4URMb+lQL7WL9tY0\nuUg2dA+7CtYokIrOkGqUitPK3yvVhxugkf51WIgKMACZDibOQSWrV5QO2vHOAaO9\nePzRGGl3+Ebmcs3+5w1fI6OLsIZH10lfEnC83C0lO8tIJlGsXMQkCjAcX22rT0rc\nAcxLm07H4EwMwgOAJUkuDjD3y4+KH91jKWF8bhaLZooFB8lccNnaCRiuZRnXlvmf\nM7uVlLGwlj5R9iHd+0dP\n-----END CERTIFICATE-----'
+  };
+
+  // Create SMTP server instance
+  const smtpServer = createSmtpServer(mockEmailServer, options);
+  
+  // Verify instance was created correctly
+  expect(smtpServer).toBeTruthy();
+  
+  // Test that the listen method exists and is callable
+  expect(typeof smtpServer.listen === 'function').toBeTruthy();
+  
+  // Test that the close method exists
+  expect(typeof smtpServer.close === 'function').toBeTruthy();
+});
+
+tap.test('verify SMTP server listen method - skipping test that accesses private properties', async (tools) => {
+  tools.skip('Skipping test that accesses private properties');
+  // Mock email server
+  const mockEmailServer = {
+    processEmailByMode: async () => new Email({
+      from: 'test@example.com',
+      to: 'recipient@example.com',
+      subject: 'Test Email',
+      text: 'This is a test email'
+    })
+  } as any;
+
+  // Create test configuration without certificates (will use self-signed)
+  const options: ISmtpServerOptions = {
+    port: 2526, // Use a different port for this test
+    hostname: 'test.example.com',
+    connectionTimeout: 5000 // Short timeout for tests
+  };
+
+  // Create SMTP server instance
+  const smtpServer = createSmtpServer(mockEmailServer, options);
+  
+  // Test that server was created
+  expect(smtpServer).toBeTruthy();
+  expect(smtpServer).toHaveProperty('server');
+  
+  // Mock server methods to avoid actual networking
+  let listenCalled = false;
+  let closeCalled = false;
+  
+  if (smtpServer.server) {
+    const originalListen = smtpServer.server.listen;
+    const originalClose = smtpServer.server.close;
+    
+    smtpServer.server.listen = function(port, callback) {
+      listenCalled = true;
+      if (callback) callback();
+      return this;
+    };
+    
+    smtpServer.server.close = function(callback) {
+      closeCalled = true;
+      if (callback) callback(null);
+      return this;
+    };
+    
+    try {
+      // Test listen method
+      await smtpServer.listen();
+      expect(listenCalled).toBeTruthy();
+      
+      // Test close method 
+      await smtpServer.close();
+      expect(closeCalled).toBeTruthy();
+    } finally {
+      // Restore original methods
+      smtpServer.server.listen = originalListen;
+      smtpServer.server.close = originalClose;
+    }
+  }
+});
+
+tap.test('verify SMTP server error handling - skipping test that accesses private properties', async (tools) => {
+  tools.skip('Skipping test that accesses private properties');
+  // Mock email server
+  const mockEmailServer = {
+    processEmailByMode: async () => new Email({
+      from: 'test@example.com',
+      to: 'recipient@example.com',
+      subject: 'Test Email',
+      text: 'This is a test email'
+    })
+  } as any;
+
+  // Create test configuration without certificates
+  const options: ISmtpServerOptions = {
+    port: 2527, // Use port that should work
+    hostname: 'test.example.com'
+  };
+
+  // Create SMTP server instance
+  const smtpServer = createSmtpServer(mockEmailServer, options);
+  
+  // Test error handling by mocking the server's error event
+  if (smtpServer.server) {
+    const originalListen = smtpServer.server.listen;
+    const originalOn = smtpServer.server.on;
+    const originalOnce = smtpServer.server.once;
+    
+    let errorCallback: (err: Error) => void;
+    let listeningCallback: () => void;
+    
+    smtpServer.server.listen = function(port, callback) {
+      // Simulate error after a delay
+      setTimeout(() => {
+        if (errorCallback) {
+          errorCallback(new Error('EACCES: Permission denied'));
+        }
+      }, 10);
+      return this;
+    };
+    
+    smtpServer.server.on = function(event: string, callback: any) {
+      if (event === 'error') {
+        errorCallback = callback;
+      }
+      return originalOn.call(this, event, callback);
+    };
+    
+    smtpServer.server.once = function(event: string, callback: any) {
+      if (event === 'listening') {
+        listeningCallback = callback;
+      }
+      return originalOnce.call(this, event, callback);
+    };
+    
+    try {
+      // This should fail with an error
+      await smtpServer.listen().catch(error => {
+        // Expect an error
+        expect(error).toBeTruthy();
+        expect(error.message).toContain('EACCES');
+      });
+    } finally {
+      // Restore original methods
+      smtpServer.server.listen = originalListen;
+      smtpServer.server.on = originalOn as any;
+      smtpServer.server.once = originalOnce as any;
+    }
+  }
+});
+
+tap.test('stop', async () => {
+  await tap.stopForcefully();
+});
+
+export default tap.start();

package/test/test.socket-handler-integration.ts

@@ -0,0 +1,240 @@
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+import { DcRouter } from '../ts/classes.dcrouter.js';
+import * as plugins from '../ts/plugins.js';
+
+let dcRouter: DcRouter;
+
+tap.test('should run both DNS and email with socket-handlers simultaneously', async () => {
+  dcRouter = new DcRouter({
+    dnsDomain: 'dns.integration.test',
+    emailConfig: {
+      ports: [25, 587, 465],
+      hostname: 'mail.integration.test',
+      domains: ['integration.test'],
+      routes: [],
+      useSocketHandler: true
+    },
+    smartProxyConfig: {
+      routes: []
+    }
+  });
+  
+  await dcRouter.start();
+  
+  // Verify both services are running
+  const dnsServer = (dcRouter as any).dnsServer;
+  const emailServer = (dcRouter as any).emailServer;
+  
+  expect(dnsServer).toBeDefined();
+  expect(emailServer).toBeDefined();
+  
+  // Verify SmartProxy has routes for both services
+  const smartProxy = (dcRouter as any).smartProxy;
+  const routes = smartProxy?.options?.routes || [];
+  
+  // Count DNS routes
+  const dnsRoutes = routes.filter((route: any) => 
+    route.name?.includes('dns-over-https')
+  );
+  expect(dnsRoutes.length).toEqual(2);
+  
+  // Count email routes
+  const emailRoutes = routes.filter((route: any) => 
+    route.name?.includes('-route') && !route.name?.includes('dns')
+  );
+  expect(emailRoutes.length).toEqual(3);
+  
+  // All routes should be socket-handler type
+  [...dnsRoutes, ...emailRoutes].forEach((route: any) => {
+    expect(route.action.type).toEqual('socket-handler');
+    expect(route.action.socketHandler).toBeDefined();
+  });
+  
+  await dcRouter.stop();
+});
+
+tap.test('should handle mixed configuration (DNS socket-handler, email traditional)', async () => {
+  dcRouter = new DcRouter({
+    dnsDomain: 'dns.mixed.test',
+    emailConfig: {
+      ports: [25, 587],
+      hostname: 'mail.mixed.test',
+      domains: ['mixed.test'],
+      routes: [],
+      useSocketHandler: false // Traditional mode
+    },
+    smartProxyConfig: {
+      routes: []
+    }
+  });
+  
+  await dcRouter.start();
+  
+  const smartProxy = (dcRouter as any).smartProxy;
+  const routes = smartProxy?.options?.routes || [];
+  
+  // DNS routes should be socket-handler
+  const dnsRoutes = routes.filter((route: any) => 
+    route.name?.includes('dns-over-https')
+  );
+  dnsRoutes.forEach((route: any) => {
+    expect(route.action.type).toEqual('socket-handler');
+  });
+  
+  // Email routes should be forward
+  const emailRoutes = routes.filter((route: any) => 
+    route.name?.includes('-route') && !route.name?.includes('dns')
+  );
+  emailRoutes.forEach((route: any) => {
+    expect(route.action.type).toEqual('forward');
+    expect(route.action.target.port).toBeGreaterThan(10000); // Internal port
+  });
+  
+  await dcRouter.stop();
+});
+
+tap.test('should properly clean up resources on stop', async () => {
+  dcRouter = new DcRouter({
+    dnsDomain: 'dns.cleanup.test',
+    emailConfig: {
+      ports: [25],
+      hostname: 'mail.cleanup.test',
+      domains: ['cleanup.test'],
+      routes: [],
+      useSocketHandler: true
+    }
+  });
+  
+  await dcRouter.start();
+  
+  // Services should be running
+  expect((dcRouter as any).dnsServer).toBeDefined();
+  expect((dcRouter as any).emailServer).toBeDefined();
+  expect((dcRouter as any).smartProxy).toBeDefined();
+  
+  await dcRouter.stop();
+  
+  // After stop, services should still be defined but stopped
+  // (The stop method doesn't null out the properties, just stops the services)
+  expect((dcRouter as any).dnsServer).toBeDefined();
+  expect((dcRouter as any).emailServer).toBeDefined();
+});
+
+tap.test('should handle configuration updates correctly', async () => {
+  // Start with minimal config
+  dcRouter = new DcRouter({
+    smartProxyConfig: {
+      routes: []
+    }
+  });
+  
+  await dcRouter.start();
+  
+  // Initially no DNS or email
+  expect((dcRouter as any).dnsServer).toBeUndefined();
+  expect((dcRouter as any).emailServer).toBeUndefined();
+  
+  // Update to add email config
+  await dcRouter.updateEmailConfig({
+    ports: [25],
+    hostname: 'mail.update.test',
+    domains: ['update.test'],
+    routes: [],
+    useSocketHandler: true
+  });
+  
+  // Now email should be running
+  expect((dcRouter as any).emailServer).toBeDefined();
+  
+  await dcRouter.stop();
+});
+
+tap.test('performance: socket-handler should not create internal listeners', async () => {
+  dcRouter = new DcRouter({
+    dnsDomain: 'dns.perf.test',
+    emailConfig: {
+      ports: [25, 587, 465],
+      hostname: 'mail.perf.test',
+      domains: ['perf.test'],
+      routes: [],
+      useSocketHandler: true
+    }
+  });
+  
+  await dcRouter.start();
+  
+  // Get the number of listeners before creating handlers
+  const eventCounts: { [key: string]: number } = {};
+  
+  // DNS server should not have HTTPS listeners
+  const dnsServer = (dcRouter as any).dnsServer;
+  // The DNS server should exist but not bind to HTTPS port
+  expect(dnsServer).toBeDefined();
+  
+  // Email server should not have any server listeners
+  const emailServer = (dcRouter as any).emailServer;
+  expect(emailServer.servers.length).toEqual(0);
+  
+  await dcRouter.stop();
+});
+
+tap.test('should handle errors gracefully', async () => {
+  dcRouter = new DcRouter({
+    dnsDomain: 'dns.error.test',
+    emailConfig: {
+      ports: [25],
+      hostname: 'mail.error.test',
+      domains: ['error.test'],
+      routes: [],
+      useSocketHandler: true
+    }
+  });
+  
+  await dcRouter.start();
+  
+  // Test DNS error handling
+  const dnsHandler = (dcRouter as any).createDnsSocketHandler();
+  const errorSocket = new plugins.net.Socket();
+  
+  let errorThrown = false;
+  try {
+    // This should handle the error gracefully
+    await dnsHandler(errorSocket);
+  } catch (error) {
+    errorThrown = true;
+  }
+  
+  // Should not throw, should handle gracefully
+  expect(errorThrown).toBeFalsy();
+  
+  await dcRouter.stop();
+});
+
+tap.test('should correctly identify secure connections', async () => {
+  dcRouter = new DcRouter({
+    emailConfig: {
+      ports: [465],
+      hostname: 'mail.secure.test',
+      domains: ['secure.test'],
+      routes: [],
+      useSocketHandler: true
+    }
+  });
+  
+  await dcRouter.start();
+  
+  // The email socket handler for port 465 should handle TLS
+  const handler = (dcRouter as any).createMailSocketHandler(465);
+  expect(handler).toBeDefined();
+  
+  // Port 465 requires immediate TLS, which is handled in the socket handler
+  // This is different from ports 25/587 which use STARTTLS
+  
+  await dcRouter.stop();
+});
+
+tap.test('stop', async () => {
+  await tap.stopForcefully();
+});
+
+export default tap.start();