120 lines
8.1 KiB
JavaScript
120 lines
8.1 KiB
JavaScript
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import { request } from 'node:http';
|
|
import { mkdtempSync, rmSync } from 'node:fs';
|
|
import { join } from 'node:path';
|
|
import { tmpdir } from 'node:os';
|
|
import { startTesterSocket, TESTER_ORIGIN } from '../src/tester-socket.mjs';
|
|
import { startServer } from '../src/serve.mjs';
|
|
import { close } from './fixture.mjs';
|
|
import { createSsoSession } from './helpers/sso-session.mjs';
|
|
const GEN = '12345678-1234-4234-8234-123456789abc';
|
|
function http(server, path, { method = 'GET', headers = {}, body = '' } = {}) {
|
|
return new Promise((resolve, reject) => {
|
|
const address = server.address();
|
|
const req = request({ ...(typeof address === 'string' ? { socketPath: address } : { host: '127.0.0.1', port: address.port }), path, method,
|
|
headers: Object.fromEntries(Object.entries({ ...(server.authHeaders ?? { host: 'console.example' }), ...headers }).filter(([, v]) => v !== undefined)) }, res => {
|
|
let text = ''; res.on('data', c => { text += c; }); res.on('end', () => resolve({ status: res.statusCode, text, value: JSON.parse(text) }));
|
|
}); req.on('error', reject); req.end(body);
|
|
});
|
|
}
|
|
const POST = { method: 'POST', headers: { origin: 'https://console.example', 'sec-fetch-site': 'same-origin', 'content-type': 'application/json' }, body: '{}' };
|
|
async function fixture(t, { send = true, tester = false } = {}) {
|
|
const calls = [];
|
|
const state = { version: 1, generation: GEN, halted: false, quiescent: true, remaining: 0, stopped: 0, stopping: false };
|
|
const processing = {
|
|
read: async () => { calls.push('read'); return { ...state }; },
|
|
halt: async args => { calls.push(['halt', args]); state.halted = true; return { ...state }; },
|
|
resume: async args => { calls.push(['resume', args]); state.halted = false; return { ...state }; },
|
|
};
|
|
const root = tester ? mkdtempSync(join(tmpdir(), 'processing-web-')) : null;
|
|
const options = { processing, log: () => {} };
|
|
const auth = tester ? null : await createSsoSession(t, { host: 'console.example' });
|
|
const server = tester ? await startTesterSocket({ dataRoot: root, ...options }) : await startServer({ port: 0,
|
|
sso: auth.sso, send: send ? async () => {} : null, ...options });
|
|
if (auth) {
|
|
const session = await auth.signIn(server.address().port);
|
|
server.authHeaders = auth.writeHeaders(session);
|
|
}
|
|
t.after(async () => { await close(server); if (root) rmSync(root, { recursive: true, force: true }); });
|
|
return { server, calls, state, processing };
|
|
}
|
|
test('read-only Console can read processing state but neither human control writes without --send', async t => {
|
|
const f = await fixture(t, { send: false });
|
|
const read = await http(f.server, '/api/processing'); assert.equal(read.status, 200); assert.equal(read.value.halted, false);
|
|
for (const action of ['halt', 'resume']) assert.equal((await http(f.server, '/api/processing/' + action, POST)).status, 403);
|
|
assert.deepEqual(f.calls, ['read']);
|
|
});
|
|
test('Console halt and generation-bound resume use only the management writer and keep partial stops honest', async t => {
|
|
const f = await fixture(t);
|
|
const halted = await http(f.server, '/api/processing/halt', POST); assert.equal(halted.status, 200); assert.equal(halted.value.halted, true);
|
|
const resumed = await http(f.server, '/api/processing/resume', { ...POST, body: JSON.stringify({ generation: GEN }) });
|
|
assert.equal(resumed.status, 200); assert.equal(resumed.value.halted, false);
|
|
assert.deepEqual(f.calls, [['halt', {}], ['resume', { generation: GEN }]]);
|
|
f.processing.halt = async () => ({ ...f.state, halted: true, quiescent: false, remaining: 1 });
|
|
const partial = await http(f.server, '/api/processing/halt', POST); assert.equal(partial.status, 202); assert.equal(partial.value.quiescent, false);
|
|
});
|
|
test('processing write fences refuse cross-site, wrong origin, unnamed host, duplicate identity and bad payload before writer', async t => {
|
|
const f = await fixture(t);
|
|
const cases = [
|
|
['wrong origin', { headers: { ...POST.headers, origin: 'https://elsewhere' } }, 403, 'cross-origin request refused'],
|
|
['cross-site', { headers: { ...POST.headers, 'sec-fetch-site': 'cross-site' } }, 403, 'cross-site'],
|
|
['unnamed host', { headers: { ...POST.headers, host: `127.0.0.1:${f.server.address().port}`,
|
|
origin: `http://127.0.0.1:${f.server.address().port}` } }, 403, 'public Host required'],
|
|
['invalid session', { headers: { ...POST.headers, cookie: '__Host-mosaic_session=invalid' } }, 401, 'sign-in required'],
|
|
['content type', { headers: { ...POST.headers, 'content-type': 'text/plain' } }, 415, 'invalid-request'],
|
|
['extra key', { body: '{"human":"jason"}' }, 400, 'invalid-request'],
|
|
['array', { body: '[]' }, 400, 'invalid-request'],
|
|
['null', { body: 'null' }, 400, 'invalid-request'],
|
|
['body bound', { body: ' '.repeat(1025) + '{}' }, 400, 'invalid-request'],
|
|
];
|
|
for (const [name, changed, status, error] of cases) {
|
|
const response = await http(f.server, '/api/processing/halt', { ...POST, ...changed });
|
|
assert.equal(response.status, status, name);
|
|
assert.equal(response.value.error, error, name);
|
|
assert.deepEqual(f.calls, [], name + ' must refuse before the writer');
|
|
}
|
|
const missingGeneration = await http(f.server, '/api/processing/resume', POST);
|
|
assert.equal(missingGeneration.status, 400);
|
|
assert.equal(missingGeneration.value.error, 'invalid-request');
|
|
assert.deepEqual(f.calls, []);
|
|
});
|
|
test('tester cannot invoke either control writer and failures never echo backend text', async t => {
|
|
const f = await fixture(t, { tester: true });
|
|
const headers = { host: new URL(TESTER_ORIGIN).host, origin: TESTER_ORIGIN, 'x-user': undefined };
|
|
for (const action of ['halt', 'resume']) assert.equal((await http(f.server, '/api/processing/' + action, { ...POST, headers: { ...POST.headers, ...headers } })).status, 403);
|
|
assert.deepEqual(f.calls, []);
|
|
const human = await fixture(t); human.processing.halt = async () => { throw Object.assign(Error('NEVER ECHO fixture path'), { code: 'outcome-unknown' }); };
|
|
const r = await http(human.server, '/api/processing/halt', POST);
|
|
assert.equal(r.status, 503); assert.equal(r.value.sent, 'unknown'); assert.doesNotMatch(r.text, /NEVER ECHO/);
|
|
});
|
|
|
|
// Rebase on row 192: the server verifies the cookie before passing its signer.
|
|
test('processing writes use a real OIDC session and still require --send and same-origin', async t => {
|
|
for (const enabled of [false, true]) {
|
|
const f = await fixture(t, { send: enabled }), calls = f.calls, server = f.server;
|
|
const headers = { ...POST.headers };
|
|
assert.equal((await http(server, '/api/processing/halt', { ...POST, headers })).status, enabled ? 200 : 403);
|
|
assert.equal((await http(server, '/api/processing/halt', { ...POST, headers: { ...headers, cookie: '__Host-mosaic_session=invalid' } })).status, 401);
|
|
assert.equal((await http(server, '/api/processing/halt', { ...POST, headers: { ...headers, origin: 'https://elsewhere' } })).status, 403);
|
|
assert.deepEqual(calls, enabled ? [['halt', {}]] : []);
|
|
}
|
|
});
|
|
|
|
// Exercise the handler's own origin/site guards independently of serve's outer fence.
|
|
test('processing handler independently refuses wrong origin and cross-site before its writer', async () => {
|
|
const { Readable } = await import('node:stream');
|
|
const { processingHTTP } = await import('../src/processing-http.mjs');
|
|
for (const changed of [{ origin: ['https://elsewhere'] }, { 'sec-fetch-site': ['cross-site'] }]) {
|
|
const req = Readable.from([Buffer.from('{}')]); req.method = 'POST';
|
|
req.headersDistinct = { 'x-user': ['jason'], origin: ['https://console.example'],
|
|
'sec-fetch-site': ['same-origin'], 'content-type': ['application/json'], ...changed };
|
|
let status, body, called = false;
|
|
const res = { writeHead: value => { status = value; }, end: value => { body = JSON.parse(value); } };
|
|
await processingHTTP(req, res, { path: '/api/processing/halt', search: '', named: true, send: () => {},
|
|
preview: { host: 'console.example', header: 'x-user', user: 'jason' },
|
|
processing: { halt: async () => { called = true; return {}; } } });
|
|
assert.equal(status, 403); assert.equal(called, false); assert.equal(body.sent, false);
|
|
}
|
|
});
|