@serve.zone/dcrouter 2.12.4

package/test/suite/smtpserver_commands/test.cmd-13.quit-command.ts

@@ -0,0 +1,384 @@
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+import * as net from 'net';
+import * as path from 'path';
+import { startTestServer, stopTestServer } from '../../helpers/server.loader.js';
+
+// Test configuration
+const TEST_PORT = 2525;
+
+let testServer;
+const TEST_TIMEOUT = 10000;
+
+// Setup
+tap.test('prepare server', async () => {
+  testServer = await startTestServer({ port: TEST_PORT });
+  await new Promise(resolve => setTimeout(resolve, 100));
+});
+
+// Test: Basic QUIT command
+tap.test('QUIT - should close connection gracefully', async (tools) => {
+  const done = tools.defer();
+  
+  const socket = net.createConnection({
+    host: 'localhost',
+    port: TEST_PORT,
+    timeout: TEST_TIMEOUT
+  });
+  
+  let receivedData = '';
+  let currentStep = 'connecting';
+  let connectionClosed = false;
+  
+  socket.on('data', (data) => {
+    receivedData += data.toString();
+    
+    if (currentStep === 'connecting' && receivedData.includes('220')) {
+      currentStep = 'ehlo';
+      socket.write('EHLO test.example.com\r\n');
+    } else if (currentStep === 'ehlo' && receivedData.includes('250')) {
+      currentStep = 'quit';
+      socket.write('QUIT\r\n');
+    } else if (currentStep === 'quit' && receivedData.includes('221')) {
+      // Don't destroy immediately, wait for server to close connection
+      setTimeout(() => {
+        if (!connectionClosed) {
+          socket.destroy();
+          expect(receivedData).toInclude('221'); // Closing connection message
+          done.resolve();
+        }
+      }, 2000);
+    }
+  });
+  
+  socket.on('close', () => {
+    if (currentStep === 'quit' && receivedData.includes('221')) {
+      connectionClosed = true;
+      expect(receivedData).toInclude('221');
+      done.resolve();
+    }
+  });
+  
+  socket.on('error', (error) => {
+    done.reject(error);
+  });
+  
+  socket.on('timeout', () => {
+    socket.destroy();
+    done.reject(new Error(`Connection timeout at step: ${currentStep}`));
+  });
+  
+  await done.promise;
+});
+
+// Test: QUIT during transaction
+tap.test('QUIT - should work during active transaction', async (tools) => {
+  const done = tools.defer();
+  
+  const socket = net.createConnection({
+    host: 'localhost',
+    port: TEST_PORT,
+    timeout: TEST_TIMEOUT
+  });
+  
+  let receivedData = '';
+  let currentStep = 'connecting';
+  
+  socket.on('data', (data) => {
+    receivedData += data.toString();
+    
+    if (currentStep === 'connecting' && receivedData.includes('220')) {
+      currentStep = 'ehlo';
+      socket.write('EHLO test.example.com\r\n');
+    } else if (currentStep === 'ehlo' && receivedData.includes('250')) {
+      currentStep = 'mail_from';
+      socket.write('MAIL FROM:<sender@example.com>\r\n');
+    } else if (currentStep === 'mail_from' && receivedData.includes('250')) {
+      currentStep = 'rcpt_to';
+      socket.write('RCPT TO:<recipient@example.com>\r\n');
+    } else if (currentStep === 'rcpt_to' && receivedData.includes('250')) {
+      currentStep = 'quit';
+      socket.write('QUIT\r\n');
+    } else if (currentStep === 'quit' && receivedData.includes('221')) {
+      setTimeout(() => {
+        socket.destroy();
+        expect(receivedData).toInclude('221');
+        done.resolve();
+      }, 100);
+    }
+  });
+  
+  socket.on('error', (error) => {
+    done.reject(error);
+  });
+  
+  socket.on('timeout', () => {
+    socket.destroy();
+    done.reject(new Error(`Connection timeout at step: ${currentStep}`));
+  });
+  
+  await done.promise;
+});
+
+// Test: QUIT immediately after connect
+tap.test('QUIT - should work immediately after connection', async (tools) => {
+  const done = tools.defer();
+  
+  const socket = net.createConnection({
+    host: 'localhost',
+    port: TEST_PORT,
+    timeout: TEST_TIMEOUT
+  });
+  
+  let receivedData = '';
+  let currentStep = 'connecting';
+  
+  socket.on('data', (data) => {
+    receivedData += data.toString();
+    
+    if (currentStep === 'connecting' && receivedData.includes('220')) {
+      currentStep = 'quit';
+      socket.write('QUIT\r\n');
+    } else if (currentStep === 'quit' && receivedData.includes('221')) {
+      setTimeout(() => {
+        socket.destroy();
+        expect(receivedData).toInclude('221');
+        done.resolve();
+      }, 100);
+    }
+  });
+  
+  socket.on('error', (error) => {
+    done.reject(error);
+  });
+  
+  socket.on('timeout', () => {
+    socket.destroy();
+    done.reject(new Error(`Connection timeout at step: ${currentStep}`));
+  });
+  
+  await done.promise;
+});
+
+// Test: QUIT with parameters (should be ignored or rejected)
+tap.test('QUIT - should handle QUIT with parameters', async (tools) => {
+  const done = tools.defer();
+  
+  const socket = net.createConnection({
+    host: 'localhost',
+    port: TEST_PORT,
+    timeout: TEST_TIMEOUT
+  });
+  
+  let receivedData = '';
+  let currentStep = 'connecting';
+  
+  socket.on('data', (data) => {
+    receivedData += data.toString();
+    
+    if (currentStep === 'connecting' && receivedData.includes('220')) {
+      currentStep = 'ehlo';
+      receivedData = '';
+      socket.write('EHLO test.example.com\r\n');
+    } else if (currentStep === 'ehlo' && receivedData.includes('250 ')) {
+      currentStep = 'quit_with_param';
+      receivedData = '';
+      socket.write('QUIT unexpected parameter\r\n');
+    } else if (currentStep === 'quit_with_param' && (receivedData.includes('221') || receivedData.includes('501'))) {
+      // Server may accept (221) or reject (501) QUIT with parameters
+      const responseCode = receivedData.match(/(\d{3})/)?.[1];
+      socket.destroy();
+      expect(['221', '501']).toInclude(responseCode);
+      done.resolve();
+    }
+  });
+  
+  socket.on('error', (error) => {
+    done.reject(error);
+  });
+  
+  socket.on('timeout', () => {
+    socket.destroy();
+    done.reject(new Error(`Connection timeout at step: ${currentStep}`));
+  });
+  
+  await done.promise;
+});
+
+// Test: Multiple QUITs (second should fail)
+tap.test('QUIT - second QUIT should fail after connection closed', async (tools) => {
+  const done = tools.defer();
+  
+  const socket = net.createConnection({
+    host: 'localhost',
+    port: TEST_PORT,
+    timeout: TEST_TIMEOUT
+  });
+  
+  let receivedData = '';
+  let currentStep = 'connecting';
+  let quitSent = false;
+  
+  socket.on('data', (data) => {
+    receivedData += data.toString();
+    
+    if (currentStep === 'connecting' && receivedData.includes('220')) {
+      currentStep = 'ehlo';
+      receivedData = '';
+      socket.write('EHLO test.example.com\r\n');
+    } else if (currentStep === 'ehlo' && receivedData.includes('250 ')) {
+      currentStep = 'quit';
+      receivedData = '';
+      socket.write('QUIT\r\n');
+      quitSent = true;
+    } else if (currentStep === 'quit' && receivedData.includes('221')) {
+      // Try to send another QUIT
+      try {
+        socket.write('QUIT\r\n');
+        // If write succeeds, wait a bit to see if we get a response
+        setTimeout(() => {
+          socket.destroy();
+          done.resolve(); // Test passes either way
+        }, 500);
+      } catch (err) {
+        // Write failed because connection closed - this is expected
+        done.resolve();
+      }
+    }
+  });
+  
+  socket.on('close', () => {
+    if (quitSent) {
+      done.resolve();
+    }
+  });
+  
+  socket.on('error', (error) => {
+    if (quitSent && error.message.includes('EPIPE')) {
+      // Expected error when writing to closed socket
+      done.resolve();
+    } else {
+      done.reject(error);
+    }
+  });
+  
+  socket.on('timeout', () => {
+    socket.destroy();
+    done.reject(new Error(`Connection timeout at step: ${currentStep}`));
+  });
+  
+  await done.promise;
+});
+
+// Test: QUIT response format
+tap.test('QUIT - should return proper 221 response', async (tools) => {
+  const done = tools.defer();
+  
+  const socket = net.createConnection({
+    host: 'localhost',
+    port: TEST_PORT,
+    timeout: TEST_TIMEOUT
+  });
+  
+  let receivedData = '';
+  let currentStep = 'connecting';
+  let quitResponse = '';
+  
+  socket.on('data', (data) => {
+    receivedData += data.toString();
+    
+    if (currentStep === 'connecting' && receivedData.includes('220')) {
+      currentStep = 'ehlo';
+      socket.write('EHLO test.example.com\r\n');
+    } else if (currentStep === 'ehlo' && receivedData.includes('250')) {
+      currentStep = 'quit';
+      receivedData = ''; // Clear buffer to capture only QUIT response
+      socket.write('QUIT\r\n');
+    } else if (currentStep === 'quit' && receivedData.includes('221')) {
+      quitResponse = receivedData.trim();
+      setTimeout(() => {
+        socket.destroy();
+        expect(quitResponse).toStartWith('221');
+        expect(quitResponse.toLowerCase()).toInclude('closing');
+        done.resolve();
+      }, 100);
+    }
+  });
+  
+  socket.on('error', (error) => {
+    done.reject(error);
+  });
+  
+  socket.on('timeout', () => {
+    socket.destroy();
+    done.reject(new Error(`Connection timeout at step: ${currentStep}`));
+  });
+  
+  await done.promise;
+});
+
+// Test: Connection cleanup after QUIT
+tap.test('QUIT - verify clean connection shutdown', async (tools) => {
+  const done = tools.defer();
+  
+  const socket = net.createConnection({
+    host: 'localhost',
+    port: TEST_PORT,
+    timeout: TEST_TIMEOUT
+  });
+  
+  let receivedData = '';
+  let currentStep = 'connecting';
+  let closeEventFired = false;
+  let endEventFired = false;
+  
+  socket.on('data', (data) => {
+    receivedData += data.toString();
+    
+    if (currentStep === 'connecting' && receivedData.includes('220')) {
+      currentStep = 'ehlo';
+      socket.write('EHLO test.example.com\r\n');
+    } else if (currentStep === 'ehlo' && receivedData.includes('250')) {
+      currentStep = 'quit';
+      socket.write('QUIT\r\n');
+    } else if (currentStep === 'quit' && receivedData.includes('221')) {
+      // Wait for clean shutdown
+      setTimeout(() => {
+        if (!closeEventFired && !endEventFired) {
+          socket.destroy();
+          done.resolve();
+        }
+      }, 3000);
+    }
+  });
+  
+  socket.on('end', () => {
+    endEventFired = true;
+  });
+  
+  socket.on('close', () => {
+    closeEventFired = true;
+    if (currentStep === 'quit') {
+      expect(endEventFired || closeEventFired).toEqual(true);
+      done.resolve();
+    }
+  });
+  
+  socket.on('error', (error) => {
+    done.reject(error);
+  });
+  
+  socket.on('timeout', () => {
+    socket.destroy();
+    done.reject(new Error(`Connection timeout at step: ${currentStep}`));
+  });
+  
+  await done.promise;
+});
+
+// Teardown
+tap.test('cleanup server', async () => {
+  await stopTestServer(testServer);
+});
+
+// Start the test
+export default tap.start();

