182 lines
15 KiB
JavaScript
182 lines
15 KiB
JavaScript
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import fs from 'node:fs';
|
|
import http from 'node:http';
|
|
import net from 'node:net';
|
|
import tls from 'node:tls';
|
|
import { fixture, until, workspace } from './helpers.mjs';
|
|
import { Provider } from '../src/server/provider.mjs';
|
|
import { Runtime } from '../src/server/runtime.mjs';
|
|
import { ModelTransport } from '../src/core/models/transport.mjs';
|
|
import { NetworkDiagnostics } from '../src/core/models/network-diagnostics.mjs';
|
|
import { CompanionTLS } from '../src/core/companion/tls-authority.mjs';
|
|
import { createRequestHandler } from '../src/server/app.mjs';
|
|
import { hostAuthority } from '../src/core/desktop/host-authority.mjs';
|
|
import { installUpgrade } from '../src/server/hot-upgrade.mjs';
|
|
|
|
async function listener(f, server) {
|
|
const sockets = new Set(); server.on('connection', socket => { sockets.add(socket); socket.on('close', () => sockets.delete(socket)); });
|
|
await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
|
|
f.onCleanup(async () => { for (const socket of sockets) socket.destroy(); await new Promise(resolve => server.close(resolve)); });
|
|
return server.address().port;
|
|
}
|
|
function setup(t, options = {}) {
|
|
const f = fixture(t, { modernDefaults: options.modernDefaults ?? false }), provider = new Provider({ transport: options.transport ?? new ModelTransport({ environment: {} }) });
|
|
const hub = provider.modelHub(f.store); hub.networkChecks = new NetworkDiagnostics(hub, options);
|
|
f.onCleanup(() => provider.abortRequests());
|
|
const add = baseUrl => hub.upsert({ name: 'Owned network check', model: 'owned-no-model', baseUrl, requiresKey: true });
|
|
const run = async connection => { const { job } = hub.networkChecks.start({ id: connection.id, revision: connection.revision });
|
|
await hub.networkChecks.active.get(job.id).promise; return hub.networkChecks.view().jobs.find(row => row.id === job.id); };
|
|
return { ...f, provider, hub, add, run, manager: hub.networkChecks };
|
|
}
|
|
async function material() {
|
|
const state = { gatewayId: 'owned-network-test' }, registry = { binding: 'owned-network-test', read: () => state, mutate: action => action(state) };
|
|
return new CompanionTLS(registry, { protect: value => Buffer.from(value), unprotect: value => Buffer.from(value) }).material('127.0.0.1');
|
|
}
|
|
|
|
test('plain endpoint checks only TCP, records family coverage and never reads model credentials or writes routing/health/attempts', async t => {
|
|
const f = setup(t); let bytes = 0;
|
|
const port = await listener(f, net.createServer(socket => socket.on('data', chunk => { bytes += chunk.length; })));
|
|
const connection = f.add('http://127.0.0.1:' + port + '/v1'), state = structuredClone(f.hub.state), config = structuredClone(f.store.config);
|
|
f.hub.credential = () => { throw Error('Credential access forbidden.'); };
|
|
f.provider.redact = () => { throw Error('Redaction must not enumerate saved keys.'); };
|
|
const job = await f.run(connection);
|
|
assert.equal(job.status, 'passed'); assert.equal(job.stages.dns.status, 'passed');
|
|
assert.equal(job.trials[0].tls, 'not_applicable'); assert.equal(job.trials[2].status, 'skipped');
|
|
assert.equal(job.trials[2].code, 'ADDRESS_FAMILY_UNAVAILABLE');
|
|
assert.equal(bytes, 0); assert.deepEqual(f.hub.state, state); assert.deepEqual(f.store.config, config);
|
|
assert.deepEqual(f.hub.attempts, []); assert.equal(f.hub.health.size, 0); assert.equal(job.credentialAccess, false);
|
|
assert.equal(job.httpRequests, 0); assert.equal(job.modelRequests, 0);
|
|
});
|
|
|
|
test('local DNS failure is separate from TCP/TLS and arbitrary input, stale revision and TLS overrides are rejected', async t => {
|
|
let lookups = 0;
|
|
const f = setup(t, { lookup: (_name, _options, callback) => { lookups++; callback(Object.assign(new Error('owned lookup'), { code: 'ENOTFOUND' })); } });
|
|
const connection = f.add('https://owned-dns.invalid/v1');
|
|
for (const extra of [{ revision: 99 }, { rejectUnauthorized: false }, { apiKey: 'must-not-read' }, { port: 1 }]) assert.throws(() => f.manager.start({ id: connection.id, revision: connection.revision, ...extra }));
|
|
const job = await f.run(connection); assert.equal(lookups, 1); assert.equal(job.status, 'failed');
|
|
assert.equal(job.stages.dns.code, 'ENOTFOUND'); assert.ok(job.trials.every(row => row.status === 'skipped'));
|
|
assert.equal(job.target.host, 'owned-dns.invalid');
|
|
});
|
|
|
|
test('refused TCP socket preserves its stage and cannot masquerade as a TLS or API response', async t => {
|
|
const f = setup(t), server = net.createServer(), port = await listener(f, server);
|
|
await new Promise(resolve => server.close(resolve));
|
|
const job = await f.run(f.add('https://127.0.0.1:' + port + '/v1'));
|
|
assert.equal(job.status, 'failed'); assert.equal(job.trials[0].stage, 'tcp'); assert.equal(job.trials[0].code, 'ECONNREFUSED');
|
|
assert.equal(job.trials[0].tlsProtocol, undefined); assert.equal(job.modelRequests, 0);
|
|
});
|
|
|
|
test('TLS validation succeeds for a trusted owned certificate and rejects the same untrusted certificate', async t => {
|
|
const cert = await material(), f = setup(t, { ca: cert.ca });
|
|
const server = tls.createServer(cert); server.on('tlsClientError', () => {});
|
|
const port = await listener(f, server), connection = f.add('https://127.0.0.1:' + port + '/v1');
|
|
const good = await f.run(connection); assert.equal(good.status, 'passed'); assert.equal(good.trials[0].certificateAuthorized, true);
|
|
assert.ok(good.trials[0].certificateFingerprint256); assert.ok(good.trials[0].tlsMs >= 0);
|
|
delete f.manager.options.ca;
|
|
const bad = await f.run(connection); assert.equal(bad.status, 'failed'); assert.equal(bad.trials[0].stage, 'tls');
|
|
assert.ok(['SELF_SIGNED_CERT_IN_CHAIN', 'UNABLE_TO_VERIFY_LEAF_SIGNATURE'].includes(bad.trials[0].code), bad.trials[0].code);
|
|
assert.notEqual(bad.trials[0].certificateAuthorized, true);
|
|
});
|
|
|
|
test('a TCP peer that never answers TLS is bounded, and cancellation waits for owned sockets to close', { timeout: 15000 }, async t => {
|
|
let open = 0, clientHellos = 0, handshakesStarted;
|
|
const handshakes = new Promise(resolve => { handshakesStarted = resolve; });
|
|
const f = setup(t, { stageTimeoutMs: 80 });
|
|
const server = net.createServer(socket => {
|
|
open++; socket.once('data', () => { if (++clientHellos === 2) handshakesStarted(); }); socket.on('close', () => open--);
|
|
});
|
|
const port = await listener(f, server), connection = f.add('https://127.0.0.1:' + port + '/v1');
|
|
// Keep real TCP/TLS I/O, but advance its deadline only after both local
|
|
// ClientHellos arrive. Synchronous progress persistence must not turn a TLS
|
|
// timeout assertion into a race with TCP connection scheduling.
|
|
t.mock.timers.enable({ apis: ['setTimeout'] });
|
|
const started = f.manager.start({ id: connection.id, revision: connection.revision });
|
|
const operation = f.manager.active.get(started.job.id), completed = operation.promise;
|
|
await handshakes; t.mock.timers.tick(79);
|
|
assert.equal(operation.job.status, 'running');
|
|
assert.equal(operation.job.trials.filter(row => row.status === 'running').length, 2);
|
|
assert.ok(operation.job.trials.filter(row => row.status === 'running').every(row => row.stage === 'tls'));
|
|
t.mock.timers.tick(1); await completed; t.mock.timers.reset();
|
|
const timed = f.manager.view().jobs.find(row => row.id === started.job.id);
|
|
assert.equal(timed.trials[0].stage, 'tls'); assert.equal(timed.trials[0].code, 'TLS_HANDSHAKE_TIMEOUT');
|
|
await until(() => open === 0); f.manager.options.stageTimeoutMs = 10000;
|
|
const { job } = f.manager.start({ id: connection.id, revision: connection.revision }); await until(() => open > 0);
|
|
assert.throws(() => f.manager.start({ id: connection.id, revision: connection.revision }), /等待/);
|
|
const stopped = await f.manager.stop(job.id, {}); assert.equal(stopped.job.status, 'cancelled'); assert.equal(f.manager.active.size, 0);
|
|
await until(() => open === 0); const repeated = await f.manager.stop(job.id, {}); assert.deepEqual(repeated, stopped);
|
|
});
|
|
|
|
test('a stalled lookup is cancellable and the overall deadline bounds DNS without late socket work', async t => {
|
|
let callback; const f = setup(t, { budgetMs: 65, lookup: (_name, _options, done) => { callback = done; } });
|
|
const connection = f.add('https://owned-stalled.invalid/v1'), job = await f.run(connection);
|
|
assert.equal(job.status, 'failed'); assert.equal(job.code, 'DIAGNOSTIC_DEADLINE'); assert.equal(job.stages.dns.status, 'cancelled');
|
|
const frozen = JSON.stringify(f.manager.view()); callback(null, [{ address: '127.0.0.1', family: 4 }]);
|
|
await new Promise(resolve => setImmediate(resolve)); assert.equal(JSON.stringify(f.manager.view()), frozen); assert.equal(f.manager.active.size, 0);
|
|
});
|
|
|
|
test('dual-stack fallback and explicit family results remain separate and never change global DNS defaults', async t => {
|
|
const lookup = (_name, options, callback) => callback(null, [{ address: '::1', family: 6 }, { address: '127.0.0.1', family: 4 }]);
|
|
const f = setup(t, { transport: new ModelTransport({ environment: {}, lookup }) });
|
|
const port = await listener(f, net.createServer()), previous = net.getDefaultAutoSelectFamily();
|
|
const job = await f.run(f.add('http://owned-dual.invalid:' + port + '/v1'));
|
|
assert.equal(job.status, 'partial'); assert.equal(job.trials[0].status, 'passed'); assert.equal(job.trials[0].family, 'IPv4');
|
|
assert.equal(job.trials[2].status, 'failed'); assert.equal(job.trials[2].code, 'ECONNREFUSED');
|
|
assert.equal(net.getDefaultAutoSelectFamily(), previous); assert.equal(f.hub.attempts.length, 0);
|
|
});
|
|
|
|
test('proxy settings are reported as scope only; diagnostics do not contact the proxy or leak its credentials', async t => {
|
|
let contacts = 0; const f = setup(t), proxy = net.createServer(() => { contacts++; }), proxyPort = await listener(f, proxy);
|
|
f.provider.transport = new ModelTransport({ environment: { HTTPS_PROXY: 'http://owned-user:owned-secret@127.0.0.1:' + proxyPort, NO_PROXY: '127.0.0.1' } });
|
|
const port = await listener(f, net.createServer()), job = await f.run(f.add('http://127.0.0.1:' + port + '/v1'));
|
|
assert.equal(job.route.proxyConfigured, true); assert.equal(job.route.noProxyConfigured, true); assert.equal(job.route.kind, 'direct-endpoint-only');
|
|
assert.equal(job.route.modelApiRouteVerified, false); assert.equal(contacts, 0); assert.equal(JSON.stringify(job).includes('owned-secret'), false);
|
|
});
|
|
|
|
test('history is bounded, survives reopening, marks interrupted work and reports changed revisions without rewriting frozen targets', async t => {
|
|
const f = setup(t), connection = f.add('http://127.0.0.1:9/v1');
|
|
assert.equal(f.store.storage.meta('modelNetworkDiagnostics', null), null, 'Reading an empty history does not create metadata.');
|
|
const job = await f.run(connection); f.hub.toggle(connection.id, false);
|
|
assert.equal(f.manager.view().jobs[0].stale, true); assert.equal(job.connectionRevision, connection.revision);
|
|
const rows = f.store.storage.meta('modelNetworkDiagnostics', []); rows[0].status = 'running'; rows[0].stages.dns.status = 'running';
|
|
f.store.storage.setMeta('modelNetworkDiagnostics', rows); const reopened = new NetworkDiagnostics(f.hub);
|
|
assert.equal(reopened.view().jobs[0].status, 'interrupted'); assert.equal(reopened.active.size, 0);
|
|
assert.equal(reopened.view().jobs[0].stages.dns.status, 'interrupted');
|
|
reopened.jobs = Array.from({ length: 30 }, (_, index) => ({ ...job, id: 'retained-' + index })); f.hub.networkChecks = reopened;
|
|
const next = f.hub.connection(connection.id); const result = reopened.start({ id: next.id, revision: next.revision });
|
|
await reopened.active.get(result.job.id).promise; assert.equal(reopened.view().jobs.length, 30); assert.equal(reopened.view().jobs.at(-1).id, 'retained-1');
|
|
});
|
|
|
|
test('HTTP API, host activity, configuration edits, model start and upgrade honor the same active diagnostic and stop operation', async t => {
|
|
const f = setup(t), port = await listener(f, net.createServer(socket => socket.on('data', () => {})));
|
|
const connection = f.add('https://127.0.0.1:' + port + '/v1'), runtime = new Runtime(f.store, f.provider), server = http.createServer();
|
|
await listener(f, server); const token = 'owned-network-token';
|
|
const context = { appDirectory: workspace, server, store: f.store, provider: f.provider, runtime, token, clients: new Set(), started: Date.now(),
|
|
getPort: () => server.address().port, exampleProject: f.project, shutdown: () => {} };
|
|
server.on('request', createRequestHandler(context));
|
|
const api = async (route, input, auth = token) => { const response = await fetch('http://127.0.0.1:' + server.address().port + '/api' + route,
|
|
{ method: input === undefined ? 'GET' : 'POST', headers: { 'X-Workbench-Token': auth, 'Content-Type': 'application/json', Connection: 'close' },
|
|
...(input === undefined ? {} : { body: JSON.stringify(input) }) }); return { status: response.status, value: await response.json() }; };
|
|
assert.equal((await api('/model-center/network-diagnostics', undefined, '')).status, 403);
|
|
const started = await api('/model-center/network-diagnostics', { id: connection.id, revision: connection.revision }); assert.equal(started.status, 201);
|
|
assert.equal(runtime.hasActivity(), true); assert.equal(hostAuthority(context).activity().counts.networkDiagnostics, 1);
|
|
assert.equal((await api('/model-center/connections', { name: 'blocked' })).status, 409);
|
|
assert.equal((await api('/sessions/' + f.session.id + '/messages', { content: 'Do not start.' })).status, 409);
|
|
assert.throws(() => installUpgrade(context, { appDirectory: workspace, updateServiceInfo: false }), /connection diagnostics/);
|
|
const stopped = await api('/model-center/network-diagnostics/' + started.value.job.id + '/stop', {}); assert.equal(stopped.value.job.status, 'cancelled');
|
|
assert.equal(runtime.hasActivity(), false); assert.equal(hostAuthority(context).activity().active, false);
|
|
const network = f.hub.networkChecks, before = JSON.stringify(network.jobs);
|
|
installUpgrade(context, { appDirectory: workspace, updateServiceInfo: false }); assert.equal(f.hub.networkChecks, network); assert.equal(JSON.stringify(network.jobs), before);
|
|
assert.equal((await api('/model-center/network-diagnostics')).value.jobs[0].id, started.value.job.id);
|
|
});
|
|
|
|
test('provider shutdown cancels diagnostics and permits explicit reuse after a failed host stop', async t => {
|
|
const f = setup(t), port = await listener(f, net.createServer(socket => socket.on('data', () => {}))), connection = f.add('https://127.0.0.1:' + port + '/v1');
|
|
const { job } = f.manager.start({ id: connection.id, revision: connection.revision });
|
|
await until(() => f.manager.jobs[0].trials.some(row => row.stage === 'tls'));
|
|
await f.provider.abortRequests(); assert.equal(f.manager.active.size, 0); assert.equal(f.manager.view().jobs[0].status, 'cancelled');
|
|
assert.equal(f.manager.view().jobs[0].id, job.id); assert.throws(() => f.manager.start({ id: connection.id, revision: connection.revision }), /停止/);
|
|
f.provider.resumeRequests(); const next = f.manager.start({ id: connection.id, revision: connection.revision });
|
|
await f.manager.stop(next.job.id, {}); assert.equal(f.manager.view().jobs[0].status, 'cancelled');
|
|
});
|