Add the interoperability harness and the smscsim experiment, which confirms the one-bad-PDU link drop

2026-09-05 18:40:56 +02:00
parent 7d855cfa5d
commit 1723a0381c
7 changed files with 641 additions and 2 deletions
@@ -0,0 +1,272 @@
+import assert from 'node:assert/strict';
+import test, { describe } from 'node:test';
+import type { Dlr } from '../src/dlr.ts';
+import type { Session } from '../src/session.ts';
+import type { Sms } from '../src/sms.ts';
+import { client } from '../src/client.ts';
+import { closeAfter } from '../test/teardown.ts';
+
+const PEER_HOST = process.env.PEER_HOST ?? 'smscsim';
+const PEER_PORT = Number(process.env.PEER_PORT ?? '2775');
+const PEER_WEB_PORT = Number(process.env.PEER_WEB_PORT ?? '12775');
+const FAILING_PEER_HOST = process.env.FAILING_PEER_HOST ?? 'smscsim-failing';
+const FAILING_PEER_PORT = Number(process.env.FAILING_PEER_PORT ?? '2775');
+
+// smscsim signs every deliver_sm it sends unprompted (a DLR, or an injected MO) with a
+// `rand.Int()`-derived sequence_number, unconstrained to the SMPP 3.4 4.7.1 ceiling
+// (0x7FFFFFFF) - about half land above it, and pdu.ts refuses the PDU outright, so the DLR or
+// MO is silently lost (see findings/01-smscsim.md, "an out-of-range deliver_sm sequence
+// number"). Retrying with a fresh send works around that peer+library interaction without
+// hiding it: a scenario only fails here if it keeps missing well past what chance alone explains.
+const DLR_RETRY_BUDGET_MS = 3000;
+const DLR_MAX_ATTEMPTS = 20;
+
+function delay(ms: number): Promise<void> {
+	return new Promise(resolve => { setTimeout(resolve, ms); });
+}
+
+/** Polls until `get()` stops returning undefined, or the budget runs out. */
+async function waitFor<T>(get: () => T | undefined, budget = 5000): Promise<T | undefined> {
+	const deadline = Date.now() + budget;
+	let value = get();
+
+	while (value === undefined && Date.now() < deadline) {
+		await delay(20);
+		value = get();
+	}
+
+	return value;
+}
+
+/** Resends the message until one attempt's segments are every one matched by a `dlr` event. */
+async function sendUntilAllDlrsArrive(session: Session, dlrs: Dlr[], message: string): Promise<string[]> {
+	for (let attempt = 0; attempt < DLR_MAX_ATTEMPTS; attempt++) {
+		const sent = await session.sendSms({ dlr: true, from: '46701113311', message, to: '46709771337' });
+
+		assert.equal(sent.err, undefined);
+
+		const complete = await waitFor(
+			() => (sent.smsIds.every(id => dlrs.some(dlr => dlr.smsId === id)) ? true : undefined),
+			DLR_RETRY_BUDGET_MS,
+		);
+
+		if (complete) return sent.smsIds;
+	}
+
+	throw new Error(`no attempt got a DLR for every segment within ${String(DLR_MAX_ATTEMPTS)} tries`);
+}
+
+describe('smscsim - C1 bind, keepalive, unbind', () => {
+	for (const bindType of ['transceiver', 'transmitter', 'receiver'] as const) {
+		test(`binds as ${bindType}, keeps the link, unbinds cleanly`, async t => {
+			const closes: unknown[] = [];
+			const sessionErrors: Error[] = [];
+
+			const { err, session } = await client({
+				bindType,
+				enquireLinkInterval: 1000,
+				host: PEER_HOST,
+				port: PEER_PORT,
+				username: `c1-${bindType}`,
+			});
+
+			assert.equal(err, undefined);
+			assert.ok(session);
+			closeAfter(t, session);
+
+			session.on('close', () => { closes.push(undefined); });
+			session.on('sessionError', sessionError => { sessionErrors.push(sessionError); });
+
+			// smscsim never sends an unsolicited enquire_link of its own - its ENQUIRE_LINK case
+			// only answers one (confirmed in its source, smsc.go). So the interval-driven
+			// keepalive is checked through its own response, not through `incomingPduObj`.
+			const enquired = await session.send({ cmdName: 'enquire_link' });
+
+			assert.equal(enquired.err, undefined);
+			assert.ok(enquired.pduObj);
+			assert.equal(enquired.pduObj.cmdName, 'enquire_link_resp');
+			assert.equal(enquired.pduObj.cmdStatus, 'ESME_ROK');
+
+			await delay(1500);
+
+			const unbound = await session.unbind();
+
+			assert.equal(unbound.err, undefined);
+
+			await delay(50);
+
+			assert.deepEqual(closes, [undefined]);
+			assert.deepEqual(sessionErrors, []);
+		});
+	}
+});
+
+describe('smscsim - a single SMS', () => {
+	test('one id back, a DLR within 5s naming it DELIVERED', async t => {
+		const dlrs: Dlr[] = [];
+
+		const { err, session } = await client({ host: PEER_HOST, port: PEER_PORT, username: 'single-sms' });
+
+		assert.equal(err, undefined);
+		assert.ok(session);
+		closeAfter(t, session);
+
+		session.on('dlr', dlr => { dlrs.push(dlr); });
+
+		const smsIds = await sendUntilAllDlrsArrive(session, dlrs, 'hello world');
+
+		assert.equal(smsIds.length, 1);
+
+		const [smsId] = smsIds;
+
+		assert.ok(smsId);
+
+		const matched = dlrs.find(dlr => dlr.smsId === smsId);
+
+		assert.ok(matched);
+		assert.equal(matched.statusMsg, 'DELIVERED');
+	});
+});
+
+describe('smscsim - multipart segments', () => {
+	test('a 2-segment GSM message gets 2 ids and a DLR per id', async t => {
+		const dlrs: Dlr[] = [];
+
+		const { err, session } = await client({ host: PEER_HOST, port: PEER_PORT, username: 'gsm-multipart' });
+
+		assert.equal(err, undefined);
+		assert.ok(session);
+		closeAfter(t, session);
+
+		session.on('dlr', dlr => { dlrs.push(dlr); });
+
+		// 200 plain GSM chars: over the 160-char single-segment budget, under the 306-char
+		// 2-segment one (153 septets each).
+		const smsIds = await sendUntilAllDlrsArrive(session, dlrs, 'a'.repeat(200));
+
+		assert.equal(smsIds.length, 2);
+	});
+
+	test('a 2-segment UCS2 message (一 and an emoji) gets 2 ids and a DLR per id', async t => {
+		const dlrs: Dlr[] = [];
+
+		const { err, session } = await client({ host: PEER_HOST, port: PEER_PORT, username: 'ucs2-multipart' });
+
+		assert.equal(err, undefined);
+		assert.ok(session);
+		closeAfter(t, session);
+
+		session.on('dlr', dlr => { dlrs.push(dlr); });
+
+		// 一 (2 bytes) + an emoji (a surrogate pair, 4 bytes) + 70 padding chars (2 bytes each):
+		// 146 bytes, over the 140-byte single-segment budget, under the 268-byte 2-segment one.
+		const smsIds = await sendUntilAllDlrsArrive(session, dlrs, `一😀${'x'.repeat(70)}`);
+
+		assert.equal(smsIds.length, 2);
+	});
+});
+
+describe('smscsim - MO injection through the web UI', () => {
+	test('a message posted to the web page arrives as an sms event', async t => {
+		const { err, session } = await client({
+			bindType: 'transceiver',
+			host: PEER_HOST,
+			port: PEER_PORT,
+			username: 'mo-inject',
+		});
+
+		assert.equal(err, undefined);
+		assert.ok(session);
+		closeAfter(t, session);
+
+		const incoming: Sms[] = [];
+
+		session.on('sms', sms => { incoming.push(sms); });
+
+		let sms: Sms | undefined;
+
+		for (let attempt = 0; attempt < DLR_MAX_ATTEMPTS && !sms; attempt++) {
+			const before = incoming.length;
+
+			const response = await fetch(`http://${PEER_HOST}:${String(PEER_WEB_PORT)}/`, {
+				body: new URLSearchParams({
+					message: 'hello from the web UI',
+					recipient: '46709771337',
+					sender: '46701113311',
+					system_id: 'mo-inject',
+				}),
+				method: 'POST',
+				redirect: 'manual',
+			});
+
+			assert.equal(response.status, 303);
+			assert.match(response.headers.get('location') ?? '', /message=/);
+
+			await waitFor(() => incoming[before], DLR_RETRY_BUDGET_MS);
+			sms = incoming[before];
+		}
+
+		assert.ok(sms, 'no MO message arrived across the attempts');
+		assert.equal(sms.from, '46701113311');
+		assert.equal(sms.to, '46709771337');
+		assert.equal(sms.message, 'hello from the web UI');
+
+		assert.equal((await sms.sendResp()).err, undefined);
+	});
+});
+
+describe('smscsim-failing - C12 refusals', () => {
+	test('even sequence numbers are refused, odd ones get an undeliverable DLR', async t => {
+		const dlrs: Dlr[] = [];
+
+		const { err, session } = await client({ host: FAILING_PEER_HOST, port: FAILING_PEER_PORT, username: 'c12' });
+
+		assert.equal(err, undefined);
+		assert.ok(session);
+		closeAfter(t, session);
+
+		session.on('dlr', dlr => { dlrs.push(dlr); });
+
+		let refusedSeen = false;
+		let acceptedConfirmed = false;
+
+		for (let attempt = 0; attempt < DLR_MAX_ATTEMPTS && !(refusedSeen && acceptedConfirmed); attempt++) {
+			const before = dlrs.length;
+
+			// Sequential: smscsim keys its refusal on each submit_sm's own sequence number parity.
+			const result = await session.sendSms({
+				dlr: true,
+				from: '46701113311',
+				message: `refusal check ${String(attempt)}`,
+				to: '46709771337',
+			});
+
+			if (result.err !== undefined) {
+				assert.match(result.err.message, /ESME_RSYSERR/);
+				refusedSeen = true;
+				continue;
+			}
+
+			assert.equal(result.smsIds.length, 1);
+
+			const [smsId] = result.smsIds;
+
+			assert.ok(smsId);
+
+			const matched = await waitFor(() => dlrs.slice(before).find(dlr => dlr.smsId === smsId), DLR_RETRY_BUDGET_MS);
+
+			if (matched) {
+				assert.equal(matched.statusMsg, 'UNDELIVERABLE');
+				acceptedConfirmed = true;
+			}
+		}
+
+		assert.ok(refusedSeen, 'no send was refused across the attempts');
+		assert.ok(acceptedConfirmed, 'no accepted send got a confirmed undeliverable DLR');
+
+		// The session must stay bound and usable after a refusal.
+		const enquired = await session.send({ cmdName: 'enquire_link' });
+
+		assert.equal(enquired.err, undefined);
+	});
+});