@serve.zone/dcrouter 2.12.4

package/test/suite/smtpclient_connection/test.ccm-07.automatic-reconnection.ts

@@ -0,0 +1,324 @@
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+import { startTestServer, stopTestServer, type ITestServer } from '../../helpers/server.loader.js';
+import { createSmtpClient, createPooledSmtpClient } from '../../../ts/mail/delivery/smtpclient/index.js';
+import type { SmtpClient } from '../../../ts/mail/delivery/smtpclient/smtp-client.js';
+import { Email } from '../../../ts/mail/core/classes.email.js';
+import * as net from 'net';
+
+let testServer: ITestServer;
+
+tap.test('setup - start SMTP server for reconnection tests', async () => {
+  testServer = await startTestServer({
+    port: 2533,
+    tlsEnabled: false,
+    authRequired: false
+  });
+  
+  expect(testServer.port).toEqual(2533);
+});
+
+tap.test('CCM-07: Automatic Reconnection - should reconnect after connection loss', async () => {
+  const client = createSmtpClient({
+    host: testServer.hostname,
+    port: testServer.port,
+    secure: false,
+    connectionTimeout: 5000,
+    debug: true
+  });
+  
+  // First connection and email
+  const email1 = new Email({
+    from: 'sender@example.com',
+    to: 'recipient@example.com',
+    subject: 'Before Disconnect',
+    text: 'First email before connection loss'
+  });
+  
+  const result1 = await client.sendMail(email1);
+  expect(result1.success).toBeTrue();
+  // Note: Connection state may vary after sending
+  
+  // Force disconnect
+  await client.close();
+  expect(client.isConnected()).toBeFalse();
+  
+  // Try to send another email - should auto-reconnect
+  const email2 = new Email({
+    from: 'sender@example.com',
+    to: 'recipient@example.com',
+    subject: 'After Reconnect',
+    text: 'Email after automatic reconnection'
+  });
+  
+  const result2 = await client.sendMail(email2);
+  expect(result2.success).toBeTrue();
+  // Connection successfully handled reconnection
+  
+  await client.close();
+  console.log('✅ Automatic reconnection successful');
+});
+
+tap.test('CCM-07: Automatic Reconnection - pooled client should reconnect failed connections', async () => {
+  const pooledClient = createPooledSmtpClient({
+    host: testServer.hostname,
+    port: testServer.port,
+    secure: false,
+    maxConnections: 3,
+    connectionTimeout: 5000,
+    debug: true
+  });
+  
+  // Send emails to establish pool connections
+  const promises = [];
+  for (let i = 0; i < 3; i++) {
+    const email = new Email({
+      from: 'sender@example.com',
+      to: `recipient${i}@example.com`,
+      subject: `Pool Test ${i}`,
+      text: 'Testing connection pool'
+    });
+    promises.push(
+      pooledClient.sendMail(email).catch(error => {
+        console.error(`Failed to send initial email ${i}:`, error.message);
+        return { success: false, error: error.message };
+      })
+    );
+  }
+  
+  await Promise.all(promises);
+  
+  const poolStatus1 = pooledClient.getPoolStatus();
+  console.log('📊 Pool status before disruption:', poolStatus1);
+  
+  // Send more emails - pool should handle any connection issues
+  const promises2 = [];
+  for (let i = 0; i < 5; i++) {
+    const email = new Email({
+      from: 'sender@example.com',
+      to: `recipient${i}@example.com`,
+      subject: `Pool Recovery ${i}`,
+      text: 'Testing pool recovery'
+    });
+    promises2.push(
+      pooledClient.sendMail(email).catch(error => {
+        console.error(`Failed to send email ${i}:`, error.message);
+        return { success: false, error: error.message };
+      })
+    );
+  }
+  
+  const results = await Promise.all(promises2);
+  let successCount = 0;
+  results.forEach(result => {
+    if (result.success) {
+      successCount++;
+    }
+  });
+  
+  // At least some emails should succeed
+  expect(successCount).toBeGreaterThan(0);
+  console.log(`✅ Pool recovery: ${successCount}/${results.length} emails succeeded`);
+  
+  const poolStatus2 = pooledClient.getPoolStatus();
+  console.log('📊 Pool status after recovery:', poolStatus2);
+  
+  await pooledClient.close();
+  console.log('✅ Connection pool handles reconnection automatically');
+});
+
+tap.test('CCM-07: Automatic Reconnection - should handle server restart', async () => {
+  // Create client
+  const client = createSmtpClient({
+    host: testServer.hostname,
+    port: testServer.port,
+    secure: false,
+    connectionTimeout: 5000
+  });
+  
+  // Send first email
+  const email1 = new Email({
+    from: 'sender@example.com',
+    to: 'recipient@example.com',
+    subject: 'Before Server Restart',
+    text: 'Email before server restart'
+  });
+  
+  const result1 = await client.sendMail(email1);
+  expect(result1.success).toBeTrue();
+  
+  // Simulate server restart
+  console.log('🔄 Simulating server restart...');
+  await stopTestServer(testServer);
+  await new Promise(resolve => setTimeout(resolve, 1000));
+  
+  // Restart server on same port
+  testServer = await startTestServer({
+    port: 2533,
+    tlsEnabled: false,
+    authRequired: false
+  });
+  
+  // Try to send another email
+  const email2 = new Email({
+    from: 'sender@example.com',
+    to: 'recipient@example.com',
+    subject: 'After Server Restart',
+    text: 'Email after server restart'
+  });
+  
+  const result2 = await client.sendMail(email2);
+  expect(result2.success).toBeTrue();
+  
+  await client.close();
+  console.log('✅ Client recovered from server restart');
+});
+
+tap.test('CCM-07: Automatic Reconnection - should handle network interruption', async () => {
+  const client = createSmtpClient({
+    host: testServer.hostname,
+    port: testServer.port,
+    secure: false,
+    connectionTimeout: 5000,
+    socketTimeout: 10000
+  });
+  
+  // Establish connection
+  await client.verify();
+  
+  // Send emails with simulated network issues
+  for (let i = 0; i < 3; i++) {
+    const email = new Email({
+      from: 'sender@example.com',
+      to: 'recipient@example.com',
+      subject: `Network Test ${i}`,
+      text: `Testing network resilience ${i}`
+    });
+    
+    try {
+      const result = await client.sendMail(email);
+      expect(result.success).toBeTrue();
+      console.log(`✅ Email ${i + 1} sent successfully`);
+    } catch (error) {
+      console.log(`⚠️ Email ${i + 1} failed, will retry`);
+      // Client should recover on next attempt
+    }
+    
+    // Add small delay between sends
+    await new Promise(resolve => setTimeout(resolve, 100));
+  }
+  
+  await client.close();
+});
+
+tap.test('CCM-07: Automatic Reconnection - should limit reconnection attempts', async () => {
+  // Connect to a port that will be closed
+  const tempServer = net.createServer();
+  await new Promise<void>((resolve) => {
+    tempServer.listen(2534, () => resolve());
+  });
+  
+  const client = createSmtpClient({
+    host: 'localhost',
+    port: 2534,
+    secure: false,
+    connectionTimeout: 2000
+  });
+  
+  // Close the server to simulate failure
+  tempServer.close();
+  await new Promise(resolve => setTimeout(resolve, 100));
+  
+  let failureCount = 0;
+  const maxAttempts = 3;
+  
+  // Try multiple times
+  for (let i = 0; i < maxAttempts; i++) {
+    const verified = await client.verify();
+    if (!verified) {
+      failureCount++;
+    }
+  }
+  
+  expect(failureCount).toEqual(maxAttempts);
+  console.log('✅ Reconnection attempts are limited to prevent infinite loops');
+});
+
+tap.test('CCM-07: Automatic Reconnection - should maintain state after reconnect', async () => {
+  const client = createSmtpClient({
+    host: testServer.hostname,
+    port: testServer.port,
+    secure: false,
+    connectionTimeout: 5000
+  });
+  
+  // Send email with specific settings
+  const email1 = new Email({
+    from: 'sender@example.com',
+    to: 'recipient@example.com',
+    subject: 'State Test 1',
+    text: 'Testing state persistence',
+    priority: 'high',
+    headers: {
+      'X-Test-ID': 'test-123'
+    }
+  });
+  
+  const result1 = await client.sendMail(email1);
+  expect(result1.success).toBeTrue();
+  
+  // Force reconnection
+  await client.close();
+  
+  // Send another email - client state should be maintained
+  const email2 = new Email({
+    from: 'sender@example.com',
+    to: 'recipient@example.com',
+    subject: 'State Test 2',
+    text: 'After reconnection',
+    priority: 'high',
+    headers: {
+      'X-Test-ID': 'test-456'
+    }
+  });
+  
+  const result2 = await client.sendMail(email2);
+  expect(result2.success).toBeTrue();
+  
+  await client.close();
+  console.log('✅ Client state maintained after reconnection');
+});
+
+tap.test('CCM-07: Automatic Reconnection - should handle rapid reconnections', async () => {
+  const client = createSmtpClient({
+    host: testServer.hostname,
+    port: testServer.port,
+    secure: false,
+    connectionTimeout: 5000
+  });
+  
+  // Rapid connect/disconnect cycles
+  for (let i = 0; i < 5; i++) {
+    const email = new Email({
+      from: 'sender@example.com',
+      to: 'recipient@example.com',
+      subject: `Rapid Test ${i}`,
+      text: 'Testing rapid reconnections'
+    });
+    
+    const result = await client.sendMail(email);
+    expect(result.success).toBeTrue();
+    
+    // Force disconnect
+    await client.close();
+    
+    // No delay - immediate next attempt
+  }
+  
+  console.log('✅ Rapid reconnections handled successfully');
+});
+
+tap.test('cleanup - stop SMTP server', async () => {
+  await stopTestServer(testServer);
+});
+
+export default tap.start();