package/test/suite/smtpserver_connection/test.cm-01.tls-connection.ts

@@ -0,0 +1,61 @@
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+import { startTestServer, stopTestServer, type ITestServer } from '../../helpers/server.loader.js';
+import { connectToSmtp, performSmtpHandshake, closeSmtpConnection } from '../../helpers/utils.js';
+
+let testServer: ITestServer;
+
+tap.test('setup - start SMTP server with TLS support', async () => {
+  testServer = await startTestServer({
+    port: 2525,
+    tlsEnabled: true  // Enable TLS support
+  });
+  
+  await new Promise(resolve => setTimeout(resolve, 1000));
+  expect(testServer.port).toEqual(2525);
+});
+
+tap.test('CM-01: TLS Connection Test - server should advertise STARTTLS capability', async () => {
+  const startTime = Date.now();
+  
+  try {
+    // Connect to SMTP server
+    const socket = await connectToSmtp(testServer.hostname, testServer.port);
+    expect(socket).toBeInstanceOf(Object);
+    
+    // Perform handshake and get capabilities
+    const capabilities = await performSmtpHandshake(socket, 'test.example.com');
+    expect(capabilities).toBeArray();
+    
+    // Check for STARTTLS support
+    const supportsStarttls = capabilities.some(cap => cap.toUpperCase().includes('STARTTLS'));
+    expect(supportsStarttls).toEqual(true);
+    
+    // Close connection gracefully
+    await closeSmtpConnection(socket);
+    
+    const duration = Date.now() - startTime;
+    console.log(`✅ TLS capability test completed in ${duration}ms`);
+    console.log(`📋 Server capabilities: ${capabilities.join(', ')}`);
+    
+  } catch (error) {
+    const duration = Date.now() - startTime;
+    console.error(`❌ TLS connection test failed after ${duration}ms:`, error);
+    throw error;
+  }
+});
+
+tap.test('CM-01: TLS Connection Test - verify TLS certificate configuration', async () => {
+  // This test verifies that the server has TLS certificates configured
+  expect(testServer.config.tlsEnabled).toEqual(true);
+  
+  // The server should have loaded certificates during startup
+  // In production, this would validate actual certificate properties
+  console.log('✅ TLS configuration verified');
+});
+
+tap.test('cleanup - stop SMTP server', async () => {
+  await stopTestServer(testServer);
+  console.log('✅ Test server stopped');
+});
+
+export default tap.start();

