import { describe, expect, it, vi } from 'vitest';
|
|
import {
|
disableTrackRevisionsCommand,
|
insertTypedControlCommand,
|
listContentControlsCommand,
|
readControlTextCommand,
|
readTrackRevisionsStateCommand,
|
setFormulaResultLockCommand,
|
updateControlSpecCommand,
|
writeTextDefaultCommand,
|
} from '../../src/onlyoffice/commands';
|
import { installOnlyOfficeGlobals, makeApiFixture, makeInsertSpec, type FixtureApi, type InsertSpec, type TextDefaultSpec } from '../fixtures/onlyoffice';
|
|
interface CommandResult {
|
controlType?: string;
|
controls?: Array<{
|
Alias: string;
|
ControlConfig: Record<string, unknown>;
|
ControlRole: string;
|
ControlType: string;
|
InternalId: string;
|
Lock: string;
|
Tag: string;
|
}>;
|
error?: string;
|
ok: boolean;
|
}
|
|
function parseResult(value: string): CommandResult {
|
return JSON.parse(value) as CommandResult;
|
}
|
|
function setFixtureInsertScope(Api: FixtureApi, overrides: Partial<InsertSpec> & Pick<InsertSpec, 'controlType'>): void {
|
installOnlyOfficeGlobals(Api, {
|
elnTemplateInsert: makeInsertSpec(overrides),
|
});
|
}
|
|
function setTextDefaultScope(Api: FixtureApi, spec: TextDefaultSpec): void {
|
installOnlyOfficeGlobals(Api, { elnTemplateTextDefault: spec });
|
}
|
|
describe('insertTypedControlCommand', () => {
|
it('使用显示值、业务值和默认项创建下拉控件', () => {
|
const fixture = makeApiFixture();
|
const options = [
|
{ display: '合格', value: 'pass' },
|
{ display: '不合格', value: 'fail' },
|
];
|
setFixtureInsertScope(fixture.Api, { controlType: 'dropdown', options, selectedIndex: 0 });
|
|
const result = parseResult(insertTypedControlCommand());
|
|
expect(result).toEqual({ ok: true, controlType: 'dropdown' });
|
expect(fixture.calls.combo).toEqual([[options, 0]]);
|
expect(fixture.calls.inserted[0]).toMatchObject({ block: false, replaceSelection: true });
|
expect(fixture.calls.inserted[0]?.control.tag).toBe('eln.field.result');
|
expect(fixture.calls.inserted[0]?.control.lock).toBe('unlocked');
|
});
|
|
it.each(['text', 'dropdown', 'checkbox', 'date', 'multiline'] as const)('带格式选区插入 %s 控件后保留完整文字格式', (controlType) => {
|
const fixture = makeApiFixture();
|
fixture.document.selectionTextPr = {
|
bold: true,
|
color: { r: 23, g: 109, b: 92 },
|
fontFamily: 'SimSun',
|
fontSize: 14,
|
italic: true,
|
strikeout: true,
|
underline: true,
|
};
|
setFixtureInsertScope(fixture.Api, {
|
controlType,
|
options: [
|
{ display: '合格', value: 'pass' },
|
{ display: '不合格', value: 'fail' },
|
],
|
selectedIndex: -1,
|
});
|
|
const result = parseResult(insertTypedControlCommand());
|
|
expect(result).toEqual({ ok: true, controlType });
|
expect(fixture.calls.inserted[0]?.control.GetRange?.().GetTextPr?.()).toEqual({
|
bold: true,
|
color: { r: 23, g: 109, b: 92 },
|
fontFamily: 'SimSun',
|
fontSize: 14,
|
italic: true,
|
strikeout: true,
|
underline: true,
|
});
|
});
|
|
it('光标位置插入复选框后继承当前字号和下划线', () => {
|
const fixture = makeApiFixture();
|
fixture.document.currentTextPr = { fontFamily: 'SimSun', fontSize: 18, underline: true };
|
setFixtureInsertScope(fixture.Api, { controlType: 'checkbox', defaultChecked: false });
|
|
const result = parseResult(insertTypedControlCommand());
|
|
expect(result).toEqual({ ok: true, controlType: 'checkbox' });
|
expect(fixture.calls.inserted[0]?.control.GetRange?.().GetTextPr?.()).toEqual({
|
fontFamily: 'SimSun',
|
fontSize: 18,
|
underline: true,
|
});
|
});
|
|
it('插入后按 Tag 重新定位持久化控件并应用选区格式', () => {
|
const fixture = makeApiFixture();
|
fixture.document.selectionTextPr = { fontFamily: 'SimSun', fontSize: 14, underline: true };
|
let persistedControl: ReturnType<typeof fixture.makeControl> | undefined;
|
fixture.document.InsertContent = (items) => {
|
const transientControl = (items[0] as { inlineControl?: ReturnType<typeof fixture.makeControl> }).inlineControl;
|
if (!transientControl) return false;
|
persistedControl = fixture.makeControl('dropdown', transientControl.tag);
|
fixture.document.controls.push(persistedControl);
|
return true;
|
};
|
setFixtureInsertScope(fixture.Api, {
|
controlType: 'dropdown',
|
options: [
|
{ display: '合格', value: 'pass' },
|
{ display: '不合格', value: 'fail' },
|
],
|
selectedIndex: -1,
|
});
|
|
expect(parseResult(insertTypedControlCommand())).toEqual({ ok: true, controlType: 'dropdown' });
|
expect(persistedControl?.GetRange?.().GetTextPr?.()).toEqual({ fontFamily: 'SimSun', fontSize: 14, underline: true });
|
});
|
|
it('使用配置的默认状态创建复选框且不写占位文本', () => {
|
const fixture = makeApiFixture();
|
setFixtureInsertScope(fixture.Api, { controlType: 'checkbox', defaultChecked: true });
|
|
const result = parseResult(insertTypedControlCommand());
|
|
expect(result.ok).toBe(true);
|
expect(fixture.calls.checkbox).toEqual([{ checked: true, checkedSymbol: 0x2611, uncheckedSymbol: 0x2610 }]);
|
expect(fixture.calls.inserted[0]?.control.placeholder).toBeUndefined();
|
});
|
|
it('使用内联内容控件写入单行文本默认值', () => {
|
const fixture = makeApiFixture();
|
setFixtureInsertScope(fixture.Api, {
|
controlType: 'text',
|
defaultValue: 'S-001',
|
placeholder: '请输入样品编号',
|
});
|
|
const result = parseResult(insertTypedControlCommand());
|
|
expect(result).toEqual({ ok: true, controlType: 'text' });
|
expect(fixture.calls.inserted[0]).toMatchObject({ block: false, replaceSelection: true });
|
expect(fixture.calls.inserted[0]?.control).toMatchObject({
|
kind: 'text',
|
elements: [{ text: 'S-001' }],
|
});
|
expect(fixture.calls.inserted[0]?.control.placeholder).toBeUndefined();
|
});
|
|
it('单行文本先挂入段落，再设置可回读的 Tag 属性', () => {
|
const fixture = makeApiFixture();
|
const control = fixture.makeControl('text');
|
const createParagraph = fixture.Api.CreateParagraph;
|
let attached = false;
|
fixture.Api.CreateInlineLvlSdt = () => control;
|
fixture.Api.CreateParagraph = () => {
|
const paragraph = createParagraph();
|
const addInlineLvlSdt = paragraph.AddInlineLvlSdt;
|
paragraph.AddInlineLvlSdt = (value) => {
|
attached = true;
|
addInlineLvlSdt(value);
|
};
|
return paragraph;
|
};
|
control.SetTag = (tag) => {
|
if (!attached) return false;
|
control.tag = tag;
|
return true;
|
};
|
setFixtureInsertScope(fixture.Api, { controlType: 'text' });
|
|
const result = parseResult(insertTypedControlCommand());
|
|
expect(result).toEqual({ ok: true, controlType: 'text' });
|
expect(fixture.document.controls).toEqual([control]);
|
});
|
|
it('单行文本没有默认值时设置占位文本', () => {
|
const fixture = makeApiFixture();
|
setFixtureInsertScope(fixture.Api, { controlType: 'text', defaultValue: '', placeholder: '请输入样品编号' });
|
|
const result = parseResult(insertTypedControlCommand());
|
|
expect(result.ok).toBe(true);
|
expect(fixture.calls.inserted[0]?.control.placeholder).toBe('请输入样品编号');
|
});
|
|
it('使用本地年月日创建日期默认值', () => {
|
const fixture = makeApiFixture();
|
setFixtureInsertScope(fixture.Api, { controlType: 'date', defaultValue: '2026-08-01' });
|
|
const result = parseResult(insertTypedControlCommand());
|
|
expect(result.ok).toBe(true);
|
expect(fixture.calls.dateProperties).toEqual({ format: 'yyyy-MM-dd', lang: 'zh-CN' });
|
expect(fixture.calls.date[0]?.getFullYear()).toBe(2026);
|
expect(fixture.calls.date[0]?.getMonth()).toBe(7);
|
expect(fixture.calls.date[0]?.getDate()).toBe(1);
|
});
|
|
it('使用字段格式和本地完整时间创建日期时间默认值', () => {
|
const fixture = makeApiFixture();
|
setFixtureInsertScope(fixture.Api, {
|
controlType: 'date',
|
dateFormat: 'yyyy-MM-dd HH:mm:ss',
|
defaultValue: '2026-08-01 14:35:27',
|
});
|
|
const result = parseResult(insertTypedControlCommand());
|
|
expect(result.ok).toBe(true);
|
expect(fixture.calls.dateProperties).toEqual({ format: 'yyyy-MM-dd HH:mm:ss', lang: 'zh-CN' });
|
expect(fixture.calls.date[0]?.getFullYear()).toBe(2026);
|
expect(fixture.calls.date[0]?.getMonth()).toBe(7);
|
expect(fixture.calls.date[0]?.getDate()).toBe(1);
|
expect(fixture.calls.date[0]?.getHours()).toBe(14);
|
expect(fixture.calls.date[0]?.getMinutes()).toBe(35);
|
expect(fixture.calls.date[0]?.getSeconds()).toBe(27);
|
});
|
|
it('把多行默认值拆成独立段落并作为块级内容插入', () => {
|
const fixture = makeApiFixture();
|
setFixtureInsertScope(fixture.Api, {
|
controlType: 'multiline',
|
tag: 'eln.field.note',
|
alias: '备注',
|
defaultValue: '第一行\n第二行',
|
placeholder: '请输入备注',
|
});
|
|
const result = parseResult(insertTypedControlCommand());
|
|
expect(result.ok).toBe(true);
|
expect(fixture.calls.paragraphTexts).toEqual(['第一行', '第二行']);
|
expect(fixture.calls.inserted[0]).toMatchObject({ block: true, replaceSelection: false });
|
expect(fixture.calls.inserted[0]?.control.elements).toHaveLength(2);
|
});
|
|
it('日期无默认值时不写入当前日期', () => {
|
const fixture = makeApiFixture();
|
const createDatePicker = fixture.Api.CreateDatePickerContentControl!;
|
fixture.Api.CreateDatePickerContentControl = (properties) => {
|
const control = createDatePicker(properties);
|
control.elements = [{ text: '2026-09-04' }];
|
return control;
|
};
|
setFixtureInsertScope(fixture.Api, { controlType: 'date', defaultValue: '', placeholder: '' });
|
|
const result = parseResult(insertTypedControlCommand());
|
|
expect(result.ok).toBe(true);
|
expect(fixture.calls.date).toEqual([]);
|
expect(fixture.calls.inserted[0]?.control.elements).toEqual([]);
|
expect(fixture.calls.inserted[0]?.control.placeholder).toBeFalsy();
|
});
|
|
it('构造器缺失时报告不支持且不插入', () => {
|
const fixture = makeApiFixture();
|
delete fixture.Api.CreateDatePickerContentControl;
|
setFixtureInsertScope(fixture.Api, { controlType: 'date' });
|
|
const result = parseResult(insertTypedControlCommand());
|
|
expect(result.ok).toBe(false);
|
expect(result.error).toMatch(/不支持日期控件/);
|
expect(fixture.calls.inserted).toHaveLength(0);
|
});
|
|
it('关键控件 setter 返回 false 时拒绝插入', () => {
|
const fixture = makeApiFixture();
|
const control = fixture.makeControl('date');
|
control.SetTag = () => false;
|
fixture.Api.CreateDatePickerContentControl = () => control;
|
setFixtureInsertScope(fixture.Api, { controlType: 'date' });
|
|
const result = parseResult(insertTypedControlCommand());
|
|
expect(result.ok).toBe(false);
|
expect(result.error).toMatch(/Tag/);
|
expect(fixture.calls.inserted).toHaveLength(0);
|
});
|
|
it.each([
|
{
|
type: 'date' as const,
|
defaultValue: '2026-08-01',
|
patch: (Api: FixtureApi, control: ReturnType<ReturnType<typeof makeApiFixture>['makeControl']>) => {
|
control.SetDate = () => false;
|
Api.CreateDatePickerContentControl = () => control;
|
},
|
},
|
{
|
type: 'multiline' as const,
|
defaultValue: '第一行\n第二行',
|
patch: (Api: FixtureApi, control: ReturnType<ReturnType<typeof makeApiFixture>['makeControl']>) => {
|
control.RemoveAllElements = () => false;
|
Api.CreateBlockLvlSdt = () => control;
|
},
|
},
|
{
|
type: 'multiline' as const,
|
defaultValue: '第一行\n第二行',
|
patch: (Api: FixtureApi, control: ReturnType<ReturnType<typeof makeApiFixture>['makeControl']>) => {
|
control.AddElement = () => false;
|
Api.CreateBlockLvlSdt = () => control;
|
},
|
},
|
])('$type 默认值写入返回 false 时拒绝插入', ({ type, defaultValue, patch }) => {
|
const fixture = makeApiFixture();
|
const control = fixture.makeControl(type);
|
patch(fixture.Api, control);
|
setFixtureInsertScope(fixture.Api, { controlType: type, defaultValue });
|
|
const result = parseResult(insertTypedControlCommand());
|
|
expect(result.ok).toBe(false);
|
expect(result.error).toMatch(/失败/);
|
expect(fixture.calls.inserted).toHaveLength(0);
|
});
|
|
it.each(['SetPlaceholderText', 'SetColor'] as const)('配置相应值时要求 %s API 存在', (missingMethod) => {
|
const fixture = makeApiFixture();
|
const control = fixture.makeControl('date');
|
delete control[missingMethod];
|
fixture.Api.CreateDatePickerContentControl = () => control;
|
setFixtureInsertScope(fixture.Api, { controlType: 'date', defaultValue: '' });
|
|
const result = parseResult(insertTypedControlCommand());
|
|
expect(result.ok).toBe(false);
|
expect(result.error).toMatch(/不支持/);
|
expect(fixture.calls.inserted).toHaveLength(0);
|
});
|
|
it('文档 InsertContent 返回 false 时报告失败', () => {
|
const fixture = makeApiFixture();
|
fixture.document.InsertContent = () => false;
|
setFixtureInsertScope(fixture.Api, { controlType: 'checkbox' });
|
|
const result = parseResult(insertTypedControlCommand());
|
|
expect(result.ok).toBe(false);
|
expect(result.error).toMatch(/插入/);
|
});
|
});
|
|
describe('disableTrackRevisionsCommand', () => {
|
it('接受历史修订后关闭修订跟踪，并回读确认最终状态', () => {
|
const fixture = makeApiFixture();
|
const operations: string[] = [];
|
let enabled = true;
|
fixture.document.AcceptAllRevisionChanges = () => {
|
operations.push('accept');
|
return true;
|
};
|
fixture.document.Document = {
|
HaveRevisionChanges: (includeCurrentUser) => {
|
operations.push(`revisions:${includeCurrentUser}`);
|
return false;
|
},
|
SetTrackRevisions: (value) => {
|
operations.push(`local-track:${value}`);
|
enabled = value;
|
},
|
};
|
fixture.document.SetTrackRevisions = (value) => {
|
operations.push(`track:${value}`);
|
enabled = value;
|
return true;
|
};
|
fixture.document.IsTrackRevisions = () => enabled;
|
installOnlyOfficeGlobals(fixture.Api, { elnTemplateReview: {} });
|
|
expect(parseResult(disableTrackRevisionsCommand())).toEqual({ ok: true });
|
expect(operations).toEqual(['accept', 'revisions:true', 'track:false', 'local-track:false']);
|
expect(enabled).toBe(false);
|
});
|
|
it('修订跟踪回读仍开启时拒绝进入模板标注', () => {
|
const fixture = makeApiFixture();
|
fixture.document.AcceptAllRevisionChanges = () => true;
|
fixture.document.Document = { HaveRevisionChanges: () => false, SetTrackRevisions: () => undefined };
|
fixture.document.SetTrackRevisions = () => true;
|
fixture.document.IsTrackRevisions = () => true;
|
installOnlyOfficeGlobals(fixture.Api, { elnTemplateReview: {} });
|
|
expect(parseResult(disableTrackRevisionsCommand())).toEqual({ ok: false, error: '修订跟踪仍处于开启状态' });
|
});
|
|
it('接受后仍有历史修订时拒绝进入模板标注', () => {
|
const fixture = makeApiFixture();
|
fixture.document.AcceptAllRevisionChanges = () => true;
|
fixture.document.Document = { HaveRevisionChanges: () => true, SetTrackRevisions: () => undefined };
|
fixture.document.SetTrackRevisions = () => true;
|
fixture.document.IsTrackRevisions = () => false;
|
installOnlyOfficeGlobals(fixture.Api, { elnTemplateReview: {} });
|
|
expect(parseResult(disableTrackRevisionsCommand())).toEqual({ ok: false, error: '历史修订仍未全部接受' });
|
});
|
});
|
|
describe('readTrackRevisionsStateCommand', () => {
|
it('独立回读当前修订跟踪状态', () => {
|
const fixture = makeApiFixture();
|
fixture.document.Document = { HaveRevisionChanges: () => false };
|
fixture.document.IsTrackRevisions = () => false;
|
installOnlyOfficeGlobals(fixture.Api, { elnTemplateReviewState: {} });
|
|
expect(parseResult(readTrackRevisionsStateCommand())).toEqual({ hasRevisionChanges: false, ok: true, trackRevisions: false });
|
});
|
});
|
|
describe('listContentControlsCommand', () => {
|
it('回读内容控件属性并识别五种具体类型', () => {
|
const fixture = makeApiFixture();
|
const definitions = [
|
{ alias: '文本', id: 'text-1', tag: 'eln.field.text', type: 'text' },
|
{ alias: '下拉', id: 'dropdown-1', tag: 'eln.field.dropdown', type: 'dropdown' },
|
{ alias: '复选', id: 'checkbox-1', tag: 'eln.field.checkbox', type: 'checkbox' },
|
{ alias: '日期', id: 'date-1', tag: 'eln.field.date', type: 'date' },
|
{ alias: '多行', id: 'multiline-1', tag: 'eln.field.multiline', type: 'multiline' },
|
] as const;
|
|
fixture.document.controls = definitions.map(({ alias, id, tag, type }) => {
|
const control = Object.assign(fixture.makeControl(type, tag), {
|
GetAlias: () => alias,
|
GetInternalId: () => id,
|
IsBlockLevel: () => type === 'multiline',
|
IsCheckBox: () => type === 'checkbox',
|
IsComboBox: () => type === 'dropdown',
|
IsDatePicker: () => type === 'date',
|
IsDropDownList: () => false,
|
});
|
if (type === 'date') Object.assign(control, { ToJSON: () => JSON.stringify({ sdtPr: { date: { dateFormat: 'dd/MM/yyyy' } } }) });
|
return control;
|
});
|
installOnlyOfficeGlobals(fixture.Api, { elnTemplateList: {} });
|
|
expect(parseResult(listContentControlsCommand())).toEqual({
|
ok: true,
|
controls: [
|
{
|
Alias: '文本',
|
ControlConfig: { placeholder: '' },
|
ControlRole: 'PRIMARY',
|
ControlType: 'text',
|
InternalId: 'text-1',
|
Lock: 'unlocked',
|
Tag: 'eln.field.text',
|
},
|
{
|
Alias: '下拉',
|
ControlConfig: { defaultValue: '', options: [], placeholder: '' },
|
ControlRole: 'PRIMARY',
|
ControlType: 'dropdown',
|
InternalId: 'dropdown-1',
|
Lock: 'unlocked',
|
Tag: 'eln.field.dropdown',
|
},
|
{
|
Alias: '复选',
|
ControlConfig: { defaultChecked: false },
|
ControlRole: 'PRIMARY',
|
ControlType: 'checkbox',
|
InternalId: 'checkbox-1',
|
Lock: 'unlocked',
|
Tag: 'eln.field.checkbox',
|
},
|
{
|
Alias: '日期',
|
ControlConfig: { dateFormat: 'dd/MM/yyyy', placeholder: '' },
|
ControlRole: 'PRIMARY',
|
ControlType: 'date',
|
InternalId: 'date-1',
|
Lock: 'unlocked',
|
Tag: 'eln.field.date',
|
},
|
{
|
Alias: '多行',
|
ControlConfig: { placeholder: '' },
|
ControlRole: 'PRIMARY',
|
ControlType: 'multiline',
|
InternalId: 'multiline-1',
|
Lock: 'unlocked',
|
Tag: 'eln.field.multiline',
|
},
|
],
|
});
|
});
|
|
it('从文档实际控件枚举角色、锁和类型专用配置', () => {
|
const fixture = makeApiFixture();
|
const dropdown = fixture.makeControl('dropdown', 'eln.ref.result.abc');
|
dropdown.alias = '检测结论';
|
dropdown.lock = 'contentLocked';
|
dropdown.placeholder = '请选择';
|
dropdown.options = [
|
{ display: '合格', value: 'PASS' },
|
{ display: '不合格', value: 'FAIL' },
|
];
|
fixture.document.controls = [dropdown];
|
installOnlyOfficeGlobals(fixture.Api, { elnTemplateList: {} });
|
|
expect(parseResult(listContentControlsCommand()).controls).toEqual([
|
{
|
Alias: '检测结论',
|
ControlConfig: { options: dropdown.options, placeholder: '请选择' },
|
ControlRole: 'REFERENCE',
|
ControlType: 'dropdown',
|
InternalId: 'id-eln.ref.result.abc',
|
Lock: 'contentLocked',
|
Tag: 'eln.ref.result.abc',
|
},
|
]);
|
});
|
|
it('下拉主控件把实际选中项规范化为业务值，引用不把同步正文伪造为默认值', () => {
|
const fixture = makeApiFixture();
|
const primary = fixture.makeControl('dropdown', 'eln.field.result');
|
const reference = fixture.makeControl('dropdown', 'eln.ref.result.ref1');
|
for (const control of [primary, reference]) {
|
control.options = [
|
{ display: '合格', value: 'PASS' },
|
{ display: '不合格', value: 'FAIL' },
|
];
|
control.elements = [{ text: '不合格' }];
|
}
|
fixture.document.controls = [primary, reference];
|
installOnlyOfficeGlobals(fixture.Api, { elnTemplateList: {} });
|
|
expect(parseResult(listContentControlsCommand()).controls?.map((control) => control.ControlConfig)).toEqual([
|
{ defaultValue: 'FAIL', options: primary.options, placeholder: '' },
|
{ options: reference.options, placeholder: '' },
|
]);
|
});
|
|
it('文本、日期和多行控件不把当前正文伪造为字段默认值', () => {
|
const fixture = makeApiFixture();
|
const text = fixture.makeControl('text', 'eln.field.text');
|
const date = fixture.makeControl('date', 'eln.field.date');
|
const multiline = fixture.makeControl('multiline', 'eln.field.note');
|
text.elements = [{ text: '当前文本' }];
|
date.elements = [{ text: '2026-08-16' }];
|
multiline.elements = [{ text: '当前多行正文' }];
|
Object.assign(date, { ToJSON: () => JSON.stringify({ sdtPr: { date: { dateFormat: 'yyyy年M月d日' } } }) });
|
fixture.document.controls = [text, date, multiline];
|
installOnlyOfficeGlobals(fixture.Api, { elnTemplateList: {} });
|
|
expect(parseResult(listContentControlsCommand()).controls?.map((control) => control.ControlConfig)).toEqual([
|
{ placeholder: '' },
|
{ dateFormat: 'yyyy年M月d日', placeholder: '' },
|
{ placeholder: '' },
|
]);
|
});
|
|
it('多个类型特征同时存在时按复选、下拉、日期、多行的顺序判定', () => {
|
const fixture = makeApiFixture();
|
fixture.document.controls = [
|
Object.assign(fixture.makeControl('ambiguous', 'eln.field.ambiguous'), {
|
GetAlias: () => '歧义字段',
|
GetInternalId: () => 'ambiguous-1',
|
IsBlockLevel: () => true,
|
IsCheckBox: () => true,
|
IsComboBox: () => true,
|
IsDatePicker: () => true,
|
IsDropDownList: () => true,
|
}),
|
];
|
installOnlyOfficeGlobals(fixture.Api, { elnTemplateList: {} });
|
|
expect(parseResult(listContentControlsCommand()).controls?.[0]?.ControlType).toBe('checkbox');
|
});
|
});
|
|
describe('writeTextDefaultCommand', () => {
|
it('按唯一 Tag 成功写入文本默认值', () => {
|
const fixture = makeApiFixture();
|
const target = fixture.makeControl('text', 'eln.field.sample_id');
|
fixture.document.controls.push(target);
|
setTextDefaultScope(fixture.Api, { tag: 'eln.field.sample_id', value: 'S-001' });
|
|
const result = parseResult(writeTextDefaultCommand());
|
|
expect(result.ok).toBe(true);
|
expect(target.elements).toHaveLength(1);
|
expect(target.elements[0]?.text).toBe('S-001');
|
});
|
|
it('写入文本默认值后保留原控件字符格式', () => {
|
const fixture = makeApiFixture();
|
const target = fixture.makeControl('text', 'eln.field.sample_id');
|
target.textPr = {
|
bold: true,
|
color: { r: 23, g: 109, b: 92 },
|
fontFamily: 'SimSun',
|
fontSize: 14,
|
italic: true,
|
strikeout: true,
|
underline: true,
|
};
|
fixture.document.controls.push(target);
|
setTextDefaultScope(fixture.Api, { tag: 'eln.field.sample_id', value: 'S-001' });
|
|
const result = parseResult(writeTextDefaultCommand());
|
|
expect(result).toEqual({ ok: true });
|
expect(target.GetRange?.().GetTextPr?.()).toEqual({
|
bold: true,
|
color: { r: 23, g: 109, b: 92 },
|
fontFamily: 'SimSun',
|
fontSize: 14,
|
italic: true,
|
strikeout: true,
|
underline: true,
|
});
|
});
|
|
it.each(['AddText', 'AddElement'] as const)('%s 返回 false 时拒绝文本默认值写入', (failedStep) => {
|
const fixture = makeApiFixture();
|
const target = fixture.makeControl('text', 'eln.field.sample_id');
|
fixture.document.controls.push(target);
|
|
if (failedStep === 'AddText') {
|
fixture.Api.CreateRun = () => ({ text: '', AddText: () => false });
|
} else {
|
target.AddElement = () => false;
|
}
|
setTextDefaultScope(fixture.Api, { tag: 'eln.field.sample_id', value: 'S-001' });
|
|
const result = parseResult(writeTextDefaultCommand());
|
|
expect(result.ok).toBe(false);
|
expect(result.error).toMatch(/失败/);
|
});
|
|
it('清空返回 false 但最终回读一致时仍接受写入', () => {
|
const fixture = makeApiFixture();
|
const target = fixture.makeControl('text', 'eln.field.sample_id');
|
target.RemoveAllElements = () => false;
|
fixture.document.controls.push(target);
|
setTextDefaultScope(fixture.Api, { tag: 'eln.field.sample_id', value: 'S-001' });
|
|
const result = parseResult(writeTextDefaultCommand());
|
|
expect(result.ok).toBe(true);
|
expect(target.GetRange?.().GetText?.()).toBe('S-001');
|
});
|
|
it('文本默认值回读不一致时拒绝写入', () => {
|
const fixture = makeApiFixture();
|
const target = fixture.makeControl('text', 'eln.field.sample_id');
|
target.GetRange = () => ({ GetText: () => '旧值' });
|
fixture.document.controls.push(target);
|
setTextDefaultScope(fixture.Api, { tag: 'eln.field.sample_id', value: 'S-001' });
|
|
const result = parseResult(writeTextDefaultCommand());
|
|
expect(result.ok).toBe(false);
|
expect(result.error).toMatch(/回读/);
|
});
|
|
it.each([0, 2])('目标 Tag 匹配数量为 %i 时拒绝写入', (targetCount) => {
|
const fixture = makeApiFixture();
|
for (let index = 0; index < targetCount; index += 1) {
|
fixture.document.controls.push(fixture.makeControl('text', 'eln.field.sample_id'));
|
}
|
setTextDefaultScope(fixture.Api, { tag: 'eln.field.sample_id', value: 'S-001' });
|
|
const result = parseResult(writeTextDefaultCommand());
|
|
expect(result.ok).toBe(false);
|
expect(result.error).toMatch(/唯一控件/);
|
});
|
});
|
|
describe('command 自包含契约', () => {
|
it.each([
|
['disableTrackRevisionsCommand', disableTrackRevisionsCommand],
|
['insertTypedControlCommand', insertTypedControlCommand],
|
['listContentControlsCommand', listContentControlsCommand],
|
['readTrackRevisionsStateCommand', readTrackRevisionsStateCommand],
|
['writeTextDefaultCommand', writeTextDefaultCommand],
|
['readControlTextCommand', readControlTextCommand],
|
['setFormulaResultLockCommand', setFormulaResultLockCommand],
|
['updateControlSpecCommand', updateControlSpecCommand],
|
] as const)('%s 源码只依赖 Asc、Api 和标准全局', (_name, command) => {
|
const source = command.toString();
|
|
expect(source).not.toMatch(/\b(?:import|require|window|document)\b/);
|
expect(source).toContain('Asc.scope');
|
expect(source).toContain('Api');
|
});
|
|
it('insertTypedControlCommand 的源码可在隔离函数中执行', () => {
|
const fixture = makeApiFixture();
|
const execute = new Function('Asc', 'Api', `return (${insertTypedControlCommand.toString()})()`) as (
|
Asc: { scope: { elnTemplateInsert: InsertSpec } },
|
Api: FixtureApi,
|
) => string;
|
|
const result = parseResult(execute({ scope: { elnTemplateInsert: makeInsertSpec({ controlType: 'checkbox', defaultChecked: true }) } }, fixture.Api));
|
|
expect(result).toEqual({ ok: true, controlType: 'checkbox' });
|
expect(fixture.calls.inserted).toHaveLength(1);
|
});
|
|
it('listContentControlsCommand 的源码可在隔离函数中执行', () => {
|
const fixture = makeApiFixture();
|
const dateControl = fixture.makeControl('date', 'eln.field.date');
|
dateControl.dateFormat = 'yyyy-MM-dd';
|
fixture.document.controls = [
|
Object.assign(dateControl, {
|
GetAlias: () => '日期',
|
GetInternalId: () => 'date-1',
|
IsDatePicker: () => true,
|
}),
|
];
|
const execute = new Function('Asc', 'Api', `return (${listContentControlsCommand.toString()})()`) as (
|
Asc: { scope: { elnTemplateList: Record<string, never> } },
|
Api: FixtureApi,
|
) => string;
|
|
expect(parseResult(execute({ scope: { elnTemplateList: {} } }, fixture.Api))).toEqual({
|
ok: true,
|
controls: [
|
{
|
Alias: '日期',
|
ControlConfig: { dateFormat: 'yyyy-MM-dd', placeholder: '' },
|
ControlRole: 'PRIMARY',
|
ControlType: 'date',
|
InternalId: 'date-1',
|
Lock: 'unlocked',
|
Tag: 'eln.field.date',
|
},
|
],
|
});
|
});
|
|
it('writeTextDefaultCommand 的源码可在隔离函数中执行', () => {
|
const fixture = makeApiFixture();
|
fixture.document.controls.push(fixture.makeControl('text', 'eln.field.sample_id'));
|
const execute = new Function('Asc', 'Api', `return (${writeTextDefaultCommand.toString()})()`) as (
|
Asc: { scope: { elnTemplateTextDefault: TextDefaultSpec } },
|
Api: FixtureApi,
|
) => string;
|
|
const result = parseResult(execute({ scope: { elnTemplateTextDefault: { tag: 'eln.field.sample_id', value: 'S-001' } } }, fixture.Api));
|
|
expect(result).toEqual({ ok: true });
|
});
|
});
|
|
describe('setFormulaResultLockCommand', () => {
|
it('锁定结果主控件与其全部引用，并返回原锁快照', () => {
|
const fixture = makeApiFixture();
|
const primary = fixture.makeControl('text', 'eln.field.result');
|
const reference = fixture.makeControl('text', 'eln.ref.result.one');
|
const unrelated = fixture.makeControl('text', 'eln.field.other');
|
primary.lock = 'unlocked';
|
reference.lock = 'contentLocked';
|
unrelated.lock = 'unlocked';
|
fixture.document.controls.push(primary, reference, unrelated);
|
installOnlyOfficeGlobals(fixture.Api, { elnTemplateFormulaLocks: { mode: 'lock', primaryTag: primary.tag } });
|
|
expect(parseResult(setFormulaResultLockCommand())).toEqual({
|
ok: true,
|
snapshot: {
|
primaryTag: 'eln.field.result',
|
locks: [
|
{ tag: 'eln.field.result', lock: 'unlocked' },
|
{ tag: 'eln.ref.result.one', lock: 'contentLocked' },
|
],
|
},
|
});
|
expect(primary.lock).toBe('sdtContentLocked');
|
expect(reference.lock).toBe('sdtContentLocked');
|
expect(unrelated.lock).toBe('unlocked');
|
});
|
|
it('恢复快照后回读每个锁状态，失败时不伪装成功', () => {
|
const fixture = makeApiFixture();
|
const primary = fixture.makeControl('text', 'eln.field.result');
|
const reference = fixture.makeControl('text', 'eln.ref.result.one');
|
primary.lock = 'contentLocked';
|
reference.lock = 'contentLocked';
|
fixture.document.controls.push(primary, reference);
|
installOnlyOfficeGlobals(fixture.Api, {
|
elnTemplateFormulaLocks: {
|
mode: 'restore',
|
snapshot: {
|
primaryTag: primary.tag,
|
locks: [
|
{ tag: primary.tag, lock: 'unlocked' },
|
{ tag: reference.tag, lock: 'contentLocked' },
|
],
|
},
|
},
|
});
|
|
expect(parseResult(setFormulaResultLockCommand())).toMatchObject({ ok: true });
|
expect(primary.lock).toBe('unlocked');
|
expect(reference.lock).toBe('contentLocked');
|
});
|
});
|
|
describe('字段引用与版本更新命令', () => {
|
it('按主字段 Tag 读取唯一控件的当前文本', () => {
|
const fixture = makeApiFixture();
|
const primary = fixture.makeControl('text', 'eln.field.result');
|
primary.elements = [{ text: '12.3' }];
|
fixture.document.controls.push(primary);
|
installOnlyOfficeGlobals(fixture.Api, { elnTemplateReadText: { tag: 'eln.field.result' } });
|
|
expect(parseResult(readControlTextCommand())).toEqual({ ok: true, text: '12.3' });
|
});
|
|
it('批量更新主字段和全部引用的 Tag、Alias、配置和只读锁', () => {
|
const fixture = makeApiFixture();
|
const primary = fixture.makeControl('text', 'eln.field.result');
|
const reference = fixture.makeControl('text', 'eln.ref.result.abc');
|
primary.placeholder = '原提示';
|
reference.placeholder = '原提示';
|
fixture.document.controls.push(primary, reference);
|
installOnlyOfficeGlobals(fixture.Api, {
|
elnTemplateUpdateControls: {
|
updates: [
|
{
|
currentTag: 'eln.field.result',
|
tag: 'eln.field.result',
|
alias: '新结果',
|
controlType: 'TEXT',
|
controlConfig: { placeholder: '请输入新结果' },
|
lock: 'unlocked',
|
},
|
{
|
currentTag: 'eln.ref.result.abc',
|
tag: 'eln.ref.result.abc',
|
alias: '新结果',
|
controlType: 'TEXT',
|
controlConfig: { placeholder: '请输入新结果' },
|
lock: 'contentLocked',
|
},
|
],
|
},
|
});
|
|
expect(parseResult(updateControlSpecCommand())).toEqual({ ok: true, updated: 2 });
|
expect(primary.alias).toBe('新结果');
|
expect(primary.placeholder).toBe('请输入新结果');
|
expect(primary.lock).toBe('unlocked');
|
expect(reference.alias).toBe('新结果');
|
expect(reference.lock).toBe('contentLocked');
|
});
|
|
it('目标 placeholder 为空但旧值非空时在任何 setter 前拒绝清空', () => {
|
const fixture = makeApiFixture();
|
const control = fixture.makeControl('text', 'eln.field.result');
|
control.alias = '原结果';
|
control.lock = 'contentLocked';
|
control.placeholder = '原提示';
|
fixture.document.controls.push(control);
|
installOnlyOfficeGlobals(fixture.Api, {
|
elnTemplateUpdateControls: {
|
updates: [
|
{
|
currentTag: control.tag,
|
tag: 'eln.field.result_new',
|
alias: '新结果',
|
controlType: 'TEXT',
|
controlConfig: { placeholder: '' },
|
lock: 'unlocked',
|
},
|
],
|
removals: [],
|
},
|
});
|
|
expect(parseResult(updateControlSpecCommand())).toEqual({ ok: false, error: '当前编辑器不支持清空已有占位文本' });
|
expect(control).toMatchObject({ alias: '原结果', lock: 'contentLocked', placeholder: '原提示', tag: 'eln.field.result' });
|
});
|
|
it('已有控件 placeholder 为空但目标非空时在任何 setter 前拒绝更新', () => {
|
const fixture = makeApiFixture();
|
const control = fixture.makeControl('text', 'eln.field.result');
|
const setters = {
|
SetAlias: vi.fn(() => true),
|
SetLock: vi.fn(() => true),
|
SetPlaceholderText: vi.fn(() => true),
|
SetTag: vi.fn(() => true),
|
};
|
Object.assign(control, setters);
|
fixture.document.controls.push(control);
|
installOnlyOfficeGlobals(fixture.Api, {
|
elnTemplateUpdateControls: {
|
updates: [
|
{
|
currentTag: control.tag,
|
tag: 'eln.field.result_new',
|
alias: '新结果',
|
controlType: 'TEXT',
|
controlConfig: { placeholder: '请输入结果' },
|
lock: 'unlocked',
|
},
|
],
|
removals: [],
|
},
|
});
|
|
expect(parseResult(updateControlSpecCommand())).toEqual({ ok: false, error: '当前编辑器不支持为已有控件设置占位文本' });
|
expect(setters.SetTag).not.toHaveBeenCalled();
|
expect(setters.SetAlias).not.toHaveBeenCalled();
|
expect(setters.SetLock).not.toHaveBeenCalled();
|
expect(setters.SetPlaceholderText).not.toHaveBeenCalled();
|
});
|
|
it('目标和旧 placeholder 均为空时允许更新', () => {
|
const fixture = makeApiFixture();
|
const control = fixture.makeControl('text', 'eln.field.result');
|
fixture.document.controls.push(control);
|
installOnlyOfficeGlobals(fixture.Api, {
|
elnTemplateUpdateControls: {
|
updates: [
|
{
|
currentTag: control.tag,
|
tag: control.tag,
|
alias: '结果',
|
controlType: 'TEXT',
|
controlConfig: { placeholder: '' },
|
lock: 'unlocked',
|
},
|
],
|
removals: [],
|
},
|
});
|
|
expect(parseResult(updateControlSpecCommand())).toEqual({ ok: true, updated: 1 });
|
});
|
|
it('下拉当前值不在新选项中时在任何 setter 前拒绝更新', () => {
|
const fixture = makeApiFixture();
|
const dropdown = fixture.makeControl('dropdown', 'eln.field.conclusion');
|
dropdown.alias = '原结论';
|
dropdown.lock = 'contentLocked';
|
dropdown.placeholder = '请选择';
|
dropdown.options = [
|
{ display: '合格', value: 'PASS' },
|
{ display: '不合格', value: 'FAIL' },
|
];
|
dropdown.elements = [{ text: '合格' }];
|
fixture.document.controls.push(dropdown);
|
installOnlyOfficeGlobals(fixture.Api, {
|
elnTemplateUpdateControls: {
|
updates: [
|
{
|
currentTag: dropdown.tag,
|
tag: 'eln.field.conclusion_new',
|
alias: '新结论',
|
controlType: 'DROPDOWN',
|
controlConfig: {
|
options: [
|
{ display: '待定', value: 'PENDING' },
|
{ display: '取消', value: 'CANCELLED' },
|
],
|
placeholder: '请选择',
|
},
|
lock: 'unlocked',
|
},
|
],
|
removals: [],
|
},
|
});
|
|
expect(parseResult(updateControlSpecCommand())).toEqual({ ok: false, error: '下拉控件当前值不在新选项中' });
|
expect(dropdown).toMatchObject({
|
alias: '原结论',
|
lock: 'contentLocked',
|
options: [
|
{ display: '合格', value: 'PASS' },
|
{ display: '不合格', value: 'FAIL' },
|
],
|
tag: 'eln.field.conclusion',
|
});
|
});
|
|
it.each([
|
['空文本', ''],
|
['占位文本', '请选择'],
|
])('下拉当前为%s时视为未选中并允许更新选项', (_label, currentText) => {
|
const fixture = makeApiFixture();
|
const dropdown = fixture.makeControl('dropdown', 'eln.field.conclusion');
|
dropdown.placeholder = '请选择';
|
dropdown.options = [
|
{ display: '合格', value: 'PASS' },
|
{ display: '不合格', value: 'FAIL' },
|
];
|
dropdown.elements = currentText ? [{ text: currentText }] : [];
|
fixture.document.controls.push(dropdown);
|
installOnlyOfficeGlobals(fixture.Api, {
|
elnTemplateUpdateControls: {
|
updates: [
|
{
|
currentTag: dropdown.tag,
|
tag: dropdown.tag,
|
alias: '结论',
|
controlType: 'DROPDOWN',
|
controlConfig: {
|
options: [
|
{ display: '待定', value: 'PENDING' },
|
{ display: '取消', value: 'CANCELLED' },
|
],
|
placeholder: '请选择',
|
},
|
lock: 'unlocked',
|
},
|
],
|
removals: [],
|
},
|
});
|
|
expect(parseResult(updateControlSpecCommand())).toEqual({ ok: true, updated: 1 });
|
expect(dropdown.options).toEqual([
|
{ display: '待定', value: 'PENDING' },
|
{ display: '取消', value: 'CANCELLED' },
|
]);
|
});
|
|
it('原位更新下拉和日期配置且保留复选框当前状态', () => {
|
const fixture = makeApiFixture();
|
const dropdown = fixture.makeControl('dropdown', 'eln.field.conclusion');
|
const checkbox = fixture.makeControl('checkbox', 'eln.field.reviewed');
|
const date = fixture.makeControl('date', 'eln.field.test_date');
|
const setCheckBoxChecked = vi.fn((value: boolean) => {
|
checkbox.checked = value;
|
return true;
|
});
|
checkbox.SetCheckBoxChecked = setCheckBoxChecked;
|
dropdown.placeholder = '原提示';
|
date.placeholder = '原提示';
|
date.dateValue = new Date(2025, 5, 15);
|
fixture.document.controls.push(dropdown, checkbox, date);
|
installOnlyOfficeGlobals(fixture.Api, {
|
elnTemplateUpdateControls: {
|
updates: [
|
{
|
currentTag: dropdown.tag,
|
tag: dropdown.tag,
|
alias: '结论',
|
controlType: 'DROPDOWN',
|
controlConfig: {
|
options: [
|
{ display: '合格', value: 'PASS' },
|
{ display: '不合格', value: 'FAIL' },
|
],
|
placeholder: '请选择',
|
},
|
lock: 'unlocked',
|
},
|
{
|
currentTag: checkbox.tag,
|
tag: checkbox.tag,
|
alias: '已复核',
|
controlType: 'CHECKBOX',
|
controlConfig: { defaultChecked: true },
|
lock: 'contentLocked',
|
},
|
{
|
currentTag: date.tag,
|
tag: date.tag,
|
alias: '检验日期',
|
controlType: 'DATE',
|
controlConfig: { defaultValue: '2026-08-16', dateFormat: 'yyyy-MM-dd', placeholder: '请选择日期' },
|
lock: 'unlocked',
|
},
|
],
|
},
|
});
|
|
expect(parseResult(updateControlSpecCommand())).toEqual({ ok: true, updated: 3 });
|
expect(dropdown.options).toEqual([
|
{ display: '合格', value: 'PASS' },
|
{ display: '不合格', value: 'FAIL' },
|
]);
|
expect(checkbox.checked).toBeFalsy();
|
expect(setCheckBoxChecked).not.toHaveBeenCalled();
|
expect(date.dateFormat).toBe('yyyy-MM-dd');
|
expect(date.dateValue).toEqual(new Date(2025, 5, 15));
|
});
|
|
it('类型变化时在修改文档前明确拒绝', () => {
|
const fixture = makeApiFixture();
|
const before = fixture.makeControl('text', 'eln.field.conclusion');
|
before.elements = [{ text: '合格' }];
|
fixture.document.controls.push(before);
|
installOnlyOfficeGlobals(fixture.Api, {
|
elnTemplateUpdateControls: {
|
updates: [
|
{
|
currentTag: before.tag,
|
tag: before.tag,
|
alias: '结论',
|
controlType: 'DROPDOWN',
|
controlConfig: {
|
options: [
|
{ display: '合格', value: 'PASS' },
|
{ display: '不合格', value: 'FAIL' },
|
],
|
},
|
lock: 'unlocked',
|
},
|
],
|
},
|
});
|
|
expect(parseResult(updateControlSpecCommand())).toEqual({ ok: false, error: '当前阶段不支持修改已有控件类型' });
|
expect(fixture.document.controls).toHaveLength(1);
|
expect(fixture.document.controls[0]).toBe(before);
|
expect(fixture.calls.inserted).toHaveLength(0);
|
});
|
|
it('同类型日期升级成功时保留文档当前日期值', () => {
|
const fixture = makeApiFixture();
|
const date = fixture.makeControl('date', 'eln.field.test_date');
|
date.placeholder = '原提示';
|
date.dateValue = new Date(2025, 5, 15);
|
fixture.document.controls.push(date);
|
installOnlyOfficeGlobals(fixture.Api, {
|
elnTemplateUpdateControls: {
|
updates: [
|
{
|
currentTag: date.tag,
|
tag: date.tag,
|
alias: '检验日期',
|
controlType: 'DATE',
|
controlConfig: { defaultValue: '2026-08-16', dateFormat: 'yyyy-MM-dd', placeholder: '请选择日期' },
|
lock: 'unlocked',
|
},
|
],
|
removals: [],
|
},
|
});
|
|
expect(parseResult(updateControlSpecCommand())).toEqual({ ok: true, updated: 1 });
|
expect(date.dateValue).toEqual(new Date(2025, 5, 15));
|
});
|
|
it('日期升级后后续控件更新失败时日期值保持不变', () => {
|
const fixture = makeApiFixture();
|
const date = fixture.makeControl('date', 'eln.field.test_date');
|
const text = fixture.makeControl('text', 'eln.field.result');
|
date.dateValue = new Date(2025, 5, 15);
|
text.SetAlias = () => false;
|
fixture.document.controls.push(date, text);
|
installOnlyOfficeGlobals(fixture.Api, {
|
elnTemplateUpdateControls: {
|
updates: [
|
{
|
currentTag: date.tag,
|
tag: date.tag,
|
alias: '检验日期',
|
controlType: 'DATE',
|
controlConfig: { defaultValue: '2026-08-16', dateFormat: 'yyyy-MM-dd' },
|
lock: 'unlocked',
|
},
|
{ currentTag: text.tag, tag: text.tag, alias: '新结果', controlType: 'TEXT', controlConfig: {}, lock: 'unlocked' },
|
],
|
removals: [],
|
},
|
});
|
|
expect(parseResult(updateControlSpecCommand()).ok).toBe(false);
|
expect(date.dateValue).toEqual(new Date(2025, 5, 15));
|
});
|
|
it('主字段提升的第二个更新失败时回滚已更新控件且不删除旧主字段', () => {
|
const fixture = makeApiFixture();
|
const oldPrimary = fixture.makeControl('text', 'eln.field.result');
|
const promoted = fixture.makeControl('text', 'eln.ref.result.promoted');
|
const remainingReference = fixture.makeControl('text', 'eln.ref.result.remaining');
|
promoted.alias = '原提升引用';
|
promoted.lock = 'contentLocked';
|
promoted.placeholder = '原提示';
|
remainingReference.alias = '原保留引用';
|
remainingReference.lock = 'contentLocked';
|
remainingReference.placeholder = '原提示';
|
remainingReference.SetTag = () => false;
|
fixture.document.controls.push(oldPrimary, promoted, remainingReference);
|
installOnlyOfficeGlobals(fixture.Api, {
|
elnTemplateUpdateControls: {
|
updates: [
|
{ currentTag: promoted.tag, tag: oldPrimary.tag, alias: '结果', controlType: 'TEXT', controlConfig: { placeholder: '新提示' }, lock: 'unlocked' },
|
{
|
currentTag: remainingReference.tag,
|
tag: remainingReference.tag,
|
alias: '结果',
|
controlType: 'TEXT',
|
controlConfig: { placeholder: '新提示' },
|
lock: 'contentLocked',
|
},
|
],
|
removals: [oldPrimary.tag],
|
},
|
});
|
|
expect(parseResult(updateControlSpecCommand()).ok).toBe(false);
|
expect(promoted).toMatchObject({ alias: '原提升引用', lock: 'contentLocked', tag: 'eln.ref.result.promoted' });
|
expect(remainingReference).toMatchObject({ alias: '原保留引用', lock: 'contentLocked', tag: 'eln.ref.result.remaining' });
|
expect(fixture.document.controls).toContain(oldPrimary);
|
});
|
|
it('删除旧控件失败时回滚全部更新', () => {
|
const fixture = makeApiFixture();
|
const oldPrimary = fixture.makeControl('text', 'eln.field.result');
|
const reference = fixture.makeControl('text', 'eln.ref.result.reference');
|
reference.alias = '原引用';
|
reference.lock = 'contentLocked';
|
reference.placeholder = '原提示';
|
oldPrimary.Delete = () => false;
|
fixture.document.controls.push(oldPrimary, reference);
|
installOnlyOfficeGlobals(fixture.Api, {
|
elnTemplateUpdateControls: {
|
updates: [
|
{
|
currentTag: reference.tag,
|
tag: reference.tag,
|
alias: '新结果',
|
controlType: 'TEXT',
|
controlConfig: { placeholder: '新提示' },
|
lock: 'contentLocked',
|
},
|
],
|
removals: [oldPrimary.tag],
|
},
|
});
|
|
expect(parseResult(updateControlSpecCommand()).ok).toBe(false);
|
expect(reference).toMatchObject({ alias: '原引用', lock: 'contentLocked', placeholder: '原提示', tag: 'eln.ref.result.reference' });
|
expect(fixture.document.controls).toContain(oldPrimary);
|
});
|
|
it('删除字段控件时同时删除占位内容', () => {
|
const fixture = makeApiFixture();
|
const reference = fixture.makeControl('text', 'eln.ref.result.reference');
|
const deleteControl = vi.fn(() => true);
|
reference.Delete = deleteControl;
|
fixture.document.controls.push(reference);
|
installOnlyOfficeGlobals(fixture.Api, {
|
elnTemplateUpdateControls: {
|
updates: [],
|
removals: [reference.tag],
|
},
|
});
|
|
expect(parseResult(updateControlSpecCommand())).toEqual({ ok: true, updated: 0 });
|
expect(deleteControl).toHaveBeenCalledWith(false);
|
});
|
|
it('引用提升时先释放主 Tag，不向编辑器写入暂态重复 Tag', () => {
|
const fixture = makeApiFixture();
|
const oldPrimary = fixture.makeControl('text', 'eln.field.result');
|
const promoted = fixture.makeControl('text', 'eln.ref.result.promoted');
|
oldPrimary.SetTag = (value) => {
|
if (fixture.document.controls.some((control) => control !== oldPrimary && control.tag === value)) return false;
|
oldPrimary.tag = value;
|
return true;
|
};
|
promoted.SetTag = (value) => {
|
if (fixture.document.controls.some((control) => control !== promoted && control.tag === value)) return false;
|
promoted.tag = value;
|
return true;
|
};
|
fixture.document.controls.push(oldPrimary, promoted);
|
installOnlyOfficeGlobals(fixture.Api, {
|
elnTemplateUpdateControls: {
|
updates: [
|
{
|
currentTag: promoted.tag,
|
tag: oldPrimary.tag,
|
alias: '结果',
|
controlType: 'TEXT',
|
controlConfig: {},
|
lock: 'unlocked',
|
},
|
],
|
removals: [oldPrimary.tag],
|
},
|
});
|
|
expect(parseResult(updateControlSpecCommand())).toEqual({ ok: true, updated: 1 });
|
expect(fixture.document.controls).toHaveLength(1);
|
expect(fixture.document.controls[0]).toBe(promoted);
|
expect(promoted.tag).toBe('eln.field.result');
|
});
|
|
it('补偿 setter 失败时明确报告文档回滚失败', () => {
|
const fixture = makeApiFixture();
|
const first = fixture.makeControl('text', 'eln.field.first');
|
const second = fixture.makeControl('text', 'eln.field.second');
|
let firstSetTagCalls = 0;
|
first.SetTag = (value) => {
|
firstSetTagCalls += 1;
|
if (firstSetTagCalls > 1) return false;
|
first.tag = value;
|
return true;
|
};
|
second.SetTag = () => false;
|
fixture.document.controls.push(first, second);
|
installOnlyOfficeGlobals(fixture.Api, {
|
elnTemplateUpdateControls: {
|
updates: [
|
{ currentTag: first.tag, tag: 'eln.field.first_new', alias: '新一', controlType: 'TEXT', controlConfig: {}, lock: 'unlocked' },
|
{ currentTag: second.tag, tag: 'eln.field.second_new', alias: '新二', controlType: 'TEXT', controlConfig: {}, lock: 'unlocked' },
|
],
|
removals: [],
|
},
|
});
|
|
expect(parseResult(updateControlSpecCommand())).toMatchObject({ ok: false, error: expect.stringContaining('回滚失败') });
|
});
|
});
|
