@serve.zone/dcrouter 2.12.4

package/test/suite/smtpclient_performance/test.cperf-06.caching-strategies.ts

@@ -0,0 +1,190 @@
+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 { Email } from '../../../ts/mail/core/classes.email.js';
+
+tap.test('setup - start SMTP server for caching tests', async () => {
+  // Just a placeholder to ensure server starts properly
+});
+
+tap.test('CPERF-06: caching strategies - connection caching', async () => {
+  const testServer = await startTestServer({
+    port: 2525,
+    tlsEnabled: false,
+    authRequired: false
+  });
+
+  console.log('Testing connection caching strategies...');
+  
+  // Create client for testing connection reuse
+  const client = createSmtpClient({
+    host: 'localhost',
+    port: 2525,
+    secure: false
+  });
+
+  // First batch - establish connections
+  console.log('Sending first batch to establish connections...');
+  const firstBatchStart = Date.now();
+  
+  const firstBatch = Array(3).fill(null).map((_, i) => 
+    new Email({
+      from: 'sender@example.com',
+      to: [`cached${i}@example.com`],
+      subject: `Cache test ${i}`,
+      text: `Testing connection caching - message ${i}`,
+    })
+  );
+
+  // Send emails sequentially
+  for (const email of firstBatch) {
+    const result = await client.sendMail(email);
+    expect(result.success).toBeTrue();
+  }
+  
+  const firstBatchTime = Date.now() - firstBatchStart;
+  
+  // Second batch - should reuse connection
+  console.log('Sending second batch using same connection...');
+  const secondBatchStart = Date.now();
+  
+  const secondBatch = Array(3).fill(null).map((_, i) => 
+    new Email({
+      from: 'sender@example.com',
+      to: [`cached2-${i}@example.com`],
+      subject: `Cache test 2-${i}`,
+      text: `Testing cached connections - message ${i}`,
+    })
+  );
+
+  // Send emails sequentially
+  for (const email of secondBatch) {
+    const result = await client.sendMail(email);
+    expect(result.success).toBeTrue();
+  }
+  
+  const secondBatchTime = Date.now() - secondBatchStart;
+  
+  console.log(`First batch: ${firstBatchTime}ms`);
+  console.log(`Second batch: ${secondBatchTime}ms`);
+  
+  // Both batches should complete successfully
+  expect(firstBatchTime).toBeGreaterThan(0);
+  expect(secondBatchTime).toBeGreaterThan(0);
+  
+  await client.close();
+  await stopTestServer(testServer);
+});
+
+tap.test('CPERF-06: caching strategies - server capability caching', async () => {
+  const testServer = await startTestServer({
+    port: 2526,
+    tlsEnabled: false,
+    authRequired: false
+  });
+
+  console.log('Testing server capability caching...');
+  
+  const client = createSmtpClient({
+    host: 'localhost',
+    port: 2526,
+    secure: false
+  });
+
+  // First email - discovers capabilities
+  console.log('First email - discovering server capabilities...');
+  const firstStart = Date.now();
+  
+  const email1 = new Email({
+    from: 'sender@example.com',
+    to: ['recipient1@example.com'],
+    subject: 'Capability test 1',
+    text: 'Testing capability discovery',
+  });
+
+  const result1 = await client.sendMail(email1);
+  expect(result1.success).toBeTrue();
+  const firstTime = Date.now() - firstStart;
+  
+  // Second email - uses cached capabilities
+  console.log('Second email - using cached capabilities...');
+  const secondStart = Date.now();
+  
+  const email2 = new Email({
+    from: 'sender@example.com',
+    to: ['recipient2@example.com'],
+    subject: 'Capability test 2',
+    text: 'Testing cached capabilities',
+  });
+
+  const result2 = await client.sendMail(email2);
+  expect(result2.success).toBeTrue();
+  const secondTime = Date.now() - secondStart;
+  
+  console.log(`First email (capability discovery): ${firstTime}ms`);
+  console.log(`Second email (cached capabilities): ${secondTime}ms`);
+  
+  // Both should complete quickly
+  expect(firstTime).toBeLessThan(1000);
+  expect(secondTime).toBeLessThan(1000);
+  
+  await client.close();
+  await stopTestServer(testServer);
+});
+
+tap.test('CPERF-06: caching strategies - message batching', async () => {
+  const testServer = await startTestServer({
+    port: 2527,
+    tlsEnabled: false,
+    authRequired: false
+  });
+
+  console.log('Testing message batching for cache efficiency...');
+  
+  const client = createSmtpClient({
+    host: 'localhost',
+    port: 2527,
+    secure: false
+  });
+
+  // Test sending messages in batches
+  const batchSizes = [2, 3, 4];
+  
+  for (const batchSize of batchSizes) {
+    console.log(`\nTesting batch size: ${batchSize}`);
+    const batchStart = Date.now();
+    
+    const emails = Array(batchSize).fill(null).map((_, i) => 
+      new Email({
+        from: 'sender@example.com',
+        to: [`batch${batchSize}-${i}@example.com`],
+        subject: `Batch ${batchSize} message ${i}`,
+        text: `Testing batching strategies - batch size ${batchSize}`,
+      })
+    );
+
+    // Send emails sequentially
+    for (const email of emails) {
+      const result = await client.sendMail(email);
+      expect(result.success).toBeTrue();
+    }
+    
+    const batchTime = Date.now() - batchStart;
+    const avgTime = batchTime / batchSize;
+    
+    console.log(`  Batch completed in ${batchTime}ms`);
+    console.log(`  Average time per message: ${avgTime.toFixed(1)}ms`);
+    
+    // All batches should complete efficiently
+    expect(avgTime).toBeLessThan(1000);
+  }
+  
+  await client.close();
+  await stopTestServer(testServer);
+});
+
+tap.test('cleanup - stop SMTP server', async () => {
+  // Cleanup is handled in individual tests
+});
+
+tap.start();