package/test/suite/smtpclient_connection/test.ccm-08.dns-resolution.ts

@@ -0,0 +1,139 @@
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+import { startTestServer, stopTestServer, type ITestServer } from '../../helpers/server.loader.js';
+import * as dns from 'dns';
+import { promisify } from 'util';
+
+const resolveMx = promisify(dns.resolveMx);
+const resolve4 = promisify(dns.resolve4);
+const resolve6 = promisify(dns.resolve6);
+
+let testServer: ITestServer;
+
+tap.test('setup test SMTP server', async () => {
+  testServer = await startTestServer({
+    port: 2534,
+    tlsEnabled: false,
+    authRequired: false
+  });
+  expect(testServer).toBeTruthy();
+  expect(testServer.port).toEqual(2534);
+});
+
+tap.test('CCM-08: DNS resolution and MX record lookup', async () => {
+  // Test basic DNS resolution
+  try {
+    const ipv4Addresses = await resolve4('example.com');
+    expect(ipv4Addresses).toBeArray();
+    expect(ipv4Addresses.length).toBeGreaterThan(0);
+    console.log('IPv4 addresses for example.com:', ipv4Addresses);
+  } catch (error) {
+    console.log('IPv4 resolution failed (may be expected in test environment):', error.message);
+  }
+
+  // Test IPv6 resolution
+  try {
+    const ipv6Addresses = await resolve6('example.com');
+    expect(ipv6Addresses).toBeArray();
+    console.log('IPv6 addresses for example.com:', ipv6Addresses);
+  } catch (error) {
+    console.log('IPv6 resolution failed (common for many domains):', error.message);
+  }
+
+  // Test MX record lookup
+  try {
+    const mxRecords = await resolveMx('example.com');
+    expect(mxRecords).toBeArray();
+    if (mxRecords.length > 0) {
+      expect(mxRecords[0]).toHaveProperty('priority');
+      expect(mxRecords[0]).toHaveProperty('exchange');
+      console.log('MX records for example.com:', mxRecords);
+    }
+  } catch (error) {
+    console.log('MX record lookup failed (may be expected in test environment):', error.message);
+  }
+
+  // Test local resolution (should work in test environment)
+  try {
+    const localhostIpv4 = await resolve4('localhost');
+    expect(localhostIpv4).toContain('127.0.0.1');
+  } catch (error) {
+    // Fallback for environments where localhost doesn't resolve via DNS
+    console.log('Localhost DNS resolution not available, using direct IP');
+  }
+
+  // Test invalid domain handling
+  try {
+    await resolve4('this-domain-definitely-does-not-exist-12345.com');
+    expect(true).toBeFalsy(); // Should not reach here
+  } catch (error) {
+    expect(error.code).toMatch(/ENOTFOUND|ENODATA/);
+  }
+
+  // Test MX record priority sorting
+  const mockMxRecords = [
+    { priority: 20, exchange: 'mx2.example.com' },
+    { priority: 10, exchange: 'mx1.example.com' },
+    { priority: 30, exchange: 'mx3.example.com' }
+  ];
+  
+  const sortedRecords = mockMxRecords.sort((a, b) => a.priority - b.priority);
+  expect(sortedRecords[0].exchange).toEqual('mx1.example.com');
+  expect(sortedRecords[1].exchange).toEqual('mx2.example.com');
+  expect(sortedRecords[2].exchange).toEqual('mx3.example.com');
+});
+
+tap.test('CCM-08: DNS caching behavior', async () => {
+  const startTime = Date.now();
+  
+  // First resolution (cold cache)
+  try {
+    await resolve4('example.com');
+  } catch (error) {
+    // Ignore errors, we're testing timing
+  }
+  
+  const firstResolutionTime = Date.now() - startTime;
+  
+  // Second resolution (potentially cached)
+  const secondStartTime = Date.now();
+  try {
+    await resolve4('example.com');
+  } catch (error) {
+    // Ignore errors, we're testing timing
+  }
+  
+  const secondResolutionTime = Date.now() - secondStartTime;
+  
+  console.log(`First resolution: ${firstResolutionTime}ms, Second resolution: ${secondResolutionTime}ms`);
+  
+  // Note: We can't guarantee caching behavior in all environments
+  // so we just log the times for manual inspection
+});
+
+tap.test('CCM-08: Multiple A record handling', async () => {
+  // Test handling of domains with multiple A records
+  try {
+    const googleIps = await resolve4('google.com');
+    if (googleIps.length > 1) {
+      expect(googleIps).toBeArray();
+      expect(googleIps.length).toBeGreaterThan(1);
+      console.log('Multiple A records found for google.com:', googleIps);
+      
+      // Verify all are valid IPv4 addresses
+      const ipv4Regex = /^(\d{1,3}\.){3}\d{1,3}$/;
+      for (const ip of googleIps) {
+        expect(ip).toMatch(ipv4Regex);
+      }
+    }
+  } catch (error) {
+    console.log('Could not resolve google.com:', error.message);
+  }
+});
+
+tap.test('cleanup test SMTP server', async () => {
+  if (testServer) {
+    await stopTestServer(testServer);
+  }
+});
+
+export default tap.start();

