Files
eip4-web/src/modeler/Eip4Panel.test.tsx
zhengwr 8ea0ef2f1e fix(modeler): activiti.json 修 Modeler.saveXML 大写元素名(断部署)+真Modeler序列化回归测试
CRITICAL:bpmn-js Modeler.saveXML 把被 activiti.json `extends` 的 bpmn 类型序列化成
PascalCase 元素名(<Process>/<UserTask>/<StartEvent>…),未扩展的 <sequenceFlow>/<endEvent>
仍小写。Flowable 大小写敏感 → <Process> 不被识别为流程,ProcessValidator 报
flowable-process-definition-not-executable,部署完全失败。

根因:moddle 把「被扩展类型」的合并描述符 $pkg 设为**最后一个 trait 的包**(moddle
index.esm.js:577)。activiti 包缺 `xml.tagAlias:"lowerCase"`,故 moddle-xml 写元素名时不做
首字母小写 → PascalCase。且 tagAlias 是**双向**的(也驱动 fromXML 解析),要求自定义元素类型名
用 activiti/camunda 惯例的 PascalCase,否则解析 <activiti:taskListener> 找不到类型而丢弃。

修法(对齐 activiti/camunda-bpmn-moddle 标准):
- activiti.json + flowable.json 加 `"xml": { "tagAlias": "lowerCase" }`;
- 自定义元素类型名改 PascalCase:taskListener→TaskListener / executionListener→ExecutionListener
  / field→Field / formProperty→FormProperty / value→Value / in→In / out→Out(属性 type 引用同步)。
  XML 元素名仍小写(tagAlias),故 fixture 与「toContain('activiti:taskListener')」类 XML 断言不变。
- Eip4Panel.tsx:moddle.create/$type 用 'activiti:TaskListener';测试 fake 类型名同步。

为何旧测试没抓到:T1.1/T1.2 只断言 activiti 扩展属性/元素多重集,从不断言基础 BPMN 元素名大小写;
fromXML→toXML 与 create 都走同一 moddle-xml Writer 且都产 PascalCase(本 commit 实证)。

新增 serialization.test.ts(4 例,RED→GREEN):以 BpmnModdle(= Modeler.saveXML 的 moddle 层,
jsdom 跑不动 diagram-js SVG)驱动 fromXML→toXML 与 create→toXML,断言基础元素名全小写、无 PascalCase、
isExecutable 保留、扩展元素/属性不丢;flowable 隔离同验。

serialization 4 + fidelity 12 + Eip4Panel 37;全量 231 单测绿,tsc -b rc=0 + build 干净。

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-02 15:23:51 +08:00

