@serve.zone/dcrouter 2.12.4

package/test/suite/smtpclient_performance/test.cperf-02.message-throughput.ts

@@ -0,0 +1,304 @@
+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 throughput tests', async () => {
+  testServer = await startTestServer({
+    port: 0,
+    enableStarttls: false,
+    authRequired: false
+  });
+  
+  expect(testServer.port).toBeGreaterThan(0);
+});
+
+tap.test('CPERF-02: Sequential message throughput', async (tools) => {
+  tools.timeout(60000);
+  
+  const smtpClient = await createSmtpClient({
+    host: testServer.hostname,
+    port: testServer.port,
+    secure: false,
+    debug: false
+  });
+  
+  const messageCount = 10;
+  const messages = Array(messageCount).fill(null).map((_, i) => 
+    new Email({
+      from: 'sender@example.com',
+      to: [`recipient${i + 1}@example.com`],
+      subject: `Sequential throughput test ${i + 1}`,
+      text: `Testing sequential message sending - message ${i + 1}`
+    })
+  );
+  
+  console.log(`Sending ${messageCount} messages sequentially...`);
+  const sequentialStart = Date.now();
+  let successCount = 0;
+  
+  for (const message of messages) {
+    try {
+      const result = await smtpClient.sendMail(message);
+      if (result.success) successCount++;
+    } catch (error) {
+      console.log('Failed to send:', error.message);
+    }
+  }
+  
+  const sequentialTime = Date.now() - sequentialStart;
+  const sequentialRate = (successCount / sequentialTime) * 1000;
+  
+  console.log(`Sequential throughput: ${sequentialRate.toFixed(2)} messages/second`);
+  console.log(`Successfully sent: ${successCount}/${messageCount} messages`);
+  console.log(`Total time: ${sequentialTime}ms`);
+  
+  expect(successCount).toBeGreaterThan(0);
+  expect(sequentialRate).toBeGreaterThan(0.1); // At least 0.1 message per second
+  
+  await smtpClient.close();
+});
+
+tap.test('CPERF-02: Concurrent message throughput', async (tools) => {
+  tools.timeout(60000);
+  
+  const smtpClient = await createSmtpClient({
+    host: testServer.hostname,
+    port: testServer.port,
+    secure: false,
+    debug: false
+  });
+  
+  const messageCount = 10;
+  const messages = Array(messageCount).fill(null).map((_, i) => 
+    new Email({
+      from: 'sender@example.com',
+      to: [`recipient${i + 1}@example.com`],
+      subject: `Concurrent throughput test ${i + 1}`,
+      text: `Testing concurrent message sending - message ${i + 1}`
+    })
+  );
+  
+  console.log(`Sending ${messageCount} messages concurrently...`);
+  const concurrentStart = Date.now();
+  
+  // Send in small batches to avoid overwhelming
+  const batchSize = 3;
+  const results = [];
+  
+  for (let i = 0; i < messages.length; i += batchSize) {
+    const batch = messages.slice(i, i + batchSize);
+    const batchResults = await Promise.all(
+      batch.map(message => smtpClient.sendMail(message).catch(err => ({ success: false, error: err })))
+    );
+    results.push(...batchResults);
+    
+    // Small delay between batches
+    if (i + batchSize < messages.length) {
+      await new Promise(resolve => setTimeout(resolve, 100));
+    }
+  }
+  
+  const successCount = results.filter(r => r.success).length;
+  const concurrentTime = Date.now() - concurrentStart;
+  const concurrentRate = (successCount / concurrentTime) * 1000;
+  
+  console.log(`Concurrent throughput: ${concurrentRate.toFixed(2)} messages/second`);
+  console.log(`Successfully sent: ${successCount}/${messageCount} messages`);
+  console.log(`Total time: ${concurrentTime}ms`);
+  
+  expect(successCount).toBeGreaterThan(0);
+  expect(concurrentRate).toBeGreaterThan(0.1);
+  
+  await smtpClient.close();
+});
+
+tap.test('CPERF-02: Connection pooling throughput', async (tools) => {
+  tools.timeout(60000);
+  
+  const pooledClient = await createPooledSmtpClient({
+    host: testServer.hostname,
+    port: testServer.port,
+    secure: false,
+    maxConnections: 3,
+    debug: false
+  });
+  
+  const messageCount = 15;
+  const messages = Array(messageCount).fill(null).map((_, i) => 
+    new Email({
+      from: 'sender@example.com',
+      to: [`recipient${i + 1}@example.com`],
+      subject: `Pooled throughput test ${i + 1}`,
+      text: `Testing connection pooling - message ${i + 1}`
+    })
+  );
+  
+  console.log(`Sending ${messageCount} messages with connection pooling...`);
+  const poolStart = Date.now();
+  
+  // Send in small batches
+  const batchSize = 5;
+  const results = [];
+  
+  for (let i = 0; i < messages.length; i += batchSize) {
+    const batch = messages.slice(i, i + batchSize);
+    const batchResults = await Promise.all(
+      batch.map(message => pooledClient.sendMail(message).catch(err => ({ success: false, error: err })))
+    );
+    results.push(...batchResults);
+    
+    // Small delay between batches
+    if (i + batchSize < messages.length) {
+      await new Promise(resolve => setTimeout(resolve, 200));
+    }
+  }
+  
+  const successCount = results.filter(r => r.success).length;
+  const poolTime = Date.now() - poolStart;
+  const poolRate = (successCount / poolTime) * 1000;
+  
+  console.log(`Pooled throughput: ${poolRate.toFixed(2)} messages/second`);
+  console.log(`Successfully sent: ${successCount}/${messageCount} messages`);
+  console.log(`Total time: ${poolTime}ms`);
+  
+  expect(successCount).toBeGreaterThan(0);
+  expect(poolRate).toBeGreaterThan(0.1);
+  
+  await pooledClient.close();
+});
+
+tap.test('CPERF-02: Variable message size throughput', async (tools) => {
+  tools.timeout(60000);
+  
+  const smtpClient = await createSmtpClient({
+    host: testServer.hostname,
+    port: testServer.port,
+    secure: false,
+    debug: false
+  });
+  
+  // Create messages of varying sizes
+  const messageSizes = [
+    { size: 'small', content: 'Short message' },
+    { size: 'medium', content: 'Medium message: ' + 'x'.repeat(500) },
+    { size: 'large', content: 'Large message: ' + 'x'.repeat(5000) }
+  ];
+  
+  const messages = [];
+  for (let i = 0; i < 9; i++) {
+    const sizeType = messageSizes[i % messageSizes.length];
+    messages.push(new Email({
+      from: 'sender@example.com',
+      to: [`recipient${i + 1}@example.com`],
+      subject: `Variable size test ${i + 1} (${sizeType.size})`,
+      text: sizeType.content
+    }));
+  }
+  
+  console.log(`Sending ${messages.length} messages of varying sizes...`);
+  const variableStart = Date.now();
+  let successCount = 0;
+  let totalBytes = 0;
+  
+  for (const message of messages) {
+    try {
+      const result = await smtpClient.sendMail(message);
+      if (result.success) {
+        successCount++;
+        // Estimate message size
+        totalBytes += message.text ? message.text.length : 0;
+      }
+    } catch (error) {
+      console.log('Failed to send:', error.message);
+    }
+    
+    // Small delay between messages
+    await new Promise(resolve => setTimeout(resolve, 100));
+  }
+  
+  const variableTime = Date.now() - variableStart;
+  const variableRate = (successCount / variableTime) * 1000;
+  const bytesPerSecond = (totalBytes / variableTime) * 1000;
+  
+  console.log(`Variable size throughput: ${variableRate.toFixed(2)} messages/second`);
+  console.log(`Data throughput: ${(bytesPerSecond / 1024).toFixed(2)} KB/second`);
+  console.log(`Successfully sent: ${successCount}/${messages.length} messages`);
+  
+  expect(successCount).toBeGreaterThan(0);
+  expect(variableRate).toBeGreaterThan(0.1);
+  
+  await smtpClient.close();
+});
+
+tap.test('CPERF-02: Sustained throughput over time', async (tools) => {
+  tools.timeout(60000);
+  
+  const smtpClient = await createPooledSmtpClient({
+    host: testServer.hostname,
+    port: testServer.port,
+    secure: false,
+    maxConnections: 2,
+    debug: false
+  });
+  
+  const totalMessages = 12;
+  const batchSize = 3;
+  const batchDelay = 1000; // 1 second between batches
+  
+  console.log(`Sending ${totalMessages} messages in batches of ${batchSize}...`);
+  const sustainedStart = Date.now();
+  let totalSuccess = 0;
+  const timestamps: number[] = [];
+  
+  for (let batch = 0; batch < totalMessages / batchSize; batch++) {
+    const batchMessages = Array(batchSize).fill(null).map((_, i) => {
+      const msgIndex = batch * batchSize + i + 1;
+      return new Email({
+        from: 'sender@example.com',
+        to: [`recipient${msgIndex}@example.com`],
+        subject: `Sustained test batch ${batch + 1} message ${i + 1}`,
+        text: `Testing sustained throughput - message ${msgIndex}`
+      });
+    });
+    
+    // Send batch
+    const batchStart = Date.now();
+    const results = await Promise.all(
+      batchMessages.map(message => smtpClient.sendMail(message).catch(err => ({ success: false })))
+    );
+    
+    const batchSuccess = results.filter(r => r.success).length;
+    totalSuccess += batchSuccess;
+    timestamps.push(Date.now());
+    
+    console.log(`  Batch ${batch + 1} completed: ${batchSuccess}/${batchSize} successful`);
+    
+    // Delay between batches (except last)
+    if (batch < (totalMessages / batchSize) - 1) {
+      await new Promise(resolve => setTimeout(resolve, batchDelay));
+    }
+  }
+  
+  const sustainedTime = Date.now() - sustainedStart;
+  const sustainedRate = (totalSuccess / sustainedTime) * 1000;
+  
+  console.log(`Sustained throughput: ${sustainedRate.toFixed(2)} messages/second`);
+  console.log(`Successfully sent: ${totalSuccess}/${totalMessages} messages`);
+  console.log(`Total time: ${sustainedTime}ms`);
+  
+  expect(totalSuccess).toBeGreaterThan(0);
+  expect(sustainedRate).toBeGreaterThan(0.05); // Very relaxed for sustained test
+  
+  await smtpClient.close();
+});
+
+tap.test('cleanup - stop SMTP server', async () => {
+  await stopTestServer(testServer);
+});
+
+export default tap.start();