package/test/suite/smtpclient_connection/test.ccm-09.ipv6-dual-stack.ts

@@ -0,0 +1,167 @@
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+import { startTestServer, stopTestServer, type ITestServer } from '../../helpers/server.loader.js';
+import { createSmtpClient } from '../../../ts/mail/delivery/smtpclient/index.js';
+import * as net from 'net';
+import * as os from 'os';
+
+let testServer: ITestServer;
+
+tap.test('setup test SMTP server', async () => {
+  testServer = await startTestServer({
+    port: 2535,
+    tlsEnabled: false,
+    authRequired: false
+  });
+  expect(testServer).toBeTruthy();
+  expect(testServer.port).toEqual(2535);
+});
+
+tap.test('CCM-09: Check system IPv6 support', async () => {
+  const networkInterfaces = os.networkInterfaces();
+  let hasIPv6 = false;
+  
+  for (const interfaceName in networkInterfaces) {
+    const interfaces = networkInterfaces[interfaceName];
+    if (interfaces) {
+      for (const iface of interfaces) {
+        if (iface.family === 'IPv6' && !iface.internal) {
+          hasIPv6 = true;
+          console.log(`Found IPv6 address: ${iface.address} on ${interfaceName}`);
+        }
+      }
+    }
+  }
+  
+  console.log(`System has IPv6 support: ${hasIPv6}`);
+});
+
+tap.test('CCM-09: IPv4 connection test', async () => {
+  const smtpClient = createSmtpClient({
+    host: '127.0.0.1', // Explicit IPv4
+    port: testServer.port,
+    secure: false,
+    connectionTimeout: 5000,
+    debug: true
+  });
+
+  // Test connection using verify
+  const verified = await smtpClient.verify();
+  expect(verified).toBeTrue();
+  
+  console.log('Successfully connected via IPv4');
+  
+  await smtpClient.close();
+});
+
+tap.test('CCM-09: IPv6 connection test (if supported)', async () => {
+  // Check if IPv6 is available
+  const hasIPv6 = await new Promise<boolean>((resolve) => {
+    const testSocket = net.createConnection({
+      host: '::1',
+      port: 1, // Any port, will fail but tells us if IPv6 works
+      timeout: 100
+    });
+    
+    testSocket.on('error', (err: any) => {
+      // ECONNREFUSED means IPv6 works but port is closed (expected)
+      // ENETUNREACH or EAFNOSUPPORT means IPv6 not available
+      resolve(err.code === 'ECONNREFUSED');
+    });
+    
+    testSocket.on('connect', () => {
+      testSocket.end();
+      resolve(true);
+    });
+  });
+
+  if (!hasIPv6) {
+    console.log('IPv6 not available on this system, skipping IPv6 tests');
+    return;
+  }
+
+  // Try IPv6 connection
+  const smtpClient = createSmtpClient({
+    host: '::1', // IPv6 loopback
+    port: testServer.port,
+    secure: false,
+    connectionTimeout: 5000,
+    debug: true
+  });
+
+  try {
+    const verified = await smtpClient.verify();
+    if (verified) {
+      console.log('Successfully connected via IPv6');
+      await smtpClient.close();
+    } else {
+      console.log('IPv6 connection failed (server may not support IPv6)');
+    }
+  } catch (error: any) {
+    console.log('IPv6 connection failed (server may not support IPv6):', error.message);
+  }
+});
+
+tap.test('CCM-09: Hostname resolution preference', async () => {
+  // Test that client can handle hostnames that resolve to both IPv4 and IPv6
+  const smtpClient = createSmtpClient({
+    host: 'localhost', // Should resolve to both 127.0.0.1 and ::1
+    port: testServer.port,
+    secure: false,
+    connectionTimeout: 5000,
+    debug: true
+  });
+
+  const verified = await smtpClient.verify();
+  expect(verified).toBeTrue();
+
+  console.log('Successfully connected to localhost');
+
+  await smtpClient.close();
+});
+
+tap.test('CCM-09: Happy Eyeballs algorithm simulation', async () => {
+  // Test connecting to multiple addresses with preference
+  const addresses = ['127.0.0.1', '::1', 'localhost'];
+  const results: Array<{ address: string; time: number; success: boolean }> = [];
+
+  for (const address of addresses) {
+    const startTime = Date.now();
+    const smtpClient = createSmtpClient({
+      host: address,
+      port: testServer.port,
+      secure: false,
+      connectionTimeout: 1000,
+      debug: false
+    });
+
+    try {
+      const verified = await smtpClient.verify();
+      const elapsed = Date.now() - startTime;
+      results.push({ address, time: elapsed, success: verified });
+      
+      if (verified) {
+        await smtpClient.close();
+      }
+    } catch (error) {
+      const elapsed = Date.now() - startTime;
+      results.push({ address, time: elapsed, success: false });
+    }
+  }
+
+  console.log('Connection race results:');
+  results.forEach(r => {
+    console.log(`  ${r.address}: ${r.success ? 'SUCCESS' : 'FAILED'} in ${r.time}ms`);
+  });
+
+  // At least one should succeed
+  const successfulConnections = results.filter(r => r.success);
+  expect(successfulConnections.length).toBeGreaterThan(0);
+});
+
+tap.test('cleanup test SMTP server', async () => {
+  if (testServer) {
+    await stopTestServer(testServer);
+  }
+});
+
+export default tap.start();