package/test/suite/smtpserver_connection/test.cm-02.multiple-connections.ts

@@ -0,0 +1,112 @@
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+import { startTestServer, stopTestServer, type ITestServer } from '../../helpers/server.loader.js';
+import { createConcurrentConnections, performSmtpHandshake, closeSmtpConnection } from '../../helpers/utils.js';
+
+let testServer: ITestServer;
+const CONCURRENT_COUNT = 10;
+const TEST_PORT = 2527;
+
+tap.test('setup - start SMTP server', async () => {
+  testServer = await startTestServer({
+    port: 2526
+  });
+  
+  await new Promise(resolve => setTimeout(resolve, 1000));
+  expect(testServer.port).toEqual(2526);
+});
+
+tap.test('CM-02: Multiple Simultaneous Connections - server handles concurrent connections', async () => {
+  const startTime = Date.now();
+  
+  try {
+    // Create multiple concurrent connections
+    console.log(`🔄 Creating ${CONCURRENT_COUNT} concurrent connections...`);
+    const sockets = await createConcurrentConnections(
+      testServer.hostname,
+      testServer.port,
+      CONCURRENT_COUNT
+    );
+    
+    expect(sockets).toBeArray();
+    expect(sockets.length).toEqual(CONCURRENT_COUNT);
+    
+    // Verify all connections are active
+    let activeCount = 0;
+    for (const socket of sockets) {
+      if (socket && !socket.destroyed) {
+        activeCount++;
+      }
+    }
+    expect(activeCount).toEqual(CONCURRENT_COUNT);
+    
+    // Perform handshake on all connections
+    console.log('🤝 Performing handshake on all connections...');
+    const handshakePromises = sockets.map(socket => 
+      performSmtpHandshake(socket).catch(err => ({ error: err.message }))
+    );
+    
+    const results = await Promise.all(handshakePromises);
+    const successCount = results.filter(r => Array.isArray(r)).length;
+    
+    expect(successCount).toBeGreaterThan(0);
+    console.log(`✅ ${successCount}/${CONCURRENT_COUNT} connections completed handshake`);
+    
+    // Close all connections
+    console.log('🔚 Closing all connections...');
+    await Promise.all(
+      sockets.map(socket => closeSmtpConnection(socket).catch(() => {}))
+    );
+    
+    const duration = Date.now() - startTime;
+    console.log(`✅ Multiple connection test completed in ${duration}ms`);
+    
+  } catch (error) {
+    console.error('❌ Multiple connection test failed:', error);
+    throw error;
+  }
+});
+
+// TODO: Enable this test when connection limits are implemented in the server
+// tap.test('CM-02: Connection limit enforcement - verify max connections', async () => {
+//   const maxConnections = 5;
+//   
+//   // Start a new server with lower connection limit
+//   const limitedServer = await startTestServer({ port: TEST_PORT });
+//   
+//   await new Promise(resolve => setTimeout(resolve, 1000));
+//   
+//   try {
+//     // Try to create more connections than allowed
+//     const attemptCount = maxConnections + 5;
+//     console.log(`🔄 Attempting ${attemptCount} connections (limit: ${maxConnections})...`);
+//     
+//     const connectionPromises = [];
+//     for (let i = 0; i < attemptCount; i++) {
+//       connectionPromises.push(
+//         createConcurrentConnections(limitedServer.hostname, limitedServer.port, 1)
+//           .then(() => ({ success: true, index: i }))
+//           .catch(err => ({ success: false, index: i, error: err.message }))
+//       );
+//     }
+//     
+//     const results = await Promise.all(connectionPromises);
+//     const successfulConnections = results.filter(r => r.success).length;
+//     const failedConnections = results.filter(r => !r.success).length;
+//     
+//     console.log(`✅ Successful connections: ${successfulConnections}`);
+//     console.log(`❌ Failed connections: ${failedConnections}`);
+//     
+//     // Some connections should fail due to limit
+//     expect(failedConnections).toBeGreaterThan(0);
+//     
+//   } finally {
+//     await stopTestServer(limitedServer);
+//   }
+// });
+
+tap.test('cleanup - stop SMTP server', async () => {
+  await stopTestServer(testServer);
+  console.log('✅ Test server stopped');
+});
+
+export default tap.start();

