Files
eip4-web/src/modeler/candidateExpression.test.ts
zhengwr 11632b4801 fix(modeler): codec 评审收口——stringToJson引号映射+半角content变体+item未知键透传+形状守卫
评审者跑全库 4794 条真实表达式往返对照原版序列化器,四项收口:
- I-1 build 补 stringToJson 引号契约(BasePropertiesConverter.java:235-280):字符串叶子值
  '→‘、"→“(经 JSON.stringify replacer,{}→【】由 halfToFull、\\与控制字符由 stringify 覆盖)。
  否则用户输入含 ' 截断外层 JUEL 单引号字面量 / 含 " 截断内层 JSON,部署后表达式解析即断。
  语料 ‘/“ 均 0 命中→对存量为 no-op,不破逐字往返。
- I-2 头注释纠偏:「content 不含花括号」被 20 条真实 ${users}(半角)证伪;改为事实——
  4774/4794 逐字,20 条半角 content 变体 build 归一为全角,引擎 :54 全局【→{ 还原后运行期等价。
- M-1 item 未知键 known-first 重排+按原序透传(与 meta 全量保留对称,不静默丢未来扩展键)。
- M-2 items 元素形状守卫:元素非对象或 type 非字符串→整体返 null 不抛。

加分:tools/codec-corpus-sweep.mjs(照 modeler-fidelity-sweep 风格,内联镜像 codec 跑全语料):
1512 文档 / 4794 表达式 → 逐字 4774 + 引擎运行期等价 20 + 解析失败 0 + 硬不匹配 0(门禁绿)。

测试 29 例(原 20 + 引号映射/幂等/meta 引号/半角变体运行期等价/未知键透传/形状守卫 9 例);
modeler 全量 66 例绿;tsc -b 干净。

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-02 11:36:53 +08:00

306 lines
14 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import { describe, it, expect } from 'vitest';
import { SYNTHETIC_BPMN } from './moddle/fixtures/synthetic-full-surface.bpmn';
import {
parseCandidateExpression,
buildCandidateExpression,
type UserPropertyItem,
} from './candidateExpression';
// ── 真实形态锚定 ────────────────────────────────────────────────────────────
// 不手抄表达式:直接从 T1.1 逐字对照「总包合同交底」写就的 synthetic-full-surface
// fixture 里,运行时抽出 activiti:candidateUsers / activiti:collection 的属性值,
// 做 XML 实体解码(&quot;→")得到 businessObject 属性值层的真实表达式。这样测试
// 与「真实形态的唯一真相」绑定,fixture 改则测试自动跟随,杜绝逐字漂移。
function xmlDecode(s: string): string {
return s
.replace(/&quot;/g, '"')
.replace(/&lt;/g, '<')
.replace(/&gt;/g, '>')
.replace(/&amp;/g, '&');
}
function extractAttr(attr: string): string {
const m = SYNTHETIC_BPMN.match(new RegExp(attr + '="([^"]*)"'));
if (!m) throw new Error('fixture 缺属性 ' + attr);
return xmlDecode(m[1]);
}
// activiti:candidateUsers,单实例办理人,type=position,content 尾部 4 个 CHAR 补白空格,
// 外层 meta 含非空 taskSuccessService(真实服务钩子)。
const REAL_CANDIDATE = extractAttr('activiti:candidateUsers');
// activiti:collection,多实例(会签)办理人,type=projectRoleType,content 为逗号分隔的
// 11 个布尔维度串,外层 meta 全部为空/false。
const REAL_MULTI = extractAttr('activiti:collection');
describe('parseCandidateExpression — 真实形态解析', () => {
it('解析真实 candidate 表达式(全角【】,识别为 candidate 变体)', () => {
const r = parseCandidateExpression(REAL_CANDIDATE);
expect(r).not.toBeNull();
expect(r!.variant).toBe('candidate');
expect(r!.items).toHaveLength(1);
expect(r!.items[0]).toMatchObject({
type: 'position',
isCandidate: true,
isSendMail: false,
isSendPhone: false,
isSendMessage: false,
});
});
it('content 尾部 CHAR 补白空格原样保留(不 trim)', () => {
const r = parseCandidateExpression(REAL_CANDIDATE);
// 32 位十六进制 id + 4 个尾部空格
expect(r!.items[0].content).toBe('402881343cd50391013d62ccd0c20f7d ');
expect(r!.items[0].content).toHaveLength(36);
});
it('multiInstance 前缀变体 multiInstanceUsersHandler.getUsers 同套解析', () => {
const r = parseCandidateExpression(REAL_MULTI);
expect(r).not.toBeNull();
expect(r!.variant).toBe('multiInstance');
expect(r!.items[0].type).toBe('projectRoleType');
});
it('content 含逗号分隔多值原样保留', () => {
const r = parseCandidateExpression(REAL_MULTI);
expect(r!.items[0].content).toBe(
'true,false,false,false,false,false,false,false,false,false,false',
);
});
});
describe('buildCandidateExpression — 与引擎口径逐字往返', () => {
it('candidate 真实表达式 round-trip 逐字一致(全角【】+前后缀逐字+meta 不丢)', () => {
const r = parseCandidateExpression(REAL_CANDIDATE)!;
expect(buildCandidateExpression(r.items, r.variant, r.meta)).toBe(REAL_CANDIDATE);
});
it('multiInstance 真实表达式 round-trip 逐字一致', () => {
const r = parseCandidateExpression(REAL_MULTI)!;
expect(buildCandidateExpression(r.items, r.variant, r.meta)).toBe(REAL_MULTI);
});
it('外层 meta(messageTemplate/taskSuccessService/isSkip* 等)往返一字不丢', () => {
const r = parseCandidateExpression(REAL_CANDIDATE)!;
// 真实服务钩子:侧板只改 items 时,taskSuccessService 等业务字段必须原样带回,
// 否则重新部署会打掉已部署流程的任务后置服务。
expect(r.meta).toMatchObject({
messageTemplate: '',
taskSuccessService: 'PM_CONTRACTUALREGISTER_UPDATEPROJECTSTATUS',
isSkipInitiator: false,
isNoUserSkip: false,
isSkipBeforeTask: true,
});
expect(buildCandidateExpression(r.items, r.variant, r.meta)).toContain(
'PM_CONTRACTUALREGISTER_UPDATEPROJECTSTATUS',
);
});
it('构建输出前缀/后缀逐字对齐 BasePropertiesConverter 常量', () => {
const r = parseCandidateExpression(REAL_CANDIDATE)!;
const built = buildCandidateExpression(r.items, r.variant, r.meta);
expect(built.startsWith("${candidateUsersHandler.getCandidateUsers(execution,'")).toBe(true);
expect(built.endsWith("')}")).toBe(true);
const rm = parseCandidateExpression(REAL_MULTI)!;
const builtM = buildCandidateExpression(rm.items, rm.variant, rm.meta);
expect(builtM.startsWith("${multiInstanceUsersHandler.getUsers(execution,'")).toBe(true);
});
});
describe('各 type 往返不丢字段(真实结构派生:同一真实外壳,仅换 type/content)', () => {
// 用真实 candidate 外壳(REAL_CANDIDATE 的 meta 与 item 键集),仅替换 type/content,
// 覆盖 §0 其余 type。结构逐字来自真实形态,值取真实业务样例。
function reshape(type: string, content: string): string {
const r = parseCandidateExpression(REAL_CANDIDATE)!;
const item: UserPropertyItem = { ...r.items[0], type, content };
return buildCandidateExpression([item], 'candidate', r.meta);
}
it('scriptUser(content=${APPLYUSERS},真实会签办理人形态)往返不丢', () => {
const expr = reshape('scriptUser', '${APPLYUSERS}');
const r = parseCandidateExpression(expr)!;
expect(r.items[0]).toMatchObject({ type: 'scriptUser', content: '${APPLYUSERS}' });
expect(buildCandidateExpression(r.items, r.variant, r.meta)).toBe(expr);
});
it('depart 往返不丢', () => {
const expr = reshape('depart', '402881343cd50391013d62ccd0c20f7d');
const r = parseCandidateExpression(expr)!;
expect(r.items[0].type).toBe('depart');
expect(buildCandidateExpression(r.items, r.variant, r.meta)).toBe(expr);
});
it('beforeTaskLeader 往返不丢', () => {
const expr = reshape('beforeTaskLeader', '');
const r = parseCandidateExpression(expr)!;
expect(r.items[0].type).toBe('beforeTaskLeader');
expect(buildCandidateExpression(r.items, r.variant, r.meta)).toBe(expr);
});
});
describe('isSendMessage 可选字段', () => {
it('含 isSendMessage 往返保留', () => {
const r = parseCandidateExpression(REAL_CANDIDATE)!;
expect(r.items[0].isSendMessage).toBe(false);
expect(buildCandidateExpression(r.items, r.variant, r.meta)).toBe(REAL_CANDIDATE);
});
it('缺 isSendMessage 的旧数据变体:parse 不填充,build 不凭空添加', () => {
// 引擎 BasePropertiesConverter:62-67 对 isCandidate/isSendMail/isSendPhone 无 null 守卫、
// 唯 isSendMessage 有(:63),故存在无 isSendMessage 的合法历史数据。此变体无 meta。
const NO_MSG =
"${candidateUsersHandler.getCandidateUsers(execution,'【\"items\":[【\"type\":\"user\",\"content\":\"u1,u2\",\"isCandidate\":true,\"isSendMail\":false,\"isSendPhone\":false】]】')}";
const r = parseCandidateExpression(NO_MSG)!;
expect(r.items[0].isSendMessage).toBeUndefined();
expect('isSendMessage' in r.items[0]).toBe(false);
expect(Object.keys(r.meta)).toHaveLength(0);
expect(buildCandidateExpression(r.items, r.variant, r.meta)).toBe(NO_MSG);
});
});
describe('半角输入兼容 + build 恒全角', () => {
it('半角{}输入可解析,build 输出恒全角【】,回到真实全角形态', () => {
const halfWidth = REAL_CANDIDATE.split('【').join('{').split('】').join('}');
expect(halfWidth).not.toBe(REAL_CANDIDATE); // 确认输入确是半角
const r = parseCandidateExpression(halfWidth);
expect(r).not.toBeNull();
expect(r!.items[0].type).toBe('position');
// build 输出恒全角 → 等于真实全角原文
expect(buildCandidateExpression(r!.items, r!.variant, r!.meta)).toBe(REAL_CANDIDATE);
});
});
describe('非法/空输入返回 null 不抛', () => {
it('undefined → null', () => {
expect(parseCandidateExpression(undefined)).toBeNull();
});
it('空串 → null', () => {
expect(parseCandidateExpression('')).toBeNull();
});
it('缺前缀(非办理人表达式)→ null', () => {
expect(parseCandidateExpression('${someOtherExpr(execution)}')).toBeNull();
});
it('有前缀但内容坏 JSON → null 不抛', () => {
const bad =
"${candidateUsersHandler.getCandidateUsers(execution,'【not a valid json】')}";
expect(() => parseCandidateExpression(bad)).not.toThrow();
expect(parseCandidateExpression(bad)).toBeNull();
});
it('有前缀但缺后缀 → null', () => {
const noSuffix = "${candidateUsersHandler.getCandidateUsers(execution,'【\"items\":[]】";
expect(parseCandidateExpression(noSuffix)).toBeNull();
});
it('JSON 合法但无 items 数组 → null', () => {
const noItems =
"${candidateUsersHandler.getCandidateUsers(execution,'【\"foo\":1】')}";
expect(parseCandidateExpression(noItems)).toBeNull();
});
// M-2 形状守卫
it('items 元素非对象(字符串)→ null 不抛', () => {
const bad =
"${candidateUsersHandler.getCandidateUsers(execution,'【\"items\":[\"notanobject\"]】')}";
expect(() => parseCandidateExpression(bad)).not.toThrow();
expect(parseCandidateExpression(bad)).toBeNull();
});
it('items 元素 type 非字符串(数字)→ null', () => {
const bad =
"${candidateUsersHandler.getCandidateUsers(execution,'【\"items\":[【\"type\":123,\"content\":\"x\"】]】')}";
expect(parseCandidateExpression(bad)).toBeNull();
});
it('items 元素为 null → null', () => {
const bad =
"${candidateUsersHandler.getCandidateUsers(execution,'【\"items\":[null]】')}";
expect(parseCandidateExpression(bad)).toBeNull();
});
});
describe('I-1 stringToJson 引号映射(T2.4 接用户输入前必须)', () => {
const CAND_PREFIX = "${candidateUsersHandler.getCandidateUsers(execution,'";
function body(built: string): string {
return built.slice(CAND_PREFIX.length, built.length - "')}".length);
}
it("content 含 ' 和 \" → build 映射为 ‘/“,值层无裸 '/\"、外层 JUEL 定界符不被截断", () => {
const item: UserPropertyItem = {
type: 'user',
content: `O'Brien "Ann"`,
isCandidate: true,
isSendMail: false,
isSendPhone: false,
isSendMessage: false,
};
const built = buildCandidateExpression([item], 'candidate');
// JUEL 单引号字面量安全:整个内容段不得出现裸 ASCII 单引号(否则截断 execution,'...')。
// 注意 " 是 JSON 结构定界符会合法出现于内容段,故只对 ' 断言整段无裸值。
expect(body(built)).not.toContain("'");
// JSON 结构安全:值里的 " 已映射走,build 产物仍是良构表达式,可无损 parse 回来。
const r = parseCandidateExpression(built);
expect(r).not.toBeNull();
const c = r!.items[0].content;
expect(c).toContain('‘'); // O‘Brien
expect(c).toContain('“'); // “Ann“(开闭同映射为左引号,与 stringToJson 逐字一致)
expect(c).not.toContain("'");
expect(c).not.toContain('"');
expect(built.startsWith(CAND_PREFIX)).toBe(true);
expect(built.endsWith("')}")).toBe(true);
});
it('引号映射幂等:build 产物再 parse→build 稳定不变', () => {
const built = buildCandidateExpression(
[{ type: 'user', content: `x'y"z`, isCandidate: true, isSendMail: false, isSendPhone: false }],
'candidate',
);
const r = parseCandidateExpression(built)!;
expect(buildCandidateExpression(r.items, r.variant, r.meta)).toBe(built);
});
it('meta 字符串叶子(messageTemplate)同样应用引号映射', () => {
const built = buildCandidateExpression(
[{ type: 'user', content: 'u1', isCandidate: true, isSendMail: false, isSendPhone: false }],
'candidate',
{ messageTemplate: `it's` },
);
expect(built).toContain('it‘s');
expect(body(built)).not.toContain("'");
});
});
describe('I-2 半角 content 变体(scriptUser ${users})——运行期等价', () => {
// 语料实测 20 条:content 用半角 ${users}(非 stringToJson 产物)。parse 保留原值,
// build 把结构性 {} 连同 content 里半角 {} 一并规范化为全角——非字节逐字,但引擎运行期
// 对整串全局 【→{ 还原后完全等价。
const HALF =
"${multiInstanceUsersHandler.getUsers(execution,'【\"items\":[【\"type\":\"scriptUser\",\"content\":\"${users}\",\"isCandidate\":true,\"isSendMail\":false,\"isSendPhone\":false】]】')}";
// 镜像引擎 CandidateUsersHandler:54 的全局字面替换
const engineRestore = (s: string): string => s.split('【').join('{').split('】').join('}');
it('半角 content 可解析,原值保留', () => {
const r = parseCandidateExpression(HALF)!;
expect(r.items[0]).toMatchObject({ type: 'scriptUser', content: '${users}' });
});
it('build 输出恒全角(content 半角{}被规范化),但引擎全局替换后与原文等价', () => {
const r = parseCandidateExpression(HALF)!;
const built = buildCandidateExpression(r.items, r.variant, r.meta);
expect(built).toContain('$【users】'); // 非字节逐字
expect(engineRestore(built)).toBe(engineRestore(HALF)); // 运行期等价
});
});
describe('M-1 item 未知键透传(不静默丢未来扩展键,与 meta 全量保留对称)', () => {
it('未知 item 键排在已知键之后,往返逐字不丢', () => {
const WITH_UNKNOWN =
"${candidateUsersHandler.getCandidateUsers(execution,'【\"items\":[【\"type\":\"user\",\"content\":\"u1\",\"isCandidate\":true,\"isSendMail\":false,\"isSendPhone\":false,\"futureFlag\":true】]】')}";
const r = parseCandidateExpression(WITH_UNKNOWN)!;
expect((r.items[0] as Record<string, unknown>).futureFlag).toBe(true);
expect(buildCandidateExpression(r.items, r.variant, r.meta)).toBe(WITH_UNKNOWN);
});
});