Files
Agent-Workbench/tests/model-wait.test.mjs
2026-11-06 06:21:59 +08:00

77 lines
6.1 KiB
JavaScript

import test from 'node:test';
import assert from 'node:assert/strict';
import { modelWaitSettings, validateModelWaitSettings, requestDeadline } from '../src/core/models/request-deadline.mjs';
import { Provider } from '../src/server/provider.mjs';
import { modelSnapshot } from '../src/shared/contracts/execution.mjs';
import { fixture } from './helpers.mjs';
import { Store } from '../src/server/store.mjs';
import { connectionFailure } from '../src/server/diagnostics.mjs';
test('older configurations receive bounded wait defaults without changing the original object', () => {
const legacy = { model: 'legacy' }, original = structuredClone(legacy);
assert.deepEqual(modelWaitSettings(legacy), { modelResponseTimeoutMs: 300000, modelStreamIdleTimeoutMs: 120000 });
assert.deepEqual(legacy, original);
for (const value of [null, '', -1, Infinity, Number.MAX_SAFE_INTEGER + 1, 60000.5]) assert.equal(modelWaitSettings({ modelResponseTimeoutMs: value }).modelResponseTimeoutMs, 300000);
assert.equal(modelWaitSettings({ modelResponseTimeoutMs: 900000 }).modelResponseTimeoutMs, 900000);
assert.throws(() => validateModelWaitSettings({ modelResponseTimeoutMs: '60000' }), /整数/);
assert.equal(validateModelWaitSettings({ modelStreamIdleTimeoutMs: 0 }).modelStreamIdleTimeoutMs, 0);
assert.equal(modelWaitSettings({ modelResponseTimeoutMs: 0 }).modelResponseTimeoutMs, 0);
assert.equal(modelWaitSettings({ modelResponseTimeoutMs: 2 ** 32 }).modelResponseTimeoutMs, 2 ** 32);
assert.equal(validateModelWaitSettings({ modelStreamIdleTimeoutMs: 15000 }, { modelResponseTimeoutMs: 600000 }).modelResponseTimeoutMs, 600000);
});
test('a fresh installation has unlimited waits and explicit long waits do not overflow Node timers', t => {
const f = fixture(t, { modernDefaults: true });
assert.deepEqual(modelWaitSettings(f.store.config), { modelResponseTimeoutMs: 0, modelStreamIdleTimeoutMs: 0 });
assert.deepEqual(validateModelWaitSettings({ modelResponseTimeoutMs: 1, modelStreamIdleTimeoutMs: 2 ** 32 }), { modelResponseTimeoutMs: 1, modelStreamIdleTimeoutMs: 2 ** 32 });
t.mock.timers.enable({ apis: ['setTimeout', 'Date'], now: 1000 });
const deadline = requestDeadline({ timeoutMs: 2 ** 32, idleTimeoutMs: 0 }); t.after(() => deadline.close());
t.mock.timers.tick(2147483647); assert.equal(deadline.signal.aborted, false);
t.mock.timers.tick(2147483647); assert.equal(deadline.signal.aborted, false);
t.mock.timers.tick(2); assert.equal(deadline.signal.aborted, true); assert.equal(deadline.timeout.limitMs, 2 ** 32);
});
test('active stream survives sixty seconds; byte activity resets idle but cannot extend total deadline', t => {
t.mock.timers.enable({ apis: ['setTimeout', 'Date'], now: 1000 });
const deadline = requestDeadline({ timeoutMs: 300000, idleTimeoutMs: 120000 }); t.after(() => deadline.close());
deadline.beginStream();
for (let index = 0; index < 4; index++) { t.mock.timers.tick(70000); assert.equal(deadline.signal.aborted, false); deadline.receive(10); }
t.mock.timers.tick(19999); assert.equal(deadline.signal.aborted, false);
t.mock.timers.tick(1); assert.equal(deadline.signal.aborted, true);
assert.deepEqual(deadline.timeout, { kind: 'total', stage: 'stream', limitMs: 300000, elapsedMs: 300000, receivedBytes: 40, idleMs: 20000 });
});
test('silent stream has its own accurate deadline; caller cancellation and cleanup preserve their cause', t => {
t.mock.timers.enable({ apis: ['setTimeout', 'Date'], now: 1000 });
const deadline = requestDeadline({ timeoutMs: 300000, idleTimeoutMs: 120000 }); t.after(() => deadline.close());
deadline.beginStream(); t.mock.timers.tick(100000); deadline.receive(7);
t.mock.timers.tick(119999); assert.equal(deadline.signal.aborted, false);
t.mock.timers.tick(1); assert.equal(deadline.timeout.kind, 'idle'); assert.equal(deadline.timeout.receivedBytes, 7);
const diagnosis = connectionFailure(deadline.signal.reason, { timedOut: true, timeout: deadline.timeout });
assert.match(diagnosis.message, /连续 120 秒未收到新数据/); assert.equal(diagnosis.timeout.elapsedMs, 220000);
const stop = new AbortController(), user = requestDeadline({ signal: stop.signal, timeoutMs: 300000, idleTimeoutMs: 120000 });
const reason = new Error('owned user stop'); stop.abort(reason); assert.equal(user.signal.reason, reason); assert.equal(user.timeout, null); user.close();
const closed = requestDeadline({ timeoutMs: 300000, idleTimeoutMs: 120000 }); closed.beginStream(); closed.close();
t.mock.timers.tick(900000); assert.equal(closed.signal.aborted, false);
});
test('waiting for headers is bounded independently of stream-idle time', t => {
t.mock.timers.enable({ apis: ['setTimeout', 'Date'], now: 1000 });
const deadline = requestDeadline({ timeoutMs: 300000, idleTimeoutMs: 120000 }); t.after(() => deadline.close());
t.mock.timers.tick(120001); assert.equal(deadline.signal.aborted, false);
t.mock.timers.tick(179999); assert.equal(deadline.timeout.stage, 'response'); assert.equal(deadline.timeout.kind, 'total');
});
test('wait settings persist, pin new runs and leave model pool, credentials and old run snapshots intact', t => {
const f = fixture(t), provider = new Provider(), hub = provider.modelHub(f.store);
const connection = hub.upsert({ name: 'Owned wait', model: 'm', baseUrl: 'http://127.0.0.1:1/v1', requiresKey: false });
const pool = hub.pool({ name: 'Original pool', members: [{ connectionId: connection.id }] }); hub.select({ type: 'pool', id: pool.id });
const before = structuredClone(hub.state), previous = modelSnapshot(f.store.config);
f.store.saveConfig(validateModelWaitSettings({ modelResponseTimeoutMs: 600000, modelStreamIdleTimeoutMs: 180000 }, f.store.config));
assert.deepEqual(hub.state, before); assert.equal(previous.modelResponseTimeoutMs, 300000);
assert.equal(hub.prepare(f.store.config).modelResponseTimeoutMs, 600000);
assert.equal(hub.view().waitSettings.modelStreamIdleTimeoutMs, 180000);
f.store.close(); const reopened = new Store(f.data); f.onCleanup(() => reopened.close());
assert.equal(reopened.config.modelResponseTimeoutMs, 600000); assert.equal(reopened.storage.meta('modelRegistry').selected.id, pool.id);
});