package/test/suite/smtpserver_connection/test.cm-03.connection-timeout.ts

@@ -0,0 +1,134 @@
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+import { startTestServer, stopTestServer, type ITestServer } from '../../helpers/server.loader.js';
+import * as plugins from '../../../ts/plugins.js';
+
+const TEST_PORT = 2525;
+let testServer: ITestServer;
+
+tap.test('setup - start SMTP server with short timeout', async () => {
+  testServer = await startTestServer({ 
+    port: TEST_PORT,
+    timeout: 5000  // 5 second timeout for this test
+  });
+  
+  await new Promise(resolve => setTimeout(resolve, 1000));
+});
+
+tap.test('CM-03: Connection Timeout - idle connections are closed after timeout', async (tools) => {
+  const startTime = Date.now();
+  
+  // Create connection
+  const socket = await new Promise<plugins.net.Socket>((resolve, reject) => {
+    const client = plugins.net.createConnection({
+      host: testServer.hostname,
+      port: testServer.port
+    });
+    
+    client.on('connect', () => resolve(client));
+    client.on('error', reject);
+    
+    setTimeout(() => reject(new Error('Connection timeout')), 3000);
+  });
+  
+  // Wait for greeting
+  await new Promise<void>((resolve) => {
+    socket.once('data', (data) => {
+      const response = data.toString();
+      expect(response).toInclude('220');
+      resolve();
+    });
+  });
+  
+  console.log('✅ Connected and received greeting');
+  
+  // Now stay idle and wait for server to timeout the connection
+  const disconnectPromise = new Promise<number>((resolve) => {
+    socket.on('close', () => {
+      const duration = Date.now() - startTime;
+      resolve(duration);
+    });
+    
+    socket.on('end', () => {
+      console.log('📡 Server initiated connection close');
+    });
+    
+    socket.on('error', (err) => {
+      console.log('⚠️ Socket error:', err.message);
+    });
+  });
+  
+  // Wait for timeout (should be around 5 seconds)
+  const duration = await disconnectPromise;
+  
+  console.log(`⏱️ Connection closed after ${duration}ms`);
+  
+  // Verify timeout happened within expected range (4-6 seconds)
+  expect(duration).toBeGreaterThan(4000);
+  expect(duration).toBeLessThan(7000);
+  
+  console.log('✅ Connection timeout test passed');
+});
+
+tap.test('CM-03: Active connection should not timeout', async () => {
+  // Create new connection
+  const socket = plugins.net.createConnection({
+    host: testServer.hostname,
+    port: testServer.port
+  });
+  
+  await new Promise<void>((resolve) => {
+    socket.on('connect', resolve);
+  });
+  
+  // Wait for greeting
+  await new Promise<void>((resolve) => {
+    socket.once('data', resolve);
+  });
+  
+  // Keep connection active with NOOP commands
+  let isConnected = true;
+  socket.on('close', () => {
+    isConnected = false;
+  });
+  
+  // Send NOOP every 2 seconds for 8 seconds
+  for (let i = 0; i < 4; i++) {
+    if (!isConnected) break;
+    
+    socket.write('NOOP\r\n');
+    
+    // Wait for response
+    await new Promise<void>((resolve) => {
+      socket.once('data', (data) => {
+        const response = data.toString();
+        expect(response).toInclude('250');
+        resolve();
+      });
+    });
+    
+    console.log(`✅ NOOP ${i + 1}/4 successful`);
+    
+    // Wait 2 seconds before next NOOP
+    await new Promise(resolve => setTimeout(resolve, 2000));
+  }
+  
+  // Connection should still be active
+  expect(isConnected).toEqual(true);
+  
+  // Close connection gracefully
+  socket.write('QUIT\r\n');
+  await new Promise<void>((resolve) => {
+    socket.once('data', () => {
+      socket.end();
+      resolve();
+    });
+  });
+  
+  console.log('✅ Active connection did not timeout');
+});
+
+tap.test('cleanup - stop SMTP server', async () => {
+  await stopTestServer(testServer);
+});
+
+export default tap.start();