Files
Agent-Workbench/tests/network-diagnostics.test.mjs
T
2026-11-06 06:21:59 +08:00

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');
});