112 lines
4.5 KiB
TypeScript
112 lines
4.5 KiB
TypeScript
import assert from 'node:assert/strict';
|
|
import { readFile } from 'node:fs/promises';
|
|
import test from 'node:test';
|
|
import {
|
|
BUSINESS_ROUTES,
|
|
allowedParserModesForRoute,
|
|
effectiveParserModeForRoute,
|
|
isParserModeAllowedForRoute,
|
|
type ParserMode
|
|
} from '../src/business-routes.js';
|
|
import { loadConfig } from '../src/config.js';
|
|
import { resolveParserModeSnapshot, TaskError, TaskService } from '../src/task-service.js';
|
|
|
|
const rosterRouteIds = [
|
|
'passenger_list_import_independent',
|
|
'passenger_list_import_shared_child'
|
|
] as const;
|
|
const parserModes: ParserMode[] = ['ai', 'shadow', 'auto', 'program'];
|
|
|
|
test('only the two roster routes are hard Program-only in the machine registry', () => {
|
|
const programOnly = BUSINESS_ROUTES.filter((route) => route.parserPolicy === 'program_only');
|
|
assert.deepEqual(programOnly.map((route) => route.routeId), rosterRouteIds);
|
|
|
|
for (const route of BUSINESS_ROUTES) {
|
|
const expectedModes = rosterRouteIds.includes(route.routeId as typeof rosterRouteIds[number])
|
|
? ['program']
|
|
: parserModes;
|
|
assert.deepEqual(allowedParserModesForRoute(route), expectedModes, route.routeId);
|
|
for (const mode of parserModes) {
|
|
assert.equal(
|
|
isParserModeAllowedForRoute(route, mode),
|
|
expectedModes.includes(mode),
|
|
`${route.routeId}:${mode}`
|
|
);
|
|
assert.equal(
|
|
effectiveParserModeForRoute(route, mode),
|
|
expectedModes.includes(mode) ? mode : 'program',
|
|
`${route.routeId}:${mode}:effective`
|
|
);
|
|
}
|
|
}
|
|
});
|
|
|
|
test('roster task snapshots stay Program with missing or hostile stored settings', async () => {
|
|
const routeText = (routeId: typeof rosterRouteIds[number]) => {
|
|
const route = BUSINESS_ROUTES.find((candidate) => candidate.routeId === routeId);
|
|
assert.ok(route);
|
|
return `${route.directive}\n单号：TEST-ORDER`;
|
|
};
|
|
|
|
for (const routeId of rosterRouteIds) {
|
|
for (const storedMode of [null, ...parserModes] as const) {
|
|
const client = {
|
|
async query() {
|
|
return storedMode === null
|
|
? { rowCount: 0, rows: [] }
|
|
: { rowCount: 1, rows: [{ mode: storedMode, revision: 7 }] };
|
|
}
|
|
};
|
|
const snapshot = await resolveParserModeSnapshot(client as never, 'test-org', routeText(routeId));
|
|
assert.equal(snapshot.routeId, routeId);
|
|
assert.equal(snapshot.mode, 'program');
|
|
assert.equal(snapshot.engineAffinity, null);
|
|
assert.equal(snapshot.revision, storedMode === null ? 0 : 7);
|
|
}
|
|
}
|
|
|
|
const configurableRoute = BUSINESS_ROUTES.find((route) => route.routeId === 'team_order_create');
|
|
assert.ok(configurableRoute);
|
|
const configurable = await resolveParserModeSnapshot({
|
|
async query() {
|
|
return { rowCount: 1, rows: [{ mode: 'shadow', revision: 4 }] };
|
|
}
|
|
} as never, 'test-org', configurableRoute.directive);
|
|
assert.equal(configurable.mode, 'shadow');
|
|
assert.equal(configurable.revision, 4);
|
|
});
|
|
|
|
test('the public route mutation rejects AI, Shadow, and Auto before touching settings storage', async () => {
|
|
const service = new TaskService(loadConfig({
|
|
NODE_ENV: 'test',
|
|
FIELD_ENCRYPTION_KEY: Buffer.alloc(32, 17).toString('base64'),
|
|
DATABASE_URL: 'postgresql://invalid:invalid@127.0.0.1:1/invalid'
|
|
}));
|
|
const context = { organizationId: 'test-org', userId: 'test-user', requestId: 'test-request' };
|
|
for (const routeId of rosterRouteIds) {
|
|
for (const mode of parserModes.filter((candidate) => candidate !== 'program')) {
|
|
await assert.rejects(
|
|
service.setParserRoutingMode(context, routeId, mode, 0),
|
|
(error: unknown) => error instanceof TaskError
|
|
&& error.code === 'parser_mode_not_supported'
|
|
&& error.statusCode === 409
|
|
&& error.details.parser_policy === 'program_only'
|
|
&& Array.isArray(error.details.allowed_modes)
|
|
&& error.details.allowed_modes.join(',') === 'program',
|
|
`${routeId}:${mode}`
|
|
);
|
|
}
|
|
}
|
|
});
|
|
|
|
test('TaskService exposes and enforces the registry parser policy at every AI override boundary', async () => {
|
|
const source = await readFile(new URL('../src/task-service.ts', import.meta.url), 'utf8');
|
|
assert.match(source, /allowed_modes:/);
|
|
assert.match(source, /parser_policy:/);
|
|
assert.match(source, /isParserModeAllowedForRoute\(route, mode\)/);
|
|
assert.match(source, /parser_mode_not_supported/);
|
|
assert.match(source, /effectiveParserModeForRoute\(route, 'ai'\)/);
|
|
assert.match(source, /ai_reparse_not_supported/);
|
|
assert.match(source, /enforceFixedParserModeForClaim/);
|
|
});
|