feat(storage): add comprehensive tests for StorageManager with memory, filesystem, and custom function backends

feat(email): implement EmailSendJob class for robust email delivery with retry logic and MX record resolution

feat(mail): restructure mail module exports for simplified access to core and delivery functionalities

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.ts';
+import { createSmtpClient } from '../../../ts/mail/delivery/smtpclient/index.ts';
+import { Email } from '../../../ts/mail/core/classes.email.ts';
+
+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();