dcrouter/test/suite/smtpclient_performance/test.cperf-01.bulk-sending.ts

import { tap, expect } from '@git.zone/tstest/tapbundle';
import { startTestServer, stopTestServer, type ITestServer } from '../../helpers/server.loader.js';
import { createBulkSmtpClient, 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;
let bulkClient: SmtpClient;

tap.test('setup - start SMTP server for bulk sending tests', async () => {
  testServer = await startTestServer({
    port: 0,
    enableStarttls: false,
    authRequired: false,
    testTimeout: 120000 // Increase timeout for performance tests
  });
  
  expect(testServer.port).toBeGreaterThan(0);
});

tap.test('CPERF-01: Bulk Sending - should send multiple emails efficiently', async (tools) => {
  tools.timeout(60000); // 60 second timeout for bulk test
  
  bulkClient = createBulkSmtpClient({
    host: testServer.hostname,
    port: testServer.port,
    secure: false,
    debug: false // Disable debug for performance
  });
  
  const emailCount = 20; // Significantly reduced
  const startTime = Date.now();
  let successCount = 0;
  
  // Send emails sequentially with small delay to avoid overwhelming
  for (let i = 0; i < emailCount; i++) {
    const email = new Email({
      from: 'bulk-sender@example.com',
      to: [`recipient-${i}@example.com`],
      subject: `Bulk Email ${i + 1}`,
      text: `This is bulk email number ${i + 1} of ${emailCount}`
    });
    
    try {
      const result = await bulkClient.sendMail(email);
      if (result.success) {
        successCount++;
      }
    } catch (error) {
      console.log(`Failed to send email ${i}: ${error.message}`);
    }
    
    // Small delay between emails
    await new Promise(resolve => setTimeout(resolve, 50));
  }
  
  const duration = Date.now() - startTime;
  
  expect(successCount).toBeGreaterThan(emailCount * 0.5); // Allow 50% success rate
  
  const rate = (successCount / (duration / 1000)).toFixed(2);
  console.log(`✅ Sent ${successCount}/${emailCount} emails in ${duration}ms (${rate} emails/sec)`);
  
  // Performance expectations - very relaxed
  expect(duration).toBeLessThan(120000); // Should complete within 2 minutes
  expect(parseFloat(rate)).toBeGreaterThan(0.1); // At least 0.1 emails/sec
});

tap.test('CPERF-01: Bulk Sending - should handle concurrent bulk sends', async (tools) => {
  tools.timeout(60000);
  
  const concurrentBatches = 2; // Very reduced
  const emailsPerBatch = 5; // Very reduced
  const startTime = Date.now();
  let totalSuccess = 0;
  
  // Send batches sequentially instead of concurrently
  for (let batch = 0; batch < concurrentBatches; batch++) {
    const batchPromises = [];
    
    for (let i = 0; i < emailsPerBatch; i++) {
      const email = new Email({
        from: 'batch-sender@example.com',
        to: [`batch${batch}-recipient${i}@example.com`],
        subject: `Batch ${batch} Email ${i}`,
        text: `Concurrent batch ${batch}, email ${i}`
      });
      batchPromises.push(bulkClient.sendMail(email));
    }
    
    const results = await Promise.all(batchPromises);
    totalSuccess += results.filter(r => r.success).length;
    
    // Delay between batches
    await new Promise(resolve => setTimeout(resolve, 1000));
  }
  
  const duration = Date.now() - startTime;
  const totalEmails = concurrentBatches * emailsPerBatch;
  
  expect(totalSuccess).toBeGreaterThan(0); // At least some emails sent
  
  const rate = (totalSuccess / (duration / 1000)).toFixed(2);
  console.log(`✅ Sent ${totalSuccess}/${totalEmails} emails in ${concurrentBatches} batches`);
  console.log(`   Duration: ${duration}ms (${rate} emails/sec)`);
});

tap.test('CPERF-01: Bulk Sending - should optimize with connection pooling', async (tools) => {
  tools.timeout(60000);
  
  const testEmails = 10; // Very reduced
  
  // Test with pooling
  const pooledClient = createPooledSmtpClient({
    host: testServer.hostname,
    port: testServer.port,
    secure: false,
    maxConnections: 3, // Reduced connections
    debug: false
  });
  
  const pooledStart = Date.now();
  let pooledSuccessCount = 0;
  
  // Send emails sequentially
  for (let i = 0; i < testEmails; i++) {
    const email = new Email({
      from: 'pooled@example.com',
      to: [`recipient${i}@example.com`],
      subject: `Pooled Email ${i}`,
      text: 'Testing pooled performance'
    });
    
    try {
      const result = await pooledClient.sendMail(email);
      if (result.success) {
        pooledSuccessCount++;
      }
    } catch (error) {
      console.log(`Pooled email ${i} failed: ${error.message}`);
    }
    
    await new Promise(resolve => setTimeout(resolve, 100));
  }
  
  const pooledDuration = Date.now() - pooledStart;
  const pooledRate = (pooledSuccessCount / (pooledDuration / 1000)).toFixed(2);
  
  await pooledClient.close();
  
  console.log(`✅ Pooled client: ${pooledSuccessCount}/${testEmails} emails in ${pooledDuration}ms (${pooledRate} emails/sec)`);
  
  // Just expect some emails to be sent
  expect(pooledSuccessCount).toBeGreaterThan(0);
});

tap.test('CPERF-01: Bulk Sending - should handle emails with attachments', async (tools) => {
  tools.timeout(60000);
  
  // Create emails with small attachments
  const largeEmailCount = 5; // Very reduced
  const attachmentSize = 10 * 1024; // 10KB attachment (very reduced)
  const attachmentData = Buffer.alloc(attachmentSize, 'x'); // Fill with 'x'
  
  const startTime = Date.now();
  let successCount = 0;
  
  for (let i = 0; i < largeEmailCount; i++) {
    const email = new Email({
      from: 'bulk-sender@example.com',
      to: [`recipient${i}@example.com`],
      subject: `Large Bulk Email ${i}`,
      text: 'This email contains an attachment',
      attachments: [{
        filename: `attachment-${i}.txt`,
        content: attachmentData.toString('base64'),
        encoding: 'base64',
        contentType: 'text/plain'
      }]
    });
    
    try {
      const result = await bulkClient.sendMail(email);
      if (result.success) {
        successCount++;
      }
    } catch (error) {
      console.log(`Large email ${i} failed: ${error.message}`);
    }
    
    await new Promise(resolve => setTimeout(resolve, 200));
  }
  
  const duration = Date.now() - startTime;
  
  expect(successCount).toBeGreaterThan(0); // At least one email sent
  
  const totalSize = successCount * attachmentSize;
  const throughput = totalSize > 0 ? (totalSize / 1024 / 1024 / (duration / 1000)).toFixed(2) : '0';
  
  console.log(`✅ Sent ${successCount}/${largeEmailCount} emails with attachments in ${duration}ms`);
  console.log(`   Total data: ${(totalSize / 1024 / 1024).toFixed(2)}MB`);
  console.log(`   Throughput: ${throughput} MB/s`);
});

tap.test('CPERF-01: Bulk Sending - should maintain performance under sustained load', async (tools) => {
  tools.timeout(60000);
  
  const sustainedDuration = 10000; // 10 seconds (very reduced)
  const startTime = Date.now();
  let emailsSent = 0;
  let errors = 0;
  
  console.log('📊 Starting sustained load test...');
  
  // Send emails continuously for duration
  while (Date.now() - startTime < sustainedDuration) {
    const email = new Email({
      from: 'sustained@example.com',
      to: ['recipient@example.com'],
      subject: `Sustained Load Email ${emailsSent + 1}`,
      text: `Email sent at ${new Date().toISOString()}`
    });
    
    try {
      const result = await bulkClient.sendMail(email);
      if (result.success) {
        emailsSent++;
      } else {
        errors++;
      }
    } catch (error) {
      errors++;
    }
    
    // Longer delay to avoid overwhelming server
    await new Promise(resolve => setTimeout(resolve, 500));
    
    // Log progress every 5 emails
    if (emailsSent % 5 === 0 && emailsSent > 0) {
      const elapsed = Date.now() - startTime;
      const rate = (emailsSent / (elapsed / 1000)).toFixed(2);
      console.log(`   Progress: ${emailsSent} emails, ${rate} emails/sec`);
    }
  }
  
  const totalDuration = Date.now() - startTime;
  const avgRate = (emailsSent / (totalDuration / 1000)).toFixed(2);
  
  console.log(`✅ Sustained load test completed:`);
  console.log(`   Duration: ${totalDuration}ms`);
  console.log(`   Emails sent: ${emailsSent}`);
  console.log(`   Errors: ${errors}`);
  console.log(`   Average rate: ${avgRate} emails/sec`);
  
  expect(emailsSent).toBeGreaterThan(5); // Should send at least 5 emails
  expect(errors).toBeLessThan(emailsSent); // Fewer errors than successes
});

tap.test('CPERF-01: Bulk Sending - should track performance metrics', async () => {
  const metricsClient = createBulkSmtpClient({
    host: testServer.hostname,
    port: testServer.port,
    secure: false,
    debug: false
  });
  
  const metrics = {
    sent: 0,
    failed: 0,
    totalTime: 0,
    minTime: Infinity,
    maxTime: 0
  };
  
  // Send emails and collect metrics
  for (let i = 0; i < 5; i++) { // Very reduced
    const email = new Email({
      from: 'metrics@example.com',
      to: [`recipient${i}@example.com`],
      subject: `Metrics Test ${i}`,
      text: 'Collecting performance metrics'
    });
    
    const sendStart = Date.now();
    try {
      const result = await metricsClient.sendMail(email);
      const sendTime = Date.now() - sendStart;
      
      if (result.success) {
        metrics.sent++;
        metrics.totalTime += sendTime;
        metrics.minTime = Math.min(metrics.minTime, sendTime);
        metrics.maxTime = Math.max(metrics.maxTime, sendTime);
      } else {
        metrics.failed++;
      }
    } catch (error) {
      metrics.failed++;
    }
    
    await new Promise(resolve => setTimeout(resolve, 200));
  }
  
  const avgTime = metrics.sent > 0 ? metrics.totalTime / metrics.sent : 0;
  
  console.log('📊 Performance metrics:');
  console.log(`   Sent: ${metrics.sent}`);
  console.log(`   Failed: ${metrics.failed}`);
  console.log(`   Avg time: ${avgTime.toFixed(2)}ms`);
  console.log(`   Min time: ${metrics.minTime === Infinity ? 'N/A' : metrics.minTime + 'ms'}`);
  console.log(`   Max time: ${metrics.maxTime}ms`);
  
  await metricsClient.close();
  
  expect(metrics.sent).toBeGreaterThan(0);
  if (metrics.sent > 0) {
    expect(avgTime).toBeLessThan(30000); // Average should be under 30 seconds
  }
});

tap.test('cleanup - close bulk client', async () => {
  if (bulkClient) {
    await bulkClient.close();
  }
});

tap.test('cleanup - stop SMTP server', async () => {
  await stopTestServer(testServer);
});

export default tap.start();