package/test/suite/smtpclient_performance/test.cperf-07.queue-management.ts

@@ -0,0 +1,171 @@
+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 { Email } from '../../../ts/mail/core/classes.email.js';
+
+tap.test('setup - start SMTP server for queue management tests', async () => {
+  // Just a placeholder to ensure server starts properly
+});
+
+tap.test('CPERF-07: queue management - basic queue processing', async () => {
+  const testServer = await startTestServer({
+    port: 2525,
+    tlsEnabled: false,
+    authRequired: false
+  });
+
+  console.log('Testing basic queue processing...');
+  
+  const client = createSmtpClient({
+    host: 'localhost',
+    port: 2525,
+    secure: false
+  });
+
+  // Queue up 5 emails (reduced from 10)
+  const emailCount = 5;
+  const emails = Array(emailCount).fill(null).map((_, i) => 
+    new Email({
+      from: 'sender@example.com',
+      to: [`queue${i}@example.com`],
+      subject: `Queue test ${i}`,
+      text: `Testing queue management - message ${i}`,
+    })
+  );
+
+  console.log(`Sending ${emailCount} emails...`);
+  const queueStart = Date.now();
+  
+  // Send all emails sequentially
+  const results = [];
+  for (let i = 0; i < emails.length; i++) {
+    const result = await client.sendMail(emails[i]);
+    console.log(`  Email ${i} sent`);
+    results.push(result);
+  }
+  
+  const queueTime = Date.now() - queueStart;
+  
+  // Verify all succeeded
+  results.forEach((result, index) => {
+    expect(result.success).toBeTrue();
+  });
+  
+  console.log(`All ${emailCount} emails processed in ${queueTime}ms`);
+  console.log(`Average time per email: ${(queueTime / emailCount).toFixed(1)}ms`);
+  
+  // Should complete within reasonable time
+  expect(queueTime).toBeLessThan(10000); // Less than 10 seconds for 5 emails
+  
+  await client.close();
+  await stopTestServer(testServer);
+});
+
+tap.test('CPERF-07: queue management - queue with rate limiting', async () => {
+  const testServer = await startTestServer({
+    port: 2526,
+    tlsEnabled: false,
+    authRequired: false
+  });
+
+  console.log('Testing queue with rate limiting...');
+  
+  const client = createSmtpClient({
+    host: 'localhost',
+    port: 2526,
+    secure: false
+  });
+
+  // Send 5 emails sequentially (simulating rate limiting)
+  const emailCount = 5;
+  const rateLimitDelay = 200; // 200ms between emails
+  
+  console.log(`Sending ${emailCount} emails with ${rateLimitDelay}ms rate limit...`);
+  const rateStart = Date.now();
+  
+  for (let i = 0; i < emailCount; i++) {
+    const email = new Email({
+      from: 'sender@example.com',
+      to: [`ratelimit${i}@example.com`],
+      subject: `Rate limit test ${i}`,
+      text: `Testing rate limited queue - message ${i}`,
+    });
+    
+    const result = await client.sendMail(email);
+    expect(result.success).toBeTrue();
+    
+    console.log(`  Email ${i} sent`);
+    
+    // Simulate rate limiting delay
+    if (i < emailCount - 1) {
+      await new Promise(resolve => setTimeout(resolve, rateLimitDelay));
+    }
+  }
+  
+  const rateTime = Date.now() - rateStart;
+  const expectedMinTime = (emailCount - 1) * rateLimitDelay;
+  
+  console.log(`Rate limited emails sent in ${rateTime}ms`);
+  console.log(`Expected minimum time: ${expectedMinTime}ms`);
+  
+  // Should respect rate limiting
+  expect(rateTime).toBeGreaterThanOrEqual(expectedMinTime);
+  
+  await client.close();
+  await stopTestServer(testServer);
+});
+
+tap.test('CPERF-07: queue management - sequential processing', async () => {
+  const testServer = await startTestServer({
+    port: 2527,
+    tlsEnabled: false,
+    authRequired: false
+  });
+
+  console.log('Testing sequential email processing...');
+  
+  const client = createSmtpClient({
+    host: 'localhost',
+    port: 2527,
+    secure: false
+  });
+
+  // Send multiple emails sequentially
+  const emails = Array(3).fill(null).map((_, i) => 
+    new Email({
+      from: 'sender@example.com',
+      to: [`sequential${i}@example.com`],
+      subject: `Sequential test ${i}`,
+      text: `Testing sequential processing - message ${i}`,
+    })
+  );
+
+  console.log('Sending 3 emails sequentially...');
+  const sequentialStart = Date.now();
+  
+  const results = [];
+  for (const email of emails) {
+    const result = await client.sendMail(email);
+    results.push(result);
+  }
+  
+  const sequentialTime = Date.now() - sequentialStart;
+  
+  // All should succeed
+  results.forEach((result, index) => {
+    expect(result.success).toBeTrue();
+    console.log(`  Email ${index} processed`);
+  });
+  
+  console.log(`Sequential processing completed in ${sequentialTime}ms`);
+  console.log(`Average time per email: ${(sequentialTime / 3).toFixed(1)}ms`);
+  
+  await client.close();
+  await stopTestServer(testServer);
+});
+
+tap.test('cleanup - stop SMTP server', async () => {
+  // Cleanup is handled in individual tests
+});
+
+tap.start();