package/test/suite/smtpclient_performance/test.cperf-03.memory-usage.ts

@@ -0,0 +1,332 @@
+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';
+
+let testServer: ITestServer;
+
+// Helper function to get memory usage
+const getMemoryUsage = () => {
+  if (process.memoryUsage) {
+    const usage = process.memoryUsage();
+    return {
+      heapUsed: usage.heapUsed,
+      heapTotal: usage.heapTotal,
+      external: usage.external,
+      rss: usage.rss
+    };
+  }
+  return null;
+};
+
+// Helper function to format bytes
+const formatBytes = (bytes: number) => {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+};
+
+tap.test('setup - start SMTP server for memory tests', async () => {
+  testServer = await startTestServer({
+    port: 0,
+    enableStarttls: false,
+    authRequired: false
+  });
+  
+  expect(testServer.port).toBeGreaterThan(0);
+});
+
+tap.test('CPERF-03: Memory usage during connection lifecycle', async (tools) => {
+  tools.timeout(30000);
+  
+  const memoryBefore = getMemoryUsage();
+  console.log('Initial memory usage:', {
+    heapUsed: formatBytes(memoryBefore.heapUsed),
+    heapTotal: formatBytes(memoryBefore.heapTotal),
+    rss: formatBytes(memoryBefore.rss)
+  });
+  
+  // Create and close multiple connections
+  const connectionCount = 10;
+  
+  for (let i = 0; i < connectionCount; i++) {
+    const client = await createSmtpClient({
+      host: testServer.hostname,
+      port: testServer.port,
+      secure: false,
+      debug: false
+    });
+    
+    // Send a test email
+    const email = new Email({
+      from: 'sender@example.com',
+      to: ['recipient@example.com'],
+      subject: `Memory test ${i + 1}`,
+      text: 'Testing memory usage'
+    });
+    
+    await client.sendMail(email);
+    await client.close();
+    
+    // Small delay between connections
+    await new Promise(resolve => setTimeout(resolve, 100));
+  }
+  
+  // Force garbage collection if available
+  if (global.gc) {
+    global.gc();
+    await new Promise(resolve => setTimeout(resolve, 100));
+  }
+  
+  const memoryAfter = getMemoryUsage();
+  const memoryIncrease = memoryAfter.heapUsed - memoryBefore.heapUsed;
+  
+  console.log(`Memory after ${connectionCount} connections:`, {
+    heapUsed: formatBytes(memoryAfter.heapUsed),
+    heapTotal: formatBytes(memoryAfter.heapTotal),
+    rss: formatBytes(memoryAfter.rss)
+  });
+  console.log(`Memory increase: ${formatBytes(memoryIncrease)}`);
+  console.log(`Average per connection: ${formatBytes(memoryIncrease / connectionCount)}`);
+  
+  // Memory increase should be reasonable
+  expect(memoryIncrease / connectionCount).toBeLessThan(1024 * 1024); // Less than 1MB per connection
+});
+
+tap.test('CPERF-03: Memory usage with large messages', async (tools) => {
+  tools.timeout(30000);
+  
+  const client = await createSmtpClient({
+    host: testServer.hostname,
+    port: testServer.port,
+    secure: false,
+    debug: false
+  });
+  
+  const memoryBefore = getMemoryUsage();
+  console.log('Memory before large messages:', {
+    heapUsed: formatBytes(memoryBefore.heapUsed)
+  });
+  
+  // Send messages of increasing size
+  const sizes = [1024, 10240, 102400]; // 1KB, 10KB, 100KB
+  
+  for (const size of sizes) {
+    const email = new Email({
+      from: 'sender@example.com',
+      to: ['recipient@example.com'],
+      subject: `Large message test (${formatBytes(size)})`,
+      text: 'x'.repeat(size)
+    });
+    
+    await client.sendMail(email);
+    
+    const memoryAfter = getMemoryUsage();
+    console.log(`Memory after ${formatBytes(size)} message:`, {
+      heapUsed: formatBytes(memoryAfter.heapUsed),
+      increase: formatBytes(memoryAfter.heapUsed - memoryBefore.heapUsed)
+    });
+    
+    // Small delay
+    await new Promise(resolve => setTimeout(resolve, 200));
+  }
+  
+  await client.close();
+  
+  const memoryFinal = getMemoryUsage();
+  const totalIncrease = memoryFinal.heapUsed - memoryBefore.heapUsed;
+  
+  console.log(`Total memory increase: ${formatBytes(totalIncrease)}`);
+  
+  // Memory should not grow excessively
+  expect(totalIncrease).toBeLessThan(10 * 1024 * 1024); // Less than 10MB total
+});
+
+tap.test('CPERF-03: Memory usage with connection pooling', async (tools) => {
+  tools.timeout(30000);
+  
+  const memoryBefore = getMemoryUsage();
+  console.log('Memory before pooling test:', {
+    heapUsed: formatBytes(memoryBefore.heapUsed)
+  });
+  
+  const pooledClient = await createPooledSmtpClient({
+    host: testServer.hostname,
+    port: testServer.port,
+    secure: false,
+    maxConnections: 3,
+    debug: false
+  });
+  
+  // Send multiple emails through the pool
+  const emailCount = 15;
+  const emails = Array(emailCount).fill(null).map((_, i) => 
+    new Email({
+      from: 'sender@example.com',
+      to: [`recipient${i}@example.com`],
+      subject: `Pooled memory test ${i + 1}`,
+      text: 'Testing memory with connection pooling'
+    })
+  );
+  
+  // Send in batches
+  for (let i = 0; i < emails.length; i += 3) {
+    const batch = emails.slice(i, i + 3);
+    await Promise.all(batch.map(email => 
+      pooledClient.sendMail(email).catch(err => console.log('Send error:', err.message))
+    ));
+    
+    // Check memory after each batch
+    const memoryNow = getMemoryUsage();
+    console.log(`Memory after batch ${Math.floor(i/3) + 1}:`, {
+      heapUsed: formatBytes(memoryNow.heapUsed),
+      increase: formatBytes(memoryNow.heapUsed - memoryBefore.heapUsed)
+    });
+    
+    await new Promise(resolve => setTimeout(resolve, 100));
+  }
+  
+  await pooledClient.close();
+  
+  const memoryFinal = getMemoryUsage();
+  const totalIncrease = memoryFinal.heapUsed - memoryBefore.heapUsed;
+  
+  console.log(`Total memory increase with pooling: ${formatBytes(totalIncrease)}`);
+  console.log(`Average per email: ${formatBytes(totalIncrease / emailCount)}`);
+  
+  // Pooling should be memory efficient
+  expect(totalIncrease / emailCount).toBeLessThan(500 * 1024); // Less than 500KB per email
+});
+
+tap.test('CPERF-03: Memory cleanup after errors', async (tools) => {
+  tools.timeout(30000);
+  
+  const memoryBefore = getMemoryUsage();
+  console.log('Memory before error test:', {
+    heapUsed: formatBytes(memoryBefore.heapUsed)
+  });
+  
+  // Try to send emails that might fail
+  const errorCount = 5;
+  
+  for (let i = 0; i < errorCount; i++) {
+    try {
+      const client = await createSmtpClient({
+        host: testServer.hostname,
+        port: testServer.port,
+        secure: false,
+        connectionTimeout: 1000, // Short timeout
+        debug: false
+      });
+      
+      // Create a large email that might cause issues
+      const email = new Email({
+        from: 'sender@example.com',
+        to: ['recipient@example.com'],
+        subject: `Error test ${i + 1}`,
+        text: 'x'.repeat(100000), // 100KB
+        attachments: [{
+          filename: 'test.txt',
+          content: Buffer.alloc(50000).toString('base64'), // 50KB attachment
+          encoding: 'base64'
+        }]
+      });
+      
+      await client.sendMail(email);
+      await client.close();
+    } catch (error) {
+      console.log(`Error ${i + 1} handled: ${error.message}`);
+    }
+    
+    await new Promise(resolve => setTimeout(resolve, 100));
+  }
+  
+  // Force garbage collection if available
+  if (global.gc) {
+    global.gc();
+    await new Promise(resolve => setTimeout(resolve, 100));
+  }
+  
+  const memoryAfter = getMemoryUsage();
+  const memoryIncrease = memoryAfter.heapUsed - memoryBefore.heapUsed;
+  
+  console.log(`Memory after ${errorCount} error scenarios:`, {
+    heapUsed: formatBytes(memoryAfter.heapUsed),
+    increase: formatBytes(memoryIncrease)
+  });
+  
+  // Memory should be properly cleaned up after errors
+  expect(memoryIncrease).toBeLessThan(5 * 1024 * 1024); // Less than 5MB increase
+});
+
+tap.test('CPERF-03: Long-running memory stability', async (tools) => {
+  tools.timeout(60000);
+  
+  const client = await createSmtpClient({
+    host: testServer.hostname,
+    port: testServer.port,
+    secure: false,
+    debug: false
+  });
+  
+  const memorySnapshots = [];
+  const duration = 10000; // 10 seconds
+  const interval = 2000; // Check every 2 seconds
+  const startTime = Date.now();
+  
+  console.log('Testing memory stability over time...');
+  
+  let emailsSent = 0;
+  
+  while (Date.now() - startTime < duration) {
+    // Send an email
+    const email = new Email({
+      from: 'sender@example.com',
+      to: ['recipient@example.com'],
+      subject: `Stability test ${++emailsSent}`,
+      text: `Testing memory stability at ${new Date().toISOString()}`
+    });
+    
+    try {
+      await client.sendMail(email);
+    } catch (error) {
+      console.log('Send error:', error.message);
+    }
+    
+    // Take memory snapshot
+    const memory = getMemoryUsage();
+    const elapsed = Date.now() - startTime;
+    memorySnapshots.push({
+      time: elapsed,
+      heapUsed: memory.heapUsed
+    });
+    
+    console.log(`[${elapsed}ms] Heap: ${formatBytes(memory.heapUsed)}, Emails sent: ${emailsSent}`);
+    
+    await new Promise(resolve => setTimeout(resolve, interval));
+  }
+  
+  await client.close();
+  
+  // Analyze memory growth
+  const firstSnapshot = memorySnapshots[0];
+  const lastSnapshot = memorySnapshots[memorySnapshots.length - 1];
+  const memoryGrowth = lastSnapshot.heapUsed - firstSnapshot.heapUsed;
+  const growthRate = memoryGrowth / (lastSnapshot.time / 1000); // bytes per second
+  
+  console.log(`\nMemory stability results:`);
+  console.log(`  Duration: ${lastSnapshot.time}ms`);
+  console.log(`  Emails sent: ${emailsSent}`);
+  console.log(`  Memory growth: ${formatBytes(memoryGrowth)}`);
+  console.log(`  Growth rate: ${formatBytes(growthRate)}/second`);
+  
+  // Memory growth should be minimal over time
+  expect(growthRate).toBeLessThan(150 * 1024); // Less than 150KB/second growth
+});
+
+tap.test('cleanup - stop SMTP server', async () => {
+  await stopTestServer(testServer);
+});
+
+export default tap.start();