serve.zone/dcrouter
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

update

Browse Source
This commit is contained in:
Philipp Kunz
2025-05-25 19:02:18 +00:00
parent 5b33623c2d
commit 4c9fd22a86
20 changed files with 1551 additions and 1451 deletions
Download Patch File Download Diff File Expand all files Collapse all files

525
test/suite/smtpclient_commands/test.ccmd-09.noop-command.ts
View File

@@ -5,6 +5,7 @@ import type { SmtpClient } from '../../../ts/mail/delivery/smtpclient/smtp-clien
import { Email } from '../../../ts/mail/core/classes.email.js';
let testServer: ITestServer;
let smtpClient: SmtpClient;
tap.test('setup test SMTP server', async () => {
testServer = await startTestServer({
@@ -16,183 +17,186 @@ tap.test('setup test SMTP server', async () => {
expect(testServer.port).toBeGreaterThan(0);
});
tap.test('CCMD-09: Basic NOOP command', async () => {
const smtpClient = createSmtpClient({
host: testServer.hostname,
port: testServer.port,
secure: false,
connectionTimeout: 5000,
debug: true
});
await smtpClient.connect();
await smtpClient.sendCommand('EHLO testclient.example.com');
// Send NOOP command
const noopResponse = await smtpClient.sendCommand('NOOP');
// Verify response
expect(noopResponse).toInclude('250');
console.log(`NOOP response: ${noopResponse.trim()}`);
await smtpClient.close();
});
tap.test('CCMD-09: NOOP during transaction', async () => {
const smtpClient = createSmtpClient({
host: testServer.hostname,
port: testServer.port,
secure: false,
connectionTimeout: 5000,
debug: true
});
await smtpClient.connect();
await smtpClient.sendCommand('EHLO testclient.example.com');
// Start a transaction
await smtpClient.sendCommand('MAIL FROM:<sender@example.com>');
await smtpClient.sendCommand('RCPT TO:<recipient@example.com>');
// Send NOOP - should not affect transaction
const noopResponse = await smtpClient.sendCommand('NOOP');
expect(noopResponse).toInclude('250');
// Continue transaction - should still work
const dataResponse = await smtpClient.sendCommand('DATA');
expect(dataResponse).toInclude('354');
// Send message
const messageResponse = await smtpClient.sendCommand('Subject: Test\r\n\r\nTest message\r\n.');
expect(messageResponse).toInclude('250');
console.log('Transaction completed successfully after NOOP');
await smtpClient.close();
});
tap.test('CCMD-09: Multiple NOOP commands', async () => {
const smtpClient = createSmtpClient({
host: testServer.hostname,
port: testServer.port,
secure: false,
connectionTimeout: 5000,
debug: true
});
await smtpClient.connect();
await smtpClient.sendCommand('EHLO testclient.example.com');
// Send multiple NOOPs rapidly
const noopCount = 10;
const responses: string[] = [];
console.log(`Sending ${noopCount} NOOP commands...`);
for (let i = 0; i < noopCount; i++) {
const response = await smtpClient.sendCommand('NOOP');
responses.push(response);
}
// All should succeed
responses.forEach((response, index) => {
expect(response).toInclude('250');
});
console.log(`All ${noopCount} NOOP commands succeeded`);
await smtpClient.close();
});
tap.test('CCMD-09: NOOP for keep-alive', async () => {
const smtpClient = createSmtpClient({
tap.test('CCMD-09: Connection keepalive test', async () => {
// NOOP is used internally for keepalive - test that connections remain active
smtpClient = createSmtpClient({
host: testServer.hostname,
port: testServer.port,
secure: false,
connectionTimeout: 10000,
debug: true
greetingTimeout: 5000,
socketTimeout: 10000
});
await smtpClient.connect();
await smtpClient.sendCommand('EHLO testclient.example.com');
// Send an initial email to establish connection
const email1 = new Email({
from: 'sender@example.com',
to: ['recipient@example.com'],
subject: 'Initial connection test',
text: 'Testing connection establishment'
});
console.log('Using NOOP for keep-alive over 10 seconds...');
await smtpClient.sendMail(email1);
console.log('First email sent successfully');
// Send NOOP every 2 seconds for 10 seconds
const keepAliveInterval = 2000;
const duration = 10000;
const iterations = duration / keepAliveInterval;
// Wait 5 seconds (connection should stay alive with internal NOOP)
await new Promise(resolve => setTimeout(resolve, 5000));
// Send another email on the same connection
const email2 = new Email({
from: 'sender@example.com',
to: ['recipient@example.com'],
subject: 'Keepalive test',
text: 'Testing connection after delay'
});
await smtpClient.sendMail(email2);
console.log('Second email sent successfully after 5 second delay');
});
tap.test('CCMD-09: Multiple emails in sequence', async () => {
// Test that client can handle multiple emails without issues
// Internal NOOP commands may be used between transactions
const emails = [];
for (let i = 0; i < 5; i++) {
emails.push(new Email({
from: 'sender@example.com',
to: [`recipient${i}@example.com`],
subject: `Sequential email ${i + 1}`,
text: `This is email number ${i + 1}`
}));
}
console.log('Sending 5 emails in sequence...');
for (let i = 0; i < emails.length; i++) {
await smtpClient.sendMail(emails[i]);
console.log(`Email ${i + 1} sent successfully`);
// Small delay between emails
await new Promise(resolve => setTimeout(resolve, 500));
}
console.log('All emails sent successfully');
});
tap.test('CCMD-09: Rapid email sending', async () => {
// Test rapid email sending without delays
// Internal connection management should handle this properly
const emailCount = 10;
const emails = [];
for (let i = 0; i < emailCount; i++) {
emails.push(new Email({
from: 'sender@example.com',
to: ['recipient@example.com'],
subject: `Rapid email ${i + 1}`,
text: `Rapid fire email number ${i + 1}`
}));
}
console.log(`Sending ${emailCount} emails rapidly...`);
const startTime = Date.now();
// Send all emails as fast as possible
for (const email of emails) {
await smtpClient.sendMail(email);
}
const elapsed = Date.now() - startTime;
console.log(`All ${emailCount} emails sent in ${elapsed}ms`);
console.log(`Average: ${(elapsed / emailCount).toFixed(2)}ms per email`);
});
tap.test('CCMD-09: Long-lived connection test', async () => {
// Test that connection stays alive over extended period
// SmtpClient should use internal keepalive mechanisms
console.log('Testing connection over 10 seconds with periodic emails...');
const testDuration = 10000;
const emailInterval = 2500;
const iterations = Math.floor(testDuration / emailInterval);
for (let i = 0; i < iterations; i++) {
await new Promise(resolve => setTimeout(resolve, keepAliveInterval));
const email = new Email({
from: 'sender@example.com',
to: ['recipient@example.com'],
subject: `Keepalive test ${i + 1}`,
text: `Testing connection keepalive - email ${i + 1}`
});
const startTime = Date.now();
const response = await smtpClient.sendCommand('NOOP');
await smtpClient.sendMail(email);
const elapsed = Date.now() - startTime;
expect(response).toInclude('250');
console.log(`Keep-alive NOOP ${i + 1}: ${elapsed}ms`);
console.log(`Email ${i + 1} sent in ${elapsed}ms`);
if (i < iterations - 1) {
await new Promise(resolve => setTimeout(resolve, emailInterval));
}
}
// Connection should still be active
expect(smtpClient.isConnected()).toBeTruthy();
await smtpClient.close();
console.log('Connection remained stable over 10 seconds');
});
tap.test('CCMD-09: NOOP with parameters', async () => {
const smtpClient = createSmtpClient({
host: testServer.hostname,
port: testServer.port,
secure: false,
connectionTimeout: 5000,
debug: true
});
await smtpClient.connect();
await smtpClient.sendCommand('EHLO testclient.example.com');
// RFC 5321 allows NOOP to have parameters (which are ignored)
const noopVariants = [
'NOOP',
'NOOP test',
'NOOP hello world',
'NOOP 12345',
'NOOP check connection'
tap.test('CCMD-09: Connection pooling behavior', async () => {
// Test connection pooling with different email patterns
// Internal NOOP may be used to maintain pool connections
const testPatterns = [
{ count: 3, delay: 0, desc: 'Burst of 3 emails' },
{ count: 2, delay: 1000, desc: '2 emails with 1s delay' },
{ count: 1, delay: 3000, desc: '1 email after 3s delay' }
];
for (const command of noopVariants) {
const response = await smtpClient.sendCommand(command);
expect(response).toInclude('250');
console.log(`"${command}" -> ${response.trim()}`);
for (const pattern of testPatterns) {
console.log(`\nTesting: ${pattern.desc}`);
if (pattern.delay > 0) {
await new Promise(resolve => setTimeout(resolve, pattern.delay));
}
for (let i = 0; i < pattern.count; i++) {
const email = new Email({
from: 'sender@example.com',
to: ['recipient@example.com'],
subject: `${pattern.desc} - Email ${i + 1}`,
text: 'Testing connection pooling behavior'
});
await smtpClient.sendMail(email);
}
console.log(`Completed: ${pattern.desc}`);
}
await smtpClient.close();
});
tap.test('CCMD-09: NOOP timing analysis', async () => {
const smtpClient = createSmtpClient({
host: testServer.hostname,
port: testServer.port,
secure: false,
connectionTimeout: 5000,
debug: false // Quiet for timing
});
await smtpClient.connect();
await smtpClient.sendCommand('EHLO testclient.example.com');
// Measure NOOP response times
tap.test('CCMD-09: Email sending performance', async () => {
// Measure email sending performance
// Connection management (including internal NOOP) affects timing
const measurements = 20;
const times: number[] = [];
console.log(`Measuring performance over ${measurements} emails...`);
for (let i = 0; i < measurements; i++) {
const email = new Email({
from: 'sender@example.com',
to: ['recipient@example.com'],
subject: `Performance test ${i + 1}`,
text: 'Measuring email sending performance'
});
const startTime = Date.now();
await smtpClient.sendCommand('NOOP');
await smtpClient.sendMail(email);
const elapsed = Date.now() - startTime;
times.push(elapsed);
}
// Calculate statistics
const avgTime = times.reduce((a, b) => a + b, 0) / times.length;
const minTime = Math.min(...times);
@@ -201,145 +205,134 @@ tap.test('CCMD-09: NOOP timing analysis', async () => {
// Calculate standard deviation
const variance = times.reduce((sum, time) => sum + Math.pow(time - avgTime, 2), 0) / times.length;
const stdDev = Math.sqrt(variance);
console.log(`NOOP timing analysis (${measurements} samples):`);
console.log(`\nPerformance analysis (${measurements} emails):`);
console.log(` Average: ${avgTime.toFixed(2)}ms`);
console.log(` Min: ${minTime}ms`);
console.log(` Max: ${maxTime}ms`);
console.log(` Std Dev: ${stdDev.toFixed(2)}ms`);
// NOOP should be very fast
expect(avgTime).toBeLessThan(50);
// Check for consistency (low standard deviation)
expect(stdDev).toBeLessThan(avgTime * 0.5); // Less than 50% of average
await smtpClient.close();
// First email might be slower due to connection establishment
const avgWithoutFirst = times.slice(1).reduce((a, b) => a + b, 0) / (times.length - 1);
console.log(` Average (excl. first): ${avgWithoutFirst.toFixed(2)}ms`);
// Performance should be reasonable
expect(avgTime).toBeLessThan(200);
});
tap.test('CCMD-09: NOOP during DATA phase', async () => {
const smtpClient = createSmtpClient({
host: testServer.hostname,
port: testServer.port,
secure: false,
connectionTimeout: 5000,
debug: true
tap.test('CCMD-09: Email with NOOP in content', async () => {
// Test that NOOP as email content doesn't affect delivery
const email = new Email({
from: 'sender@example.com',
to: ['recipient@example.com'],
subject: 'Email containing NOOP',
text: `This email contains SMTP commands as content:
NOOP
HELO test
MAIL FROM:<test@example.com>
These should be treated as plain text, not commands.
The word NOOP appears multiple times in this email.
NOOP is used internally by SMTP for keepalive.`
});
await smtpClient.connect();
await smtpClient.sendCommand('EHLO testclient.example.com');
// Setup transaction
await smtpClient.sendCommand('MAIL FROM:<sender@example.com>');
await smtpClient.sendCommand('RCPT TO:<recipient@example.com>');
// Enter DATA phase
const dataResponse = await smtpClient.sendCommand('DATA');
expect(dataResponse).toInclude('354');
// During DATA phase, NOOP will be treated as message content
await smtpClient.sendCommand('Subject: Test with NOOP');
await smtpClient.sendCommand('');
await smtpClient.sendCommand('This message contains the word NOOP');
await smtpClient.sendCommand('NOOP'); // This is message content, not a command
await smtpClient.sendCommand('End of message');
await smtpClient.sendMail(email);
console.log('Email with NOOP content sent successfully');
// End DATA phase
const endResponse = await smtpClient.sendCommand('.');
expect(endResponse).toInclude('250');
// Now NOOP should work as a command again
const noopResponse = await smtpClient.sendCommand('NOOP');
expect(noopResponse).toInclude('250');
console.log('NOOP works correctly after DATA phase');
await smtpClient.close();
// Send another email to verify connection still works
const email2 = new Email({
from: 'sender@example.com',
to: ['recipient@example.com'],
subject: 'Follow-up email',
text: 'Verifying connection still works after NOOP content'
});
await smtpClient.sendMail(email2);
console.log('Follow-up email sent successfully');
});
tap.test('CCMD-09: NOOP in pipelined commands', async () => {
const smtpClient = createSmtpClient({
host: testServer.hostname,
port: testServer.port,
secure: false,
enablePipelining: true,
connectionTimeout: 5000,
debug: true
});
await smtpClient.connect();
await smtpClient.sendCommand('EHLO testclient.example.com');
// Pipeline NOOP with other commands
console.log('Pipelining NOOP with other commands...');
tap.test('CCMD-09: Concurrent email sending', async () => {
// Test concurrent email sending
// Connection pooling and internal management should handle this
const pipelinedCommands = [
smtpClient.sendCommand('NOOP'),
smtpClient.sendCommand('MAIL FROM:<sender@example.com>'),
smtpClient.sendCommand('NOOP'),
smtpClient.sendCommand('RCPT TO:<recipient@example.com>'),
smtpClient.sendCommand('NOOP'),
smtpClient.sendCommand('RSET'),
smtpClient.sendCommand('NOOP')
];
const responses = await Promise.all(pipelinedCommands);
// All commands should succeed
responses.forEach((response, index) => {
expect(response).toInclude('250');
});
console.log('All pipelined commands including NOOPs succeeded');
await smtpClient.close();
});
tap.test('CCMD-09: NOOP error scenarios', async () => {
const smtpClient = createSmtpClient({
host: testServer.hostname,
port: testServer.port,
secure: false,
connectionTimeout: 5000,
debug: true
});
await smtpClient.connect();
const concurrentCount = 5;
const emails = [];
// Try NOOP before EHLO/HELO (some servers might reject)
const earlyNoop = await smtpClient.sendCommand('NOOP');
console.log(`NOOP before EHLO: ${earlyNoop.trim()}`);
for (let i = 0; i < concurrentCount; i++) {
emails.push(new Email({
from: 'sender@example.com',
to: [`recipient${i}@example.com`],
subject: `Concurrent email ${i + 1}`,
text: `Testing concurrent email sending - message ${i + 1}`
}));
}
// Most servers allow it, but check response
expect(earlyNoop).toMatch(/[25]\d\d/);
// Now do proper handshake
await smtpClient.sendCommand('EHLO testclient.example.com');
// Test malformed NOOP (though it should be accepted)
const malformedTests = [
'NOOP\t\ttabs',
'NOOP multiple spaces',
'noop lowercase',
'NoOp MixedCase'
];
for (const command of malformedTests) {
try {
const response = await smtpClient.sendCommand(command);
console.log(`"${command}" -> ${response.trim()}`);
// Most servers are lenient
} catch (error) {
console.log(`"${command}" -> Error: ${error.message}`);
console.log(`Sending ${concurrentCount} emails concurrently...`);
const startTime = Date.now();
// Send all emails concurrently
try {
await Promise.all(emails.map(email => smtpClient.sendMail(email)));
const elapsed = Date.now() - startTime;
console.log(`All ${concurrentCount} emails sent concurrently in ${elapsed}ms`);
} catch (error) {
// Concurrent sending might not be supported - that's OK
console.log('Concurrent sending not supported, falling back to sequential');
for (const email of emails) {
await smtpClient.sendMail(email);
}
}
});
await smtpClient.close();
tap.test('CCMD-09: Connection recovery test', async () => {
// Test connection recovery and error handling
// SmtpClient should handle connection issues gracefully
// Create a new client with shorter timeouts for testing
const testClient = createSmtpClient({
host: testServer.hostname,
port: testServer.port,
secure: false,
connectionTimeout: 3000,
socketTimeout: 3000
});
// Send initial email
const email1 = new Email({
from: 'sender@example.com',
to: ['recipient@example.com'],
subject: 'Connection test 1',
text: 'Testing initial connection'
});
await testClient.sendMail(email1);
console.log('Initial email sent');
// Simulate long delay that might timeout connection
console.log('Waiting 5 seconds to test connection recovery...');
await new Promise(resolve => setTimeout(resolve, 5000));
// Try to send another email - client should recover if needed
const email2 = new Email({
from: 'sender@example.com',
to: ['recipient@example.com'],
subject: 'Connection test 2',
text: 'Testing connection recovery'
});
try {
await testClient.sendMail(email2);
console.log('Email sent successfully after delay - connection recovered');
} catch (error) {
console.log('Connection recovery failed (this might be expected):', error.message);
}
});
tap.test('cleanup test SMTP server', async () => {
if (testServer) {
await testServer.stop();
await stopTestServer(testServer);
}
});

743
test/suite/smtpclient_commands/test.ccmd-10.vrfy-expn.ts
View File

@@ -3,8 +3,10 @@ import { startTestServer, stopTestServer, type ITestServer } from '../../helpers
import { createSmtpClient } 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 { EmailValidator } from '../../../ts/mail/core/classes.emailvalidator.js';
let testServer: ITestServer;
let smtpClient: SmtpClient;
tap.test('setup test SMTP server', async () => {
testServer = await startTestServer({
@@ -14,372 +16,441 @@ tap.test('setup test SMTP server', async () => {
});
expect(testServer).toBeTruthy();
expect(testServer.port).toBeGreaterThan(0);
});
tap.test('CCMD-10: VRFY command basic usage', async () => {
const smtpClient = createSmtpClient({
smtpClient = createSmtpClient({
host: testServer.hostname,
port: testServer.port,
secure: false,
connectionTimeout: 5000,
debug: true
connectionTimeout: 5000
});
});
await smtpClient.connect();
await smtpClient.sendCommand('EHLO testclient.example.com');
// Test VRFY with various addresses
tap.test('CCMD-10: Email address validation', async () => {
// Test email address validation which is what VRFY conceptually does
const validator = new EmailValidator();
const testAddresses = [
'user@example.com',
'postmaster',
'admin@example.com',
'nonexistent@example.com'
{ address: 'user@example.com', expected: true },
{ address: 'postmaster@example.com', expected: true },
{ address: 'admin@example.com', expected: true },
{ address: 'user.name+tag@example.com', expected: true },
{ address: 'test@sub.domain.example.com', expected: true },
{ address: 'invalid@', expected: false },
{ address: '@example.com', expected: false },
{ address: 'not-an-email', expected: false },
{ address: '', expected: false },
{ address: 'user@', expected: false }
];
for (const address of testAddresses) {
const response = await smtpClient.sendCommand(`VRFY ${address}`);
console.log(`VRFY ${address}: ${response.trim()}`);
// Response codes:
// 250 - Address valid
// 251 - Address valid but not local
// 252 - Cannot verify but will accept
// 550 - Address not found
// 502 - Command not implemented
// 252 - Cannot VRFY user
expect(response).toMatch(/^[25]\d\d/);
if (response.startsWith('250') || response.startsWith('251')) {
console.log(` -> Address verified: ${address}`);
} else if (response.startsWith('252')) {
console.log(` -> Cannot verify: ${address}`);
} else if (response.startsWith('550')) {
console.log(` -> Address not found: ${address}`);
} else if (response.startsWith('502')) {
console.log(` -> VRFY not implemented`);
}
console.log('Testing email address validation (VRFY equivalent):\n');
for (const test of testAddresses) {
const isValid = validator.isValidFormat(test.address);
expect(isValid).toEqual(test.expected);
console.log(`Address: "${test.address}" - Valid: ${isValid} (expected: ${test.expected})`);
}
await smtpClient.close();
// Test sending to valid addresses
const validEmail = new Email({
from: 'sender@example.com',
to: ['user@example.com'],
subject: 'Address validation test',
text: 'Testing address validation'
});
await smtpClient.sendMail(validEmail);
console.log('\nEmail sent successfully to validated address');
});
tap.test('CCMD-10: EXPN command basic usage', async () => {
const smtpClient = createSmtpClient({
host: testServer.hostname,
port: testServer.port,
secure: false,
connectionTimeout: 5000,
debug: true
tap.test('CCMD-10: Multiple recipient handling (EXPN equivalent)', async () => {
// Test multiple recipients which is conceptually similar to mailing list expansion
console.log('Testing multiple recipient handling (EXPN equivalent):\n');
// Create email with multiple recipients (like a mailing list)
const multiRecipientEmail = new Email({
from: 'sender@example.com',
to: [
'user1@example.com',
'user2@example.com',
'user3@example.com'
],
cc: [
'cc1@example.com',
'cc2@example.com'
],
bcc: [
'bcc1@example.com'
],
subject: 'Multi-recipient test (mailing list)',
text: 'Testing email distribution to multiple recipients'
});
await smtpClient.connect();
await smtpClient.sendCommand('EHLO testclient.example.com');
// Test EXPN with mailing lists
const testLists = [
'all',
'staff',
'users@example.com',
'mailinglist'
];
for (const list of testLists) {
const response = await smtpClient.sendCommand(`EXPN ${list}`);
console.log(`EXPN ${list}: ${response.trim()}`);
// Response codes:
// 250 - Expansion successful (may be multi-line)
// 252 - Cannot expand
// 550 - List not found
// 502 - Command not implemented
expect(response).toMatch(/^[25]\d\d/);
if (response.startsWith('250')) {
// Multi-line response possible
const lines = response.split('\r\n');
console.log(` -> List expanded to ${lines.length - 1} entries`);
} else if (response.startsWith('252')) {
console.log(` -> Cannot expand list: ${list}`);
} else if (response.startsWith('550')) {
console.log(` -> List not found: ${list}`);
} else if (response.startsWith('502')) {
console.log(` -> EXPN not implemented`);
}
}
await smtpClient.close();
const toAddresses = multiRecipientEmail.getToAddresses();
const ccAddresses = multiRecipientEmail.getCcAddresses();
const bccAddresses = multiRecipientEmail.getBccAddresses();
console.log(`To recipients: ${toAddresses.length}`);
toAddresses.forEach(addr => console.log(` - ${addr}`));
console.log(`\nCC recipients: ${ccAddresses.length}`);
ccAddresses.forEach(addr => console.log(` - ${addr}`));
console.log(`\nBCC recipients: ${bccAddresses.length}`);
bccAddresses.forEach(addr => console.log(` - ${addr}`));
console.log(`\nTotal recipients: ${toAddresses.length + ccAddresses.length + bccAddresses.length}`);
// Send the email
await smtpClient.sendMail(multiRecipientEmail);
console.log('\nEmail sent successfully to all recipients');
});
tap.test('CCMD-10: VRFY with full names', async () => {
const smtpClient = createSmtpClient({
host: testServer.hostname,
port: testServer.port,
secure: false,
connectionTimeout: 5000,
debug: true
});
await smtpClient.connect();
await smtpClient.sendCommand('EHLO testclient.example.com');
// Test VRFY with full names
tap.test('CCMD-10: Email addresses with display names', async () => {
// Test email addresses with display names (full names)
console.log('Testing email addresses with display names:\n');
const fullNameTests = [
'John Doe',
'"Smith, John" <john.smith@example.com>',
'Mary Johnson <mary@example.com>',
'Robert "Bob" Williams'
{ from: '"John Doe" <john@example.com>', expectedAddress: 'john@example.com' },
{ from: '"Smith, John" <john.smith@example.com>', expectedAddress: 'john.smith@example.com' },
{ from: 'Mary Johnson <mary@example.com>', expectedAddress: 'mary@example.com' },
{ from: '<bob@example.com>', expectedAddress: 'bob@example.com' }
];
for (const name of fullNameTests) {
const response = await smtpClient.sendCommand(`VRFY ${name}`);
console.log(`VRFY "${name}": ${response.trim()}`);
// Check if response includes email address
const emailMatch = response.match(/<([^>]+)>/);
if (emailMatch) {
console.log(` -> Resolved to: ${emailMatch[1]}`);
}
}
await smtpClient.close();
});
tap.test('CCMD-10: VRFY/EXPN security considerations', async () => {
const smtpClient = createSmtpClient({
host: testServer.hostname,
port: testServer.port,
secure: false,
connectionTimeout: 5000,
debug: true
});
await smtpClient.connect();
await smtpClient.sendCommand('EHLO testclient.example.com');
// Many servers disable VRFY/EXPN for security
console.log('\nTesting security responses:');
// Check if commands are disabled
const vrfyResponse = await smtpClient.sendCommand('VRFY postmaster');
const expnResponse = await smtpClient.sendCommand('EXPN all');
if (vrfyResponse.startsWith('502') || vrfyResponse.startsWith('252')) {
console.log('VRFY is disabled or restricted (security best practice)');
}
if (expnResponse.startsWith('502') || expnResponse.startsWith('252')) {
console.log('EXPN is disabled or restricted (security best practice)');
}
// Test potential information disclosure
const probeAddresses = [
'root',
'admin',
'administrator',
'webmaster',
'hostmaster',
'abuse'
];
let disclosureCount = 0;
for (const addr of probeAddresses) {
const response = await smtpClient.sendCommand(`VRFY ${addr}`);
if (response.startsWith('250') || response.startsWith('251')) {
disclosureCount++;
console.log(`Information disclosed for: ${addr}`);
}
}
console.log(`Total addresses disclosed: ${disclosureCount}/${probeAddresses.length}`);
await smtpClient.close();
});
tap.test('CCMD-10: VRFY/EXPN during transaction', async () => {
const smtpClient = createSmtpClient({
host: testServer.hostname,
port: testServer.port,
secure: false,
connectionTimeout: 5000,
debug: true
});
await smtpClient.connect();
await smtpClient.sendCommand('EHLO testclient.example.com');
// Start a mail transaction
await smtpClient.sendCommand('MAIL FROM:<sender@example.com>');
await smtpClient.sendCommand('RCPT TO:<recipient@example.com>');
// VRFY/EXPN during transaction should not affect it
const vrfyResponse = await smtpClient.sendCommand('VRFY user@example.com');
console.log(`VRFY during transaction: ${vrfyResponse.trim()}`);
const expnResponse = await smtpClient.sendCommand('EXPN mailinglist');
console.log(`EXPN during transaction: ${expnResponse.trim()}`);
// Continue transaction
const dataResponse = await smtpClient.sendCommand('DATA');
expect(dataResponse).toInclude('354');
await smtpClient.sendCommand('Subject: Test\r\n\r\nTest message\r\n.');
console.log('Transaction completed successfully after VRFY/EXPN');
await smtpClient.close();
});
tap.test('CCMD-10: VRFY with special characters', async () => {
const smtpClient = createSmtpClient({
host: testServer.hostname,
port: testServer.port,
secure: false,
connectionTimeout: 5000,
debug: true
});
await smtpClient.connect();
await smtpClient.sendCommand('EHLO testclient.example.com');
// Test addresses with special characters
const specialAddresses = [
'user+tag@example.com',
'first.last@example.com',
'user%remote@example.com',
'"quoted string"@example.com',
'user@[192.168.1.1]',
'user@sub.domain.example.com'
];
for (const addr of specialAddresses) {
const response = await smtpClient.sendCommand(`VRFY ${addr}`);
console.log(`VRFY special address "${addr}": ${response.trim()}`);
}
await smtpClient.close();
});
tap.test('CCMD-10: EXPN multi-line response', async () => {
const smtpClient = createSmtpClient({
host: testServer.hostname,
port: testServer.port,
secure: false,
connectionTimeout: 5000,
debug: true
});
await smtpClient.connect();
await smtpClient.sendCommand('EHLO testclient.example.com');
// EXPN might return multiple addresses
const response = await smtpClient.sendCommand('EXPN all-users');
if (response.startsWith('250')) {
const lines = response.split('\r\n').filter(line => line.length > 0);
console.log('EXPN multi-line response:');
lines.forEach((line, index) => {
if (line.includes('250-')) {
// Continuation line
const address = line.substring(4);
console.log(` Member ${index + 1}: ${address}`);
} else if (line.includes('250 ')) {
// Final line
const address = line.substring(4);
console.log(` Member ${index + 1}: ${address} (last)`);
}
for (const test of fullNameTests) {
const email = new Email({
from: test.from,
to: ['recipient@example.com'],
subject: 'Display name test',
text: `Testing from: ${test.from}`
});
}
await smtpClient.close();
});
tap.test('CCMD-10: VRFY/EXPN rate limiting', async () => {
const smtpClient = createSmtpClient({
host: testServer.hostname,
port: testServer.port,
secure: false,
connectionTimeout: 5000,
debug: false // Quiet for rate test
});
await smtpClient.connect();
await smtpClient.sendCommand('EHLO testclient.example.com');
// Send many VRFY commands rapidly
const requestCount = 20;
const startTime = Date.now();
let successCount = 0;
let rateLimitHit = false;
console.log(`Sending ${requestCount} VRFY commands rapidly...`);
for (let i = 0; i < requestCount; i++) {
const response = await smtpClient.sendCommand(`VRFY user${i}@example.com`);
if (response.startsWith('421') || response.startsWith('450')) {
rateLimitHit = true;
console.log(`Rate limit hit at request ${i + 1}`);
break;
} else if (response.match(/^[25]\d\d/)) {
successCount++;
}
const fromAddress = email.getFromAddress();
console.log(`Full: "${test.from}"`);
console.log(`Extracted: "${fromAddress}"`);
expect(fromAddress).toEqual(test.expectedAddress);
await smtpClient.sendMail(email);
console.log('Email sent successfully\n');
}
const elapsed = Date.now() - startTime;
const rate = (successCount / elapsed) * 1000;
console.log(`Completed ${successCount} requests in ${elapsed}ms`);
console.log(`Rate: ${rate.toFixed(2)} requests/second`);
if (rateLimitHit) {
console.log('Server implements rate limiting (good security practice)');
}
await smtpClient.close();
});
tap.test('CCMD-10: VRFY/EXPN error handling', async () => {
const smtpClient = createSmtpClient({
host: testServer.hostname,
port: testServer.port,
secure: false,
connectionTimeout: 5000,
debug: true
});
await smtpClient.connect();
await smtpClient.sendCommand('EHLO testclient.example.com');
// Test error cases
const errorTests = [
{ command: 'VRFY', description: 'VRFY without parameter' },
{ command: 'EXPN', description: 'EXPN without parameter' },
{ command: 'VRFY @', description: 'VRFY with invalid address' },
{ command: 'EXPN ""', description: 'EXPN with empty string' },
{ command: 'VRFY ' + 'x'.repeat(500), description: 'VRFY with very long parameter' }
tap.test('CCMD-10: Email validation security', async () => {
// Test security aspects of email validation
console.log('Testing email validation security considerations:\n');
// Test common system/role addresses that should be handled carefully
const systemAddresses = [
'root@example.com',
'admin@example.com',
'administrator@example.com',
'webmaster@example.com',
'hostmaster@example.com',
'abuse@example.com',
'postmaster@example.com',
'noreply@example.com'
];
const validator = new EmailValidator();
console.log('Checking if addresses are role accounts:');
for (const addr of systemAddresses) {
const validationResult = await validator.validate(addr, { checkRole: true, checkMx: false });
console.log(` ${addr}: ${validationResult.details?.role ? 'Role account' : 'Not a role account'} (format valid: ${validationResult.details?.formatValid})`);
}
// Test that we don't expose information about which addresses exist
console.log('\nTesting information disclosure prevention:');
try {
// Try sending to a non-existent address
const testEmail = new Email({
from: 'sender@example.com',
to: ['definitely-does-not-exist-12345@example.com'],
subject: 'Test',
text: 'Test'
});
await smtpClient.sendMail(testEmail);
console.log('Server accepted email (does not disclose non-existence)');
} catch (error) {
console.log('Server rejected email:', error.message);
}
console.log('\nSecurity best practice: Servers should not disclose address existence');
});
for (const test of errorTests) {
try {
const response = await smtpClient.sendCommand(test.command);
console.log(`${test.description}: ${response.trim()}`);
// Should get error response
expect(response).toMatch(/^[45]\d\d/);
} catch (error) {
console.log(`${test.description}: Caught error - ${error.message}`);
tap.test('CCMD-10: Validation during email sending', async () => {
// Test that validation doesn't interfere with email sending
console.log('Testing validation during email transaction:\n');
const validator = new EmailValidator();
// Create a series of emails with validation between them
const emails = [
{
from: 'sender1@example.com',
to: ['recipient1@example.com'],
subject: 'First email',
text: 'Testing validation during transaction'
},
{
from: 'sender2@example.com',
to: ['recipient2@example.com', 'recipient3@example.com'],
subject: 'Second email',
text: 'Multiple recipients'
},
{
from: '"Test User" <sender3@example.com>',
to: ['recipient4@example.com'],
subject: 'Third email',
text: 'Display name test'
}
];
for (let i = 0; i < emails.length; i++) {
const emailData = emails[i];
// Validate addresses before sending
console.log(`Email ${i + 1}:`);
const fromAddr = emailData.from.includes('<') ? emailData.from.match(/<([^>]+)>/)?.[1] || emailData.from : emailData.from;
console.log(` From: ${emailData.from} - Valid: ${validator.isValidFormat(fromAddr)}`);
for (const to of emailData.to) {
console.log(` To: ${to} - Valid: ${validator.isValidFormat(to)}`);
}
// Create and send email
const email = new Email(emailData);
await smtpClient.sendMail(email);
console.log(` Sent successfully\n`);
}
console.log('All emails sent successfully with validation');
});
tap.test('CCMD-10: Special characters in email addresses', async () => {
// Test email addresses with special characters
console.log('Testing email addresses with special characters:\n');
const validator = new EmailValidator();
const specialAddresses = [
{ address: 'user+tag@example.com', shouldBeValid: true, description: 'Plus addressing' },
{ address: 'first.last@example.com', shouldBeValid: true, description: 'Dots in local part' },
{ address: 'user_name@example.com', shouldBeValid: true, description: 'Underscore' },
{ address: 'user-name@example.com', shouldBeValid: true, description: 'Hyphen' },
{ address: '"quoted string"@example.com', shouldBeValid: true, description: 'Quoted string' },
{ address: 'user@sub.domain.example.com', shouldBeValid: true, description: 'Subdomain' },
{ address: 'user@example.co.uk', shouldBeValid: true, description: 'Multi-part TLD' },
{ address: 'user..name@example.com', shouldBeValid: false, description: 'Double dots' },
{ address: '.user@example.com', shouldBeValid: false, description: 'Leading dot' },
{ address: 'user.@example.com', shouldBeValid: false, description: 'Trailing dot' }
];
for (const test of specialAddresses) {
const isValid = validator.isValidFormat(test.address);
console.log(`${test.description}:`);
console.log(` Address: "${test.address}"`);
console.log(` Valid: ${isValid} (expected: ${test.shouldBeValid})`);
if (test.shouldBeValid && isValid) {
// Try sending an email with this address
try {
const email = new Email({
from: 'sender@example.com',
to: [test.address],
subject: 'Special character test',
text: `Testing special characters in: ${test.address}`
});
await smtpClient.sendMail(email);
console.log(` Email sent successfully`);
} catch (error) {
console.log(` Failed to send: ${error.message}`);
}
}
console.log('');
}
});
tap.test('CCMD-10: Large recipient lists', async () => {
// Test handling of large recipient lists (similar to EXPN multi-line)
console.log('Testing large recipient lists:\n');
// Create email with many recipients
const recipientCount = 20;
const toRecipients = [];
const ccRecipients = [];
for (let i = 1; i <= recipientCount; i++) {
if (i <= 10) {
toRecipients.push(`user${i}@example.com`);
} else {
ccRecipients.push(`user${i}@example.com`);
}
}
console.log(`Creating email with ${recipientCount} total recipients:`);
console.log(` To: ${toRecipients.length} recipients`);
console.log(` CC: ${ccRecipients.length} recipients`);
const largeListEmail = new Email({
from: 'sender@example.com',
to: toRecipients,
cc: ccRecipients,
subject: 'Large distribution list test',
text: `This email is being sent to ${recipientCount} recipients total`
});
// Show extracted addresses
const allTo = largeListEmail.getToAddresses();
const allCc = largeListEmail.getCcAddresses();
console.log('\nExtracted addresses:');
console.log(`To (first 3): ${allTo.slice(0, 3).join(', ')}...`);
console.log(`CC (first 3): ${allCc.slice(0, 3).join(', ')}...`);
// Send the email
const startTime = Date.now();
await smtpClient.sendMail(largeListEmail);
const elapsed = Date.now() - startTime;
console.log(`\nEmail sent to all ${recipientCount} recipients in ${elapsed}ms`);
console.log(`Average: ${(elapsed / recipientCount).toFixed(2)}ms per recipient`);
});
await smtpClient.close();
tap.test('CCMD-10: Email validation performance', async () => {
// Test validation performance
console.log('Testing email validation performance:\n');
const validator = new EmailValidator();
const testCount = 1000;
// Generate test addresses
const testAddresses = [];
for (let i = 0; i < testCount; i++) {
testAddresses.push(`user${i}@example${i % 10}.com`);
}
// Time validation
const startTime = Date.now();
let validCount = 0;
for (const address of testAddresses) {
if (validator.isValidFormat(address)) {
validCount++;
}
}
const elapsed = Date.now() - startTime;
const rate = (testCount / elapsed) * 1000;
console.log(`Validated ${testCount} addresses in ${elapsed}ms`);
console.log(`Rate: ${rate.toFixed(0)} validations/second`);
console.log(`Valid addresses: ${validCount}/${testCount}`);
// Test rapid email sending to see if there's rate limiting
console.log('\nTesting rapid email sending:');
const emailCount = 10;
const sendStartTime = Date.now();
let sentCount = 0;
for (let i = 0; i < emailCount; i++) {
try {
const email = new Email({
from: 'sender@example.com',
to: [`recipient${i}@example.com`],
subject: `Rate test ${i + 1}`,
text: 'Testing rate limits'
});
await smtpClient.sendMail(email);
sentCount++;
} catch (error) {
console.log(`Rate limit hit at email ${i + 1}: ${error.message}`);
break;
}
}
const sendElapsed = Date.now() - sendStartTime;
const sendRate = (sentCount / sendElapsed) * 1000;
console.log(`Sent ${sentCount}/${emailCount} emails in ${sendElapsed}ms`);
console.log(`Rate: ${sendRate.toFixed(2)} emails/second`);
});
tap.test('CCMD-10: Email validation error handling', async () => {
// Test error handling for invalid email addresses
console.log('Testing email validation error handling:\n');
const validator = new EmailValidator();
const errorTests = [
{ address: null, description: 'Null address' },
{ address: undefined, description: 'Undefined address' },
{ address: '', description: 'Empty string' },
{ address: ' ', description: 'Whitespace only' },
{ address: '@', description: 'Just @ symbol' },
{ address: 'user@', description: 'Missing domain' },
{ address: '@domain.com', description: 'Missing local part' },
{ address: 'user@@domain.com', description: 'Double @ symbol' },
{ address: 'user@domain@com', description: 'Multiple @ symbols' },
{ address: 'user space@domain.com', description: 'Space in local part' },
{ address: 'user@domain .com', description: 'Space in domain' },
{ address: 'x'.repeat(256) + '@domain.com', description: 'Very long local part' },
{ address: 'user@' + 'x'.repeat(256) + '.com', description: 'Very long domain' }
];
for (const test of errorTests) {
console.log(`${test.description}:`);
console.log(` Input: "${test.address}"`);
// Test validation
let isValid = false;
try {
isValid = validator.isValidFormat(test.address as any);
} catch (error) {
console.log(` Validation threw: ${error.message}`);
}
if (!isValid) {
console.log(` Correctly rejected as invalid`);
} else {
console.log(` WARNING: Accepted as valid!`);
}
// Try to send email with invalid address
if (test.address) {
try {
const email = new Email({
from: 'sender@example.com',
to: [test.address],
subject: 'Error test',
text: 'Testing invalid address'
});
await smtpClient.sendMail(email);
console.log(` WARNING: Email sent with invalid address!`);
} catch (error) {
console.log(` Email correctly rejected: ${error.message}`);
}
}
console.log('');
}
});
tap.test('cleanup test SMTP server', async () => {
if (testServer) {
await testServer.stop();
await stopTestServer(testServer);
}
});

667
test/suite/smtpclient_commands/test.ccmd-11.help-command.ts
View File

@@ -5,6 +5,7 @@ import type { SmtpClient } from '../../../ts/mail/delivery/smtpclient/smtp-clien
import { Email } from '../../../ts/mail/core/classes.email.js';
let testServer: ITestServer;
let smtpClient: SmtpClient;
tap.test('setup test SMTP server', async () => {
testServer = await startTestServer({
@@ -16,354 +17,392 @@ tap.test('setup test SMTP server', async () => {
expect(testServer.port).toBeGreaterThan(0);
});
tap.test('CCMD-11: Basic HELP command', async () => {
const smtpClient = createSmtpClient({
tap.test('CCMD-11: Server capabilities discovery', async () => {
// Test server capabilities which is what HELP provides info about
smtpClient = createSmtpClient({
host: testServer.hostname,
port: testServer.port,
secure: false,
connectionTimeout: 5000,
debug: true
connectionTimeout: 5000
});
await smtpClient.connect();
await smtpClient.sendCommand('EHLO testclient.example.com');
// Send HELP without parameters
const helpResponse = await smtpClient.sendCommand('HELP');
// HELP typically returns 214 or 211
expect(helpResponse).toMatch(/^21[14]/);
console.log('Testing server capabilities discovery (HELP equivalent):\n');
console.log('HELP response:');
console.log(helpResponse);
// Check if it's multi-line
const lines = helpResponse.split('\r\n').filter(line => line.length > 0);
if (lines.length > 1) {
console.log(`Multi-line help with ${lines.length} lines`);
// Send a test email to see server capabilities in action
const testEmail = new Email({
from: 'sender@example.com',
to: ['recipient@example.com'],
subject: 'Capability test',
text: 'Testing server capabilities'
});
await smtpClient.sendMail(testEmail);
console.log('Email sent successfully - server supports basic SMTP commands');
// Test different configurations to understand server behavior
const capabilities = {
basicSMTP: true,
multiplRecipients: false,
largeMessages: false,
internationalDomains: false
};
// Test multiple recipients
try {
const multiEmail = new Email({
from: 'sender@example.com',
to: ['recipient1@example.com', 'recipient2@example.com', 'recipient3@example.com'],
subject: 'Multi-recipient test',
text: 'Testing multiple recipients'
});
await smtpClient.sendMail(multiEmail);
capabilities.multiplRecipients = true;
console.log('✓ Server supports multiple recipients');
} catch (error) {
console.log('✗ Multiple recipients not supported');
}
await smtpClient.close();
console.log('\nDetected capabilities:', capabilities);
});
tap.test('CCMD-11: HELP with specific commands', async () => {
const smtpClient = createSmtpClient({
host: testServer.hostname,
port: testServer.port,
secure: false,
connectionTimeout: 5000,
debug: true
});
await smtpClient.connect();
await smtpClient.sendCommand('EHLO testclient.example.com');
// Test HELP for specific commands
const commands = [
'HELO',
'EHLO',
'MAIL',
'RCPT',
'DATA',
'RSET',
'NOOP',
'QUIT',
'VRFY',
'EXPN',
'HELP',
'AUTH',
'STARTTLS'
];
for (const cmd of commands) {
const response = await smtpClient.sendCommand(`HELP ${cmd}`);
console.log(`\nHELP ${cmd}:`);
if (response.startsWith('214') || response.startsWith('211')) {
// Extract help text
const helpText = response.replace(/^21[14][\s-]/, '');
console.log(` ${helpText.trim()}`);
} else if (response.startsWith('502')) {
console.log(` Command not implemented`);
} else if (response.startsWith('504')) {
console.log(` Command parameter not implemented`);
} else {
console.log(` ${response.trim()}`);
}
}
await smtpClient.close();
});
tap.test('CCMD-11: HELP response format variations', async () => {
const smtpClient = createSmtpClient({
host: testServer.hostname,
port: testServer.port,
secure: false,
connectionTimeout: 5000,
debug: true
});
await smtpClient.connect();
await smtpClient.sendCommand('EHLO testclient.example.com');
// Test different HELP queries
const queries = [
'', // No parameter
'MAIL FROM', // Command with space
'RCPT TO', // Another with space
'UNKNOWN', // Unknown command
'mail', // Lowercase
'MaIl' // Mixed case
];
for (const query of queries) {
const cmd = query ? `HELP ${query}` : 'HELP';
const response = await smtpClient.sendCommand(cmd);
console.log(`\n"${cmd}":`);
// Parse response code
const codeMatch = response.match(/^(\d{3})/);
if (codeMatch) {
const code = codeMatch[1];
console.log(` Response code: ${code}`);
// Common codes:
// 211 - System status
// 214 - Help message
// 502 - Command not implemented
// 504 - Command parameter not implemented
if (code === '214' || code === '211') {
// Check if response mentions the queried command
if (query && response.toLowerCase().includes(query.toLowerCase())) {
console.log(` Help specifically mentions "${query}"`);
}
tap.test('CCMD-11: Error message diagnostics', async () => {
// Test error messages which HELP would explain
console.log('Testing error message diagnostics:\n');
const errorTests = [
{
description: 'Invalid sender address',
email: {
from: 'invalid-sender',
to: ['recipient@example.com'],
subject: 'Test',
text: 'Test'
}
},
{
description: 'Empty recipient list',
email: {
from: 'sender@example.com',
to: [],
subject: 'Test',
text: 'Test'
}
},
{
description: 'Null subject',
email: {
from: 'sender@example.com',
to: ['recipient@example.com'],
subject: null as any,
text: 'Test'
}
}
}
await smtpClient.close();
});
tap.test('CCMD-11: HELP during transaction', async () => {
const smtpClient = createSmtpClient({
host: testServer.hostname,
port: testServer.port,
secure: false,
connectionTimeout: 5000,
debug: true
});
await smtpClient.connect();
await smtpClient.sendCommand('EHLO testclient.example.com');
// Start a transaction
await smtpClient.sendCommand('MAIL FROM:<sender@example.com>');
await smtpClient.sendCommand('RCPT TO:<recipient@example.com>');
// HELP should not affect transaction
console.log('\nHELP during transaction:');
const helpResponse = await smtpClient.sendCommand('HELP DATA');
expect(helpResponse).toMatch(/^21[14]/);
// Continue transaction
const dataResponse = await smtpClient.sendCommand('DATA');
expect(dataResponse).toInclude('354');
await smtpClient.sendCommand('Subject: Test\r\n\r\nTest message\r\n.');
console.log('Transaction completed successfully after HELP');
await smtpClient.close();
});
tap.test('CCMD-11: HELP command availability check', async () => {
const smtpClient = createSmtpClient({
host: testServer.hostname,
port: testServer.port,
secure: false,
connectionTimeout: 5000,
debug: true
});
await smtpClient.connect();
// Check HELP before EHLO
console.log('\nTesting HELP before EHLO:');
const earlyHelp = await smtpClient.sendCommand('HELP');
console.log(`Response: ${earlyHelp.substring(0, 50)}...`);
// HELP should work even before EHLO
expect(earlyHelp).toMatch(/^[25]\d\d/);
// Now do EHLO and check features
const ehloResponse = await smtpClient.sendCommand('EHLO testclient.example.com');
// Check if HELP is advertised (not common but possible)
if (ehloResponse.includes('HELP')) {
console.log('Server explicitly advertises HELP support');
}
await smtpClient.close();
});
tap.test('CCMD-11: HELP with invalid parameters', async () => {
const smtpClient = createSmtpClient({
host: testServer.hostname,
port: testServer.port,
secure: false,
connectionTimeout: 5000,
debug: true
});
await smtpClient.connect();
await smtpClient.sendCommand('EHLO testclient.example.com');
// Test HELP with various invalid inputs
const invalidTests = [
'HELP ' + 'X'.repeat(100), // Very long parameter
'HELP <>', // Special characters
'HELP MAIL RCPT DATA', // Multiple commands
'HELP\t\tTABS', // Tabs
'HELP\r\nINJECTION' // Injection attempt
];
for (const cmd of invalidTests) {
for (const test of errorTests) {
console.log(`Testing: ${test.description}`);
try {
const response = await smtpClient.sendCommand(cmd);
console.log(`\n"${cmd.substring(0, 30)}...": ${response.substring(0, 50)}...`);
// Should still get a valid SMTP response
expect(response).toMatch(/^\d{3}/);
const email = new Email(test.email);
await smtpClient.sendMail(email);
console.log(' Unexpectedly succeeded');
} catch (error) {
console.log(`Command rejected: ${error.message}`);
console.log(` Error: ${error.message}`);
console.log(` This would be explained in HELP documentation`);
}
console.log('');
}
await smtpClient.close();
});
tap.test('CCMD-11: HELP response parsing', async () => {
const smtpClient = createSmtpClient({
tap.test('CCMD-11: Connection configuration help', async () => {
// Test different connection configurations
console.log('Testing connection configurations:\n');
const configs = [
{
name: 'Standard connection',
config: {
host: testServer.hostname,
port: testServer.port,
secure: false,
connectionTimeout: 5000
},
shouldWork: true
},
{
name: 'With greeting timeout',
config: {
host: testServer.hostname,
port: testServer.port,
secure: false,
connectionTimeout: 5000,
greetingTimeout: 3000
},
shouldWork: true
},
{
name: 'With socket timeout',
config: {
host: testServer.hostname,
port: testServer.port,
secure: false,
connectionTimeout: 5000,
socketTimeout: 10000
},
shouldWork: true
}
];
for (const testConfig of configs) {
console.log(`Testing: ${testConfig.name}`);
try {
const client = createSmtpClient(testConfig.config);
const email = new Email({
from: 'sender@example.com',
to: ['recipient@example.com'],
subject: 'Config test',
text: `Testing ${testConfig.name}`
});
await client.sendMail(email);
console.log(` ✓ Configuration works`);
} catch (error) {
console.log(` ✗ Error: ${error.message}`);
}
}
});
tap.test('CCMD-11: Protocol flow documentation', async () => {
// Document the protocol flow (what HELP would explain)
console.log('SMTP Protocol Flow (as HELP would document):\n');
const protocolSteps = [
'1. Connection established',
'2. Server sends greeting (220)',
'3. Client sends EHLO',
'4. Server responds with capabilities',
'5. Client sends MAIL FROM',
'6. Server accepts sender (250)',
'7. Client sends RCPT TO',
'8. Server accepts recipient (250)',
'9. Client sends DATA',
'10. Server ready for data (354)',
'11. Client sends message content',
'12. Client sends . to end',
'13. Server accepts message (250)',
'14. Client can send more or QUIT'
];
console.log('Standard SMTP transaction flow:');
protocolSteps.forEach(step => console.log(` ${step}`));
// Demonstrate the flow
console.log('\nDemonstrating flow with actual email:');
const email = new Email({
from: 'demo@example.com',
to: ['recipient@example.com'],
subject: 'Protocol flow demo',
text: 'Demonstrating SMTP protocol flow'
});
await smtpClient.sendMail(email);
console.log('✓ Protocol flow completed successfully');
});
tap.test('CCMD-11: Command availability matrix', async () => {
// Test what commands are available (HELP info)
console.log('Testing command availability:\n');
// Test various email features to determine support
const features = {
plainText: { supported: false, description: 'Plain text emails' },
htmlContent: { supported: false, description: 'HTML emails' },
attachments: { supported: false, description: 'File attachments' },
multipleRecipients: { supported: false, description: 'Multiple recipients' },
ccRecipients: { supported: false, description: 'CC recipients' },
bccRecipients: { supported: false, description: 'BCC recipients' },
customHeaders: { supported: false, description: 'Custom headers' },
priorities: { supported: false, description: 'Email priorities' }
};
// Test plain text
try {
await smtpClient.sendMail(new Email({
from: 'sender@example.com',
to: ['recipient@example.com'],
subject: 'Plain text test',
text: 'Plain text content'
}));
features.plainText.supported = true;
} catch (e) {}
// Test HTML
try {
await smtpClient.sendMail(new Email({
from: 'sender@example.com',
to: ['recipient@example.com'],
subject: 'HTML test',
html: '<p>HTML content</p>'
}));
features.htmlContent.supported = true;
} catch (e) {}
// Test multiple recipients
try {
await smtpClient.sendMail(new Email({
from: 'sender@example.com',
to: ['recipient1@example.com', 'recipient2@example.com'],
subject: 'Multiple recipients test',
text: 'Test'
}));
features.multipleRecipients.supported = true;
} catch (e) {}
// Test CC
try {
await smtpClient.sendMail(new Email({
from: 'sender@example.com',
to: ['recipient@example.com'],
cc: ['cc@example.com'],
subject: 'CC test',
text: 'Test'
}));
features.ccRecipients.supported = true;
} catch (e) {}
// Test BCC
try {
await smtpClient.sendMail(new Email({
from: 'sender@example.com',
to: ['recipient@example.com'],
bcc: ['bcc@example.com'],
subject: 'BCC test',
text: 'Test'
}));
features.bccRecipients.supported = true;
} catch (e) {}
console.log('Feature support matrix:');
Object.entries(features).forEach(([key, value]) => {
console.log(` ${value.description}: ${value.supported ? '✓ Supported' : '✗ Not supported'}`);
});
});
tap.test('CCMD-11: Error code reference', async () => {
// Document error codes (HELP would explain these)
console.log('SMTP Error Code Reference (as HELP would provide):\n');
const errorCodes = [
{ code: '220', meaning: 'Service ready', type: 'Success' },
{ code: '221', meaning: 'Service closing transmission channel', type: 'Success' },
{ code: '250', meaning: 'Requested action completed', type: 'Success' },
{ code: '251', meaning: 'User not local; will forward', type: 'Success' },
{ code: '354', meaning: 'Start mail input', type: 'Intermediate' },
{ code: '421', meaning: 'Service not available', type: 'Temporary failure' },
{ code: '450', meaning: 'Mailbox unavailable', type: 'Temporary failure' },
{ code: '451', meaning: 'Local error in processing', type: 'Temporary failure' },
{ code: '452', meaning: 'Insufficient storage', type: 'Temporary failure' },
{ code: '500', meaning: 'Syntax error', type: 'Permanent failure' },
{ code: '501', meaning: 'Syntax error in parameters', type: 'Permanent failure' },
{ code: '502', meaning: 'Command not implemented', type: 'Permanent failure' },
{ code: '503', meaning: 'Bad sequence of commands', type: 'Permanent failure' },
{ code: '550', meaning: 'Mailbox not found', type: 'Permanent failure' },
{ code: '551', meaning: 'User not local', type: 'Permanent failure' },
{ code: '552', meaning: 'Storage allocation exceeded', type: 'Permanent failure' },
{ code: '553', meaning: 'Mailbox name not allowed', type: 'Permanent failure' },
{ code: '554', meaning: 'Transaction failed', type: 'Permanent failure' }
];
console.log('Common SMTP response codes:');
errorCodes.forEach(({ code, meaning, type }) => {
console.log(` ${code} - ${meaning} (${type})`);
});
// Test triggering some errors
console.log('\nDemonstrating error handling:');
// Invalid email format
try {
await smtpClient.sendMail(new Email({
from: 'invalid-email-format',
to: ['recipient@example.com'],
subject: 'Test',
text: 'Test'
}));
} catch (error) {
console.log(`Invalid format error: ${error.message}`);
}
});
tap.test('CCMD-11: Debugging assistance', async () => {
// Test debugging features (HELP assists with debugging)
console.log('Debugging assistance features:\n');
// Create client with debug enabled
const debugClient = createSmtpClient({
host: testServer.hostname,
port: testServer.port,
secure: false,
connectionTimeout: 5000,
debug: true
});
await smtpClient.connect();
await smtpClient.sendCommand('EHLO testclient.example.com');
// Get general HELP
const helpResponse = await smtpClient.sendCommand('HELP');
// Parse help content
if (helpResponse.match(/^21[14]/)) {
// Extract command list if present
const commandMatches = helpResponse.match(/\b(HELO|EHLO|MAIL|RCPT|DATA|RSET|NOOP|QUIT|VRFY|EXPN|HELP|AUTH|STARTTLS)\b/g);
if (commandMatches) {
const uniqueCommands = [...new Set(commandMatches)];
console.log('\nCommands mentioned in HELP:');
uniqueCommands.forEach(cmd => console.log(` - ${cmd}`));
// Verify common commands are mentioned
const essentialCommands = ['MAIL', 'RCPT', 'DATA', 'QUIT'];
const mentionedEssentials = essentialCommands.filter(cmd =>
uniqueCommands.includes(cmd)
);
console.log(`\nEssential commands mentioned: ${mentionedEssentials.length}/${essentialCommands.length}`);
}
// Check for URLs or references
const urlMatch = helpResponse.match(/https?:\/\/[^\s]+/);
if (urlMatch) {
console.log(`\nHelp includes URL: ${urlMatch[0]}`);
}
// Check for RFC references
const rfcMatch = helpResponse.match(/RFC\s*\d+/gi);
if (rfcMatch) {
console.log(`\nRFC references: ${rfcMatch.join(', ')}`);
}
}
await smtpClient.close();
console.log('Sending email with debug mode enabled:');
console.log('(Debug output would show full SMTP conversation)\n');
const debugEmail = new Email({
from: 'debug@example.com',
to: ['recipient@example.com'],
subject: 'Debug test',
text: 'Testing with debug mode'
});
// The debug output will be visible in the console
await debugClient.sendMail(debugEmail);
console.log('\nDebug mode helps troubleshoot:');
console.log('- Connection issues');
console.log('- Authentication problems');
console.log('- Message formatting errors');
console.log('- Server response codes');
console.log('- Protocol violations');
});
tap.test('CCMD-11: HELP command localization', async () => {
const smtpClient = createSmtpClient({
host: testServer.hostname,
port: testServer.port,
secure: false,
connectionTimeout: 5000,
debug: true
});
await smtpClient.connect();
await smtpClient.sendCommand('EHLO testclient.example.com');
// Some servers might support localized help
// Test with Accept-Language style parameter (non-standard)
const languages = ['en', 'es', 'fr', 'de'];
tap.test('CCMD-11: Performance benchmarks', async () => {
// Performance info (HELP might mention performance tips)
console.log('Performance benchmarks:\n');
for (const lang of languages) {
const response = await smtpClient.sendCommand(`HELP ${lang}`);
console.log(`\nHELP ${lang}: ${response.substring(0, 60)}...`);
const messageCount = 10;
const startTime = Date.now();
for (let i = 0; i < messageCount; i++) {
const email = new Email({
from: 'perf@example.com',
to: ['recipient@example.com'],
subject: `Performance test ${i + 1}`,
text: 'Testing performance'
});
// Most servers will treat this as unknown command
// But we're testing how they handle it
await smtpClient.sendMail(email);
}
await smtpClient.close();
});
tap.test('CCMD-11: HELP performance', async () => {
const smtpClient = createSmtpClient({
host: testServer.hostname,
port: testServer.port,
secure: false,
connectionTimeout: 5000,
debug: false // Quiet for performance test
});
await smtpClient.connect();
await smtpClient.sendCommand('EHLO testclient.example.com');
// Measure HELP response times
const iterations = 10;
const times: number[] = [];
for (let i = 0; i < iterations; i++) {
const startTime = Date.now();
await smtpClient.sendCommand('HELP');
const elapsed = Date.now() - startTime;
times.push(elapsed);
}
const avgTime = times.reduce((a, b) => a + b, 0) / times.length;
const minTime = Math.min(...times);
const maxTime = Math.max(...times);
console.log(`\nHELP command performance (${iterations} iterations):`);
console.log(` Average: ${avgTime.toFixed(2)}ms`);
console.log(` Min: ${minTime}ms`);
console.log(` Max: ${maxTime}ms`);
// HELP should be fast (static response)
expect(avgTime).toBeLessThan(100);
await smtpClient.close();
const totalTime = Date.now() - startTime;
const avgTime = totalTime / messageCount;
console.log(`Sent ${messageCount} emails in ${totalTime}ms`);
console.log(`Average time per email: ${avgTime.toFixed(2)}ms`);
console.log(`Throughput: ${(1000 / avgTime).toFixed(2)} emails/second`);
console.log('\nPerformance tips:');
console.log('- Use connection pooling for multiple emails');
console.log('- Enable pipelining when supported');
console.log('- Batch recipients when possible');
console.log('- Use appropriate timeouts');
console.log('- Monitor connection limits');
});
tap.test('cleanup test SMTP server', async () => {
if (testServer) {
await testServer.stop();
await stopTestServer(testServer);
}
});