import { createPinia, setActivePinia } from 'pinia';
|
import { beforeEach, describe, expect, it, vi } from 'vitest';
|
|
import type { TemplateAnnotationClient } from '../../src/api/template-annotation';
|
import { TemplateAnnotationApiError } from '../../src/api/template-annotation';
|
import { useTemplateAnnotator } from '../../src/composables/useTemplateAnnotator';
|
import type {
|
CrossTemplateScalarCandidate,
|
CrossTemplateSourceTemplate,
|
TemplateAnnotationContext,
|
TemplateBinding,
|
TemplateChangeCheck,
|
TemplateFieldOption,
|
TemplateRepairContext,
|
} from '../../src/domain/types';
|
import type { TemplateFormulaBinding } from '../../src/domain/formula-mapping';
|
import type { OnlyOfficeBridge } from '../../src/onlyoffice/bridge';
|
import type { OfficeContentControl } from '../../src/onlyoffice/types';
|
|
function binding(overrides: Partial<TemplateBinding> = {}): TemplateBinding {
|
return {
|
controlAlias: '结果',
|
controlConfig: { placeholder: '请输入' },
|
controlRole: 'PRIMARY',
|
controlTag: 'eln.field.result',
|
controlType: 'TEXT',
|
fieldCode: 'result',
|
fieldId: 'field',
|
fieldVersionId: 'version',
|
id: 'binding',
|
primaryBindingId: null,
|
status: 'PENDING',
|
templateId: 'template',
|
version: 0,
|
...overrides,
|
};
|
}
|
|
const option: TemplateFieldOption = {
|
alias: '结果',
|
controlConfig: { placeholder: '请输入' },
|
fieldCode: 'result',
|
fieldId: 'field',
|
fieldVersionId: 'version',
|
isCurrent: true,
|
label: '结果',
|
required: false,
|
scope: 'GLOBAL',
|
source: 'NONE',
|
type: 'TEXT',
|
versionStatus: 'PUBLISHED',
|
};
|
const crossTemplateCandidate: CrossTemplateScalarCandidate = {
|
sourceFieldCode: 'result',
|
sourceFieldId: 'source-field',
|
sourceFieldName: '来源结果',
|
sourceFieldType: 'TEXT',
|
sourceFieldVersionId: 'source-version',
|
sourceTemplateCode: 'SOURCE-TPL',
|
sourceTemplateId: 'source-template',
|
};
|
const validOptions = {
|
apiBaseUrl: 'http://localhost:30000',
|
documentId: 'file-1',
|
bizDataId: 'record-1',
|
bizModule: 'eln.template',
|
bizScene: 'eln.template.annotate',
|
pluginVersion: '0.1.0',
|
scope: 'onlyoffice:eln-template-annotate',
|
ticket: 'ticket',
|
canAnnotate: true,
|
};
|
|
function annotationContext(overrides: Partial<TemplateAnnotationContext> = {}): TemplateAnnotationContext {
|
return {
|
bindings: [],
|
fields: [],
|
stepConfiguration: {
|
singleStep: true,
|
steps: [{ id: 'step-1', name: '实验步骤', order: 1 }],
|
},
|
templateCode: 'TMP',
|
templateId: 'template',
|
...overrides,
|
} as TemplateAnnotationContext;
|
}
|
|
function check(overrides: Partial<TemplateChangeCheck> = {}): TemplateChangeCheck {
|
return { controls: [], dependencies: [], expectedVersions: { binding: 2 }, operationCode: 'check-op', ...overrides };
|
}
|
|
function formulaBinding(overrides: Partial<TemplateFormulaBinding> = {}): TemplateFormulaBinding {
|
return {
|
formulaVersionId: 'formula-version',
|
id: 'formula-binding',
|
jieguoSuoKuaizhao: [{ bindingId: 'result-binding', controlRole: 'PRIMARY', controlTag: 'eln.field.result', lock: 'unlocked' }],
|
operationCode: 'formula-reserve',
|
parameterBindings: { amount: 'input-binding' },
|
resultBindingId: 'result-binding',
|
status: 'PENDING',
|
version: 1,
|
...overrides,
|
};
|
}
|
|
function createFixture() {
|
let ready: (() => void) | undefined;
|
const order: string[] = [];
|
const bridge: OnlyOfficeBridge = {
|
applyControlPlan: vi.fn(async () => {
|
order.push('document');
|
}),
|
bindLifecycle: vi.fn((callbacks) => {
|
ready = callbacks.onReady;
|
return vi.fn();
|
}),
|
close: vi.fn(),
|
deleteControl: vi.fn(),
|
disableTrackRevisions: vi.fn(async () => {
|
order.push('review');
|
}),
|
getRuntimeOptions: vi.fn(() => validOptions),
|
insertBinding: vi.fn(async () => {
|
order.push('insert');
|
}),
|
insertReadOnlyBinding: vi.fn(async () => {
|
order.push('insert-cross-template');
|
}),
|
insertField: vi.fn(),
|
insertReference: vi.fn(async () => {
|
order.push('insert-reference');
|
}),
|
isFormulaResultLocked: vi.fn(async () => false),
|
listControls: vi.fn(async () => {
|
order.push('list');
|
return [];
|
}),
|
lockFormulaResult: vi.fn(async () => ({ primaryTag: 'eln.field.result', locks: [{ tag: 'eln.field.result', lock: 'unlocked' }] })),
|
readSelectedText: vi.fn(async () => ''),
|
restoreFormulaResultLocks: vi.fn(async () => undefined),
|
unlockFormulaResult: vi.fn(async () => undefined),
|
selectControl: vi.fn(),
|
snapshotControls: vi.fn((bindings: TemplateBinding[], controls: OfficeContentControl[]) => {
|
const bindingIds = new Set(bindings.map((item) => item.id));
|
return controls.flatMap((control) =>
|
control.BindingId && control.Tag && bindingIds.has(control.BindingId) ? [{ bindingId: control.BindingId, controlTag: control.Tag }] : [],
|
);
|
}),
|
};
|
const client: TemplateAnnotationClient = {
|
activateBinding: vi.fn(async () => {
|
order.push('activate');
|
}),
|
cancelBinding: vi.fn(async () => {
|
order.push('cancel');
|
}),
|
changeCheckboxGroup: vi.fn(async (_context, _bindingId, form) =>
|
binding({ checkboxGroupCode: form.checkboxGroupCode, status: 'ACTIVE', version: form.expectedVersion + 1 }),
|
),
|
changeCheckboxGroupRule: vi.fn(async (_context, groupCode, form) => ({
|
groupCode,
|
maxSelected: form.maxSelected,
|
minSelected: form.minSelected,
|
version: form.expectedVersion + 1,
|
})),
|
checkBindingRemoval: vi.fn(async () => check()),
|
checkBindingVersionUpgrade: vi.fn(async () => check()),
|
checkReferencePromotion: vi.fn(async () => check()),
|
confirmBindingRemoval: vi.fn(async () => {
|
order.push('confirm-remove');
|
}),
|
confirmBindingVersionUpgrade: vi.fn(async () => {
|
order.push('confirm-upgrade');
|
}),
|
confirmReferencePromotion: vi.fn(async () => {
|
order.push('confirm-promote');
|
}),
|
confirmRepair: vi.fn(async () => {
|
order.push('confirm-repair');
|
}),
|
confirmVersionCopy: vi.fn(async () => {
|
order.push('confirm-copy');
|
}),
|
fetchAnnotationContext: vi.fn(async () => {
|
order.push('context');
|
return annotationContext();
|
}),
|
fetchCrossTemplateScalarCandidates: vi.fn(async () => []),
|
fetchCrossTemplateSourceTemplates: vi.fn(async () => []),
|
fetchRepairContext: vi.fn(async () => ({ ...check(), binding: binding({ status: 'ACTIVE', version: 2 }) })),
|
reservePrimaryBinding: vi.fn(async () => {
|
order.push('reserve');
|
return binding();
|
}),
|
reserveCrossTemplateScalarBinding: vi.fn(async () => {
|
order.push('reserve-cross-template');
|
return binding({ id: 'cross-binding', readOnly: true, valueSource: 'CROSS_TEMPLATE' });
|
}),
|
reservePrivateField: vi.fn(async () => {
|
order.push('reserve-private');
|
return binding({ fieldId: 'private' });
|
}),
|
reserveReferenceBinding: vi.fn(async () => {
|
order.push('reserve-reference');
|
return binding({ controlRole: 'REFERENCE', controlTag: 'eln.ref.result.abc', id: 'reference', primaryBindingId: 'binding' });
|
}),
|
activateFormulaBinding: vi.fn(async () => {
|
order.push('activate-formula');
|
}),
|
cancelFormulaBinding: vi.fn(async () => {
|
order.push('cancel-formula');
|
}),
|
checkFormulaBindingRemoval: vi.fn(async () => ({
|
downstreamFormulaBindingIds: [],
|
expectedVersions: { 'formula-binding': 1 },
|
operationCode: 'remove-formula',
|
})),
|
checkFormulaBindingUpgrade: vi.fn(async () => ({
|
downstreamFormulaBindingIds: [],
|
expectedVersions: { 'formula-binding': 1 },
|
operationCode: 'upgrade-formula',
|
})),
|
confirmFormulaBindingRemoval: vi.fn(async () => {
|
order.push('confirm-remove-formula');
|
}),
|
confirmFormulaBindingUpgrade: vi.fn(async () => {
|
order.push('confirm-upgrade-formula');
|
}),
|
confirmFormulaVersionCopy: vi.fn(async () => {
|
order.push('confirm-copy-formula');
|
}),
|
fetchFormulaMappings: vi.fn(async () => ({ bindings: [], versions: [] })),
|
reserveFormulaBinding: vi.fn(async () => {
|
order.push('reserve-formula');
|
return formulaBinding();
|
}),
|
suggestCode: vi.fn(async () => 'jianyan_jieguo'),
|
};
|
return { bridge, client, order, ready: () => ready?.() };
|
}
|
|
describe('useTemplateAnnotator binding workflow', () => {
|
beforeEach(() => setActivePinia(createPinia()));
|
|
it('使用当前插件 Ticket 上下文请求编码建议', async () => {
|
const fixture = createFixture();
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
|
await expect(api.suggestCode('检验结果')).resolves.toBe('jianyan_jieguo');
|
|
expect(fixture.client.suggestCode).toHaveBeenCalledWith(
|
expect.objectContaining({ apiBaseUrl: validOptions.apiBaseUrl, ticket: validOptions.ticket }),
|
{ text: '检验结果' },
|
);
|
});
|
|
it('公式 reserve 后锁定结果控件并确认 activate，保存请求不含表达式或计算结果', async () => {
|
const fixture = createFixture();
|
const result = binding({ id: 'result-binding', status: 'ACTIVE' });
|
vi.mocked(fixture.client.fetchAnnotationContext).mockResolvedValue(annotationContext({ bindings: [result] }));
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
|
await api.reserveFormulaBinding({ formulaVersionId: 'formula-version', parameterBindings: { amount: 'input-binding' }, resultBindingId: result.id });
|
|
expect(fixture.client.reserveFormulaBinding).toHaveBeenCalledWith(expect.anything(), {
|
formulaVersionId: 'formula-version',
|
parameterBindings: { amount: 'input-binding' },
|
resultBindingId: result.id,
|
operationCode: expect.any(String),
|
jieguoSuoKuaizhao: [{ bindingId: result.id, controlRole: 'PRIMARY', controlTag: result.controlTag, lock: 'unlocked' }],
|
});
|
expect(fixture.bridge.lockFormulaResult).toHaveBeenCalledWith('eln.field.result');
|
expect(fixture.client.activateFormulaBinding).toHaveBeenCalledWith(expect.anything(), 'formula-binding', {
|
controls: [{ bindingId: result.id, controlRole: 'PRIMARY', controlTag: result.controlTag, lock: 'sdtContentLocked' }],
|
expectedVersion: 1,
|
operationCode: 'formula-reserve',
|
});
|
});
|
|
it('公式 activate 失败时先恢复锁再 cancel PENDING', async () => {
|
const fixture = createFixture();
|
const result = binding({ id: 'result-binding', status: 'ACTIVE' });
|
vi.mocked(fixture.client.fetchAnnotationContext).mockResolvedValue(annotationContext({ bindings: [result] }));
|
vi.mocked(fixture.client.activateFormulaBinding).mockRejectedValue(new Error('activate failed'));
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
|
await expect(api.reserveFormulaBinding({ formulaVersionId: 'formula-version', parameterBindings: {}, resultBindingId: result.id })).rejects.toThrow(
|
'activate failed',
|
);
|
|
expect(fixture.bridge.restoreFormulaResultLocks).toHaveBeenCalledBefore(fixture.client.cancelFormulaBinding as ReturnType<typeof vi.fn>);
|
expect(fixture.client.cancelFormulaBinding).toHaveBeenCalledOnce();
|
});
|
|
it('公式 activate 返回过期 Ticket 后不恢复控件或发送 cancel', async () => {
|
const fixture = createFixture();
|
const result = binding({ id: 'result-binding', status: 'ACTIVE' });
|
vi.mocked(fixture.client.fetchAnnotationContext).mockResolvedValue(annotationContext({ bindings: [result] }));
|
vi.mocked(fixture.client.activateFormulaBinding).mockRejectedValue(new TemplateAnnotationApiError(401, 'Ticket 已过期'));
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
|
await expect(api.reserveFormulaBinding({ formulaVersionId: 'formula-version', parameterBindings: {}, resultBindingId: result.id })).rejects.toThrow(
|
'Ticket 已过期',
|
);
|
|
expect(fixture.bridge.restoreFormulaResultLocks).not.toHaveBeenCalled();
|
expect(fixture.client.cancelFormulaBinding).not.toHaveBeenCalled();
|
});
|
|
it('启动时对已完整锁定的公式 PENDING 使用原操作码 activate，不重复 reserve', async () => {
|
const fixture = createFixture();
|
const result = binding({ id: 'result-binding', status: 'ACTIVE' });
|
const pending = formulaBinding();
|
vi.mocked(fixture.client.fetchAnnotationContext).mockResolvedValue(annotationContext({ bindings: [result] }));
|
vi.mocked(fixture.client.fetchFormulaMappings).mockResolvedValue({ bindings: [pending], versions: [] });
|
vi.mocked(fixture.bridge.isFormulaResultLocked).mockResolvedValue(true);
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
|
expect(fixture.client.activateFormulaBinding).toHaveBeenCalledWith(
|
expect.anything(),
|
pending.id,
|
expect.objectContaining({ operationCode: pending.operationCode }),
|
);
|
expect(fixture.client.reserveFormulaBinding).not.toHaveBeenCalled();
|
expect(api.formulaBindings[0]?.status).toBe('ACTIVE');
|
});
|
|
it('启动时对锁不完整的公式 PENDING 先恢复服务端快照再 cancel', async () => {
|
const fixture = createFixture();
|
const result = binding({ id: 'result-binding', status: 'ACTIVE' });
|
const pending = formulaBinding();
|
vi.mocked(fixture.client.fetchAnnotationContext).mockResolvedValue(annotationContext({ bindings: [result] }));
|
vi.mocked(fixture.client.fetchFormulaMappings).mockResolvedValue({ bindings: [pending], versions: [] });
|
vi.mocked(fixture.bridge.isFormulaResultLocked).mockResolvedValue(false);
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
|
expect(fixture.bridge.restoreFormulaResultLocks).toHaveBeenCalledWith({
|
primaryTag: result.controlTag,
|
locks: [{ tag: result.controlTag, lock: 'unlocked' }],
|
});
|
expect(fixture.bridge.restoreFormulaResultLocks).toHaveBeenCalledBefore(fixture.client.cancelFormulaBinding as ReturnType<typeof vi.fn>);
|
expect(fixture.client.cancelFormulaBinding).toHaveBeenCalledWith(expect.anything(), pending.id, {
|
expectedVersion: pending.version,
|
operationCode: pending.operationCode,
|
reason: 'PENDING_LOCK_INCOMPLETE',
|
});
|
expect(api.formulaBindings[0]?.status).toBe('CANCELLED');
|
});
|
|
it('启动时服务端快照恢复失败则保留 PENDING 且不 cancel', async () => {
|
const fixture = createFixture();
|
const result = binding({ id: 'result-binding', status: 'ACTIVE' });
|
const pending = formulaBinding();
|
vi.mocked(fixture.client.fetchAnnotationContext).mockResolvedValue(annotationContext({ bindings: [result] }));
|
vi.mocked(fixture.client.fetchFormulaMappings).mockResolvedValue({ bindings: [pending], versions: [] });
|
vi.mocked(fixture.bridge.isFormulaResultLocked).mockResolvedValue(false);
|
vi.mocked(fixture.bridge.restoreFormulaResultLocks).mockRejectedValue(new Error('恢复锁失败'));
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
|
expect(fixture.client.cancelFormulaBinding).not.toHaveBeenCalled();
|
expect(api.formulaBindings[0]?.status).toBe('PENDING');
|
expect(api.store.operation).toMatchObject({ kind: 'error', message: expect.stringContaining('需对账') });
|
});
|
|
it('启动时缺少服务端快照的锁不完整 PENDING 保持待对账', async () => {
|
const fixture = createFixture();
|
const result = binding({ id: 'result-binding', status: 'ACTIVE' });
|
const pending = formulaBinding({ jieguoSuoKuaizhao: [] });
|
vi.mocked(fixture.client.fetchAnnotationContext).mockResolvedValue(annotationContext({ bindings: [result] }));
|
vi.mocked(fixture.client.fetchFormulaMappings).mockResolvedValue({ bindings: [pending], versions: [] });
|
vi.mocked(fixture.bridge.isFormulaResultLocked).mockResolvedValue(false);
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
|
expect(fixture.bridge.restoreFormulaResultLocks).not.toHaveBeenCalled();
|
expect(fixture.client.cancelFormulaBinding).not.toHaveBeenCalled();
|
expect(api.formulaBindings[0]?.status).toBe('PENDING');
|
expect(api.store.operation).toMatchObject({ kind: 'error', message: expect.stringContaining('需对账') });
|
});
|
|
it('公式 PENDING activate 的 Ticket 过期后停止后续写入', async () => {
|
const fixture = createFixture();
|
const result = binding({ id: 'result-binding', status: 'ACTIVE' });
|
const pending = formulaBinding();
|
vi.mocked(fixture.client.fetchAnnotationContext).mockResolvedValue(annotationContext({ bindings: [result] }));
|
vi.mocked(fixture.client.fetchFormulaMappings).mockResolvedValue({ bindings: [pending], versions: [] });
|
vi.mocked(fixture.bridge.isFormulaResultLocked).mockResolvedValue(true);
|
vi.mocked(fixture.client.activateFormulaBinding).mockRejectedValue(new TemplateAnnotationApiError(401, 'Ticket 已过期'));
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('error'));
|
|
expect(fixture.client.cancelFormulaBinding).not.toHaveBeenCalled();
|
expect(api.contextStore.context).toBeNull();
|
});
|
|
it('启动时只对跨模板标识且已完整锁定的 PENDING 绑定 activate，不重复 reserve', async () => {
|
const fixture = createFixture();
|
const pending = binding({ id: 'cross-pending', readOnly: true, status: 'PENDING', valueSource: 'CROSS_TEMPLATE', version: 3 });
|
vi.mocked(fixture.client.fetchAnnotationContext).mockResolvedValue(annotationContext({ bindings: [pending] }));
|
vi.mocked(fixture.bridge.listControls).mockResolvedValue([{ BindingId: pending.id, Lock: 'sdtContentLocked', Tag: pending.controlTag }]);
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
|
expect(fixture.client.activateBinding).toHaveBeenCalledWith(expect.anything(), pending.id, { operationCode: expect.any(String) });
|
expect(fixture.client.reserveCrossTemplateScalarBinding).not.toHaveBeenCalled();
|
expect(api.bindings[0]).toMatchObject({ id: pending.id, status: 'ACTIVE' });
|
});
|
|
it('启动时跨模板 PENDING 锁不完整则先删除控件再 cancel', async () => {
|
const fixture = createFixture();
|
const pending = binding({ id: 'cross-pending', readOnly: true, status: 'PENDING', valueSource: 'CROSS_TEMPLATE', version: 3 });
|
vi.mocked(fixture.client.fetchAnnotationContext).mockResolvedValue(annotationContext({ bindings: [pending] }));
|
vi.mocked(fixture.bridge.listControls).mockResolvedValue([{ InternalId: 'cross-control', Lock: 'unlocked', Tag: pending.controlTag }]);
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
|
expect(fixture.bridge.deleteControl).toHaveBeenCalledWith('cross-control');
|
expect(fixture.bridge.deleteControl).toHaveBeenCalledBefore(fixture.client.cancelBinding as ReturnType<typeof vi.fn>);
|
expect(fixture.client.cancelBinding).toHaveBeenCalledWith(expect.anything(), pending.id, {
|
operationCode: expect.any(String),
|
reason: 'PENDING_LOCK_INCOMPLETE',
|
});
|
expect(api.bindings[0]).toMatchObject({ id: pending.id, status: 'CANCELLED' });
|
});
|
|
it('公式复制 PENDING 仅在全部结果锁已确认后批量 confirm', async () => {
|
const fixture = createFixture();
|
const result = binding({ id: 'result-binding', status: 'ACTIVE' });
|
const copied = formulaBinding({ id: 'copied-formula', operationCode: 'copy-op' });
|
vi.mocked(fixture.client.fetchAnnotationContext).mockResolvedValue(annotationContext({ bindings: [result] }));
|
vi.mocked(fixture.client.fetchFormulaMappings).mockResolvedValue({
|
bindings: [copied],
|
copiedPendingBindingIds: [copied.id],
|
upgradeOperationCode: 'copy-op',
|
versions: [],
|
});
|
vi.mocked(fixture.bridge.isFormulaResultLocked).mockResolvedValue(true);
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
|
expect(fixture.client.confirmFormulaVersionCopy).toHaveBeenCalledWith(expect.anything(), {
|
controls: [{ bindingId: result.id, controlRole: 'PRIMARY', controlTag: result.controlTag, lock: 'sdtContentLocked' }],
|
expectedVersions: { [copied.id]: copied.version },
|
upgradeOperationCode: 'copy-op',
|
});
|
expect(fixture.client.reserveFormulaBinding).not.toHaveBeenCalled();
|
expect(api.formulaBindings[0]?.status).toBe('ACTIVE');
|
});
|
|
it('升级锁定新结果后锁旧结果失败时立即恢复新结果', async () => {
|
const fixture = createFixture();
|
const oldResult = binding({ id: 'old-result', status: 'ACTIVE', controlTag: 'eln.field.old' });
|
const newResult = binding({ id: 'new-result', status: 'ACTIVE', controlTag: 'eln.field.new' });
|
const current = formulaBinding({ id: 'formula-binding', resultBindingId: oldResult.id, status: 'ACTIVE' });
|
vi.mocked(fixture.client.fetchAnnotationContext).mockResolvedValue(annotationContext({ bindings: [oldResult, newResult] }));
|
vi.mocked(fixture.client.fetchFormulaMappings).mockResolvedValue({ bindings: [current], versions: [] });
|
vi.mocked(fixture.client.checkFormulaBindingUpgrade).mockResolvedValue({
|
downstreamFormulaBindingIds: [],
|
expectedVersions: { [current.id]: current.version },
|
operationCode: 'upgrade-op',
|
});
|
const newSnapshot = { primaryTag: newResult.controlTag, locks: [{ tag: newResult.controlTag, lock: 'unlocked' }] };
|
vi.mocked(fixture.bridge.lockFormulaResult).mockResolvedValueOnce(newSnapshot).mockRejectedValueOnce(new Error('旧结果锁失败'));
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
|
await expect(
|
api.upgradeFormulaBinding(current.id, { formulaVersionId: 'formula-version-2', parameterBindings: {}, resultBindingId: newResult.id }),
|
).rejects.toThrow('旧结果锁失败');
|
|
expect(fixture.bridge.restoreFormulaResultLocks).toHaveBeenCalledWith(newSnapshot);
|
expect(fixture.client.confirmFormulaBindingUpgrade).not.toHaveBeenCalled();
|
});
|
|
it('公式升级预检失败后恢复可操作状态并展示完整原因', async () => {
|
const fixture = createFixture();
|
const result = binding({ id: 'result-binding', status: 'ACTIVE' });
|
const current = formulaBinding({ id: 'formula-binding', resultBindingId: result.id, status: 'ACTIVE' });
|
vi.mocked(fixture.client.fetchAnnotationContext).mockResolvedValue(annotationContext({ bindings: [result] }));
|
vi.mocked(fixture.client.fetchFormulaMappings).mockResolvedValue({ bindings: [current], versions: [] });
|
vi.mocked(fixture.client.checkFormulaBindingUpgrade).mockRejectedValue(new TemplateAnnotationApiError(422, '公式依赖存在循环: [公式A, 公式B, 公式A]'));
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
|
await expect(
|
api.upgradeFormulaBinding(current.id, {
|
formulaVersionId: 'formula-version-2',
|
parameterBindings: {},
|
resultBindingId: result.id,
|
}),
|
).rejects.toThrow('公式依赖存在循环: [公式A, 公式B, 公式A]');
|
|
expect(api.store.status).toBe('ready');
|
expect(api.store.operation).toEqual({ kind: 'error', message: '公式依赖存在循环: [公式A, 公式B, 公式A]' });
|
});
|
|
it('公式升级 confirm 响应丢失时使用同一操作码重试且不恢复结果锁', async () => {
|
const fixture = createFixture();
|
const oldResult = binding({ id: 'old-result', status: 'ACTIVE', controlTag: 'eln.field.old' });
|
const newResult = binding({ id: 'new-result', status: 'ACTIVE', controlTag: 'eln.field.new' });
|
const current = formulaBinding({ id: 'formula-binding', resultBindingId: oldResult.id, status: 'ACTIVE' });
|
vi.mocked(fixture.client.fetchAnnotationContext).mockResolvedValue(annotationContext({ bindings: [oldResult, newResult] }));
|
vi.mocked(fixture.client.fetchFormulaMappings).mockResolvedValue({ bindings: [current], versions: [] });
|
vi.mocked(fixture.client.checkFormulaBindingUpgrade).mockResolvedValue({
|
downstreamFormulaBindingIds: [],
|
expectedVersions: { [current.id]: current.version },
|
operationCode: 'upgrade-op',
|
});
|
vi.mocked(fixture.client.confirmFormulaBindingUpgrade).mockRejectedValueOnce(new TypeError('Failed to fetch')).mockResolvedValueOnce(undefined);
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
|
await api.upgradeFormulaBinding(current.id, { formulaVersionId: 'formula-version-2', parameterBindings: {}, resultBindingId: newResult.id });
|
|
expect(fixture.client.confirmFormulaBindingUpgrade).toHaveBeenCalledTimes(2);
|
expect(vi.mocked(fixture.client.confirmFormulaBindingUpgrade).mock.calls[0]?.[2]?.operationCode).toBe('upgrade-op');
|
expect(vi.mocked(fixture.client.confirmFormulaBindingUpgrade).mock.calls[1]?.[2]?.operationCode).toBe('upgrade-op');
|
expect(fixture.bridge.restoreFormulaResultLocks).not.toHaveBeenCalled();
|
expect(api.formulaBindings[0]?.status).toBe('ACTIVE');
|
});
|
|
it('公式升级 confirm 连续响应丢失后保留结果锁并恢复可操作状态', async () => {
|
const fixture = createFixture();
|
const oldResult = binding({ id: 'old-result', status: 'ACTIVE', controlTag: 'eln.field.old' });
|
const newResult = binding({ id: 'new-result', status: 'ACTIVE', controlTag: 'eln.field.new' });
|
const current = formulaBinding({ id: 'formula-binding', resultBindingId: oldResult.id, status: 'ACTIVE' });
|
vi.mocked(fixture.client.fetchAnnotationContext).mockResolvedValue(annotationContext({ bindings: [oldResult, newResult] }));
|
vi.mocked(fixture.client.fetchFormulaMappings).mockResolvedValue({ bindings: [current], versions: [] });
|
vi.mocked(fixture.client.checkFormulaBindingUpgrade).mockResolvedValue({
|
downstreamFormulaBindingIds: [],
|
expectedVersions: { [current.id]: current.version },
|
operationCode: 'upgrade-op',
|
});
|
vi.mocked(fixture.client.confirmFormulaBindingUpgrade)
|
.mockRejectedValueOnce(new TypeError('Failed to fetch'))
|
.mockRejectedValueOnce(new TypeError('Failed to fetch'));
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
|
await expect(
|
api.upgradeFormulaBinding(current.id, { formulaVersionId: 'formula-version-2', parameterBindings: {}, resultBindingId: newResult.id }),
|
).rejects.toThrow('待确认');
|
|
expect(fixture.client.confirmFormulaBindingUpgrade).toHaveBeenCalledTimes(2);
|
expect(vi.mocked(fixture.client.confirmFormulaBindingUpgrade).mock.calls.map((call) => call[2].operationCode)).toEqual(['upgrade-op', 'upgrade-op']);
|
expect(fixture.bridge.restoreFormulaResultLocks).not.toHaveBeenCalled();
|
expect(api.store.status).toBe('ready');
|
expect(api.store.operation).toMatchObject({ kind: 'error', message: expect.stringContaining('待对账') });
|
expect(api.formulaBindings[0]).toMatchObject({ id: current.id, resultBindingId: oldResult.id, status: 'ACTIVE' });
|
});
|
|
it('刷新会重新读取服务端公式映射以完成公式升级对账', async () => {
|
const fixture = createFixture();
|
const oldResult = binding({ id: 'old-result', status: 'ACTIVE', controlTag: 'eln.field.old' });
|
const newResult = binding({ id: 'new-result', status: 'ACTIVE', controlTag: 'eln.field.new' });
|
const current = formulaBinding({ id: 'formula-binding', resultBindingId: oldResult.id, status: 'ACTIVE' });
|
const committed = formulaBinding({
|
formulaVersionId: 'formula-version-2',
|
id: current.id,
|
resultBindingId: newResult.id,
|
status: 'ACTIVE',
|
version: current.version + 1,
|
});
|
vi.mocked(fixture.client.fetchAnnotationContext)
|
.mockResolvedValueOnce(annotationContext({ bindings: [oldResult, newResult] }))
|
.mockResolvedValueOnce(annotationContext({ bindings: [oldResult, newResult] }));
|
vi.mocked(fixture.client.fetchFormulaMappings)
|
.mockResolvedValueOnce({ bindings: [current], versions: [] })
|
.mockResolvedValueOnce({ bindings: [committed], versions: [] });
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
|
await api.refresh();
|
|
expect(fixture.client.fetchAnnotationContext).toHaveBeenCalledTimes(2);
|
expect(fixture.client.fetchFormulaMappings).toHaveBeenCalledTimes(2);
|
expect(api.formulaBindings[0]).toMatchObject({
|
formulaVersionId: committed.formulaVersionId,
|
id: committed.id,
|
resultBindingId: newResult.id,
|
status: 'ACTIVE',
|
version: committed.version,
|
});
|
});
|
|
it('刷新步骤配置时保留有效选择，并清空已失效的当前步骤', async () => {
|
const fixture = createFixture();
|
const initial = annotationContext({
|
stepConfiguration: {
|
singleStep: false,
|
steps: [
|
{ id: 'step-1', name: '称量', order: 1 },
|
{ id: 'step-2', name: '溶解', order: 2 },
|
],
|
},
|
} as Partial<TemplateAnnotationContext>);
|
const withoutSelectedStep = annotationContext({
|
stepConfiguration: {
|
singleStep: false,
|
steps: [{ id: 'step-1', name: '称量', order: 1 }],
|
},
|
} as Partial<TemplateAnnotationContext>);
|
vi.mocked(fixture.client.fetchAnnotationContext).mockResolvedValueOnce(initial).mockResolvedValueOnce(initial).mockResolvedValueOnce(withoutSelectedStep);
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
api.setCurrentStepId('step-2');
|
|
await api.refresh();
|
expect(api.currentStepId).toBe('step-2');
|
|
await api.refresh();
|
expect(api.currentStepId).toBeNull();
|
});
|
|
it('删除仍被下游公式引用的映射时不解除任何结果锁', async () => {
|
const fixture = createFixture();
|
const result = binding({ id: 'result-binding', status: 'ACTIVE' });
|
const current = formulaBinding({ id: 'formula-binding', resultBindingId: result.id, status: 'ACTIVE' });
|
vi.mocked(fixture.client.fetchAnnotationContext).mockResolvedValue(annotationContext({ bindings: [result] }));
|
vi.mocked(fixture.client.fetchFormulaMappings).mockResolvedValue({ bindings: [current], versions: [] });
|
vi.mocked(fixture.client.checkFormulaBindingRemoval).mockResolvedValue({
|
downstreamFormulaBindingIds: ['downstream-formula'],
|
expectedVersions: { [current.id]: current.version },
|
operationCode: 'remove-formula',
|
});
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
|
await expect(api.removeFormulaBinding(current.id)).rejects.toThrow('公式结果仍被下游公式引用');
|
|
expect(fixture.bridge.lockFormulaResult).not.toHaveBeenCalled();
|
expect(fixture.bridge.unlockFormulaResult).not.toHaveBeenCalled();
|
expect(fixture.client.confirmFormulaBindingRemoval).not.toHaveBeenCalled();
|
});
|
|
it('SDK ready 先关闭修订再读取模板标注，避免写操作前打断用户选择', async () => {
|
const fixture = createFixture();
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
expect(fixture.order).toEqual(['review', 'list', 'context']);
|
expect(fixture.bridge.disableTrackRevisions).toHaveBeenCalledOnce();
|
expect(fixture.client.fetchAnnotationContext).toHaveBeenCalledWith(expect.objectContaining({ ticket: 'ticket' }));
|
});
|
|
it('重复 SDK ready 复用同一个修订关闭操作', async () => {
|
const fixture = createFixture();
|
let completeReview!: () => void;
|
vi.mocked(fixture.bridge.disableTrackRevisions).mockImplementation(
|
() =>
|
new Promise<void>((resolve) => {
|
completeReview = resolve;
|
}),
|
);
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
|
fixture.ready();
|
fixture.ready();
|
await vi.waitFor(() => expect(fixture.bridge.disableTrackRevisions).toHaveBeenCalledOnce());
|
completeReview();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
|
expect(fixture.bridge.disableTrackRevisions).toHaveBeenCalledOnce();
|
});
|
|
it('只读定位模式仅枚举并唯一定位，不创建 API 上下文或关闭修订', async () => {
|
const fixture = createFixture();
|
const { scope: _scope, ticket: _ticket, ...locateOptions } = validOptions;
|
vi.mocked(fixture.bridge.getRuntimeOptions).mockReturnValue({ ...locateOptions, canAnnotate: false, locateControlTag: 'eln.field.orphan' });
|
vi.mocked(fixture.bridge.listControls).mockResolvedValue([{ InternalId: 'orphan-control', Tag: 'eln.field.orphan' }]);
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
|
expect(fixture.bridge.selectControl).toHaveBeenCalledWith('orphan-control', expect.any(AbortSignal));
|
expect(fixture.bridge.disableTrackRevisions).not.toHaveBeenCalled();
|
expect(fixture.client.fetchAnnotationContext).not.toHaveBeenCalled();
|
expect(fixture.client.fetchRepairContext).not.toHaveBeenCalled();
|
expect(fixture.client.activateBinding).not.toHaveBeenCalled();
|
expect(fixture.client.cancelBinding).not.toHaveBeenCalled();
|
expect(fixture.client.checkBindingRemoval).not.toHaveBeenCalled();
|
expect(fixture.client.checkBindingVersionUpgrade).not.toHaveBeenCalled();
|
expect(fixture.client.checkReferencePromotion).not.toHaveBeenCalled();
|
expect(fixture.client.confirmBindingRemoval).not.toHaveBeenCalled();
|
expect(fixture.client.confirmBindingVersionUpgrade).not.toHaveBeenCalled();
|
expect(fixture.client.confirmReferencePromotion).not.toHaveBeenCalled();
|
expect(fixture.client.confirmRepair).not.toHaveBeenCalled();
|
expect(fixture.client.reservePrimaryBinding).not.toHaveBeenCalled();
|
expect(fixture.client.reservePrivateField).not.toHaveBeenCalled();
|
expect(fixture.client.reserveReferenceBinding).not.toHaveBeenCalled();
|
expect(fixture.client.confirmVersionCopy).not.toHaveBeenCalled();
|
|
await api.refresh();
|
expect(fixture.bridge.listControls).toHaveBeenCalledTimes(2);
|
expect(fixture.bridge.selectControl).toHaveBeenCalledTimes(2);
|
expect(fixture.client.fetchAnnotationContext).not.toHaveBeenCalled();
|
});
|
|
it('纯定位 initialize 的枚举在 dispose 后返回时不再定位控件', async () => {
|
const fixture = createFixture();
|
let resolveControls!: (controls: OfficeContentControl[]) => void;
|
vi.mocked(fixture.bridge.getRuntimeOptions).mockReturnValue({ ...validOptions, canAnnotate: false, locateControlTag: 'eln.field.orphan' });
|
vi.mocked(fixture.bridge.listControls).mockReturnValue(
|
new Promise((done) => {
|
resolveControls = done;
|
}),
|
);
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(fixture.bridge.listControls).toHaveBeenCalledOnce());
|
|
api.dispose();
|
resolveControls([{ InternalId: 'orphan-control', Tag: 'eln.field.orphan' }]);
|
await new Promise((done) => setTimeout(done, 0));
|
|
expect(fixture.bridge.selectControl).not.toHaveBeenCalled();
|
});
|
|
it.each([
|
['不存在', [], '不存在'],
|
[
|
'出现多次',
|
[
|
{ InternalId: 'first', Tag: 'eln.field.orphan' },
|
{ InternalId: 'second', Tag: 'eln.field.orphan' },
|
],
|
'出现多次',
|
],
|
])('只读定位刷新目标%s时只报告本地诊断', async (_label, refreshControls, diagnostic) => {
|
const fixture = createFixture();
|
vi.mocked(fixture.bridge.getRuntimeOptions).mockReturnValue({ ...validOptions, canAnnotate: false, locateControlTag: 'eln.field.orphan' });
|
vi.mocked(fixture.bridge.listControls)
|
.mockResolvedValueOnce([{ InternalId: 'orphan-control', Tag: 'eln.field.orphan' }])
|
.mockResolvedValueOnce(refreshControls);
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
|
await expect(api.refresh()).rejects.toThrow(diagnostic);
|
|
expect(api.store.operation.message).toContain(diagnostic);
|
expect(fixture.client.fetchAnnotationContext).not.toHaveBeenCalled();
|
expect(fixture.client.fetchRepairContext).not.toHaveBeenCalled();
|
});
|
|
it.each([
|
['不存在', [], '不存在'],
|
[
|
'出现多次',
|
[
|
{ InternalId: 'first', Tag: 'eln.field.orphan' },
|
{ InternalId: 'second', Tag: 'eln.field.orphan' },
|
],
|
'出现多次',
|
],
|
])('只读定位目标%s时明确失败', async (_label, controls, diagnostic) => {
|
const fixture = createFixture();
|
vi.mocked(fixture.bridge.getRuntimeOptions).mockReturnValue({ ...validOptions, canAnnotate: false, locateControlTag: 'eln.field.orphan' });
|
vi.mocked(fixture.bridge.listControls).mockResolvedValue(controls);
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('error'));
|
|
expect(api.store.operation.message).toContain(diagnostic);
|
expect(fixture.bridge.selectControl).not.toHaveBeenCalled();
|
expect(fixture.client.fetchAnnotationContext).not.toHaveBeenCalled();
|
expect(fixture.client.fetchRepairContext).not.toHaveBeenCalled();
|
});
|
|
it('固定执行 reserve→插入→重新枚举确认 0→1→activate', async () => {
|
const fixture = createFixture();
|
vi.mocked(fixture.bridge.listControls)
|
.mockResolvedValueOnce([])
|
.mockResolvedValueOnce([])
|
.mockResolvedValueOnce([{ Tag: 'eln.field.result', BindingId: 'binding' }]);
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
fixture.order.splice(0);
|
await api.insertSelectedField(option);
|
expect(fixture.order).toEqual(['reserve', 'insert', 'activate']);
|
const calls = [
|
vi.mocked(fixture.client.reservePrimaryBinding).mock.invocationCallOrder[0]!,
|
vi.mocked(fixture.bridge.listControls).mock.invocationCallOrder[1]!,
|
vi.mocked(fixture.bridge.insertBinding).mock.invocationCallOrder[0]!,
|
vi.mocked(fixture.bridge.listControls).mock.invocationCallOrder[2]!,
|
vi.mocked(fixture.client.activateBinding).mock.invocationCallOrder[0]!,
|
];
|
expect(calls).toEqual([...calls].sort((left, right) => left - right));
|
});
|
|
it('复选框标注携带选择组规则，改组和改规则只更新元数据而不写 DOCX', async () => {
|
const fixture = createFixture();
|
const checkbox = { ...option, fieldCode: 'passed_new', fieldId: 'passed-new-field', fieldVersionId: 'passed-new-version', type: 'CHECKBOX' as const };
|
const active = binding({
|
checkboxGroupCode: 'inspection_result',
|
controlTag: 'eln.field.passed',
|
controlType: 'CHECKBOX',
|
fieldCode: 'passed',
|
fieldId: 'passed-field',
|
fieldVersionId: 'passed-version',
|
status: 'ACTIVE',
|
version: 4,
|
});
|
vi.mocked(fixture.client.fetchAnnotationContext).mockResolvedValue(
|
annotationContext({
|
bindings: [active],
|
checkboxGroups: [{ groupCode: 'inspection_result', maxSelected: 2, minSelected: 1, version: 3 }],
|
}),
|
);
|
vi.mocked(fixture.bridge.listControls).mockResolvedValue([{ BindingId: active.id, Tag: active.controlTag }]);
|
vi.mocked(fixture.client.reservePrimaryBinding).mockResolvedValue(binding({
|
checkboxGroupCode: 'inspection_result',
|
controlTag: 'eln.field.passed_new',
|
controlType: 'CHECKBOX',
|
fieldCode: 'passed_new',
|
id: 'new-checkbox',
|
}));
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
|
vi.mocked(fixture.bridge.listControls)
|
.mockResolvedValueOnce([{ BindingId: active.id, Tag: active.controlTag }])
|
.mockResolvedValueOnce([
|
{ BindingId: active.id, Tag: active.controlTag },
|
{ BindingId: 'new-checkbox', Tag: 'eln.field.passed_new' },
|
]);
|
await api.insertSelectedField(checkbox, { groupCode: 'inspection_result', maxSelected: 2, minSelected: 1 });
|
expect(fixture.client.reservePrimaryBinding).toHaveBeenCalledWith(
|
expect.anything(),
|
expect.objectContaining({
|
checkboxGroupCode: 'inspection_result',
|
checkboxGroupMaxSelected: 2,
|
checkboxGroupMinSelected: 1,
|
}),
|
);
|
expect(api.checkboxGroups).toEqual([{ groupCode: 'inspection_result', maxSelected: 2, minSelected: 1, version: 3 }]);
|
|
vi.mocked(fixture.bridge.insertBinding).mockClear();
|
await api.changeCheckboxGroup(active.id, { groupCode: 'review_result', maxSelected: null, minSelected: 2 }, active.version);
|
expect(fixture.client.changeCheckboxGroup).toHaveBeenCalledWith(expect.anything(), active.id, {
|
checkboxGroupCode: 'review_result',
|
checkboxGroupMaxSelected: null,
|
checkboxGroupMinSelected: 2,
|
expectedVersion: 4,
|
operationCode: expect.any(String),
|
});
|
await api.changeCheckboxGroupRule('inspection_result', 0, 3, 3);
|
expect(fixture.client.changeCheckboxGroupRule).toHaveBeenCalledWith(expect.anything(), 'inspection_result', {
|
expectedVersion: 3,
|
maxSelected: 3,
|
minSelected: 0,
|
operationCode: expect.any(String),
|
});
|
expect(fixture.bridge.insertBinding).not.toHaveBeenCalled();
|
expect(api.bindings.find((item) => item.id === active.id)).toMatchObject({ checkboxGroupCode: 'review_result', version: 5 });
|
expect(api.checkboxGroups).toContainEqual({ groupCode: 'inspection_result', maxSelected: 3, minSelected: 0, version: 4 });
|
});
|
|
it('先加载来源模板，再按所选模板加载字段候选', async () => {
|
const fixture = createFixture();
|
const sourceTemplate: CrossTemplateSourceTemplate = {
|
sourceTemplateCode: 'SOURCE-TPL',
|
sourceTemplateId: 'source-template',
|
};
|
vi.mocked(fixture.client.fetchCrossTemplateSourceTemplates).mockResolvedValue([sourceTemplate]);
|
vi.mocked(fixture.client.fetchCrossTemplateScalarCandidates).mockResolvedValue([crossTemplateCandidate]);
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
|
await api.loadCrossTemplateSourceTemplates();
|
expect(api.crossTemplateSourceTemplates).toEqual([sourceTemplate]);
|
expect(api.crossTemplateScalarCandidates).toEqual([]);
|
|
await api.loadCrossTemplateScalarCandidates('source-template');
|
expect(fixture.client.fetchCrossTemplateScalarCandidates).toHaveBeenCalledWith(
|
expect.anything(),
|
'source-template',
|
);
|
expect(api.crossTemplateScalarCandidates).toEqual([crossTemplateCandidate]);
|
});
|
|
it('跨模板字段值走独立 reserve，并以锁定的 PRIMARY 控件完成 activate', async () => {
|
const fixture = createFixture();
|
const bridge = fixture.bridge as OnlyOfficeBridge & { insertReadOnlyBinding: ReturnType<typeof vi.fn> };
|
bridge.insertReadOnlyBinding = vi.fn(async () => {
|
fixture.order.push('insert-cross-template');
|
});
|
vi.mocked(fixture.bridge.listControls)
|
.mockResolvedValueOnce([])
|
.mockResolvedValueOnce([])
|
.mockResolvedValueOnce([{ BindingId: 'cross-binding', Lock: 'sdtContentLocked', Tag: 'eln.field.result' }]);
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
fixture.order.splice(0);
|
|
await api.insertCrossTemplateScalar(crossTemplateCandidate);
|
|
expect(fixture.order).toEqual(['reserve-cross-template', 'insert-cross-template', 'activate']);
|
expect(fixture.client.reserveCrossTemplateScalarBinding).toHaveBeenCalledWith(expect.anything(), {
|
operationCode: expect.any(String),
|
repeatRequest: false,
|
sourceFieldId: 'source-field',
|
sourceFieldVersionId: 'source-version',
|
sourceTemplateCode: 'SOURCE-TPL',
|
sourceTemplateId: 'source-template',
|
stepId: 'step-1',
|
});
|
expect(fixture.client.reservePrimaryBinding).not.toHaveBeenCalled();
|
expect(bridge.insertReadOnlyBinding).toHaveBeenCalledWith(
|
expect.objectContaining({ controlRole: 'PRIMARY', controlTag: 'eln.field.result', readOnly: true, valueSource: 'CROSS_TEMPLATE' }),
|
expect.any(AbortSignal),
|
);
|
});
|
|
it('跨模板 activate 响应丢失但服务端已 ACTIVE 时保留只读控件', async () => {
|
const fixture = createFixture();
|
const active = binding({ id: 'cross-binding', readOnly: true, status: 'ACTIVE', valueSource: 'CROSS_TEMPLATE' });
|
vi.mocked(fixture.bridge.listControls)
|
.mockResolvedValueOnce([])
|
.mockResolvedValueOnce([])
|
.mockResolvedValueOnce([{ BindingId: active.id, InternalId: 'cross-control', Lock: 'sdtContentLocked', Tag: active.controlTag }]);
|
vi.mocked(fixture.client.activateBinding).mockRejectedValue(new TypeError('Failed to fetch'));
|
vi.mocked(fixture.client.fetchAnnotationContext)
|
.mockResolvedValueOnce(annotationContext())
|
.mockResolvedValueOnce(annotationContext({ bindings: [active] }));
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
|
await api.insertCrossTemplateScalar(crossTemplateCandidate);
|
|
expect(fixture.bridge.deleteControl).not.toHaveBeenCalled();
|
expect(fixture.client.cancelBinding).not.toHaveBeenCalled();
|
expect(api.bindings).toContainEqual(expect.objectContaining({ id: active.id, status: 'ACTIVE' }));
|
});
|
|
it('跨模板 activate 结果无法查明时保留控件等待对账', async () => {
|
const fixture = createFixture();
|
vi.mocked(fixture.bridge.listControls)
|
.mockResolvedValueOnce([])
|
.mockResolvedValueOnce([])
|
.mockResolvedValueOnce([{ BindingId: 'cross-binding', InternalId: 'cross-control', Lock: 'sdtContentLocked', Tag: 'eln.field.result' }]);
|
vi.mocked(fixture.client.activateBinding).mockRejectedValue(new TypeError('Failed to fetch'));
|
vi.mocked(fixture.client.fetchAnnotationContext)
|
.mockResolvedValueOnce(annotationContext())
|
.mockRejectedValueOnce(new TypeError('Failed to fetch'));
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
|
await expect(api.insertCrossTemplateScalar(crossTemplateCandidate)).rejects.toThrow('待对账');
|
|
expect(fixture.bridge.deleteControl).not.toHaveBeenCalled();
|
expect(fixture.client.cancelBinding).not.toHaveBeenCalled();
|
expect(api.store.operation).toMatchObject({ kind: 'error', message: expect.stringContaining('待对账') });
|
});
|
|
it('跨模板 activate 结果查询返回过期 Ticket 时清空上下文且停止补偿写', async () => {
|
const fixture = createFixture();
|
vi.mocked(fixture.bridge.listControls)
|
.mockResolvedValueOnce([])
|
.mockResolvedValueOnce([])
|
.mockResolvedValueOnce([{ BindingId: 'cross-binding', InternalId: 'cross-control', Lock: 'sdtContentLocked', Tag: 'eln.field.result' }]);
|
vi.mocked(fixture.client.activateBinding).mockRejectedValue(new TypeError('Failed to fetch'));
|
vi.mocked(fixture.client.fetchAnnotationContext)
|
.mockResolvedValueOnce(annotationContext())
|
.mockRejectedValueOnce(new TemplateAnnotationApiError(401, 'Ticket 已过期'));
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
|
await expect(api.insertCrossTemplateScalar(crossTemplateCandidate)).rejects.toThrow('Ticket 已过期');
|
|
expect(fixture.bridge.deleteControl).not.toHaveBeenCalled();
|
expect(fixture.client.cancelBinding).not.toHaveBeenCalled();
|
expect(api.contextStore.context).toBeNull();
|
expect(api.store.status).toBe('error');
|
});
|
|
it('跨模板插入命令已落控件但响应失败时删除控件后 cancel', async () => {
|
const fixture = createFixture();
|
vi.mocked(fixture.bridge.insertReadOnlyBinding).mockRejectedValue(new Error('OnlyOffice command response lost'));
|
vi.mocked(fixture.bridge.listControls)
|
.mockResolvedValueOnce([])
|
.mockResolvedValueOnce([])
|
.mockResolvedValueOnce([{ InternalId: 'cross-control', Lock: 'sdtContentLocked', Tag: 'eln.field.result' }]);
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
|
await expect(api.insertCrossTemplateScalar(crossTemplateCandidate)).rejects.toThrow('response lost');
|
|
expect(fixture.bridge.deleteControl).toHaveBeenCalledWith('cross-control');
|
expect(fixture.bridge.deleteControl).toHaveBeenCalledBefore(fixture.client.cancelBinding as ReturnType<typeof vi.fn>);
|
});
|
|
it('多步骤模板选择当前步骤后才允许标注，并在 reserve 中携带步骤归属', async () => {
|
const fixture = createFixture();
|
vi.mocked(fixture.client.fetchAnnotationContext).mockResolvedValue(
|
annotationContext({
|
stepConfiguration: {
|
singleStep: false,
|
steps: [
|
{ id: 'step-1', name: '称量', order: 1 },
|
{ id: 'step-2', name: '溶解', order: 2 },
|
],
|
},
|
} as Partial<TemplateAnnotationContext>),
|
);
|
vi.mocked(fixture.bridge.listControls)
|
.mockResolvedValueOnce([])
|
.mockResolvedValueOnce([])
|
.mockResolvedValueOnce([{ Tag: 'eln.field.result', BindingId: 'binding' }]);
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
|
expect(api.currentStepId).toBeNull();
|
await expect(api.insertSelectedField(option)).rejects.toThrow('多步骤模板必须选择当前步骤');
|
|
api.setCurrentStepId('step-2');
|
await api.insertSelectedField(option);
|
|
expect(fixture.client.reservePrimaryBinding).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({ stepId: 'step-2' }));
|
});
|
|
it('重复行 reserve 携带模板版本内的行数约束', async () => {
|
const fixture = createFixture();
|
const repeat = binding({
|
controlRole: 'REPEAT',
|
controlTag: 'eln.repeat.results.prototype.result',
|
repeatGroupCode: 'results',
|
repeatPrototypeRowId: 'prototype',
|
});
|
vi.mocked(fixture.client.reservePrimaryBinding).mockResolvedValue(repeat);
|
vi.mocked(fixture.bridge.listControls)
|
.mockResolvedValueOnce([])
|
.mockResolvedValueOnce([])
|
.mockResolvedValueOnce([{ Tag: repeat.controlTag, BindingId: repeat.id }]);
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
|
await api.insertRepeatField(option, { groupCode: 'results', maxRows: 20, minRows: 2 });
|
|
expect(fixture.client.reservePrimaryBinding).toHaveBeenCalledWith(
|
expect.anything(),
|
expect.objectContaining({
|
maxRows: 20,
|
minRows: 2,
|
repeatGroupCode: 'results',
|
repeatPrototypeRowId: 'prototype',
|
repeatRequest: true,
|
stepId: 'step-1',
|
}),
|
);
|
});
|
|
it('已有重复组后续字段继承组原步骤，不随当前步骤变化', async () => {
|
const fixture = createFixture();
|
const repeat = binding({
|
controlRole: 'REPEAT',
|
controlTag: 'eln.repeat.results.prototype.result',
|
repeatGroupCode: 'results',
|
repeatPrototypeRowId: 'prototype',
|
stepId: 'step-1',
|
});
|
vi.mocked(fixture.client.fetchAnnotationContext).mockResolvedValue(
|
annotationContext({
|
repeatGroups: [{ groupCode: 'results', maxRows: 20, minRows: 2, stepId: 'step-1' }],
|
stepConfiguration: {
|
singleStep: false,
|
steps: [
|
{ id: 'step-1', name: '称量', order: 1 },
|
{ id: 'step-2', name: '溶解', order: 2 },
|
],
|
},
|
} as Partial<TemplateAnnotationContext>),
|
);
|
vi.mocked(fixture.client.reservePrimaryBinding).mockResolvedValue(repeat);
|
vi.mocked(fixture.bridge.listControls)
|
.mockResolvedValueOnce([])
|
.mockResolvedValueOnce([])
|
.mockResolvedValueOnce([{ Tag: repeat.controlTag, BindingId: repeat.id }]);
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
api.setCurrentStepId('step-2');
|
|
await api.insertRepeatField(option, { groupCode: 'results', maxRows: 20, minRows: 2 });
|
|
expect(fixture.client.reservePrimaryBinding).toHaveBeenCalledWith(
|
expect.anything(),
|
expect.objectContaining({ repeatGroupCode: 'results', stepId: 'step-1' }),
|
);
|
});
|
|
it('已有重复组缺少步骤归属时拒绝标注，不回退到当前步骤', async () => {
|
const fixture = createFixture();
|
vi.mocked(fixture.client.fetchAnnotationContext).mockResolvedValue(
|
annotationContext({
|
repeatGroups: [{ groupCode: 'results', maxRows: 20, minRows: 2 }],
|
stepConfiguration: {
|
singleStep: false,
|
steps: [
|
{ id: 'step-1', name: '称量', order: 1 },
|
{ id: 'step-2', name: '溶解', order: 2 },
|
],
|
},
|
} as Partial<TemplateAnnotationContext>),
|
);
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
api.setCurrentStepId('step-2');
|
|
await expect(api.insertRepeatField(option, { groupCode: 'results', maxRows: 20, minRows: 2 })).rejects.toThrow('重复组步骤归属无效');
|
|
expect(fixture.client.reservePrimaryBinding).not.toHaveBeenCalled();
|
});
|
|
it('重复行 reserve 拒绝越界行数约束', async () => {
|
const fixture = createFixture();
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
|
await expect(
|
api.insertRepeatField(option, {
|
groupCode: 'results',
|
maxRows: 20,
|
minRows: -1,
|
}),
|
).rejects.toThrow('重复组行数约束无效');
|
await expect(
|
api.insertRepeatField(option, {
|
groupCode: 'results',
|
maxRows: 4,
|
minRows: 5,
|
}),
|
).rejects.toThrow('重复组行数约束无效');
|
await expect(
|
api.insertRepeatField(option, {
|
groupCode: 'results',
|
maxRows: 1001,
|
minRows: 0,
|
}),
|
).rejects.toThrow('重复组行数约束无效');
|
expect(fixture.client.reservePrimaryBinding).not.toHaveBeenCalled();
|
});
|
|
it('插入失败只取消仍为 PENDING 的绑定，cancel 失败不覆盖原始错误', async () => {
|
const fixture = createFixture();
|
vi.mocked(fixture.bridge.insertBinding).mockRejectedValue(new Error('文档写入失败'));
|
vi.mocked(fixture.client.cancelBinding).mockRejectedValue(new Error('补偿失败'));
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
await expect(api.insertSelectedField(option)).rejects.toThrow('文档写入失败');
|
expect(fixture.client.cancelBinding).toHaveBeenCalledWith(expect.anything(), 'binding', expect.objectContaining({ reason: '文档写入失败' }));
|
|
vi.mocked(fixture.client.reservePrimaryBinding).mockResolvedValue(binding({ status: 'ACTIVE' }));
|
await expect(api.insertSelectedField(option)).rejects.toThrow('文档写入失败');
|
expect(fixture.client.cancelBinding).toHaveBeenCalledTimes(1);
|
});
|
|
it('私有字段创建激活后刷新字段上下文，使公式映射可立即使用', async () => {
|
const fixture = createFixture();
|
const privateBinding = binding({ checkboxGroupCode: 'inspection_result', controlType: 'CHECKBOX', fieldId: 'private', fieldVersionId: 'private-version' });
|
const updatedContext = annotationContext({
|
bindings: [{ ...privateBinding, status: 'ACTIVE' }],
|
fields: [
|
{
|
beizhu: null,
|
bizEnabled: 'enabled',
|
dangqianZiduanBanbenId: null,
|
id: 'private',
|
mubanBianhao: 'TMP',
|
versions: [
|
{
|
banbenHao: 1,
|
binding: { read: { property: null, source: 'NONE' }, write: { target: 'ELN_RECORD' } },
|
bizStatus: 'PRE_RELEASE',
|
chuangjianShijian: null,
|
danwei: null,
|
gengxinShijian: null,
|
id: 'private-version',
|
kongjianPeizhi: { defaultChecked: false, placeholder: '' },
|
piciMoshi: 'RECORD_PRIVATE',
|
shifouBitian: 0,
|
shujuLeixing: 'CHECKBOX',
|
ziduanDingyiId: 'private',
|
ziduanMingcheng: 'P3验收参数A',
|
zuofeiYuanyin: null,
|
},
|
],
|
ziduanBianma: 'p3_parameter_a',
|
zuoyongFanwei: 'TEMPLATE',
|
},
|
],
|
});
|
vi.mocked(fixture.client.reservePrivateField).mockImplementation(async () => {
|
fixture.order.push('reserve-private');
|
return privateBinding;
|
});
|
vi.mocked(fixture.client.fetchAnnotationContext)
|
.mockImplementationOnce(async () => {
|
fixture.order.push('context');
|
return annotationContext();
|
})
|
.mockImplementationOnce(async () => {
|
fixture.order.push('context');
|
return updatedContext;
|
});
|
vi.mocked(fixture.bridge.listControls)
|
.mockResolvedValueOnce([])
|
.mockResolvedValueOnce([])
|
.mockResolvedValueOnce([{ Tag: 'eln.field.result', BindingId: 'binding' }]);
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
fixture.order.splice(0);
|
await api.createPrivateField({
|
checkboxGroupCode: 'inspection_result',
|
kongjianPeizhi: { defaultChecked: false, placeholder: '' },
|
shujuLeixing: 'CHECKBOX',
|
ziduanMingcheng: 'P3验收参数A',
|
});
|
expect(fixture.order).toEqual(['reserve-private', 'insert', 'activate', 'context']);
|
expect(fixture.client.reservePrivateField).toHaveBeenCalledWith(
|
expect.anything(),
|
expect.objectContaining({ checkboxGroupCode: 'inspection_result', stepId: 'step-1' }),
|
);
|
expect(fixture.bridge.listControls).toHaveBeenCalledTimes(3);
|
expect(api.fields).toEqual(expect.arrayContaining([expect.objectContaining({ fieldVersionId: 'private-version', label: 'P3验收参数A', type: 'CHECKBOX' })]));
|
});
|
|
it('引用使用后端 eln.ref Tag，在插入和枚举后激活', async () => {
|
const fixture = createFixture();
|
const primary = binding({ status: 'ACTIVE', version: 2 });
|
vi.mocked(fixture.client.fetchAnnotationContext).mockResolvedValue(annotationContext({ bindings: [primary] }));
|
vi.mocked(fixture.bridge.listControls)
|
.mockResolvedValueOnce([{ Tag: primary.controlTag, Text: '12.3', BindingId: primary.id }])
|
.mockResolvedValueOnce([{ Tag: primary.controlTag }])
|
.mockResolvedValueOnce([{ Tag: primary.controlTag }, { Tag: 'eln.ref.result.abc', BindingId: 'reference' }]);
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
fixture.order.splice(0);
|
await api.insertReference('binding');
|
expect(fixture.bridge.insertReference).toHaveBeenCalledWith(
|
expect.objectContaining({ controlTag: 'eln.ref.result.abc' }),
|
primary.controlTag,
|
expect.any(AbortSignal),
|
);
|
expect(fixture.order).toEqual(['reserve-reference', 'insert-reference', 'activate']);
|
expect(fixture.bridge.listControls).toHaveBeenCalledTimes(3);
|
});
|
|
it('升版复制 PENDING 枚举全部控件后一次 confirm，成功后才显示 ACTIVE', async () => {
|
const fixture = createFixture();
|
const pending = binding({ id: 'copy', version: 4 });
|
vi.mocked(fixture.client.fetchAnnotationContext).mockResolvedValue(
|
annotationContext({ bindings: [pending], copiedPendingBindingIds: ['copy'], upgradeOperationCode: 'upgrade-1' } as any),
|
);
|
vi.mocked(fixture.bridge.listControls).mockResolvedValue([{ Tag: pending.controlTag, BindingId: pending.id }]);
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
expect(fixture.client.confirmVersionCopy).toHaveBeenCalledWith(expect.anything(), {
|
controls: [{ bindingId: 'copy', controlTag: 'eln.field.result' }],
|
expectedVersions: { copy: 4 },
|
upgradeOperationCode: 'upgrade-1',
|
});
|
const snapshotOptions = vi.mocked(fixture.bridge.snapshotControls).mock.calls[0]?.[2];
|
expect([...snapshotOptions!.inheritedFormulaLockBindingIds!]).toEqual([]);
|
expect(api.bindings[0]?.status).toBe('ACTIVE');
|
});
|
|
it('升版字段确认使用服务端公式锁白名单，并刷新上下文确认随后生成的公式复制', async () => {
|
const fixture = createFixture();
|
const pending = binding({ id: 'locked-copy', status: 'PENDING', version: 4 });
|
const reference = binding({
|
controlRole: 'REFERENCE',
|
controlTag: 'eln.ref.result.copy',
|
id: 'locked-reference-copy',
|
primaryBindingId: pending.id,
|
status: 'PENDING',
|
version: 3,
|
});
|
const copiedFormula = formulaBinding({
|
id: 'copied-formula',
|
operationCode: 'upgrade-locked',
|
resultBindingId: pending.id,
|
status: 'PENDING',
|
version: 2,
|
});
|
vi.mocked(fixture.client.fetchAnnotationContext).mockResolvedValue(
|
annotationContext({
|
bindings: [pending, reference],
|
copiedPendingBindingIds: [pending.id, reference.id],
|
upgradeOperationCode: 'upgrade-locked',
|
} as any),
|
);
|
vi.mocked(fixture.client.fetchFormulaMappings)
|
.mockResolvedValueOnce({
|
bindings: [],
|
inheritedFormulaLockBindingIds: [pending.id, reference.id],
|
versions: [],
|
})
|
.mockResolvedValueOnce({
|
bindings: [copiedFormula],
|
copiedPendingBindingIds: [copiedFormula.id],
|
upgradeOperationCode: 'upgrade-locked',
|
versions: [],
|
});
|
vi.mocked(fixture.bridge.listControls).mockResolvedValue([
|
{
|
BindingId: pending.id,
|
Lock: 'sdtContentLocked',
|
Tag: pending.controlTag,
|
},
|
{
|
BindingId: reference.id,
|
Lock: 'sdtContentLocked',
|
Tag: reference.controlTag,
|
},
|
]);
|
vi.mocked(fixture.bridge.snapshotControls).mockImplementation((_bindings, _controls, options) => {
|
if (!options?.inheritedFormulaLockBindingIds?.has(pending.id) || !options.inheritedFormulaLockBindingIds.has(reference.id))
|
throw new Error('复制公式结果锁未按绑定显式允许');
|
return [
|
{ bindingId: pending.id, controlTag: pending.controlTag },
|
{ bindingId: reference.id, controlTag: reference.controlTag },
|
];
|
});
|
vi.mocked(fixture.bridge.isFormulaResultLocked).mockResolvedValue(true);
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
expect(fixture.client.fetchFormulaMappings).toHaveBeenCalledTimes(2);
|
expect(fixture.client.confirmVersionCopy).toHaveBeenCalledOnce();
|
expect(fixture.client.confirmFormulaVersionCopy).toHaveBeenCalledOnce();
|
expect(api.bindings.every((item) => item.status === 'ACTIVE')).toBe(true);
|
expect(api.formulaBindings[0]?.status).toBe('ACTIVE');
|
});
|
|
it('复制 PENDING 缺少后端升级操作码时明确失败且不猜测', async () => {
|
const fixture = createFixture();
|
vi.mocked(fixture.client.fetchAnnotationContext).mockResolvedValue(annotationContext({ bindings: [binding()], copiedPendingBindingIds: ['binding'] }));
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('error'));
|
expect(api.store.operation.message).toContain('缺少升版操作码');
|
expect(fixture.client.confirmVersionCopy).not.toHaveBeenCalled();
|
});
|
|
it('普通 PENDING 不触发复制确认，且无升级操作码时保持 PENDING', async () => {
|
const fixture = createFixture();
|
const ordinary = binding({ id: 'ordinary' });
|
vi.mocked(fixture.client.fetchAnnotationContext).mockResolvedValue(annotationContext({ bindings: [ordinary] }));
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
|
expect(fixture.client.confirmVersionCopy).not.toHaveBeenCalled();
|
expect(api.bindings).toEqual([ordinary]);
|
});
|
|
it('混合 PENDING 只确认后端标记的复制绑定', async () => {
|
const fixture = createFixture();
|
const ordinary = binding({ id: 'ordinary', controlTag: 'eln.field.ordinary' });
|
const copied = binding({ id: 'copied', controlTag: 'eln.field.copied', version: 4 });
|
vi.mocked(fixture.client.fetchAnnotationContext).mockResolvedValue(
|
annotationContext({
|
bindings: [ordinary, copied],
|
copiedPendingBindingIds: ['copied'],
|
upgradeOperationCode: 'upgrade-1',
|
} as any),
|
);
|
vi.mocked(fixture.bridge.listControls).mockResolvedValue([
|
{ BindingId: ordinary.id, Tag: ordinary.controlTag },
|
{ BindingId: copied.id, Tag: copied.controlTag },
|
]);
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
|
expect(fixture.client.confirmVersionCopy).toHaveBeenCalledWith(expect.anything(), {
|
controls: [{ bindingId: copied.id, controlTag: copied.controlTag }],
|
expectedVersions: { copied: 4 },
|
upgradeOperationCode: 'upgrade-1',
|
});
|
expect(api.bindings.find((item) => item.id === ordinary.id)?.status).toBe('PENDING');
|
expect(api.bindings.find((item) => item.id === copied.id)?.status).toBe('ACTIVE');
|
});
|
|
it('复制 PENDING 集合指向非 PENDING 绑定时拒绝不一致上下文', async () => {
|
const fixture = createFixture();
|
const active = binding({ id: 'active', status: 'ACTIVE' });
|
vi.mocked(fixture.client.fetchAnnotationContext).mockResolvedValue(
|
annotationContext({
|
bindings: [active],
|
copiedPendingBindingIds: [active.id],
|
} as any),
|
);
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('error'));
|
|
expect(api.store.operation.message).toContain('复制绑定上下文不一致');
|
expect(fixture.client.confirmVersionCopy).not.toHaveBeenCalled();
|
});
|
|
it('dispose 后 reserve 首轮枚举返回时不写 DOCX 或使用新会话 Ticket', async () => {
|
const fixture = createFixture();
|
let resolveControls!: (controls: OfficeContentControl[]) => void;
|
vi.mocked(fixture.bridge.listControls)
|
.mockResolvedValueOnce([])
|
.mockReturnValueOnce(
|
new Promise((done) => {
|
resolveControls = done;
|
}),
|
);
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
|
const operation = api.insertSelectedField(option);
|
await vi.waitFor(() => expect(fixture.bridge.listControls).toHaveBeenCalledTimes(2));
|
api.dispose();
|
const freshFixture = createFixture();
|
vi.mocked(freshFixture.bridge.getRuntimeOptions).mockReturnValue({ ...validOptions, ticket: 'fresh-ticket' });
|
const freshApi = useTemplateAnnotator(freshFixture.bridge, freshFixture.client);
|
freshFixture.ready();
|
await vi.waitFor(() => expect(freshApi.store.status).toBe('ready'));
|
resolveControls([]);
|
await operation;
|
|
expect(fixture.bridge.insertBinding).not.toHaveBeenCalled();
|
expect(fixture.client.activateBinding).not.toHaveBeenCalled();
|
expect(fixture.client.cancelBinding).not.toHaveBeenCalled();
|
});
|
|
it('dispose 后 DOCX 插入返回时不继续枚举、激活、取消或删除，PENDING 残留留给重开对账', async () => {
|
const fixture = createFixture();
|
let resolveInsert!: () => void;
|
vi.mocked(fixture.bridge.listControls)
|
.mockResolvedValueOnce([])
|
.mockResolvedValueOnce([])
|
.mockResolvedValueOnce([{ Tag: 'eln.field.result', BindingId: 'binding' }]);
|
vi.mocked(fixture.bridge.insertBinding).mockReturnValue(
|
new Promise((done) => {
|
resolveInsert = done;
|
}),
|
);
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
|
const operation = api.insertSelectedField(option);
|
await vi.waitFor(() => expect(fixture.bridge.insertBinding).toHaveBeenCalledOnce());
|
api.dispose();
|
resolveInsert();
|
await operation;
|
|
expect(fixture.bridge.listControls).toHaveBeenCalledTimes(2);
|
expect(fixture.client.activateBinding).not.toHaveBeenCalled();
|
expect(fixture.client.cancelBinding).not.toHaveBeenCalled();
|
expect(fixture.bridge.deleteControl).not.toHaveBeenCalled();
|
});
|
|
it('dispose 后 repair-context 返回时不继续插入或确认', async () => {
|
const fixture = createFixture();
|
const active = binding({ status: 'ACTIVE', version: 2 });
|
let resolveRepair!: (value: TemplateRepairContext) => void;
|
vi.mocked(fixture.client.fetchAnnotationContext).mockResolvedValue(annotationContext({ bindings: [active] }));
|
vi.mocked(fixture.bridge.listControls)
|
.mockResolvedValueOnce([])
|
.mockResolvedValueOnce([])
|
.mockResolvedValueOnce([{ Tag: active.controlTag, BindingId: active.id }]);
|
vi.mocked(fixture.client.fetchRepairContext).mockReturnValue(
|
new Promise((done) => {
|
resolveRepair = done;
|
}),
|
);
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
|
const operation = api.repairBindingId(active.id);
|
await vi.waitFor(() => expect(fixture.client.fetchRepairContext).toHaveBeenCalledOnce());
|
api.dispose();
|
resolveRepair({ ...check(), binding: active });
|
await operation;
|
|
expect(fixture.bridge.insertBinding).not.toHaveBeenCalled();
|
expect(fixture.client.confirmRepair).not.toHaveBeenCalled();
|
});
|
|
it('dispose 后拒绝新的独占操作', async () => {
|
const fixture = createFixture();
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
api.dispose();
|
|
await expect(api.refresh()).rejects.toThrow('插件已关闭');
|
});
|
|
it('公开定位向 bridge 传递实例中止信号', async () => {
|
const fixture = createFixture();
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
|
await api.select('control-1');
|
|
expect(fixture.bridge.selectControl).toHaveBeenCalledWith('control-1', expect.any(AbortSignal));
|
});
|
|
it('repairBindingId 启动时 Tag 缺失只加载修复上下文，点击恢复后才插入并 confirm', async () => {
|
const fixture = createFixture();
|
const active = binding({ status: 'ACTIVE', version: 2 });
|
vi.mocked(fixture.client.fetchAnnotationContext).mockResolvedValue(annotationContext({ bindings: [active] }));
|
vi.mocked(fixture.bridge.listControls)
|
.mockResolvedValueOnce([])
|
.mockResolvedValueOnce([])
|
.mockResolvedValueOnce([{ Tag: active.controlTag, BindingId: active.id }]);
|
vi.mocked(fixture.bridge.getRuntimeOptions).mockReturnValue({ ...validOptions, repairBindingId: 'binding' });
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
|
expect(fixture.client.fetchRepairContext).toHaveBeenCalledWith(expect.anything(), 'binding');
|
expect(fixture.bridge.insertBinding).not.toHaveBeenCalled();
|
expect(fixture.client.confirmRepair).not.toHaveBeenCalled();
|
expect(api.repairMode).toBe(true);
|
expect(api.pendingRepairBindingId).toBe('binding');
|
|
await api.repairBindingId('binding');
|
expect(fixture.bridge.insertBinding).toHaveBeenCalledWith(expect.objectContaining({ id: 'binding' }), expect.any(AbortSignal));
|
expect(fixture.client.confirmRepair).toHaveBeenCalledWith(expect.anything(), 'binding', expect.objectContaining({ operationCode: 'check-op' }));
|
});
|
|
it('点击恢复后立即进入处理中状态', async () => {
|
const fixture = createFixture();
|
const active = binding({ status: 'ACTIVE', version: 2 });
|
let resolveControls!: (controls: OfficeContentControl[]) => void;
|
vi.mocked(fixture.client.fetchAnnotationContext).mockResolvedValue(annotationContext({ bindings: [active] }));
|
vi.mocked(fixture.bridge.getRuntimeOptions).mockReturnValue({ ...validOptions, repairBindingId: active.id });
|
vi.mocked(fixture.bridge.listControls)
|
.mockResolvedValueOnce([])
|
.mockImplementationOnce(
|
() =>
|
new Promise((resolve) => {
|
resolveControls = resolve;
|
}),
|
);
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.pendingRepairBindingId).toBe(active.id));
|
|
const operation = api.repairBindingId(active.id);
|
|
expect(api.store.status).toBe('working');
|
expect(api.store.operation).toEqual({ kind: 'working', message: '正在恢复控件...' });
|
|
resolveControls([{ InternalId: 'restored', Tag: active.controlTag }]);
|
await operation;
|
});
|
|
it('点击恢复前重新枚举，Tag 已被其他会话恢复时只定位且不重复写入', async () => {
|
const fixture = createFixture();
|
const active = binding({ status: 'ACTIVE', version: 2 });
|
vi.mocked(fixture.client.fetchAnnotationContext).mockResolvedValue(annotationContext({ bindings: [active] }));
|
vi.mocked(fixture.bridge.getRuntimeOptions).mockReturnValue({ ...validOptions, repairBindingId: 'binding' });
|
vi.mocked(fixture.bridge.listControls)
|
.mockResolvedValueOnce([])
|
.mockResolvedValueOnce([{ InternalId: 'restored-elsewhere', Tag: active.controlTag }]);
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.pendingRepairBindingId).toBe('binding'));
|
|
await api.repairBindingId('binding');
|
|
expect(fixture.bridge.selectControl).toHaveBeenCalledWith('restored-elsewhere', expect.any(AbortSignal));
|
expect(fixture.bridge.insertBinding).not.toHaveBeenCalled();
|
expect(fixture.client.confirmRepair).not.toHaveBeenCalled();
|
});
|
|
it('repair confirm 网络失败后发现 Tag 已存在时复用同一 operationCode 幂等确认', async () => {
|
const fixture = createFixture();
|
const active = binding({ status: 'ACTIVE', version: 2 });
|
vi.mocked(fixture.client.fetchAnnotationContext).mockResolvedValue(annotationContext({ bindings: [active] }));
|
vi.mocked(fixture.bridge.getRuntimeOptions).mockReturnValue({ ...validOptions, repairBindingId: 'binding' });
|
vi.mocked(fixture.bridge.listControls)
|
.mockResolvedValueOnce([])
|
.mockResolvedValueOnce([])
|
.mockResolvedValueOnce([{ BindingId: active.id, InternalId: 'restored', Tag: active.controlTag }])
|
.mockResolvedValueOnce([{ BindingId: active.id, InternalId: 'restored', Tag: active.controlTag }]);
|
vi.mocked(fixture.client.confirmRepair).mockRejectedValueOnce(new TypeError('network failed')).mockResolvedValueOnce(undefined);
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.pendingRepairBindingId).toBe('binding'));
|
|
await expect(api.repairBindingId('binding')).rejects.toThrow('network failed');
|
await expect(api.repairBindingId('binding')).resolves.toBeUndefined();
|
|
expect(fixture.client.fetchRepairContext).toHaveBeenCalledOnce();
|
expect(fixture.bridge.insertBinding).toHaveBeenCalledOnce();
|
expect(fixture.client.confirmRepair).toHaveBeenCalledTimes(2);
|
expect(vi.mocked(fixture.client.confirmRepair).mock.calls.map((call) => call[2].operationCode)).toEqual(['check-op', 'check-op']);
|
expect(fixture.bridge.selectControl).toHaveBeenCalledWith('restored', expect.any(AbortSignal));
|
});
|
|
it('点击恢复前重新枚举，Tag 出现多次时拒绝写入和确认', async () => {
|
const fixture = createFixture();
|
const active = binding({ status: 'ACTIVE', version: 2 });
|
vi.mocked(fixture.client.fetchAnnotationContext).mockResolvedValue(annotationContext({ bindings: [active] }));
|
vi.mocked(fixture.bridge.getRuntimeOptions).mockReturnValue({ ...validOptions, repairBindingId: 'binding' });
|
vi.mocked(fixture.bridge.listControls)
|
.mockResolvedValueOnce([])
|
.mockResolvedValueOnce([
|
{ InternalId: 'duplicate-1', Tag: active.controlTag },
|
{ InternalId: 'duplicate-2', Tag: active.controlTag },
|
]);
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.pendingRepairBindingId).toBe('binding'));
|
|
await expect(api.repairBindingId('binding')).rejects.toThrow('修复目标 Tag 在文档中出现多次');
|
|
expect(fixture.bridge.selectControl).not.toHaveBeenCalled();
|
expect(fixture.bridge.insertBinding).not.toHaveBeenCalled();
|
expect(fixture.client.confirmRepair).not.toHaveBeenCalled();
|
});
|
|
it('repairBindingId 启动时 Tag 已存在只定位，不加载修复上下文或重复插入', async () => {
|
const fixture = createFixture();
|
const active = binding({ status: 'ACTIVE', version: 2 });
|
vi.mocked(fixture.client.fetchAnnotationContext).mockResolvedValue(annotationContext({ bindings: [active] }));
|
vi.mocked(fixture.bridge.getRuntimeOptions).mockReturnValue({ ...validOptions, repairBindingId: 'binding' });
|
vi.mocked(fixture.bridge.listControls).mockResolvedValue([{ InternalId: 'existing', Tag: active.controlTag }]);
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
|
expect(fixture.bridge.selectControl).toHaveBeenCalledWith('existing', expect.any(AbortSignal));
|
expect(fixture.client.fetchRepairContext).not.toHaveBeenCalled();
|
expect(fixture.bridge.insertBinding).not.toHaveBeenCalled();
|
expect(api.pendingRepairBindingId).toBeNull();
|
});
|
|
it('repair 初始化定位响应在 dispose 后返回时不覆盖新会话 operation', async () => {
|
const fixture = createFixture();
|
const active = binding({ status: 'ACTIVE', version: 2 });
|
let resolve!: () => void;
|
vi.mocked(fixture.client.fetchAnnotationContext).mockResolvedValue(annotationContext({ bindings: [active] }));
|
vi.mocked(fixture.bridge.getRuntimeOptions).mockReturnValue({ ...validOptions, repairBindingId: active.id });
|
vi.mocked(fixture.bridge.listControls).mockResolvedValue([{ InternalId: 'existing', Tag: active.controlTag }]);
|
vi.mocked(fixture.bridge.selectControl).mockReturnValue(
|
new Promise((done) => {
|
resolve = done;
|
}),
|
);
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(fixture.bridge.selectControl).toHaveBeenCalledOnce());
|
api.dispose();
|
|
const freshFixture = createFixture();
|
const freshApi = useTemplateAnnotator(freshFixture.bridge, freshFixture.client);
|
freshFixture.ready();
|
await vi.waitFor(() => expect(freshApi.store.status).toBe('ready'));
|
const operationAfterFreshReady = { ...freshApi.store.operation };
|
resolve();
|
await new Promise((done) => setTimeout(done, 0));
|
expect(freshApi.store.operation).toEqual(operationAfterFreshReady);
|
});
|
|
it('repair 初始化上下文响应在 dispose 后返回时不回填 pending repair 或新会话 operation', async () => {
|
const fixture = createFixture();
|
const active = binding({ status: 'ACTIVE', version: 2 });
|
let resolve!: (value: TemplateRepairContext) => void;
|
vi.mocked(fixture.client.fetchAnnotationContext).mockResolvedValue(annotationContext({ bindings: [active] }));
|
vi.mocked(fixture.bridge.getRuntimeOptions).mockReturnValue({ ...validOptions, repairBindingId: active.id });
|
vi.mocked(fixture.bridge.listControls).mockResolvedValue([]);
|
vi.mocked(fixture.client.fetchRepairContext).mockReturnValue(
|
new Promise((done) => {
|
resolve = done;
|
}),
|
);
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(fixture.client.fetchRepairContext).toHaveBeenCalledOnce());
|
api.dispose();
|
|
const freshFixture = createFixture();
|
const freshApi = useTemplateAnnotator(freshFixture.bridge, freshFixture.client);
|
freshFixture.ready();
|
await vi.waitFor(() => expect(freshApi.store.status).toBe('ready'));
|
const operationAfterFreshReady = { ...freshApi.store.operation };
|
resolve({ ...check(), binding: active });
|
await new Promise((done) => setTimeout(done, 0));
|
expect(api.pendingRepairBindingId).toBeNull();
|
expect(freshApi.store.operation).toEqual(operationAfterFreshReady);
|
});
|
|
it('字段升级按 check→文档改写→枚举→confirm 执行并携带目标版本', async () => {
|
const fixture = createFixture();
|
const active = binding({ status: 'ACTIVE', version: 2 });
|
vi.mocked(fixture.client.fetchAnnotationContext).mockResolvedValue(annotationContext({ bindings: [active] }));
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
fixture.order.splice(0);
|
|
await api.upgradeBinding('binding', 'published-v2');
|
|
expect(fixture.client.checkBindingVersionUpgrade).toHaveBeenCalledWith(expect.anything(), 'binding', { targetFieldVersionId: 'published-v2' });
|
expect(fixture.bridge.applyControlPlan).toHaveBeenCalledWith(expect.anything(), expect.anything(), expect.any(AbortSignal));
|
expect(fixture.order).toEqual(['document', 'list', 'confirm-upgrade']);
|
expect(fixture.client.confirmBindingVersionUpgrade).toHaveBeenCalledWith(
|
expect.anything(),
|
'binding',
|
expect.objectContaining({ targetFieldVersionId: 'published-v2' }),
|
);
|
});
|
|
it('局部变更计划不会把未涉及的其他 ACTIVE 绑定标记为 REMOVED', async () => {
|
const fixture = createFixture();
|
const active = binding({ status: 'ACTIVE', version: 2 });
|
const unrelated = binding({ controlTag: 'eln.field.other', fieldCode: 'other', fieldId: 'other-field', id: 'other', status: 'ACTIVE', version: 3 });
|
vi.mocked(fixture.client.fetchAnnotationContext).mockResolvedValue(annotationContext({ bindings: [active, unrelated] }));
|
vi.mocked(fixture.client.checkBindingVersionUpgrade).mockResolvedValue(
|
check({
|
controls: [{ bindingId: active.id, controlTag: active.controlTag }],
|
}),
|
);
|
vi.mocked(fixture.bridge.listControls)
|
.mockResolvedValueOnce([])
|
.mockResolvedValueOnce([{ BindingId: active.id, Tag: active.controlTag }]);
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
|
await api.upgradeBinding(active.id, 'published-v2');
|
|
expect(api.bindings.find((item) => item.id === unrelated.id)?.status).toBe('ACTIVE');
|
});
|
|
it('删除必须 check→文档改写→枚举→confirm，confirm 失败时绑定保持 ACTIVE', async () => {
|
const fixture = createFixture();
|
const active = binding({ status: 'ACTIVE', version: 2 });
|
vi.mocked(fixture.client.fetchAnnotationContext).mockResolvedValue(annotationContext({ bindings: [active] }));
|
const enumeratedControls = [{ BindingId: 'unrelated', Tag: 'eln.field.unrelated' }, { Tag: '' }, { Tag: ' ' }];
|
vi.mocked(fixture.bridge.listControls).mockImplementation(async () => {
|
fixture.order.push('list');
|
return enumeratedControls;
|
});
|
vi.mocked(fixture.client.confirmBindingRemoval).mockRejectedValue(new Error('确认冲突'));
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
fixture.order.splice(0);
|
await expect(api.removeBinding('binding')).rejects.toThrow('确认冲突');
|
expect(fixture.order).toEqual(['document', 'list']);
|
expect(fixture.client.confirmBindingRemoval).toHaveBeenCalledOnce();
|
expect(fixture.client.confirmBindingRemoval).toHaveBeenCalledWith(
|
expect.anything(),
|
active.id,
|
expect.objectContaining({ observedControlTags: ['eln.field.unrelated'] }),
|
);
|
expect(api.bindings[0]?.status).toBe('ACTIVE');
|
expect(api.store.operation).toEqual({ kind: 'error', message: '删除失败：确认冲突' });
|
});
|
|
it('删除孤立控件只操作 DOCX 控件并更新字段列表', async () => {
|
const fixture = createFixture();
|
const remainingControls = [{ InternalId: 'remaining-id', Tag: 'eln.field.other' }];
|
vi.mocked(fixture.bridge.deleteControl).mockResolvedValue(remainingControls);
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
fixture.order.splice(0);
|
|
await api.removeOrphanControl('orphan-id');
|
|
expect(fixture.bridge.disableTrackRevisions).toHaveBeenCalledOnce();
|
expect(fixture.bridge.deleteControl).toHaveBeenCalledWith('orphan-id');
|
expect(fixture.client.checkBindingRemoval).not.toHaveBeenCalled();
|
expect(fixture.client.confirmBindingRemoval).not.toHaveBeenCalled();
|
expect(api.store.controls).toEqual(remainingControls);
|
expect(api.store.operation).toEqual({ kind: 'success', message: '异常控件已删除' });
|
});
|
|
it('引用提升必须 check→文档改写→枚举→confirm', async () => {
|
const fixture = createFixture();
|
const reference = binding({ controlRole: 'REFERENCE', controlTag: 'eln.ref.result.abc', id: 'reference', primaryBindingId: 'binding', status: 'ACTIVE' });
|
vi.mocked(fixture.client.fetchAnnotationContext).mockResolvedValue(annotationContext({ bindings: [binding({ status: 'ACTIVE' }), reference] }));
|
vi.mocked(fixture.client.checkReferencePromotion).mockResolvedValue(
|
check({
|
controls: [{ bindingId: reference.id, controlRole: 'PRIMARY', controlTag: 'eln.field.result', primaryBindingId: null }],
|
}),
|
);
|
vi.mocked(fixture.bridge.listControls).mockImplementation(async () => {
|
fixture.order.push('list');
|
return [{ BindingId: reference.id, Tag: 'eln.field.result' }, { BindingId: 'unrelated', Tag: 'eln.field.unrelated' }, { Tag: '' }, { Tag: ' ' }];
|
});
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
fixture.order.splice(0);
|
await api.promoteReference('reference');
|
expect(fixture.order).toEqual(['document', 'list', 'confirm-promote']);
|
expect(fixture.client.confirmReferencePromotion).toHaveBeenCalledWith(
|
expect.anything(),
|
reference.id,
|
expect.objectContaining({ observedControlTags: ['eln.field.result', 'eln.field.unrelated'] }),
|
);
|
});
|
|
it('引用提升 confirm 网络失败后用同一 operationCode 重新枚举并幂等重试，不回滚 DOCX', async () => {
|
const fixture = createFixture();
|
const reference = binding({ controlRole: 'REFERENCE', controlTag: 'eln.ref.result.abc', id: 'reference', primaryBindingId: 'binding', status: 'ACTIVE' });
|
const promotionCheck = check({
|
controls: [
|
{
|
bindingId: reference.id,
|
controlAlias: '结果',
|
controlConfig: { placeholder: '请输入' },
|
controlRole: 'PRIMARY',
|
controlTag: 'eln.field.result',
|
controlType: 'TEXT',
|
fieldVersionId: 'version',
|
primaryBindingId: null,
|
},
|
],
|
operationCode: 'promote-op',
|
});
|
vi.mocked(fixture.client.fetchAnnotationContext).mockResolvedValue(annotationContext({ bindings: [binding({ status: 'ACTIVE' }), reference] }));
|
vi.mocked(fixture.client.checkReferencePromotion).mockResolvedValue(promotionCheck);
|
vi.mocked(fixture.bridge.listControls).mockResolvedValue([{ BindingId: reference.id, Tag: 'eln.field.result' }]);
|
vi.mocked(fixture.client.confirmReferencePromotion).mockRejectedValueOnce(new TypeError('network failed')).mockResolvedValueOnce(undefined);
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
|
await expect(api.promoteReference(reference.id)).rejects.toThrow('network failed');
|
await expect(api.promoteReference(reference.id)).resolves.toBeUndefined();
|
|
expect(fixture.bridge.applyControlPlan).toHaveBeenCalledTimes(2);
|
expect(fixture.bridge.listControls).toHaveBeenCalledTimes(3);
|
expect(fixture.client.checkReferencePromotion).toHaveBeenCalledOnce();
|
expect(fixture.client.confirmReferencePromotion).toHaveBeenCalledTimes(2);
|
expect(vi.mocked(fixture.client.confirmReferencePromotion).mock.calls.map((call) => call[2].operationCode)).toEqual(['promote-op', 'promote-op']);
|
expect(fixture.bridge.deleteControl).not.toHaveBeenCalled();
|
});
|
|
it.each([
|
['删除', 'confirmBindingRemoval', (api: ReturnType<typeof useTemplateAnnotator>) => api.removeBinding('binding')],
|
['引用提升', 'confirmReferencePromotion', (api: ReturnType<typeof useTemplateAnnotator>) => api.promoteReference('binding')],
|
['字段升级', 'confirmBindingVersionUpgrade', (api: ReturnType<typeof useTemplateAnnotator>) => api.upgradeBinding('binding', 'published-v2')],
|
] as const)('%s确认响应在 dispose 后才返回时不回填本地状态', async (_label, confirmMethod, execute) => {
|
const fixture = createFixture();
|
const active = binding({ status: 'ACTIVE', version: 2 });
|
let resolve!: () => void;
|
vi.mocked(fixture.client.fetchAnnotationContext).mockResolvedValue(annotationContext({ bindings: [active] }));
|
vi.mocked(fixture.bridge.listControls)
|
.mockResolvedValueOnce([])
|
.mockResolvedValueOnce([{ BindingId: active.id, Tag: active.controlTag }]);
|
vi.mocked(fixture.client[confirmMethod]).mockReturnValue(
|
new Promise((done) => {
|
resolve = done;
|
}),
|
);
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
|
const operation = execute(api);
|
await vi.waitFor(() => expect(fixture.client[confirmMethod]).toHaveBeenCalledOnce());
|
api.dispose();
|
const controlsAfterDispose = [...api.store.controls];
|
resolve();
|
await operation;
|
|
expect(api.bindings).toEqual([]);
|
expect(api.contextStore.context).toBeNull();
|
expect(api.store.controls).toEqual(controlsAfterDispose);
|
});
|
|
it('dispose 后晚到的 confirm 401 不清空新会话上下文', async () => {
|
const fixture = createFixture();
|
const active = binding({ status: 'ACTIVE', version: 2 });
|
let reject!: (error: Error) => void;
|
vi.mocked(fixture.client.fetchAnnotationContext).mockResolvedValue(annotationContext({ bindings: [active] }));
|
vi.mocked(fixture.bridge.listControls)
|
.mockResolvedValueOnce([])
|
.mockResolvedValueOnce([{ BindingId: active.id, Tag: active.controlTag }]);
|
vi.mocked(fixture.client.confirmBindingRemoval).mockReturnValue(
|
new Promise((_, fail) => {
|
reject = fail;
|
}),
|
);
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
|
const operation = api.removeBinding(active.id);
|
await vi.waitFor(() => expect(fixture.client.confirmBindingRemoval).toHaveBeenCalledOnce());
|
api.dispose();
|
|
const freshFixture = createFixture();
|
const freshApi = useTemplateAnnotator(freshFixture.bridge, freshFixture.client);
|
freshFixture.ready();
|
await vi.waitFor(() => expect(freshApi.store.status).toBe('ready'));
|
reject(new TemplateAnnotationApiError(401, '旧会话 Ticket 已过期'));
|
await expect(operation).rejects.toThrow('旧会话 Ticket 已过期');
|
|
expect(freshApi.contextStore.context).not.toBeNull();
|
expect(freshApi.store.status).toBe('ready');
|
});
|
|
it('401/403 Ticket 失败后清空上下文并停止后续写操作', async () => {
|
const fixture = createFixture();
|
vi.mocked(fixture.client.reservePrimaryBinding).mockRejectedValue(new TemplateAnnotationApiError(401, 'Ticket 已过期'));
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
await expect(api.insertSelectedField(option)).rejects.toThrow('Ticket 已过期');
|
expect(api.contextStore.context).toBeNull();
|
await expect(api.insertSelectedField(option)).rejects.toThrow('插件运行上下文不可用');
|
expect(fixture.client.reservePrimaryBinding).toHaveBeenCalledTimes(1);
|
});
|
|
it('activate 返回 Ticket 过期后不再发送 cancel 补偿写请求', async () => {
|
const fixture = createFixture();
|
vi.mocked(fixture.bridge.listControls)
|
.mockResolvedValueOnce([])
|
.mockResolvedValueOnce([])
|
.mockResolvedValueOnce([{ Tag: 'eln.field.result' }]);
|
vi.mocked(fixture.client.activateBinding).mockRejectedValue(new TemplateAnnotationApiError(401, 'Ticket 已过期'));
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
await vi.waitFor(() => expect(api.store.status).toBe('ready'));
|
await expect(api.insertSelectedField(option)).rejects.toThrow('Ticket 已过期');
|
expect(fixture.client.cancelBinding).not.toHaveBeenCalled();
|
});
|
|
it('dispose 后晚到 context 响应不覆盖新状态', async () => {
|
const fixture = createFixture();
|
let resolve!: (value: TemplateAnnotationContext) => void;
|
vi.mocked(fixture.client.fetchAnnotationContext).mockReturnValue(
|
new Promise((done) => {
|
resolve = done;
|
}),
|
);
|
const api = useTemplateAnnotator(fixture.bridge, fixture.client);
|
fixture.ready();
|
api.dispose();
|
resolve(annotationContext({ bindings: [binding({ status: 'ACTIVE' })] }));
|
await Promise.resolve();
|
expect(api.bindings).toEqual([]);
|
expect(api.contextStore.context).toBeNull();
|
});
|
});
|