package/test/suite/smtpclient_performance/test.cperf-08.dns-caching.ts

@@ -0,0 +1,50 @@
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+import { createTestServer } from '../../helpers/server.loader.js';
+import { createTestSmtpClient } from '../../helpers/smtp.client.js';
+import { Email } from '../../../ts/mail/core/classes.email.js';
+
+tap.test('CPERF-08: DNS Caching Tests', async () => {
+  console.log('\n🌐 Testing SMTP Client DNS Caching');
+  console.log('=' .repeat(60));
+
+  const testServer = await createTestServer({});
+
+  try {
+    console.log('\nTest: DNS caching with multiple connections');
+    
+    // Create multiple clients to test DNS caching
+    const clients = [];
+    
+    for (let i = 0; i < 3; i++) {
+      const smtpClient = createTestSmtpClient({
+        host: testServer.hostname,
+        port: testServer.port
+      });
+      clients.push(smtpClient);
+      console.log(`  ✓ Client ${i + 1} created (DNS should be cached)`);
+    }
+
+    // Send email with first client
+    const email = new Email({
+      from: 'sender@example.com',
+      to: 'recipient@example.com',
+      subject: 'DNS Caching Test',
+      text: 'Testing DNS caching efficiency'
+    });
+
+    const result = await clients[0].sendMail(email);
+    console.log('  ✓ Email sent successfully');
+    expect(result).toBeDefined();
+
+    // Clean up all clients
+    clients.forEach(client => client.close());
+    console.log('  ✓ All clients closed');
+
+    console.log('\n✅ CPERF-08: DNS caching tests completed');
+
+  } finally {
+    testServer.server.close();
+  }
+});
+
+tap.start();

package/test/suite/smtpclient_reliability/test.crel-01.reconnection-logic.ts

