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-23 19:03:44 +00:00
parent 7d28d23bbd
commit 1b141ec8f3
101 changed files with 30736 additions and 374 deletions
Download Patch File Download Diff File Expand all files Collapse all files

406
test/suite/reliability/test.dns-resolution-failure.ts Normal file
View File

@ -0,0 +1,406 @@
import * as plugins from '@push.rocks/tapbundle';
import { expect, tap } from '@push.rocks/tapbundle';
import * as net from 'net';
import { startTestServer, stopTestServer } from '../server.loader.js';
const TEST_PORT = 2525;
interface DnsTestResult {
scenario: string;
domain: string;
expectedBehavior: string;
mailFromSuccess: boolean;
rcptToSuccess: boolean;
mailFromResponse: string;
rcptToResponse: string;
handledGracefully: boolean;
}
tap.test('prepare server', async () => {
await startTestServer();
await new Promise(resolve => setTimeout(resolve, 100));
});
tap.test('REL-05: DNS resolution failure handling - Non-existent domains', async (tools) => {
const done = tools.defer();
try {
const socket = net.createConnection({
host: 'localhost',
port: TEST_PORT,
timeout: 30000
});
await new Promise<void>((resolve, reject) => {
socket.once('connect', resolve);
socket.once('error', reject);
});
// Read greeting
await new Promise<void>((resolve) => {
socket.once('data', () => resolve());
});
// Send EHLO
socket.write('EHLO dns-test\r\n');
await new Promise<void>((resolve) => {
let data = '';
const handleData = (chunk: Buffer) => {
data += chunk.toString();
if (data.includes('250 ') && !data.includes('250-')) {
socket.removeListener('data', handleData);
resolve();
}
};
socket.on('data', handleData);
});
console.log('Testing DNS resolution for non-existent domains...');
// Test 1: Non-existent domain in MAIL FROM
socket.write('MAIL FROM:<sender@non-existent-domain-12345.invalid>\r\n');
const mailResponse = await new Promise<string>((resolve) => {
socket.once('data', (chunk) => {
resolve(chunk.toString());
});
});
console.log(' MAIL FROM response:', mailResponse.trim());
// Server should either accept (and defer later) or reject immediately
const mailFromHandled = mailResponse.includes('250') ||
mailResponse.includes('450') ||
mailResponse.includes('550');
expect(mailFromHandled).toBeTrue();
// Reset if needed
if (mailResponse.includes('250')) {
socket.write('RSET\r\n');
await new Promise<void>((resolve) => {
socket.once('data', () => resolve());
});
}
// Test 2: Non-existent domain in RCPT TO
socket.write('MAIL FROM:<sender@example.com>\r\n');
await new Promise<void>((resolve) => {
socket.once('data', (chunk) => {
const response = chunk.toString();
expect(response).toInclude('250');
resolve();
});
});
socket.write('RCPT TO:<recipient@non-existent-domain-xyz.invalid>\r\n');
const rcptResponse = await new Promise<string>((resolve) => {
socket.once('data', (chunk) => {
resolve(chunk.toString());
});
});
console.log(' RCPT TO response:', rcptResponse.trim());
// Server should reject or defer non-existent domains
const rcptToHandled = rcptResponse.includes('450') || // Temporary failure
rcptResponse.includes('550') || // Permanent failure
rcptResponse.includes('553'); // Address error
expect(rcptToHandled).toBeTrue();
socket.write('QUIT\r\n');
socket.end();
done.resolve();
} catch (error) {
done.reject(error);
}
});
tap.test('REL-05: DNS resolution failure handling - Malformed domains', async (tools) => {
const done = tools.defer();
try {
const socket = net.createConnection({
host: 'localhost',
port: TEST_PORT,
timeout: 30000
});
await new Promise<void>((resolve, reject) => {
socket.once('connect', resolve);
socket.once('error', reject);
});
// Read greeting
await new Promise<void>((resolve) => {
socket.once('data', () => resolve());
});
// Send EHLO
socket.write('EHLO malformed-test\r\n');
await new Promise<void>((resolve) => {
let data = '';
const handleData = (chunk: Buffer) => {
data += chunk.toString();
if (data.includes('250 ') && !data.includes('250-')) {
socket.removeListener('data', handleData);
resolve();
}
};
socket.on('data', handleData);
});
console.log('\nTesting malformed domain handling...');
const malformedDomains = [
'malformed..domain..test',
'invalid-.domain.com',
'domain.with.spaces .com',
'.leading-dot.com',
'trailing-dot.com.',
'domain@with@at.com',
'a'.repeat(255) + '.toolong.com' // Domain too long
];
for (const domain of malformedDomains) {
console.log(` Testing: ${domain.substring(0, 50)}${domain.length > 50 ? '...' : ''}`);
socket.write(`MAIL FROM:<test@${domain}>\r\n`);
const response = await new Promise<string>((resolve) => {
socket.once('data', (chunk) => {
resolve(chunk.toString());
});
});
// Server should reject malformed domains
const properlyHandled = response.includes('501') || // Syntax error
response.includes('550') || // Rejected
response.includes('553'); // Address error
console.log(` Response: ${response.trim().substring(0, 50)}`);
expect(properlyHandled).toBeTrue();
// Reset if needed
if (!response.includes('5')) {
socket.write('RSET\r\n');
await new Promise<void>((resolve) => {
socket.once('data', () => resolve());
});
}
}
socket.write('QUIT\r\n');
socket.end();
done.resolve();
} catch (error) {
done.reject(error);
}
});
tap.test('REL-05: DNS resolution failure handling - Special cases', async (tools) => {
const done = tools.defer();
try {
const socket = net.createConnection({
host: 'localhost',
port: TEST_PORT,
timeout: 30000
});
await new Promise<void>((resolve, reject) => {
socket.once('connect', resolve);
socket.once('error', reject);
});
// Read greeting
await new Promise<void>((resolve) => {
socket.once('data', () => resolve());
});
// Send EHLO
socket.write('EHLO special-test\r\n');
await new Promise<void>((resolve) => {
let data = '';
const handleData = (chunk: Buffer) => {
data += chunk.toString();
if (data.includes('250 ') && !data.includes('250-')) {
socket.removeListener('data', handleData);
resolve();
}
};
socket.on('data', handleData);
});
console.log('\nTesting special DNS cases...');
// Test 1: Localhost (should work)
socket.write('MAIL FROM:<sender@localhost>\r\n');
const localhostResponse = await new Promise<string>((resolve) => {
socket.once('data', (chunk) => {
resolve(chunk.toString());
});
});
console.log(' Localhost response:', localhostResponse.trim());
expect(localhostResponse).toInclude('250');
socket.write('RSET\r\n');
await new Promise<void>((resolve) => {
socket.once('data', () => resolve());
});
// Test 2: IP address (should work)
socket.write('MAIL FROM:<sender@[127.0.0.1]>\r\n');
const ipResponse = await new Promise<string>((resolve) => {
socket.once('data', (chunk) => {
resolve(chunk.toString());
});
});
console.log(' IP address response:', ipResponse.trim());
const ipHandled = ipResponse.includes('250') || ipResponse.includes('501');
expect(ipHandled).toBeTrue();
socket.write('RSET\r\n');
await new Promise<void>((resolve) => {
socket.once('data', () => resolve());
});
// Test 3: Empty domain
socket.write('MAIL FROM:<sender@>\r\n');
const emptyResponse = await new Promise<string>((resolve) => {
socket.once('data', (chunk) => {
resolve(chunk.toString());
});
});
console.log(' Empty domain response:', emptyResponse.trim());
expect(emptyResponse).toMatch(/50[1-3]/); // Should reject
socket.write('QUIT\r\n');
socket.end();
done.resolve();
} catch (error) {
done.reject(error);
}
});
tap.test('REL-05: DNS resolution failure handling - Mixed valid/invalid recipients', async (tools) => {
const done = tools.defer();
try {
const socket = net.createConnection({
host: 'localhost',
port: TEST_PORT,
timeout: 30000
});
await new Promise<void>((resolve, reject) => {
socket.once('connect', resolve);
socket.once('error', reject);
});
// Read greeting
await new Promise<void>((resolve) => {
socket.once('data', () => resolve());
});
// Send EHLO
socket.write('EHLO mixed-test\r\n');
await new Promise<void>((resolve) => {
let data = '';
const handleData = (chunk: Buffer) => {
data += chunk.toString();
if (data.includes('250 ') && !data.includes('250-')) {
socket.removeListener('data', handleData);
resolve();
}
};
socket.on('data', handleData);
});
console.log('\nTesting mixed valid/invalid recipients...');
// Start transaction
socket.write('MAIL FROM:<sender@example.com>\r\n');
await new Promise<void>((resolve) => {
socket.once('data', (chunk) => {
const response = chunk.toString();
expect(response).toInclude('250');
resolve();
});
});
// Add valid recipient
socket.write('RCPT TO:<valid@example.com>\r\n');
const validRcptResponse = await new Promise<string>((resolve) => {
socket.once('data', (chunk) => {
resolve(chunk.toString());
});
});
console.log(' Valid recipient:', validRcptResponse.trim());
expect(validRcptResponse).toInclude('250');
// Add invalid recipient
socket.write('RCPT TO:<invalid@non-existent-domain-abc.invalid>\r\n');
const invalidRcptResponse = await new Promise<string>((resolve) => {
socket.once('data', (chunk) => {
resolve(chunk.toString());
});
});
console.log(' Invalid recipient:', invalidRcptResponse.trim());
// Server should reject invalid domain but keep transaction alive
const invalidHandled = invalidRcptResponse.includes('450') ||
invalidRcptResponse.includes('550') ||
invalidRcptResponse.includes('553');
expect(invalidHandled).toBeTrue();
// Try to send data (should work if at least one valid recipient)
socket.write('DATA\r\n');
const dataResponse = await new Promise<string>((resolve) => {
socket.once('data', (chunk) => {
resolve(chunk.toString());
});
});
if (dataResponse.includes('354')) {
socket.write('Subject: Mixed recipient test\r\n\r\nTest\r\n.\r\n');
await new Promise<void>((resolve) => {
socket.once('data', () => resolve());
});
console.log(' Message accepted with valid recipient');
} else {
console.log(' Server rejected DATA (acceptable behavior)');
}
socket.write('QUIT\r\n');
socket.end();
done.resolve();
} catch (error) {
done.reject(error);
}
});
tap.test('cleanup server', async () => {
await stopTestServer();
});
tap.start();