AtlatestRepositorysigil-http3
sigil-http3 / tree / testtest-echo-lifecycle.mjs
1
// Linux lifecycle checks. The executable fixture opens no sockets and2
// its synthetic acceptance receipt is never evidence of real WebTransport.3
import assert from 'node:assert/strict';4
import { spawn } from 'node:child_process';5
import { createHash } from 'node:crypto';6
import { chmodSync, copyFileSync, existsSync, mkdirSync, mkdtempSync,7
readFileSync, writeFileSync } from 'node:fs';8
import { hostname } from 'node:os';9
import { join, resolve } from 'node:path';10
import { test } from 'node:test';11
import { identity, inspectPlan, runTest, sameIdentity, stopRun } from '../scripts/echo-lifecycle.mjs';13
const root = resolve('build/lifecycle');14
const runner = resolve('scripts/echo-lifecycle.mjs');15
const certificateDirectory = join(root, 'certificate');16
const certificate = JSON.parse(readFileSync(join(certificateDirectory, 'certificate.json')));17
const digest = path => createHash('sha256').update(readFileSync(path)).digest('hex');18
const pause = ms => new Promise(done => setTimeout(done, ms));19
const synthetic = {20
mode: 'webtransport-echo', ready: true, bidirectionalEcho: true, unidirectionalEcho: true,21
datagramEcho: true, chromeReaped: true, serverReaped: true,22
sourceRevision: '0'.repeat(40), quicRevision: '0'.repeat(40),23
browser: 'SOCKET-FREE FIXTURE', profile: 'synthetic unit test; not interop',24
server: Object.fromEntries(['configurableBind', 'retry', 'antiAmplification', 'peerAddressLogging',25
'pathChangeLogging', 'cidChangeLogging', 'boundedAdmission', 'echoOnly'].map(key => [key, true])),26
};27
const fixtureSource = `#!${process.execPath}28
import { readFileSync, writeFileSync, renameSync } from 'node:fs';29
import { createHash } from 'node:crypto';30
const env = process.env;31
const certificateSha256 = createHash('sha256')32
.update(readFileSync(env.HTTP3_CERTIFICATE_DIR + '/cert.der')).digest('hex');33
const ready = { testId: env.HTTP3_TEST_ID, bindAddress: env.HTTP3_BIND_ADDRESS,34
port: Number(env.HTTP3_PORT), certificateSha256, retry: true, antiAmplification: true };35
if (env.HTTP3_TEST_ID === 'wrong-ready') ready.port++;36
writeFileSync(env.HTTP3_READY_FILE + '.next', JSON.stringify(ready), { mode: 0o600 });37
renameSync(env.HTTP3_READY_FILE + '.next', env.HTTP3_READY_FILE);38
if (env.HTTP3_TEST_ID === 'log-budget') process.stdout.write(Buffer.alloc(9 * 1024 * 1024, 120));39
process.on('SIGTERM', () => process.exit(0));40
setInterval(() => {}, 1000);41
`;42
function fixture(name = 'fixture', seconds = 2) {43
const directory = mkdtempSync(join(root, 'case-'));44
const binary = join(directory, 'server.mjs');45
writeFileSync(binary, fixtureSource, { mode: 0o700 });46
const receiptPath = join(directory, 'receipt.json');47
const receipt = { ...synthetic, binarySha256: digest(binary), certificateSha256: certificate.sha256,48
server: { ...synthetic.server } };49
const config = { schema: 1, testId: name, expectedHost: hostname(), binary,50
binarySha256: receipt.binarySha256, certificateDirectory, runDirectory: join(directory, 'run'),51
interopReceipt: receiptPath, bindAddress: '127.0.0.1', port: 54433, lifetimeSeconds: seconds,52
authority: '127.0.0.1:54433', origins: ['http://127.0.0.1:54434'] };53
const path = join(directory, 'config.json');54
const save = () => {55
writeFileSync(path, JSON.stringify(config));56
writeFileSync(receiptPath, JSON.stringify(receipt));57
};58
save();59
return { config, receipt, path, save };60
}61
function launch(t, configPath) {62
const child = spawn(process.execPath, [runner, 'run', configPath], { stdio: ['ignore', 'pipe', 'pipe'] });63
const admitted = identity(child.pid);64
assert.ok(admitted);65
let output = '';66
let closed = false;67
for (const stream of [child.stdout, child.stderr]) stream.on('data', bytes => { output += bytes; });68
const done = new Promise((resolveDone, reject) => {69
child.once('error', reject);70
child.once('close', code => { closed = true; resolveDone({ code, output }); });71
});72
const deadline = setTimeout(() => {73
if (!closed && sameIdentity(admitted, identity(child.pid))) child.kill('SIGTERM');74
}, 12000);75
t.after(async () => {76
clearTimeout(deadline);77
if (!closed && sameIdentity(admitted, identity(child.pid))) child.kill('SIGTERM');78
await done;79
});80
return { done };81
}82
function state(config) { return JSON.parse(readFileSync(join(config.runDirectory, 'state.json'))); }83
function reaped(config) {84
const result = state(config);85
assert.equal(result.phase, 'finished');86
assert.equal(result.childReaped, true);87
assert.equal(identity(result.child.pid), null, 'Owned fixture must have been reaped');88
return result;89
}91
test('parent cancellation reaps its admitted child without signalling the parent', async t => {92
const f = fixture('parent-cancel', 5);93
const cancellation = new AbortController();94
const running = runTest(f.path, { signal: cancellation.signal });95
t.after(async () => { cancellation.abort(); await running.catch(() => {}); });96
const deadline = Date.now() + 5000;97
while (!existsSync(join(f.config.runDirectory, 'state.json')) || state(f.config).phase !== 'ready') {98
assert.ok(Date.now() < deadline, 'Owned fixture readiness deadline');99
await pause(25);100
}101
cancellation.abort();102
await running;103
assert.equal(reaped(f.config).reason, 'parent-stop');104
});106
test('plan is read-only and rejects capability-only or unproved admission', () => {107
const f = fixture();108
assert.equal(inspectPlan(f.path).ready, true);109
assert.equal(existsSync(f.config.runDirectory), false);110
f.config.lifetimeSeconds = 7200; f.save();111
assert.equal(inspectPlan(f.path).ready, true, 'A two-hour plan remains read-only');112
f.config.lifetimeSeconds = 7201; f.save();113
assert.throws(() => inspectPlan(f.path), /7200/);114
f.config.lifetimeSeconds = 2;115
f.config.bindAddress = '0.0.0.0'; f.save();116
assert.throws(() => inspectPlan(f.path), /configured run scope/);117
f.config.bindAddress = '::1'; f.config.authority = '[::1]:54433'; f.save();118
assert.equal(inspectPlan(f.path).ready, true);119
f.config.authority = '[::1]:54435'; f.save();120
assert.throws(() => inspectPlan(f.path), /admitted bind and port/);121
f.config.bindAddress = '127.0.0.1'; f.config.authority = '127.0.0.1:54433'; f.save();122
f.receipt.mode = 'capability-preflight'; f.save();123
assert.equal(inspectPlan(f.path).ready, false);124
f.receipt.mode = 'webtransport-echo'; f.receipt.server.retry = false; f.save();125
assert.match(inspectPlan(f.path).blockers.join(' '), /retry/);126
f.receipt.server.retry = true; f.receipt.datagramEcho = false; f.save();127
assert.equal(inspectPlan(f.path).ready, false);128
});130
test('plan binds host, exact binary/certificate, key permissions and fresh run directory', () => {131
const f = fixture();132
f.config.expectedHost = hostname() + '-wrong'; f.save();133
assert.throws(() => inspectPlan(f.path), /host/);134
f.config.expectedHost = hostname(); f.config.binarySha256 = '0'.repeat(64); f.save();135
assert.throws(() => inspectPlan(f.path), /binary SHA/);136
f.config.binarySha256 = f.receipt.binarySha256;137
f.receipt.certificateSha256 = '0'.repeat(64); f.save();138
assert.match(inspectPlan(f.path).blockers.join(' '), /exact binary and certificate/);139
f.receipt.certificateSha256 = certificate.sha256;140
const badCertificate = join(f.config.binary, '..', 'certificate');141
mkdirSync(badCertificate);142
copyFileSync(join(certificateDirectory, 'cert.der'), join(badCertificate, 'cert.der'));143
copyFileSync(join(certificateDirectory, 'private.raw'), join(badCertificate, 'private.raw'));144
chmodSync(join(badCertificate, 'private.raw'), 0o644);145
f.config.certificateDirectory = badCertificate; f.save();146
assert.throws(() => inspectPlan(f.path), /signing key/);147
f.config.certificateDirectory = certificateDirectory; f.save();148
mkdirSync(f.config.runDirectory, { mode: 0o700 });149
assert.match(inspectPlan(f.path).blockers.join(' '), /already exists/);150
});152
test('lifetime shutdown reaps only the admitted socket-free child', async t => {153
const f = fixture();154
const result = await launch(t, f.path).done;155
assert.equal(result.code, 0, result.output);156
assert.equal(reaped(f.config).reason, 'lifetime');157
});159
test('manual teardown reaches supervisor, reaps child and is idempotent', async t => {160
const f = fixture('manual-stop', 8);161
const running = launch(t, f.path);162
const deadline = Date.now() + 5000;163
while ((!existsSync(join(f.config.runDirectory, 'state.json')) || state(f.config).phase !== 'ready') &&164
Date.now() < deadline) await pause(25);165
assert.equal(state(f.config).phase, 'ready');166
assert.equal(stopRun(f.config.runDirectory).stopRequested, true);167
const result = await running.done;168
assert.equal(result.code, 0, result.output);169
assert.equal(reaped(f.config).reason, 'SIGTERM');170
assert.equal(stopRun(f.config.runDirectory).alreadyFinished, true);171
});173
test('teardown refuses a reused PID identity before sending a signal', () => {174
const f = fixture();175
mkdirSync(f.config.runDirectory, { mode: 0o700 });176
const supervisor = { ...identity(process.pid), start: 'wrong-start' };177
writeFileSync(join(f.config.runDirectory, 'state.json'), JSON.stringify({ schema: 1,178
phase: 'ready', supervisor }), { mode: 0o600 });179
assert.throws(() => stopRun(f.config.runDirectory), /Refusing reused PID/);180
});182
test('readiness mismatch fails and reaps its owned child', async t => {183
const f = fixture('wrong-ready');184
const result = await launch(t, f.path).done;185
assert.equal(result.code, 1, result.output);186
assert.match(reaped(f.config).error, /readiness contract/);187
});189
test('log budget bounds retained bytes and reaps its owned child', async t => {190
const f = fixture('log-budget');191
const result = await launch(t, f.path).done;192
assert.equal(result.code, 1, result.output);193
assert.match(reaped(f.config).error, /log budget/);194
assert.equal(readFileSync(join(f.config.runDirectory, 'stdout.log')).length, 8388608);195
});