@@ -0,0 +1,305 @@
+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 { Email } from '../../../ts/mail/core/classes.email.js';
+
+let testServer: ITestServer;
+
+tap.test('setup test SMTP server', async () => {
+  testServer = await startTestServer({
+    port: 2600,
+    tlsEnabled: false,
+    authRequired: false
+  });
+  expect(testServer).toBeTruthy();
+  expect(testServer.port).toEqual(2600);
+});
+
+tap.test('CREL-01: Basic reconnection after close', async () => {
+  const smtpClient = createSmtpClient({
+    host: testServer.hostname,
+    port: testServer.port,
+    secure: false,
+    connectionTimeout: 5000,
+    debug: true
+  });
+
+  // First verify connection works
+  const result1 = await smtpClient.verify();
+  expect(result1).toBeTrue();
+  console.log('Initial connection verified');
+
+  // Close connection
+  await smtpClient.close();
+  console.log('Connection closed');
+
+  // Verify again - should reconnect automatically
+  const result2 = await smtpClient.verify();
+  expect(result2).toBeTrue();
+  console.log('Reconnection successful');
+
+  await smtpClient.close();
+});
+
+tap.test('CREL-01: Multiple sequential connections', async () => {
+  const smtpClient = createSmtpClient({
+    host: testServer.hostname,
+    port: testServer.port,
+    secure: false,
+    connectionTimeout: 5000,
+    debug: true
+  });
+
+  // Send multiple emails with closes in between
+  for (let i = 0; i < 3; i++) {
+    const email = new Email({
+      from: 'sender@example.com',
+      to: ['recipient@example.com'],
+      subject: `Sequential Test ${i + 1}`,
+      text: 'Testing sequential connections'
+    });
+
+    const result = await smtpClient.sendMail(email);
+    expect(result.success).toBeTrue();
+    console.log(`Email ${i + 1} sent successfully`);
+
+    // Close connection after each send
+    await smtpClient.close();
+    console.log(`Connection closed after email ${i + 1}`);
+  }
+});
+
+tap.test('CREL-01: Recovery from server restart', async () => {
+  const smtpClient = createSmtpClient({
+    host: testServer.hostname,
+    port: testServer.port,
+    secure: false,
+    connectionTimeout: 5000,
+    debug: true
+  });
+
+  // Send first email
+  const email1 = new Email({
+    from: 'sender@example.com',
+    to: ['recipient@example.com'],
+    subject: 'Before Server Restart',
+    text: 'Testing server restart recovery'
+  });
+
+  const result1 = await smtpClient.sendMail(email1);
+  expect(result1.success).toBeTrue();
+  console.log('First email sent successfully');
+
+  // Simulate server restart by creating a brief interruption
+  console.log('Simulating server restart...');
+  
+  // The SMTP client should handle the disconnection gracefully
+  // and reconnect for the next operation
+  
+  // Wait a moment
+  await new Promise(resolve => setTimeout(resolve, 1000));
+
+  // Try to send another email
+  const email2 = new Email({
+    from: 'sender@example.com',
+    to: ['recipient@example.com'],
+    subject: 'After Server Restart',
+    text: 'Testing recovery after restart'
+  });
+
+  const result2 = await smtpClient.sendMail(email2);
+  expect(result2.success).toBeTrue();
+  console.log('Second email sent successfully after simulated restart');
+
+  await smtpClient.close();
+});
+
+tap.test('CREL-01: Connection pool reliability', async () => {
+  const pooledClient = createSmtpClient({
+    host: testServer.hostname,
+    port: testServer.port,
+    secure: false,
+    pool: true,
+    maxConnections: 3,
+    maxMessages: 10,
+    connectionTimeout: 5000,
+    debug: true
+  });
+
+  // Send multiple emails concurrently
+  const emails = Array.from({ length: 10 }, (_, i) => new Email({
+    from: 'sender@example.com',
+    to: [`recipient${i}@example.com`],
+    subject: `Pool Test ${i}`,
+    text: 'Testing connection pool'
+  }));
+
+  console.log('Sending 10 emails through connection pool...');
+  
+  const results = await Promise.allSettled(
+    emails.map(email => pooledClient.sendMail(email))
+  );
+  
+  const successful = results.filter(r => r.status === 'fulfilled').length;
+  const failed = results.filter(r => r.status === 'rejected').length;
+  
+  console.log(`Pool results: ${successful} successful, ${failed} failed`);
+  expect(successful).toBeGreaterThan(0);
+  
+  // Most should succeed
+  expect(successful).toBeGreaterThanOrEqual(8);
+
+  await pooledClient.close();
+});
+
+tap.test('CREL-01: Rapid connection cycling', async () => {
+  const smtpClient = createSmtpClient({
+    host: testServer.hostname,
+    port: testServer.port,
+    secure: false,
+    connectionTimeout: 5000,
+    debug: true
+  });
+
+  // Rapidly open and close connections
+  console.log('Testing rapid connection cycling...');
+  
+  for (let i = 0; i < 5; i++) {
+    const result = await smtpClient.verify();
+    expect(result).toBeTrue();
+    await smtpClient.close();
+    console.log(`Cycle ${i + 1} completed`);
+  }
+
+  console.log('Rapid cycling completed successfully');
+});
+
+tap.test('CREL-01: Error recovery', async () => {
+  // Test with invalid server first
+  const smtpClient = createSmtpClient({
+    host: 'invalid.host.local',
+    port: 9999,
+    secure: false,
+    connectionTimeout: 1000,
+    debug: true
+  });
+
+  // First attempt should fail
+  const result1 = await smtpClient.verify();
+  expect(result1).toBeFalse();
+  console.log('Connection to invalid host failed as expected');
+
+  // Now update to valid server (simulating failover)
+  // Since we can't update options, create a new client
+  const recoveredClient = createSmtpClient({
+    host: testServer.hostname,
+    port: testServer.port,
+    secure: false,
+    connectionTimeout: 5000,
+    debug: true
+  });
+
+  // Should connect successfully
+  const result2 = await recoveredClient.verify();
+  expect(result2).toBeTrue();
+  console.log('Connection to valid host succeeded');
+
+  // Send email to verify full functionality
+  const email = new Email({
+    from: 'sender@example.com',
+    to: ['recipient@example.com'],
+    subject: 'Recovery Test',
+    text: 'Testing error recovery'
+  });
+
+  const sendResult = await recoveredClient.sendMail(email);
+  expect(sendResult.success).toBeTrue();
+  console.log('Email sent successfully after recovery');
+
+  await recoveredClient.close();
+});
+
+tap.test('CREL-01: Long-lived connection', async () => {
+  const smtpClient = createSmtpClient({
+    host: testServer.hostname,
+    port: testServer.port,
+    secure: false,
+    connectionTimeout: 30000, // 30 second timeout
+    socketTimeout: 30000,
+    debug: true
+  });
+
+  console.log('Testing long-lived connection...');
+
+  // Send emails over time
+  for (let i = 0; i < 3; i++) {
+    const email = new Email({
+      from: 'sender@example.com',
+      to: ['recipient@example.com'],
+      subject: `Long-lived Test ${i + 1}`,
+      text: `Email ${i + 1} over long-lived connection`
+    });
+
+    const result = await smtpClient.sendMail(email);
+    expect(result.success).toBeTrue();
+    console.log(`Email ${i + 1} sent at ${new Date().toISOString()}`);
+
+    // Wait between sends
+    if (i < 2) {
+      await new Promise(resolve => setTimeout(resolve, 2000));
+    }
+  }
+
+  console.log('Long-lived connection test completed');
+  await smtpClient.close();
+});
+
+tap.test('CREL-01: Concurrent operations', async () => {
+  const smtpClient = createSmtpClient({
+    host: testServer.hostname,
+    port: testServer.port,
+    secure: false,
+    pool: true,
+    maxConnections: 5,
+    connectionTimeout: 5000,
+    debug: true
+  });
+
+  console.log('Testing concurrent operations...');
+
+  // Mix verify and send operations
+  const operations = [
+    smtpClient.verify(),
+    smtpClient.sendMail(new Email({
+      from: 'sender@example.com',
+      to: ['recipient1@example.com'],
+      subject: 'Concurrent 1',
+      text: 'First concurrent email'
+    })),
+    smtpClient.verify(),
+    smtpClient.sendMail(new Email({
+      from: 'sender@example.com',
+      to: ['recipient2@example.com'],
+      subject: 'Concurrent 2',
+      text: 'Second concurrent email'
+    })),
+    smtpClient.verify()
+  ];
+
+  const results = await Promise.allSettled(operations);
+  
+  const successful = results.filter(r => r.status === 'fulfilled').length;
+  console.log(`Concurrent operations: ${successful}/${results.length} successful`);
+  
+  expect(successful).toEqual(results.length);
+
+  await smtpClient.close();
+});
+
+tap.test('cleanup test SMTP server', async () => {
+  if (testServer) {
+    await stopTestServer(testServer);
+  }
+});
+
+export default tap.start();