630 lines
30 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, vi, beforeEach, afterEach } from 'vitest';
import { render, screen, fireEvent, act, waitFor } from '@testing-library/react';
import { SYNTHETIC_BPMN } from './moddle/fixtures/synthetic-full-surface.bpmn';
import {
parseCandidateExpression,
buildCandidateExpression,
type UserPropertyItem,
} from './candidateExpression';
// formKey 下拉数据源:mock,其中一个 id 对齐 fixture 的 formKey 值;第三项 name===id(未命名)。
vi.mock('../api/processModeler', () => ({
fetchWfTemplates: vi.fn(() =>
Promise.resolve({
templates: [
{ id: '2098ce21-400b-4425-9c22-63e350974b98', name: '合同交底表单' },
{ id: 'aaaa-bbbb', name: '另一个表单' },
{ id: 'deadbeef-1111-2222', name: 'deadbeef-1111-2222' }, // 未命名(name 回落为 id)
],
degraded: false,
}),
),
}));
import { Eip4Panel } from './Eip4Panel';
import { fetchWfTemplates } from '../api/processModeler';
const mWfTemplates = vi.mocked(fetchWfTemplates);
// ── 真实办理人形态锚定(同 candidateExpression.test.ts:抽 fixture,做 XML 实体解码) ────
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]);
}
const REAL_CANDIDATE = extractAttr('activiti:candidateUsers'); // type=position + 非空 taskSuccessService
// ── 假 modeler / element(vi.fn 捕获 updateProperties 载荷) ────────────────────
function makeModeler() {
let selHandler: ((e: unknown) => void) | null = null;
let cmdHandler: (() => void) | null = null;
const updateProperties = vi.fn();
const created: Array<Record<string, unknown>> = [];
const moddle = {
create: vi.fn((type: string, props: Record<string, unknown> = {}) => {
const o = { $type: type, ...props };
created.push(o);
return o;
}),
};
const modeling = { updateProperties };
const on = vi.fn((ev: string, cb: (e: unknown) => void) => {
if (ev === 'selection.changed') selHandler = cb;
if (ev === 'commandStack.changed') cmdHandler = cb as () => void;
});
const off = vi.fn();
const get = (svc: string) => (svc === 'modeling' ? modeling : svc === 'moddle' ? moddle : {});
const modeler = { on, off, get };
// 选中同时 flush 微任务队列:fetchWfTemplates(mock 已 resolve)的 setState 在 act 内落定,
// 避免「update not wrapped in act」告警。
const select = (element: unknown) =>
act(async () => {
selHandler?.({ newSelection: element ? [element] : [] });
await Promise.resolve();
await Promise.resolve();
});
// 模拟外部 undo/redo:commandStack.changed。
const fireCommandStack = () =>
act(async () => {
cmdHandler?.();
await Promise.resolve();
});
return { modeler, updateProperties, moddle, created, select, fireCommandStack };
}
/** 全项目 window.confirm 默认放行(具体测试可再 spy 覆盖);afterEach 复原。 */
let confirmSpy: ReturnType<typeof vi.spyOn>;
beforeEach(() => {
confirmSpy = vi.spyOn(window, 'confirm').mockReturnValue(true);
});
afterEach(() => {
confirmSpy.mockRestore();
});
/** 一个内容非空、meta 为空的合法办理人表达式(清空时不触发 confirm)。 */
function candidateNoMeta(content = 'u1'): string {
const item: UserPropertyItem = {
type: 'user',
content,
isCandidate: true,
isSendMail: false,
isSendPhone: false,
};
return buildCandidateExpression([item], 'candidate', {});
}
/** 造一个 userTask element:map=businessObject.get(name) 源,$attrs=原始扩展属性袋。 */
function userTask(map: Record<string, unknown> = {}, $attrs?: Record<string, string>) {
return {
id: map.__id ? String(map.__id) : 't1',
type: 'bpmn:UserTask',
businessObject: { $type: 'bpmn:UserTask', $attrs, get: (n: string) => map[n] },
};
}
/** 造一个 moddle-ish 元素(taskListener/loop 等):$type + get(name) + 直读属性。 */
function moddleEl(type: string, props: Record<string, unknown>) {
return { $type: type, ...props, get: (n: string) => props[n] };
}
/** 取最后一次 updateProperties 载荷。 */
function lastPayload(updateProperties: ReturnType<typeof vi.fn>): Record<string, unknown> {
const calls = updateProperties.mock.calls;
return calls[calls.length - 1][1] as Record<string, unknown>;
}
beforeEach(() => {
vi.clearAllMocks();
});
describe('Eip4Panel — 选择状态', () => {
it('未选中任何节点时提示选择', async () => {
const { modeler } = makeModeler();
render(<Eip4Panel modeler={modeler} />);
expect(screen.getByText(/请选择/)).toBeInTheDocument();
// flush 挂载期 fetchWfTemplates 的 setState(避免 act 告警)
await act(async () => {
await Promise.resolve();
});
});
it('选中非 userTask 显示简短提示,不渲染办理人控件', async () => {
const { modeler, select } = makeModeler();
render(<Eip4Panel modeler={modeler} />);
await select({ id: 'g1', type: 'bpmn:ExclusiveGateway', businessObject: { get: () => undefined } });
expect(screen.getByText(/不是用户任务|仅.*用户任务/)).toBeInTheDocument();
expect(screen.queryByTestId('eip4-candidate-add')).not.toBeInTheDocument();
});
});
describe('Eip4Panel — 办理人(candidateUsers)', () => {
it('顶部灰字提示:引擎以本控件为准', async () => {
const { modeler, select } = makeModeler();
render(<Eip4Panel modeler={modeler} />);
await select(userTask());
expect(screen.getByText(/引擎以本控件为准/)).toBeInTheDocument();
});
it('set:改 content 写回 activiti:candidateUsers(可被 codec 解析)', async () => {
const { modeler, updateProperties, select } = makeModeler();
render(<Eip4Panel modeler={modeler} />);
await select(userTask({ 'activiti:candidateUsers': REAL_CANDIDATE }));
const input = screen.getByTestId('eip4-candidate-content-0');
fireEvent.change(input, { target: { value: 'newUser1,newUser2' } });
const payload = lastPayload(updateProperties);
const written = payload['activiti:candidateUsers'] as string;
const parsed = parseCandidateExpression(written)!;
expect(parsed.items[0].content).toBe('newUser1,newUser2');
expect(parsed.items[0].type).toBe('position');
});
it('🔴 改 items 后 meta 逐字保留(taskSuccessService 等业务字段不丢)', async () => {
const { modeler, updateProperties, select } = makeModeler();
const original = parseCandidateExpression(REAL_CANDIDATE)!;
render(<Eip4Panel modeler={modeler} />);
await select(userTask({ 'activiti:candidateUsers': REAL_CANDIDATE }));
fireEvent.change(screen.getByTestId('eip4-candidate-content-0'), {
target: { value: 'changed' },
});
const written = lastPayload(updateProperties)['activiti:candidateUsers'] as string;
const parsed = parseCandidateExpression(written)!;
// meta 逐字保留
expect(parsed.meta).toEqual(original.meta);
expect(parsed.meta.taskSuccessService).toBe('PM_CONTRACTUALREGISTER_UPDATEPROJECTSTATUS');
// items 确已改
expect(parsed.items[0].content).toBe('changed');
});
it('清空最后一行(meta 为空):无 confirm,直接写回 undefined', async () => {
const { modeler, updateProperties, select } = makeModeler();
render(<Eip4Panel modeler={modeler} />);
await select(userTask({ 'activiti:candidateUsers': candidateNoMeta() }));
fireEvent.click(screen.getByTestId('eip4-candidate-remove-0'));
expect(confirmSpy).not.toHaveBeenCalled();
expect(lastPayload(updateProperties)['activiti:candidateUsers']).toBeUndefined();
expect('activiti:candidateUsers' in lastPayload(updateProperties)).toBe(true);
});
it('I-3 清空含非空业务 meta:confirm=确认 → 写回 undefined', async () => {
const { modeler, updateProperties, select } = makeModeler();
confirmSpy.mockReturnValue(true);
render(<Eip4Panel modeler={modeler} />);
await select(userTask({ 'activiti:candidateUsers': REAL_CANDIDATE }));
fireEvent.click(screen.getByTestId('eip4-candidate-remove-0'));
expect(confirmSpy).toHaveBeenCalledTimes(1);
expect(String(confirmSpy.mock.calls[0][0])).toContain('PM_CONTRACTUALREGISTER_UPDATEPROJECTSTATUS');
expect(lastPayload(updateProperties)['activiti:candidateUsers']).toBeUndefined();
});
it('I-3 清空含非空业务 meta:confirm=取消 → 不写回、行仍在', async () => {
const { modeler, updateProperties, select } = makeModeler();
confirmSpy.mockReturnValue(false);
render(<Eip4Panel modeler={modeler} />);
await select(userTask({ 'activiti:candidateUsers': REAL_CANDIDATE }));
fireEvent.click(screen.getByTestId('eip4-candidate-remove-0'));
expect(confirmSpy).toHaveBeenCalledTimes(1);
expect(updateProperties).not.toHaveBeenCalled(); // 引擎未变
expect(screen.getByTestId('eip4-candidate-content-0')).toBeInTheDocument(); // 行未删
});
it('I-3 非空业务 meta 顶部只读徽标显示任务后置服务', async () => {
const { modeler, select } = makeModeler();
render(<Eip4Panel modeler={modeler} />);
await select(userTask({ 'activiti:candidateUsers': REAL_CANDIDATE }));
const badge = screen.getByTestId('eip4-candidate-meta-badge');
expect(badge.textContent).toContain('PM_CONTRACTUALREGISTER_UPDATEPROJECTSTATUS');
});
it('顺手:非标准办理人表达式显示「编辑将覆盖」警示', async () => {
const { modeler, select } = makeModeler();
render(<Eip4Panel modeler={modeler} />);
await select(userTask({ 'activiti:candidateUsers': '${someOtherExpr(execution)}' }));
expect(screen.getByTestId('eip4-candidate-nonstandard')).toBeInTheDocument();
});
it('增行:改 type 下拉写回对应 type', async () => {
const { modeler, updateProperties, select } = makeModeler();
render(<Eip4Panel modeler={modeler} />);
await select(userTask());
fireEvent.click(screen.getByTestId('eip4-candidate-add'));
fireEvent.change(screen.getByTestId('eip4-candidate-type-0'), {
target: { value: 'scriptUser' },
});
fireEvent.change(screen.getByTestId('eip4-candidate-content-0'), {
target: { value: '${APPLYUSERS}' },
});
const written = lastPayload(updateProperties)['activiti:candidateUsers'] as string;
const parsed = parseCandidateExpression(written)!;
expect(parsed.items[0]).toMatchObject({ type: 'scriptUser', content: '${APPLYUSERS}' });
});
// codec build 对叶子值应用引擎 stringToJson 转义(' → ‘、" → “),防用户输入含撇号/双引号
// 截断外层 JUEL 单引号字面量或内层 JSON。侧板消费 codec 即受保护——断言写回载荷的内容段
// (剥离 JUEL 前后缀定界引号后)无裸 ASCII 撇号、有全角‘。
it("content 含撇号 O'Brien:写回载荷转义为‘、内容段无裸单引号(防截断 JUEL 字面量)", async () => {
const { modeler, updateProperties, select } = makeModeler();
render(<Eip4Panel modeler={modeler} />);
await select(userTask({ 'activiti:candidateUsers': REAL_CANDIDATE }));
fireEvent.change(screen.getByTestId('eip4-candidate-content-0'), {
target: { value: "O'Brien" },
});
const written = lastPayload(updateProperties)['activiti:candidateUsers'] as string;
const PREFIX = "${candidateUsersHandler.getCandidateUsers(execution,'";
const SUFFIX = "')}";
const content = written.slice(PREFIX.length, written.length - SUFFIX.length);
expect(content).toContain('O‘Brien'); // U+2018 全角撇号
expect(content.includes("'")).toBe(false); // 内容段完全无裸 ASCII 单引号
});
});
describe('Eip4Panel — 会签(multiInstance)', () => {
it('开:载荷含 loopCharacteristics(collection multiInstance 前缀+elementVariable+completionCondition 全票预设)', async () => {
const { modeler, updateProperties, select } = makeModeler();
render(<Eip4Panel modeler={modeler} />);
await select(userTask());
fireEvent.click(screen.getByTestId('eip4-cosign-toggle'));
const loop = lastPayload(updateProperties).loopCharacteristics as Record<string, unknown>;
expect(loop).toBeTruthy();
expect(String(loop['activiti:collection'])).toContain('multiInstanceUsersHandler.getUsers');
expect(loop['activiti:elementVariable']).toBe('assignee');
expect((loop.completionCondition as { body: string }).body).toBe(
'${nrOfCompletedInstances/nrOfInstances==1}',
);
expect(loop.isSequential).toBe(false);
});
it('关:已有会签 → 载荷 loopCharacteristics=undefined', async () => {
const { modeler, updateProperties, select } = makeModeler();
const loop = moddleEl('bpmn:MultiInstanceLoopCharacteristics', {
'activiti:collection': extractAttr('activiti:collection'),
'activiti:elementVariable': 'assignee',
completionCondition: { body: '${nrOfCompletedInstances/nrOfInstances==1}' },
});
render(<Eip4Panel modeler={modeler} />);
await select(userTask({ loopCharacteristics: loop }));
// 初始应为开
expect((screen.getByTestId('eip4-cosign-toggle') as HTMLInputElement).checked).toBe(true);
fireEvent.click(screen.getByTestId('eip4-cosign-toggle'));
const payload = lastPayload(updateProperties);
expect('loopCharacteristics' in payload).toBe(true);
expect(payload.loopCharacteristics).toBeUndefined();
});
it('指定数 N:completionCondition body 代入 N', async () => {
const { modeler, updateProperties, select } = makeModeler();
render(<Eip4Panel modeler={modeler} />);
await select(userTask());
fireEvent.click(screen.getByTestId('eip4-cosign-toggle'));
fireEvent.change(screen.getByTestId('eip4-cosign-completion-type'), {
target: { value: 'count' },
});
fireEvent.change(screen.getByTestId('eip4-cosign-completion-n'), { target: { value: '3' } });
const loop = lastPayload(updateProperties).loopCharacteristics as Record<string, unknown>;
expect((loop.completionCondition as { body: string }).body).toBe(
'${nrOfCompletedInstances>=3}',
);
});
it('过半预设:body 为 >0.5', async () => {
const { modeler, updateProperties, select } = makeModeler();
render(<Eip4Panel modeler={modeler} />);
await select(userTask());
fireEvent.click(screen.getByTestId('eip4-cosign-toggle'));
fireEvent.change(screen.getByTestId('eip4-cosign-completion-type'), {
target: { value: 'majority' },
});
const loop = lastPayload(updateProperties).loopCharacteristics as Record<string, unknown>;
expect((loop.completionCondition as { body: string }).body).toBe(
'${nrOfCompletedInstances/nrOfInstances>0.5}',
);
});
// ── I-1 会签保真:读回并原样保留 isSequential / elementVariable / 非预设完成条件 ──────
// 真实库存在 isSequential=true、elementVariable=assign、完成条件 >0.6 等形态;强写会静默改坏。
function cosignLoop() {
return moddleEl('bpmn:MultiInstanceLoopCharacteristics', {
isSequential: true,
'activiti:collection': extractAttr('activiti:collection'),
'activiti:elementVariable': 'assign',
completionCondition: { body: '${nrOfCompletedInstances/nrOfInstances>0.6}' },
});
}
it('I-1 串行会签往返保 isSequential=true(不被强写 false)', async () => {
const { modeler, updateProperties, select } = makeModeler();
render(<Eip4Panel modeler={modeler} />);
await select(userTask({ loopCharacteristics: cosignLoop() }));
expect((screen.getByTestId('eip4-cosign-sequential') as HTMLInputElement).checked).toBe(true);
// 触发一次写(编辑会签人员 content),断言 isSequential 保留 true
fireEvent.change(screen.getByTestId('eip4-cosign-content-0'), { target: { value: 'x' } });
const loop = lastPayload(updateProperties).loopCharacteristics as Record<string, unknown>;
expect(loop.isSequential).toBe(true);
});
it('I-1 elementVariable=assign 往返保 assign(不被强写 assignee)', async () => {
const { modeler, updateProperties, select } = makeModeler();
render(<Eip4Panel modeler={modeler} />);
await select(userTask({ loopCharacteristics: cosignLoop() }));
expect((screen.getByTestId('eip4-cosign-element-variable') as HTMLInputElement).value).toBe('assign');
fireEvent.change(screen.getByTestId('eip4-cosign-content-0'), { target: { value: 'x' } });
const loop = lastPayload(updateProperties).loopCharacteristics as Record<string, unknown>;
expect(loop['activiti:elementVariable']).toBe('assign');
});
it('I-1 非预设完成条件 >0.6 不被归一为全票(自定义态保留原 body)', async () => {
const { modeler, updateProperties, select } = makeModeler();
render(<Eip4Panel modeler={modeler} />);
await select(userTask({ loopCharacteristics: cosignLoop() }));
// 下拉显「自定义(保留)」+ 原 body 展示
expect(screen.getByText(/自定义(保留)/)).toBeInTheDocument();
expect(screen.getByTestId('eip4-cosign-completion-custom').textContent).toContain(
'${nrOfCompletedInstances/nrOfInstances>0.6}',
);
fireEvent.change(screen.getByTestId('eip4-cosign-content-0'), { target: { value: 'x' } });
const loop = lastPayload(updateProperties).loopCharacteristics as Record<string, unknown>;
expect((loop.completionCondition as { body: string }).body).toBe(
'${nrOfCompletedInstances/nrOfInstances>0.6}',
);
});
it('I-1 缺 elementVariable 的会签:写回省略该属性(不凭空写空)', async () => {
const { modeler, updateProperties, select } = makeModeler();
const loop = moddleEl('bpmn:MultiInstanceLoopCharacteristics', {
isSequential: false,
'activiti:collection': extractAttr('activiti:collection'),
// 无 activiti:elementVariable、无 completionCondition
});
render(<Eip4Panel modeler={modeler} />);
await select(userTask({ loopCharacteristics: loop }));
fireEvent.change(screen.getByTestId('eip4-cosign-content-0'), { target: { value: 'x' } });
const written = lastPayload(updateProperties).loopCharacteristics as Record<string, unknown>;
expect('activiti:elementVariable' in written).toBe(false); // 缺省态不写
expect('completionCondition' in written).toBe(false); // 原本无完成条件不发出
});
});
describe('Eip4Panel — formKey', () => {
it('选择模板 → 写回 activiti:formKey=裸 UUID', async () => {
const { modeler, updateProperties, select } = makeModeler();
render(<Eip4Panel modeler={modeler} />);
await select(userTask());
const sel = await screen.findByTestId('eip4-formkey-select');
// 等待模板选项加载
await waitFor(() => expect(sel.querySelectorAll('option').length).toBeGreaterThan(2));
fireEvent.change(sel, { target: { value: 'aaaa-bbbb' } });
expect(lastPayload(updateProperties)['activiti:formKey']).toBe('aaaa-bbbb');
});
it('选「无」→ 写回 undefined 清除', async () => {
const { modeler, updateProperties, select } = makeModeler();
render(<Eip4Panel modeler={modeler} />);
await select(userTask({ 'activiti:formKey': '2098ce21-400b-4425-9c22-63e350974b98' }));
const sel = await screen.findByTestId('eip4-formkey-select');
fireEvent.change(sel, { target: { value: '' } });
const payload = lastPayload(updateProperties);
expect('activiti:formKey' in payload).toBe(true);
expect(payload['activiti:formKey']).toBeUndefined();
});
it('过滤输入实时 filter 选项(名称匹配)', async () => {
const { modeler, select } = makeModeler();
render(<Eip4Panel modeler={modeler} />);
await select(userTask());
const sel = await screen.findByTestId('eip4-formkey-select');
await waitFor(() => expect(sel.querySelectorAll('option').length).toBeGreaterThan(3)); // (无)+3
fireEvent.change(screen.getByTestId('eip4-formkey-filter'), { target: { value: '合同' } });
const opts = Array.from(sel.querySelectorAll('option')).map((o) => o.textContent);
expect(opts).toContain('合同交底表单');
expect(opts).not.toContain('另一个表单');
});
it('未命名项(name===id)显示「<uuid前8>…(未命名)」', async () => {
const { modeler, select } = makeModeler();
render(<Eip4Panel modeler={modeler} />);
await select(userTask());
const sel = await screen.findByTestId('eip4-formkey-select');
await waitFor(() => expect(sel.querySelectorAll('option').length).toBeGreaterThan(3));
const opts = Array.from(sel.querySelectorAll('option')).map((o) => o.textContent);
expect(opts).toContain('deadbeef…(未命名)');
});
it('degraded:显示「模板列表暂不可用」提示', async () => {
mWfTemplates.mockResolvedValueOnce({ templates: [], degraded: true });
const { modeler, select } = makeModeler();
render(<Eip4Panel modeler={modeler} />);
await select(userTask());
expect(await screen.findByTestId('eip4-formkey-degraded')).toBeInTheDocument();
});
it('过滤掉当前值后 select 仍保留该值(占位「(当前)」防丢值)', async () => {
const { modeler, select } = makeModeler();
render(<Eip4Panel modeler={modeler} />);
await select(userTask({ 'activiti:formKey': 'aaaa-bbbb' })); // 当前值=另一个表单
const sel = (await screen.findByTestId('eip4-formkey-select')) as HTMLSelectElement;
await waitFor(() => expect(sel.querySelectorAll('option').length).toBeGreaterThan(3));
// 过滤到「合同」→ aaaa-bbbb(另一个表单)被过滤掉
fireEvent.change(screen.getByTestId('eip4-formkey-filter'), { target: { value: '合同' } });
expect(sel.value).toBe('aaaa-bbbb'); // 值未丢
const cur = Array.from(sel.querySelectorAll('option')).find(
(o) => (o as HTMLOptionElement).value === 'aaaa-bbbb',
);
expect(cur).toBeTruthy();
expect(cur!.textContent).toContain('(当前)');
});
});
describe('Eip4Panel — 扩展属性(长尾 $attrs)', () => {
it('增:填 key/value 后写回命名空间键', async () => {
const { modeler, updateProperties, select } = makeModeler();
render(<Eip4Panel modeler={modeler} />);
await select(userTask());
fireEvent.change(screen.getByTestId('eip4-extattr-new-key'), {
target: { value: 'activiti:custom' },
});
fireEvent.change(screen.getByTestId('eip4-extattr-new-value'), { target: { value: 'v1' } });
fireEvent.click(screen.getByTestId('eip4-extattr-add'));
expect(lastPayload(updateProperties)).toEqual({ 'activiti:custom': 'v1' });
});
it('删:已有扩展属性写回 undefined', async () => {
const { modeler, updateProperties, select } = makeModeler();
render(<Eip4Panel modeler={modeler} />);
await select(userTask({}, { 'activiti:custom': 'v1' }));
expect(screen.getByTestId('eip4-extattr-key-0')).toBeInTheDocument();
fireEvent.click(screen.getByTestId('eip4-extattr-remove-0'));
const payload = lastPayload(updateProperties);
expect('activiti:custom' in payload).toBe(true);
expect(payload['activiti:custom']).toBeUndefined();
});
it('只列 activiti:/flowable: 前缀的 $attrs(其它前缀不显示)', async () => {
const { modeler, select } = makeModeler();
render(<Eip4Panel modeler={modeler} />);
await select(userTask({}, { 'activiti:custom': 'v1', 'xmlns:foo': 'bar' }));
expect(screen.getByTestId('eip4-extattr-key-0')).toHaveValue('activiti:custom');
expect(screen.queryByTestId('eip4-extattr-key-1')).not.toBeInTheDocument();
});
it('顺手:无 activiti:/flowable: 前缀的新键被拒(不写回)', async () => {
const { modeler, updateProperties, select } = makeModeler();
render(<Eip4Panel modeler={modeler} />);
await select(userTask());
fireEvent.change(screen.getByTestId('eip4-extattr-new-key'), { target: { value: 'foo' } });
fireEvent.change(screen.getByTestId('eip4-extattr-new-value'), { target: { value: 'v' } });
fireEvent.click(screen.getByTestId('eip4-extattr-add'));
expect(updateProperties).not.toHaveBeenCalled();
});
it('顺手:拉黑有专用控件的键(activiti:formKey)不允许从扩展属性写', async () => {
const { modeler, updateProperties, select } = makeModeler();
render(<Eip4Panel modeler={modeler} />);
await select(userTask());
fireEvent.change(screen.getByTestId('eip4-extattr-new-key'), {
target: { value: 'activiti:formKey' },
});
fireEvent.change(screen.getByTestId('eip4-extattr-new-value'), { target: { value: 'x' } });
fireEvent.click(screen.getByTestId('eip4-extattr-add'));
expect(updateProperties).not.toHaveBeenCalled();
});
});
describe('Eip4Panel — 任务监听器(taskListener)', () => {
it('增:新监听器写回 extensionElements,并保留已有监听器的 field(引用不动)', async () => {
const { modeler, updateProperties, moddle, select } = makeModeler();
const fieldObj = moddleEl('activiti:Field', { name: 'mailTemplate' });
const existing = moddleEl('activiti:TaskListener', {
event: 'complete',
class: 'com.dsasp.server.wf.user.listener.TaskCompleteListener',
fields: [fieldObj],
});
render(<Eip4Panel modeler={modeler} />);
await select(userTask({ extensionElements: { values: [existing] } }));
// 已有监听器显示 field 徽标
expect(screen.getByText(/含 field 配置/)).toBeInTheDocument();
fireEvent.click(screen.getByTestId('eip4-listener-add'));
const ext = lastPayload(updateProperties).extensionElements as { values: Array<Record<string, unknown>> };
expect(ext.$type).toBe('bpmn:ExtensionElements');
expect(ext.values.length).toBe(2);
// 原监听器被重建但其 fields 数组引用与 field 元素引用原样保留
const withFields = ext.values.find((v) => Array.isArray(v.fields));
expect(withFields).toBeTruthy();
expect((withFields!.fields as unknown[])[0]).toBe(fieldObj);
// moddle.create 被用于构造 taskListener 与 ExtensionElements
expect(moddle.create).toHaveBeenCalledWith('bpmn:ExtensionElements', expect.anything());
});
it('编辑 event 下拉 + class 值写回', async () => {
const { modeler, updateProperties, select } = makeModeler();
render(<Eip4Panel modeler={modeler} />);
await select(userTask());
fireEvent.click(screen.getByTestId('eip4-listener-add'));
fireEvent.change(screen.getByTestId('eip4-listener-event-0'), { target: { value: 'assignment' } });
fireEvent.change(screen.getByTestId('eip4-listener-value-0'), { target: { value: 'com.X.Listener' } });
const ext = lastPayload(updateProperties).extensionElements as { values: Array<Record<string, unknown>> };
const listener = ext.values.find((v) => v.$type === 'activiti:TaskListener')!;
expect(listener.event).toBe('assignment');
expect(listener.class).toBe('com.X.Listener');
});
it('删:移除唯一监听器 → extensionElements=undefined', async () => {
const { modeler, updateProperties, select } = makeModeler();
const existing = moddleEl('activiti:TaskListener', { event: 'create', class: 'com.X' });
render(<Eip4Panel modeler={modeler} />);
await select(userTask({ extensionElements: { values: [existing] } }));
fireEvent.click(screen.getByTestId('eip4-listener-remove-0'));
const payload = lastPayload(updateProperties);
expect('extensionElements' in payload).toBe(true);
expect(payload.extensionElements).toBeUndefined();
});
it('delegateExpression 模式:互斥写回 delegateExpression', async () => {
const { modeler, updateProperties, select } = makeModeler();
render(<Eip4Panel modeler={modeler} />);
await select(userTask());
fireEvent.click(screen.getByTestId('eip4-listener-add'));
fireEvent.change(screen.getByTestId('eip4-listener-mode-0'), {
target: { value: 'delegateExpression' },
});
fireEvent.change(screen.getByTestId('eip4-listener-value-0'), { target: { value: '${bean}' } });
const ext = lastPayload(updateProperties).extensionElements as { values: Array<Record<string, unknown>> };
const listener = ext.values.find((v) => v.$type === 'activiti:TaskListener')!;
expect(listener.delegateExpression).toBe('${bean}');
expect('class' in listener).toBe(false);
});
});
describe('Eip4Panel — 切换节点 / undo-redo 重灌(评审 I-2 + 顺手)', () => {
it('I-2 A(meta X)→B(meta Y)→编辑 B→写回 meta===Y 且 ≠X', async () => {
const { modeler, updateProperties, select } = makeModeler();
const item = (c: string): UserPropertyItem => ({
type: 'user',
content: c,
isCandidate: true,
isSendMail: false,
isSendPhone: false,
isSendMessage: false,
});
const exprA = buildCandidateExpression([item('a')], 'candidate', { taskSuccessService: 'SVC_X' });
const exprB = buildCandidateExpression([item('b')], 'candidate', { taskSuccessService: 'SVC_Y' });
render(<Eip4Panel modeler={modeler} />);
await select(userTask({ __id: 'A', 'activiti:candidateUsers': exprA }));
await select(userTask({ __id: 'B', 'activiti:candidateUsers': exprB }));
// 编辑 B 的 content
fireEvent.change(screen.getByTestId('eip4-candidate-content-0'), { target: { value: 'b2' } });
const written = lastPayload(updateProperties)['activiti:candidateUsers'] as string;
const meta = parseCandidateExpression(written)!.meta;
expect(meta.taskSuccessService).toBe('SVC_Y'); // 用 B 的 meta
expect(meta.taskSuccessService).not.toBe('SVC_X'); // 不串到 A 的 meta
});
it('顺手:commandStack.changed(外部 undo)对当前选中重灌本地态', async () => {
const { modeler, select, fireCommandStack } = makeModeler();
const item = (c: string): UserPropertyItem => ({
type: 'user',
content: c,
isCandidate: true,
isSendMail: false,
isSendPhone: false,
isSendMessage: false,
});
// 可变 map:模拟外部 undo 改写 businessObject。
const map: Record<string, unknown> = {
'activiti:candidateUsers': buildCandidateExpression([item('X')], 'candidate', {}),
};
const el = {
id: 't1',
type: 'bpmn:UserTask',
businessObject: { $type: 'bpmn:UserTask', get: (n: string) => map[n] },
};
render(<Eip4Panel modeler={modeler} />);
await select(el);
expect((screen.getByTestId('eip4-candidate-content-0') as HTMLInputElement).value).toBe('X');
// 外部 undo 改了 businessObject → commandStack.changed → 重灌
map['activiti:candidateUsers'] = buildCandidateExpression([item('Y')], 'candidate', {});
await fireCommandStack();
expect((screen.getByTestId('eip4-candidate-content-0') as HTMLInputElement).value).toBe('Y');
});
});