/* @vitest-environment happy-dom */
|
|
import type { VueWrapper } from '@vue/test-utils';
|
|
import { mount } from '@vue/test-utils';
|
import { defineComponent, h, nextTick, onMounted } from 'vue';
|
|
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
|
|
import GlobalOfficeDocumentModal from '../index.vue';
|
|
const mocks = vi.hoisted(() => ({
|
afterEach: vi.fn(),
|
autoEditorReady: true,
|
closeModal: vi.fn(),
|
confirm: vi.fn(),
|
confirmDestroy: vi.fn(),
|
getOnlyOfficeConfig: vi.fn(),
|
getOnlyOfficeSaveStatus: vi.fn(),
|
grabEditorFocus: vi.fn(),
|
messageError: vi.fn(),
|
messageSuccess: vi.fn(),
|
messageWarning: vi.fn(),
|
openModal: vi.fn(),
|
printDmsDocument: vi.fn(),
|
printManagedDmsDocument: vi.fn(),
|
prepareDmsPrintAttempt: vi.fn(),
|
finishDmsPrintAttempt: vi.fn(),
|
register: vi.fn(),
|
removeRouteHook: vi.fn(),
|
requestEditorClose: vi.fn(),
|
shouldEditorClose: true,
|
}));
|
|
vi.mock('#/router', () => ({ router: { afterEach: mocks.afterEach, push: vi.fn() } }));
|
|
vi.mock('@jnpf/hooks', () => ({
|
useGlobSetting: () => ({ apiURL: '' }),
|
useMessage: () => ({
|
createConfirm: mocks.confirm,
|
createMessage: { error: mocks.messageError, success: mocks.messageSuccess, warning: mocks.messageWarning },
|
}),
|
}));
|
|
vi.mock('@jnpf/ui/modal', async () => {
|
const { defineComponent, h, onMounted } = await import('vue');
|
|
return {
|
BasicModal: defineComponent({
|
name: 'BasicModal',
|
props: { closeFunc: Function },
|
emits: ['register'],
|
setup(_, { emit, slots }) {
|
onMounted(() => emit('register'));
|
|
return () =>
|
h('section', { 'data-test': 'basic-modal' }, [
|
h('header', { 'data-test': 'modal-title' }, slots.title?.()),
|
h('main', { 'data-test': 'modal-content' }, slots.default?.()),
|
]);
|
},
|
}),
|
useModal: () => [mocks.register, { closeModal: mocks.closeModal, openModal: mocks.openModal }],
|
};
|
});
|
|
vi.mock('ant-design-vue', async () => {
|
const { defineComponent, h } = await import('vue');
|
|
return {
|
Button: defineComponent({
|
name: 'AButton',
|
emits: ['click'],
|
setup(_, { emit, slots }) {
|
return () => h('button', { type: 'button', onClick: () => emit('click') }, slots.default?.());
|
},
|
}),
|
InputNumber: defineComponent({
|
props: ['value', 'disabled'],
|
emits: ['update:value'],
|
setup(props, { emit }) {
|
return () => h('input', { value: props.value, disabled: props.disabled, onInput: (event: any) => emit('update:value', Number(event.target.value)) });
|
},
|
}),
|
Space: defineComponent({
|
name: 'ASpace',
|
setup(_, { slots }) {
|
return () => h('div', slots.default?.());
|
},
|
}),
|
Spin: defineComponent({
|
name: 'ASpin',
|
props: { tip: String },
|
setup(props) {
|
return () => h('div', { 'data-test': 'spin' }, props.tip);
|
},
|
}),
|
Tag: defineComponent({
|
name: 'ATag',
|
setup(_, { slots }) {
|
return () => h('span', { 'data-test': 'tag' }, slots.default?.());
|
},
|
}),
|
Tooltip: defineComponent({
|
name: 'ATooltip',
|
props: { placement: String, title: String },
|
setup(_, { slots }) {
|
return () => slots.default?.();
|
},
|
}),
|
};
|
});
|
|
vi.mock('#/api/x/onlyoffice', () => ({
|
getOnlyOfficeConfig: mocks.getOnlyOfficeConfig,
|
getOnlyOfficeSaveStatus: mocks.getOnlyOfficeSaveStatus,
|
}));
|
|
vi.mock('#/views/x/dms/shared/dmsHiprint', () => ({
|
DmsPrintError: class DmsPrintError extends Error {},
|
printDmsDocument: mocks.printDmsDocument,
|
printManagedDmsDocument: mocks.printManagedDmsDocument,
|
}));
|
|
vi.mock('#/views/x/dms/shared/dmsPrintAttempt', () => ({
|
prepareDmsPrintAttempt: mocks.prepareDmsPrintAttempt,
|
finishDmsPrintAttempt: mocks.finishDmsPrintAttempt,
|
}));
|
|
// 真实编辑器会去加载 DS 的 api.js，测试里换成能手动触发事件的桩
|
vi.mock('#/components/OnlyOfficeEditor/src/Editor.vue', () => ({
|
default: defineComponent({
|
name: 'OnlyOfficeEditor',
|
props: { config: { required: true, type: Object } },
|
emits: ['close', 'error', 'modified', 'ready'],
|
setup(_, { emit, expose }) {
|
onMounted(() => {
|
if (mocks.autoEditorReady) emit('ready');
|
});
|
expose({
|
grabFocus: mocks.grabEditorFocus,
|
requestClose() {
|
mocks.requestEditorClose();
|
if (mocks.shouldEditorClose) emit('close');
|
},
|
});
|
return () =>
|
h('div', {
|
'data-test': 'onlyoffice-editor',
|
onClick: () => emit('modified', true),
|
onContextmenu: () => {
|
emit('modified', true);
|
emit('modified', false);
|
},
|
onDblclick: () => {
|
emit('modified', true);
|
emit('modified', false);
|
},
|
onMouseup: () => emit('ready'),
|
});
|
},
|
}),
|
}));
|
|
const { onlineUtils } = await import('#/utils/jnpf');
|
|
const FILE = { fileId: 'file_001', name: '检验报告.docx' };
|
const CONFIG_RESPONSE = {
|
data: {
|
document: { fileType: 'docx', key: 'key_v1', title: '检验报告.docx', url: 'http://gw/api/file/Image/annex/file_001?s=sk' },
|
documentType: 'word',
|
editorConfig: { callbackUrl: 'http://gw/api/biz/onlyoffice/callback', mode: 'edit' },
|
token: 'signed.jwt.value',
|
},
|
};
|
|
let wrapper: VueWrapper<any>;
|
/** 组件注册进 router.afterEach 的那个钩子，测试里手动触发以模拟路由跳转 */
|
let routeHook: (to: any, from: any, failure?: any) => void = () => {};
|
|
async function flush(times = 3) {
|
for (let i = 0; i < times; i++) {
|
await nextTick();
|
}
|
}
|
|
describe('globalOfficeDocumentModal', () => {
|
beforeEach(() => {
|
mocks.openModal.mockClear();
|
mocks.autoEditorReady = true;
|
mocks.closeModal.mockClear();
|
mocks.confirm.mockClear();
|
mocks.confirm.mockImplementation(() => ({ destroy: mocks.confirmDestroy }));
|
mocks.confirmDestroy.mockClear();
|
mocks.removeRouteHook.mockClear();
|
mocks.getOnlyOfficeConfig.mockReset();
|
mocks.getOnlyOfficeConfig.mockResolvedValue(CONFIG_RESPONSE);
|
mocks.getOnlyOfficeSaveStatus.mockReset();
|
mocks.getOnlyOfficeSaveStatus.mockResolvedValue({ data: { lastSaveTime: null, sessionStatus: 'IDLE', version: 1 } });
|
mocks.messageSuccess.mockClear();
|
mocks.messageError.mockClear();
|
mocks.messageWarning.mockClear();
|
mocks.printManagedDmsDocument.mockReset();
|
mocks.prepareDmsPrintAttempt.mockReset();
|
mocks.finishDmsPrintAttempt.mockReset();
|
mocks.printDmsDocument.mockReset();
|
mocks.printDmsDocument.mockResolvedValue({ mode: 'hiprint' });
|
mocks.requestEditorClose.mockClear();
|
mocks.grabEditorFocus.mockClear();
|
mocks.shouldEditorClose = true;
|
mocks.afterEach.mockReset();
|
mocks.afterEach.mockImplementation((hook) => {
|
routeHook = hook;
|
return mocks.removeRouteHook;
|
});
|
wrapper = mount(GlobalOfficeDocumentModal);
|
});
|
|
afterEach(() => {
|
wrapper?.unmount();
|
});
|
|
it('重打预览打开不派发，手动发送成功才刷新关闭，固定一份', async () => {
|
const send = vi.fn().mockResolvedValue(undefined);
|
const refresh = vi.fn();
|
onlineUtils.openOfficeDocument({ file: FILE, fileType: 'dms', mode: 'view', dmsPrint: {
|
fileVersionId: 'version', copies: 1, onPrintSuccess: refresh,
|
reprint: { requestId: 'request', printRecordId: 'record', send },
|
} });
|
await flush();
|
expect(send).not.toHaveBeenCalled();
|
expect(wrapper.text()).toContain('重打份数：1 份');
|
expect(wrapper.find('[data-test="dms-print-icon"]').exists()).toBe(true);
|
expect(wrapper.find('[aria-label="关闭"]').exists()).toBe(true);
|
expect(wrapper.find('#dms-print-copies').exists()).toBe(false);
|
await wrapper.find('[aria-label="打印"]').trigger('click');
|
await flush(6);
|
expect(send).toHaveBeenCalledTimes(1);
|
expect(refresh).toHaveBeenCalledTimes(1);
|
expect(mocks.closeModal).toHaveBeenCalledTimes(1);
|
expect(mocks.printDmsDocument).not.toHaveBeenCalled();
|
expect(mocks.prepareDmsPrintAttempt).not.toHaveBeenCalled();
|
});
|
it('重打预览直接关闭不派发，不更新执行状态', async () => {
|
const send = vi.fn(); const refresh = vi.fn();
|
onlineUtils.openOfficeDocument({ file: FILE, fileType: 'dms', mode: 'view', dmsPrint: {
|
fileVersionId: 'version', onPrintSuccess: refresh, reprint: { requestId: 'request', printRecordId: 'record', send },
|
} });
|
await flush();
|
await wrapper.find('[aria-label="关闭"]').trigger('click');
|
await flush();
|
expect(send).not.toHaveBeenCalled(); expect(refresh).not.toHaveBeenCalled();
|
expect(mocks.closeModal).toHaveBeenCalledTimes(1);
|
});
|
it('重打超时停止loading，迟到成功通知仍关闭且只刷新一次', async () => {
|
const send = vi.fn().mockRejectedValue(new Error('发送结果未知')); const refresh = vi.fn();
|
onlineUtils.openOfficeDocument({ file: FILE, fileType: 'dms', mode: 'view', dmsPrint: {
|
fileVersionId: 'version', onPrintSuccess: refresh, reprint: { requestId: 'request', printRecordId: 'record', send },
|
} });
|
await flush();
|
await wrapper.find('[aria-label="打印"]').trigger('click');
|
await flush(6);
|
expect(wrapper.find('[data-test="dms-print-loading-icon"]').exists()).toBe(false);
|
expect(mocks.closeModal).not.toHaveBeenCalled();
|
onlineUtils.getEmitter().emit('DMS_REPRINT_COMPLETED', { printRecordId: 'other', requestId: 'request' });
|
await flush(); expect(refresh).not.toHaveBeenCalled();
|
onlineUtils.getEmitter().emit('DMS_REPRINT_COMPLETED', { printRecordId: 'record', requestId: 'request' });
|
onlineUtils.getEmitter().emit('DMS_REPRINT_COMPLETED', { printRecordId: 'record', requestId: 'request' });
|
await flush(6);
|
expect(refresh).toHaveBeenCalledTimes(1); expect(mocks.closeModal).toHaveBeenCalledTimes(1);
|
});
|
|
it('拿到后端 config 后才渲染编辑器，且透传文档参数和业务场景', async () => {
|
onlineUtils.openOfficeDocument({ file: FILE, bizScene: 'eln.template.annotate' });
|
await flush();
|
|
expect(mocks.openModal).toHaveBeenCalledWith(true);
|
expect(mocks.getOnlyOfficeConfig).toHaveBeenCalledWith(
|
expect.objectContaining({ bizScene: 'eln.template.annotate', fileId: 'file_001', fileName: '检验报告.docx', fileType: 'annex', mode: 'edit' }),
|
);
|
expect(mocks.getOnlyOfficeSaveStatus).toHaveBeenCalledWith('file_001', 'annex');
|
expect(wrapper.find('[data-test="onlyoffice-editor"]').exists()).toBe(true);
|
});
|
|
it('弹窗打开失败时提示并通知调用方，之后可以重试', async () => {
|
const error = new Error('useModal instance is undefined!');
|
const onOpenError = vi.fn();
|
mocks.openModal.mockImplementationOnce(() => {
|
throw error;
|
});
|
onlineUtils.openOfficeDocument({ file: FILE, onOpenError });
|
await flush();
|
expect(mocks.messageError).toHaveBeenCalledWith(error.message);
|
expect(onOpenError).toHaveBeenCalledWith(error);
|
expect(mocks.getOnlyOfficeConfig).not.toHaveBeenCalled();
|
onlineUtils.openOfficeDocument({ file: FILE, mode: 'view' });
|
await flush();
|
expect(mocks.getOnlyOfficeConfig).toHaveBeenCalled();
|
});
|
|
it('关闭预览后可打开上传附件编辑，并显示配置接口错误', async () => {
|
mocks.getOnlyOfficeConfig.mockResolvedValueOnce({ data: { ...CONFIG_RESPONSE.data, editorConfig: { mode: 'view' } } });
|
onlineUtils.openOfficeDocument({ file: FILE, mode: 'view' });
|
await flush();
|
await wrapper.find('button[aria-label="关闭"]').trigger('click');
|
await flush();
|
mocks.getOnlyOfficeConfig.mockRejectedValueOnce(new Error('系统异常'));
|
onlineUtils.openOfficeDocument({ file: { ...FILE, fileId: 'lease' }, bizScene: 'visualdev.uploadFile', mode: 'edit' });
|
await flush(6);
|
expect(mocks.openModal).toHaveBeenCalledTimes(2);
|
expect(wrapper.find('.state-pane').text()).toBe('系统异常');
|
});
|
|
it('DMS 预览把文件类型和短期票据交给配置签发接口', async () => {
|
onlineUtils.openOfficeDocument({
|
dmsAccessTicket: 'ticket-1',
|
file: { fileId: 'version-1', name: '质量手册.docx' },
|
fileType: 'dms',
|
mode: 'view',
|
});
|
await flush();
|
|
expect(mocks.getOnlyOfficeConfig).toHaveBeenCalledWith(
|
expect.objectContaining({
|
dmsAccessTicket: 'ticket-1',
|
fileId: 'version-1',
|
fileName: '质量手册.docx',
|
fileType: 'dms',
|
mode: 'view',
|
}),
|
);
|
});
|
|
it('DMS 票据失效时静默换票并继续打开预览', async () => {
|
mocks.getOnlyOfficeConfig.mockRejectedValueOnce(new Error('DMS 预览票据无效或已过期'));
|
const refresh = vi.fn().mockResolvedValue({ accessTicket: 'fresh-ticket', fileVersionId: 'version-1', fileName: '质量手册.docx' });
|
onlineUtils.openOfficeDocument({
|
dmsAccessTicket: 'expired-ticket',
|
refreshDmsPreviewTicket: refresh,
|
file: { fileId: 'version-1', name: '质量手册.docx' },
|
fileType: 'dms',
|
mode: 'view',
|
});
|
await flush(12);
|
expect(refresh).toHaveBeenCalledTimes(1);
|
expect(mocks.getOnlyOfficeConfig).toHaveBeenLastCalledWith(expect.objectContaining({ dmsAccessTicket: 'fresh-ticket', fileId: 'version-1' }), {
|
errorMessageMode: 'none',
|
});
|
expect(wrapper.find('[data-test="onlyoffice-editor"]').exists()).toBe(true);
|
expect(mocks.messageError).not.toHaveBeenCalled();
|
});
|
|
it('仅为携带打印上下文的 DMS 预览显示打印按钮', async () => {
|
onlineUtils.openOfficeDocument({ file: FILE, mode: 'view' });
|
await flush();
|
expect(wrapper.find('[aria-label="打印"]').exists()).toBe(false);
|
|
onlineUtils.openOfficeDocument({
|
dmsPrint: { copies: 1, fileVersionId: 'version-1', pageVariables: [] },
|
file: { fileId: 'version-1', name: '质量手册.docx' },
|
fileType: 'dms',
|
mode: 'view',
|
});
|
await flush();
|
expect(wrapper.find('[aria-label="打印"]').exists()).toBe(true);
|
});
|
|
it('OnlyOffice 文档未 ready 前禁用打印，ready 后才允许点击', async () => {
|
mocks.autoEditorReady = false;
|
onlineUtils.openOfficeDocument({
|
dmsPrint: { copies: 1, fileVersionId: 'version-1', pageVariables: [] },
|
file: { fileId: 'version-1', name: '质量手册.docx' },
|
fileType: 'dms',
|
mode: 'view',
|
});
|
await flush();
|
|
const printButton = wrapper.find('[aria-label="打印"]');
|
expect(printButton.attributes('disabled')).toBeDefined();
|
await printButton.trigger('click');
|
expect(mocks.printDmsDocument).not.toHaveBeenCalled();
|
|
await wrapper.find('[data-test="onlyoffice-editor"]').trigger('mouseup');
|
await flush();
|
expect(wrapper.find('[aria-label="打印"]').attributes('disabled')).toBeUndefined();
|
});
|
|
it('Hiprint 离线时不进入打印票据和 PDF 编排链路', async () => {
|
const ready = vi.spyOn(onlineUtils, 'isHiprintClientReady').mockResolvedValue(false);
|
onlineUtils.openOfficeDocument({
|
dmsPrint: { copies: 1, fileVersionId: 'version-1', pageVariables: [] },
|
file: { fileId: 'version-1', name: '质量手册.docx' },
|
fileType: 'dms',
|
mode: 'view',
|
});
|
await flush();
|
|
await wrapper.find('[aria-label="打印"]').trigger('click');
|
await flush();
|
|
expect(mocks.printDmsDocument).not.toHaveBeenCalled();
|
expect(mocks.messageError).toHaveBeenCalledWith('打印客户端未连接，请启动客户端后重试');
|
ready.mockRestore();
|
});
|
|
it('打印前回调成功后才进入 PDF 编排，回调失败时终止打印', async () => {
|
const beforePrint = vi.fn().mockResolvedValueOnce(undefined).mockRejectedValueOnce(new Error('打印确认失败'));
|
const ready = vi.spyOn(onlineUtils, 'isHiprintClientReady').mockResolvedValue(true);
|
onlineUtils.openOfficeDocument({
|
dmsPrint: { beforePrint, copies: 1, fileVersionId: 'version-1', pageVariables: [] },
|
file: { fileId: 'version-1', name: '质量手册.docx' },
|
fileType: 'dms',
|
mode: 'view',
|
});
|
await flush();
|
|
await wrapper.find('[aria-label="打印"]').trigger('click');
|
await flush();
|
expect(beforePrint).toHaveBeenCalledTimes(1);
|
expect(mocks.printDmsDocument).toHaveBeenCalledTimes(1);
|
|
await wrapper.find('[aria-label="打印"]').trigger('click');
|
await flush();
|
expect(beforePrint).toHaveBeenCalledTimes(2);
|
expect(mocks.printDmsDocument).toHaveBeenCalledTimes(1);
|
expect(mocks.messageError).toHaveBeenCalledWith('打印确认失败');
|
ready.mockRestore();
|
});
|
|
it('打印中和打印完成时原子切换加载与打印图标', async () => {
|
let completePrint: (value: unknown) => void = () => {};
|
mocks.printDmsDocument.mockImplementation(
|
() =>
|
new Promise((resolve) => {
|
completePrint = resolve;
|
}),
|
);
|
const ready = vi.spyOn(onlineUtils, 'isHiprintClientReady').mockResolvedValue(true);
|
onlineUtils.openOfficeDocument({
|
dmsPrint: { copies: 1, fileVersionId: 'version-1', pageVariables: [] },
|
file: { fileId: 'version-1', name: '质量手册.docx' },
|
fileType: 'dms',
|
mode: 'view',
|
});
|
await flush();
|
|
await wrapper.find('[aria-label="打印"]').trigger('click');
|
await flush();
|
expect(wrapper.find('[data-test="dms-print-loading-icon"]').exists()).toBe(true);
|
expect(wrapper.find('[data-test="dms-print-icon"]').exists()).toBe(false);
|
|
completePrint({ mode: 'hiprint' });
|
await flush(5);
|
expect(wrapper.find('[data-test="dms-print-loading-icon"]').exists()).toBe(false);
|
expect(wrapper.find('[data-test="dms-print-icon"]').exists()).toBe(true);
|
ready.mockRestore();
|
});
|
|
it('所有 Hiprint 批次确认成功后等待业务回调再关闭预览', async () => {
|
const order: string[] = [];
|
const onPrintSuccess = vi.fn(() => {
|
order.push('refresh');
|
});
|
mocks.closeModal.mockImplementation(() => order.push('close'));
|
mocks.printDmsDocument.mockImplementation(async (_fileName, printConfig) => {
|
await printConfig.onPrintSuccess?.();
|
return { mode: 'hiprint' };
|
});
|
const ready = vi.spyOn(onlineUtils, 'isHiprintClientReady').mockResolvedValue(true);
|
onlineUtils.openOfficeDocument({
|
dmsPrint: {
|
closeOnPrintSuccess: true,
|
copies: 1,
|
fileVersionId: 'version-1',
|
onPrintSuccess,
|
pageVariables: [],
|
},
|
file: { fileId: 'version-1', name: '质量手册.docx' },
|
fileType: 'dms',
|
mode: 'view',
|
});
|
await flush();
|
|
await wrapper.find('[aria-label="打印"]').trigger('click');
|
await flush();
|
|
expect(order).toEqual(['refresh', 'close']);
|
expect(mocks.closeModal).toHaveBeenCalledTimes(1);
|
expect(onPrintSuccess).toHaveBeenCalledTimes(1);
|
ready.mockRestore();
|
});
|
|
it('成功回传后的确认失败仅重试确认，期间阻止关闭和新预览', async () => {
|
const attempt = { id: 'attempt', taskId: 'task', copies: 3, state: 'OPEN' };
|
mocks.prepareDmsPrintAttempt.mockResolvedValue(attempt);
|
mocks.finishDmsPrintAttempt.mockRejectedValueOnce(new Error('确认网络异常')).mockResolvedValueOnce(undefined);
|
const refresh = vi.fn();
|
const ready = vi.spyOn(onlineUtils, 'isHiprintClientReady').mockResolvedValue(true);
|
mocks.printManagedDmsDocument.mockResolvedValue(undefined);
|
onlineUtils.openOfficeDocument({
|
dmsPrint: {
|
printQuantity: { total: 10, printed: 2 },
|
printTaskId: 'task',
|
onPrintSuccess: refresh,
|
closeOnPrintSuccess: true,
|
copies: 1,
|
fileVersionId: 'version-1',
|
},
|
file: { fileId: 'version-1', name: '质量手册.docx' },
|
fileType: 'dms',
|
mode: 'view',
|
});
|
await flush();
|
expect(wrapper.find('[data-test="print-quantity-summary"]').text()).toContain('剩余份数：8');
|
expect((wrapper.find('[aria-label="本次打印份数"]').element as HTMLInputElement).value).toBe('1');
|
await wrapper.find('[aria-label="本次打印份数"]').setValue('3');
|
await wrapper.find('[aria-label="打印"]').trigger('click');
|
await flush(5);
|
expect(mocks.finishDmsPrintAttempt).toHaveBeenCalledWith(attempt);
|
expect(mocks.printManagedDmsDocument.mock.calls[0]![2].copies).toBe(3);
|
expect(wrapper.find('[aria-label="本次打印份数"]').attributes('disabled')).toBeDefined();
|
expect(refresh).not.toHaveBeenCalled();
|
expect(mocks.closeModal).not.toHaveBeenCalled();
|
await wrapper.find('[aria-label="关闭"]').trigger('click');
|
onlineUtils.openOfficeDocument({ file: { fileId: 'other', name: 'other.docx' }, mode: 'view' });
|
await flush();
|
expect(mocks.closeModal).not.toHaveBeenCalled();
|
await wrapper.find('[aria-label="重试记录确认"]').trigger('click');
|
await flush(5);
|
expect(mocks.finishDmsPrintAttempt).toHaveBeenCalledTimes(2);
|
expect(mocks.finishDmsPrintAttempt).toHaveBeenLastCalledWith(attempt);
|
expect(mocks.printManagedDmsDocument).toHaveBeenCalledTimes(1);
|
expect(mocks.prepareDmsPrintAttempt).toHaveBeenCalledTimes(1);
|
expect(refresh).toHaveBeenCalledTimes(1);
|
expect(mocks.closeModal).toHaveBeenCalledTimes(1);
|
ready.mockRestore();
|
});
|
|
it('旧台账配置在发送前阻断，不能先打印后被后端拒绝', async () => {
|
onlineUtils.openOfficeDocument({
|
dmsPrint: { printQuantity: { total: 10, printed: 0 }, confirmPrint: vi.fn(), fileVersionId: 'version-1' },
|
file: { fileId: 'version-1', name: '质量手册.docx' },
|
fileType: 'dms',
|
mode: 'view',
|
});
|
await flush();
|
await wrapper.find('[aria-label="打印"]').trigger('click');
|
await flush();
|
expect(mocks.printDmsDocument).not.toHaveBeenCalled();
|
expect(mocks.messageError).toHaveBeenCalledWith(expect.stringContaining('台账配置需要更新'));
|
});
|
|
it('重新打开后恢复原技术任务份数，未知结果只走恢复入口', async () => {
|
const attempt = { id: 'original', taskId: 'task', copies: 2, state: 'OPEN' };
|
mocks.prepareDmsPrintAttempt.mockResolvedValue(attempt);
|
mocks.printManagedDmsDocument.mockRejectedValueOnce(new Error('发送结果未知')).mockResolvedValueOnce(undefined);
|
mocks.finishDmsPrintAttempt.mockResolvedValue(undefined);
|
onlineUtils.openOfficeDocument({
|
dmsPrint: { printTaskId: 'task', printQuantity: { total: 10, printed: 1 }, fileVersionId: 'version-1' },
|
file: { fileId: 'version-1', name: '质量手册.docx' },
|
fileType: 'dms',
|
mode: 'view',
|
});
|
await flush();
|
await wrapper.find('[aria-label="打印"]').trigger('click');
|
await flush(5);
|
expect((wrapper.find('[aria-label="本次打印份数"]').element as HTMLInputElement).value).toBe('2');
|
expect(mocks.finishDmsPrintAttempt).not.toHaveBeenCalled();
|
await wrapper.find('[aria-label="恢复打印任务"]').trigger('click');
|
await flush(5);
|
expect(mocks.prepareDmsPrintAttempt).toHaveBeenCalledTimes(2);
|
expect(mocks.printManagedDmsDocument.mock.calls[1]![2].id).toBe('original');
|
expect(mocks.finishDmsPrintAttempt).toHaveBeenCalledTimes(1);
|
expect(mocks.printDmsDocument).not.toHaveBeenCalled();
|
});
|
|
it('异步确认未完成前不刷新、不关闭且保持忙碌', async () => {
|
let resolveConfirmation!: () => void;
|
const confirmPrint = vi.fn(
|
() =>
|
new Promise<void>((resolve) => {
|
resolveConfirmation = resolve;
|
}),
|
);
|
const refresh = vi.fn();
|
const ready = vi.spyOn(onlineUtils, 'isHiprintClientReady').mockResolvedValue(true);
|
mocks.printDmsDocument.mockImplementation(async (_name, options) => {
|
await options.onPrintSuccess();
|
});
|
onlineUtils.openOfficeDocument({
|
dmsPrint: { confirmPrint, onPrintSuccess: refresh, closeOnPrintSuccess: true, copies: 1, fileVersionId: 'version-1' },
|
file: { fileId: 'version-1', name: '质量手册.docx' },
|
fileType: 'dms',
|
mode: 'view',
|
});
|
await flush();
|
await wrapper.find('[aria-label="打印"]').trigger('click');
|
await flush();
|
expect(confirmPrint).toHaveBeenCalledTimes(1);
|
expect(refresh).not.toHaveBeenCalled();
|
expect(mocks.closeModal).not.toHaveBeenCalled();
|
expect(wrapper.find('[aria-label="正在打印"]').exists()).toBe(true);
|
resolveConfirmation();
|
await flush(5);
|
expect(refresh).toHaveBeenCalledTimes(1);
|
expect(mocks.closeModal).toHaveBeenCalledTimes(1);
|
ready.mockRestore();
|
});
|
|
it('打印失败时不关闭预览且不执行成功回调', async () => {
|
const onPrintSuccess = vi.fn();
|
mocks.printDmsDocument.mockRejectedValue(new Error('打印失败'));
|
const ready = vi.spyOn(onlineUtils, 'isHiprintClientReady').mockResolvedValue(true);
|
onlineUtils.openOfficeDocument({
|
dmsPrint: {
|
closeOnPrintSuccess: true,
|
copies: 1,
|
fileVersionId: 'version-1',
|
onPrintSuccess,
|
pageVariables: [],
|
},
|
file: { fileId: 'version-1', name: '质量手册.docx' },
|
fileType: 'dms',
|
mode: 'view',
|
});
|
await flush();
|
|
await wrapper.find('[aria-label="打印"]').trigger('click');
|
await flush();
|
|
expect(mocks.closeModal).not.toHaveBeenCalled();
|
expect(onPrintSuccess).not.toHaveBeenCalled();
|
expect(wrapper.find('[data-test="dms-print-loading-icon"]').exists()).toBe(false);
|
expect(wrapper.find('[data-test="dms-print-icon"]').exists()).toBe(true);
|
expect(mocks.messageError).toHaveBeenCalledWith('打印失败');
|
ready.mockRestore();
|
});
|
|
it('批注预览不查询保存状态，审批模式沿用保存基线', async () => {
|
onlineUtils.openOfficeDocument({ file: FILE, mode: 'viewComments' });
|
await flush();
|
expect(mocks.getOnlyOfficeSaveStatus).not.toHaveBeenCalled();
|
expect(mocks.getOnlyOfficeConfig).toHaveBeenCalledWith(expect.objectContaining({ mode: 'viewComments' }));
|
onlineUtils.openOfficeDocument({ file: FILE, mode: 'review' });
|
await flush();
|
expect(mocks.getOnlyOfficeSaveStatus).toHaveBeenCalledWith('file_001', 'annex');
|
expect(mocks.getOnlyOfficeConfig).toHaveBeenCalledWith(expect.objectContaining({ mode: 'review' }));
|
});
|
|
it('签批页模式按可编辑模式获取配置与保存状态', async () => {
|
onlineUtils.openOfficeDocument({ file: FILE, mode: 'qianpiye' });
|
await flush();
|
|
expect(mocks.getOnlyOfficeSaveStatus).toHaveBeenCalledWith('file_001', 'annex');
|
expect(mocks.getOnlyOfficeConfig).toHaveBeenCalledWith(
|
expect.objectContaining({ bizModule: 'dms', bizScene: 'dms.qianpiye', fileId: 'file_001', mode: 'qianpiye' }),
|
);
|
});
|
|
it('config 和状态查询使用同一文件存储类型', async () => {
|
onlineUtils.openOfficeDocument({ file: FILE, fileType: 'temporary' });
|
await flush();
|
|
expect(mocks.getOnlyOfficeConfig).toHaveBeenCalledWith(expect.objectContaining({ fileType: 'temporary' }));
|
expect(mocks.getOnlyOfficeSaveStatus).toHaveBeenCalledWith('file_001', 'temporary');
|
});
|
|
it('编辑器挂载前必须取得保存基线，避免首次 status 6 被误当成基线', async () => {
|
mocks.getOnlyOfficeSaveStatus.mockRejectedValueOnce(new Error('save-status unavailable'));
|
|
onlineUtils.openOfficeDocument({ file: FILE });
|
await flush();
|
|
expect(mocks.getOnlyOfficeConfig).not.toHaveBeenCalled();
|
expect(wrapper.find('[data-test="onlyoffice-editor"]').exists()).toBe(false);
|
expect(wrapper.find('[data-test="modal-content"]').text()).toContain('save-status unavailable');
|
});
|
|
it('普通标注不发送 repairBindingId，修复时准确透传绑定 ID', async () => {
|
onlineUtils.openOfficeDocument({ file: FILE, bizScene: 'eln.template.annotate' });
|
await flush();
|
|
expect(mocks.getOnlyOfficeConfig).toHaveBeenLastCalledWith(expect.not.objectContaining({ repairBindingId: expect.anything() }));
|
|
onlineUtils.openOfficeDocument({ file: FILE, bizScene: 'eln.template.annotate', repairBindingId: 'binding-1' });
|
await flush();
|
|
expect(mocks.getOnlyOfficeConfig).toHaveBeenLastCalledWith(expect.objectContaining({ repairBindingId: 'binding-1' }));
|
});
|
|
it('普通打开不发送 locateControlTag，体检定位时准确透传控件 Tag', async () => {
|
onlineUtils.openOfficeDocument({ file: FILE, bizScene: 'eln.template.annotate' });
|
await flush();
|
expect(mocks.getOnlyOfficeConfig).toHaveBeenLastCalledWith(expect.not.objectContaining({ locateControlTag: expect.anything() }));
|
|
onlineUtils.openOfficeDocument({ file: FILE, bizScene: 'eln.template.annotate', locateControlTag: 'eln.field.orphan', mode: 'view' });
|
await flush();
|
expect(mocks.getOnlyOfficeConfig).toHaveBeenLastCalledWith(expect.objectContaining({ locateControlTag: 'eln.field.orphan', mode: 'view' }));
|
});
|
|
it('后端把 edit 降级为 view 时给出只读提示', async () => {
|
mocks.getOnlyOfficeConfig.mockResolvedValue({
|
data: { ...CONFIG_RESPONSE.data, editorConfig: { ...CONFIG_RESPONSE.data.editorConfig, mode: 'view' } },
|
});
|
|
onlineUtils.openOfficeDocument({ file: FILE, mode: 'edit' });
|
await flush();
|
|
// 标签紧跟标题，不在右侧按钮区——放右边太容易被当成装饰略过
|
expect(wrapper.find('.header-main [data-test="tag"]').exists()).toBe(true);
|
});
|
|
it('config 缺 token 时不渲染编辑器——没有签名 DS 一定会拒，早报错好过让编辑器空转', async () => {
|
mocks.getOnlyOfficeConfig.mockResolvedValue({ data: { document: { key: 'key_v1' } } });
|
|
onlineUtils.openOfficeDocument({ file: FILE });
|
await flush();
|
|
expect(wrapper.find('[data-test="onlyoffice-editor"]').exists()).toBe(false);
|
expect(wrapper.text()).toContain('编辑器配置不完整');
|
});
|
|
it('改动过再关闭才触发 onSave，onClose 则总会触发', async () => {
|
const onSave = vi.fn();
|
const onClose = vi.fn();
|
|
onlineUtils.openOfficeDocument({ file: FILE, onClose, onSave });
|
await flush();
|
|
await wrapper.find('[data-test="onlyoffice-editor"]').trigger('click'); // 桩组件的 click = emit modified
|
await wrapper.find('button').trigger('click'); // 头部关闭按钮
|
await flush();
|
|
expect(mocks.confirm).toHaveBeenCalledWith(
|
expect.objectContaining({
|
cancelText: '继续编辑',
|
content: '关闭后，当前未保存的文档更改将丢失。',
|
okText: '放弃并关闭',
|
okType: 'danger',
|
title: '放弃未保存的更改？',
|
}),
|
);
|
expect(mocks.requestEditorClose).not.toHaveBeenCalled();
|
mocks.confirm.mock.calls[0]?.[0].onOk();
|
await flush();
|
|
expect(mocks.requestEditorClose).not.toHaveBeenCalled();
|
expect(onSave).toHaveBeenCalledWith({ file: FILE, modified: true });
|
expect(onClose).toHaveBeenCalledTimes(1);
|
expect(mocks.closeModal).toHaveBeenCalled();
|
});
|
|
it('提交收尾委托编辑器关闭并等待服务端释放，不走放弃修改分支', async () => {
|
const registerSubmitPreparation = vi.fn();
|
const onClose = vi.fn();
|
onlineUtils.openOfficeDocument({ file: FILE, onClose, registerSubmitPreparation });
|
await flush();
|
await wrapper.find('[data-test="onlyoffice-editor"]').trigger('click');
|
let release!: (value: unknown) => void;
|
mocks.getOnlyOfficeSaveStatus.mockImplementationOnce(() => new Promise((resolve) => { release = resolve; }));
|
const prepare = registerSubmitPreparation.mock.calls[0]![0];
|
let finished = false;
|
const pending = prepare().then(() => { finished = true; });
|
await flush();
|
expect(mocks.requestEditorClose).toHaveBeenCalledOnce();
|
expect(mocks.confirm).not.toHaveBeenCalled();
|
expect(finished).toBe(false);
|
release({ data: { sessionStatus: 'IDLE', lastSaveTime: 200 } });
|
await pending;
|
expect(onClose).toHaveBeenCalledOnce();
|
expect(registerSubmitPreparation).toHaveBeenLastCalledWith(undefined);
|
});
|
|
it('没改动就关闭不触发 onSave', async () => {
|
const onSave = vi.fn();
|
|
onlineUtils.openOfficeDocument({ file: FILE, onSave });
|
await flush();
|
await wrapper.find('button').trigger('click');
|
await flush();
|
|
expect(onSave).not.toHaveBeenCalled();
|
});
|
|
it('编辑器关闭后等待后端会话空闲才完成外层关闭', async () => {
|
const onClose = vi.fn();
|
let resolveReleaseStatus: (value: any) => void = () => {};
|
mocks.getOnlyOfficeSaveStatus
|
.mockResolvedValueOnce({ data: { lastSaveTime: null, sessionStatus: 'IDLE', version: 1 } })
|
.mockReturnValueOnce(new Promise((resolve) => (resolveReleaseStatus = resolve)));
|
|
onlineUtils.openOfficeDocument({ file: FILE, onClose });
|
await flush();
|
await wrapper.find('button').trigger('click');
|
await flush();
|
|
expect(mocks.requestEditorClose).toHaveBeenCalledTimes(1);
|
expect(wrapper.find('[data-test="onlyoffice-editor"]').exists()).toBe(false);
|
expect(wrapper.find('[data-test="document-saving-mask"]').text()).toContain('正在关闭文档');
|
expect(mocks.closeModal).not.toHaveBeenCalled();
|
expect(onClose).not.toHaveBeenCalled();
|
|
resolveReleaseStatus({ data: { lastSaveTime: null, sessionStatus: 'IDLE', version: 2 } });
|
await flush();
|
|
expect(mocks.closeModal).toHaveBeenCalledTimes(1);
|
expect(onClose).toHaveBeenCalledTimes(1);
|
});
|
|
it('等待会话释放期间路由切换也不能提前完成关闭', async () => {
|
let resolveReleaseStatus: (value: any) => void = () => {};
|
mocks.getOnlyOfficeSaveStatus
|
.mockResolvedValueOnce({ data: { lastSaveTime: null, sessionStatus: 'IDLE', version: 1 } })
|
.mockReturnValueOnce(new Promise((resolve) => (resolveReleaseStatus = resolve)));
|
|
onlineUtils.openOfficeDocument({ file: FILE });
|
await flush();
|
await wrapper.find('button').trigger('click');
|
await flush();
|
|
routeHook({ fullPath: '/b' }, { fullPath: '/a' });
|
await flush();
|
|
expect(mocks.closeModal).not.toHaveBeenCalled();
|
|
resolveReleaseStatus({ data: { lastSaveTime: null, sessionStatus: 'IDLE', version: 2 } });
|
await flush();
|
|
expect(mocks.closeModal).toHaveBeenCalledTimes(1);
|
});
|
|
it('会话释放超时不强制关闭并允许用户重试', async () => {
|
vi.useFakeTimers();
|
mocks.getOnlyOfficeSaveStatus
|
.mockResolvedValueOnce({ data: { lastSaveTime: null, sessionStatus: 'IDLE', version: 1 } })
|
.mockResolvedValue({ data: { lastSaveTime: null, sessionStatus: 'EDITING', version: 1 } });
|
|
onlineUtils.openOfficeDocument({ file: FILE });
|
await flush();
|
await wrapper.find('button').trigger('click');
|
await flush();
|
await vi.advanceTimersByTimeAsync(60_000);
|
await flush();
|
|
expect(mocks.closeModal).not.toHaveBeenCalled();
|
expect(mocks.messageError).toHaveBeenCalledWith('文档会话尚未结束，请稍后重试关闭');
|
|
mocks.getOnlyOfficeSaveStatus.mockResolvedValueOnce({ data: { lastSaveTime: null, sessionStatus: 'IDLE', version: 2 } });
|
await wrapper.find('button').trigger('click');
|
await flush();
|
|
expect(mocks.closeModal).toHaveBeenCalledTimes(1);
|
vi.useRealTimers();
|
});
|
|
it('选择继续编辑后等确认框退场再恢复文档焦点，保留原编辑器', async () => {
|
const onClose = vi.fn();
|
|
onlineUtils.openOfficeDocument({ file: FILE, onClose });
|
await flush();
|
await wrapper.find('[data-test="onlyoffice-editor"]').trigger('click');
|
await wrapper.find('button').trigger('click');
|
await flush();
|
|
expect(mocks.confirm).toHaveBeenCalledTimes(1);
|
expect(mocks.requestEditorClose).not.toHaveBeenCalled();
|
const confirm = mocks.confirm.mock.calls[0]?.[0];
|
expect(confirm.focusTriggerAfterClose).toBe(false);
|
confirm.onCancel();
|
await flush();
|
|
expect(mocks.grabEditorFocus).not.toHaveBeenCalled();
|
await confirm.afterClose();
|
expect(mocks.grabEditorFocus).toHaveBeenCalledTimes(1);
|
|
expect(mocks.closeModal).not.toHaveBeenCalled();
|
expect(onClose).not.toHaveBeenCalled();
|
expect(wrapper.find('[data-test="onlyoffice-editor"]').exists()).toBe(true);
|
});
|
|
it('确认放弃并关闭时不恢复文档焦点', async () => {
|
onlineUtils.openOfficeDocument({ file: FILE });
|
await flush();
|
await wrapper.find('[data-test="onlyoffice-editor"]').trigger('click');
|
await wrapper.find('button').trigger('click');
|
const confirm = mocks.confirm.mock.calls[0]?.[0];
|
|
await confirm.onOk();
|
await confirm.afterClose();
|
|
expect(mocks.grabEditorFocus).not.toHaveBeenCalled();
|
expect(mocks.closeModal).toHaveBeenCalledTimes(1);
|
});
|
|
it('继续编辑后打开另一文档，旧确认框退场不能抢新文档焦点', async () => {
|
onlineUtils.openOfficeDocument({ file: FILE });
|
await flush();
|
await wrapper.find('[data-test="onlyoffice-editor"]').trigger('click');
|
await wrapper.find('button').trigger('click');
|
const confirm = mocks.confirm.mock.calls[0]?.[0];
|
confirm.onCancel();
|
|
onlineUtils.openOfficeDocument({ file: { fileId: 'file_002', name: '另一文档.docx' } });
|
await flush();
|
await confirm.afterClose();
|
|
expect(mocks.grabEditorFocus).not.toHaveBeenCalled();
|
});
|
|
it('连续弹出关闭确认时，旧确认框退场不能抢当前确认框焦点', async () => {
|
onlineUtils.openOfficeDocument({ file: FILE });
|
await flush();
|
await wrapper.find('[data-test="onlyoffice-editor"]').trigger('click');
|
await wrapper.find('button').trigger('click');
|
const firstConfirm = mocks.confirm.mock.calls[0]?.[0];
|
firstConfirm.onCancel();
|
await wrapper.find('button').trigger('click');
|
await firstConfirm.afterClose();
|
expect(mocks.grabEditorFocus).not.toHaveBeenCalled();
|
|
const secondConfirm = mocks.confirm.mock.calls[1]?.[0];
|
secondConfirm.onCancel();
|
await secondConfirm.afterClose();
|
expect(mocks.grabEditorFocus).toHaveBeenCalledTimes(1);
|
});
|
|
it('未保存确认框打开期间忽略重复关闭请求', async () => {
|
onlineUtils.openOfficeDocument({ file: FILE });
|
await flush();
|
await wrapper.find('[data-test="onlyoffice-editor"]').trigger('click');
|
|
await wrapper.find('button').trigger('click');
|
await wrapper.find('button').trigger('click');
|
await flush();
|
|
expect(mocks.confirm).toHaveBeenCalledTimes(1);
|
expect(mocks.closeModal).not.toHaveBeenCalled();
|
});
|
|
it('确认框打开后路由跳转会关闭确认框和编辑器', async () => {
|
onlineUtils.openOfficeDocument({ file: FILE });
|
await flush();
|
await wrapper.find('[data-test="onlyoffice-editor"]').trigger('click');
|
await wrapper.find('button').trigger('click');
|
await flush();
|
|
routeHook({ fullPath: '/b' }, { fullPath: '/a' });
|
await flush();
|
|
expect(mocks.confirmDestroy).toHaveBeenCalledTimes(1);
|
expect(mocks.closeModal).toHaveBeenCalledTimes(1);
|
expect(wrapper.find('[data-test="onlyoffice-editor"]').exists()).toBe(false);
|
});
|
|
it('onlyoffice 关闭请求也进入应用未保存确认流程', async () => {
|
onlineUtils.openOfficeDocument({ file: FILE });
|
await flush();
|
const editor = wrapper.getComponent({ name: 'OnlyOfficeEditor' });
|
|
editor.vm.$emit('modified', true);
|
editor.vm.$emit('close');
|
await flush();
|
|
expect(mocks.confirm).toHaveBeenCalledWith(expect.objectContaining({ title: '放弃未保存的更改？' }));
|
expect(mocks.closeModal).not.toHaveBeenCalled();
|
});
|
|
it('关闭前业务校验失败时使用确认弹窗，由用户确认后继续关闭', async () => {
|
const beforeClose = vi.fn().mockRejectedValue(new Error('标注未完成：缺少检验结果'));
|
|
onlineUtils.openOfficeDocument({ beforeClose, file: FILE });
|
await flush();
|
await wrapper.find('button').trigger('click');
|
await flush();
|
|
expect(beforeClose).toHaveBeenCalledTimes(1);
|
expect(mocks.confirm).toHaveBeenCalledWith(
|
expect.objectContaining({
|
cancelText: '返回标注',
|
content: '标注未完成：缺少检验结果',
|
iconType: 'warning',
|
okText: '仍然关闭',
|
title: '标注未完成',
|
}),
|
);
|
expect(mocks.messageError).not.toHaveBeenCalled();
|
expect(mocks.requestEditorClose).not.toHaveBeenCalled();
|
|
mocks.shouldEditorClose = false;
|
mocks.confirm.mock.calls[0]?.[0].onOk();
|
await flush();
|
|
expect(mocks.requestEditorClose).toHaveBeenCalledTimes(1);
|
expect(mocks.closeModal).not.toHaveBeenCalled();
|
wrapper.getComponent({ name: 'OnlyOfficeEditor' }).vm.$emit('close');
|
await flush();
|
|
expect(mocks.closeModal).toHaveBeenCalledTimes(1);
|
expect(wrapper.find('[data-test="onlyoffice-editor"]').exists()).toBe(false);
|
});
|
|
it('关闭校验确认弹窗选择返回标注时保留编辑器', async () => {
|
const beforeClose = vi.fn().mockRejectedValue(new Error('标注未完成：缺少检验结果'));
|
|
onlineUtils.openOfficeDocument({ beforeClose, file: FILE });
|
await flush();
|
await wrapper.find('button').trigger('click');
|
await flush();
|
|
mocks.confirm.mock.calls[0]?.[0].onCancel();
|
await flush();
|
|
expect(mocks.requestEditorClose).not.toHaveBeenCalled();
|
expect(mocks.closeModal).not.toHaveBeenCalled();
|
expect(wrapper.find('[data-test="onlyoffice-editor"]').exists()).toBe(true);
|
});
|
|
it('校验失败且有未保存更改时合并提示并由应用直接关闭', async () => {
|
const beforeClose = vi.fn().mockRejectedValue(new Error('标注未完成：缺少检验结果'));
|
|
onlineUtils.openOfficeDocument({ beforeClose, file: FILE });
|
await flush();
|
await wrapper.find('[data-test="onlyoffice-editor"]').trigger('click');
|
await wrapper.find('button').trigger('click');
|
await flush();
|
|
expect(beforeClose).toHaveBeenCalledTimes(1);
|
expect(mocks.confirm).toHaveBeenCalledWith(
|
expect.objectContaining({
|
content: '标注未完成：缺少检验结果\n关闭后，当前未保存的文档更改也将丢失。',
|
okText: '仍然关闭',
|
title: '标注未完成',
|
}),
|
);
|
mocks.confirm.mock.calls[0]?.[0].onOk();
|
await flush();
|
|
expect(mocks.requestEditorClose).not.toHaveBeenCalled();
|
expect(mocks.closeModal).toHaveBeenCalled();
|
expect(wrapper.find('[data-test="onlyoffice-editor"]').exists()).toBe(false);
|
});
|
|
it('未改动文档时关闭仍校验提示但不阻止关闭', async () => {
|
const beforeClose = vi.fn().mockRejectedValue(new Error('标注未完成：缺少检验结论'));
|
|
onlineUtils.openOfficeDocument({ beforeClose, file: FILE });
|
await flush();
|
await wrapper.find('button').trigger('click');
|
await flush();
|
|
expect(beforeClose).toHaveBeenCalledTimes(1);
|
expect(mocks.confirm).toHaveBeenCalledWith(expect.objectContaining({ content: '标注未完成：缺少检验结论' }));
|
mocks.confirm.mock.calls[0]?.[0].onOk();
|
await flush();
|
|
expect(mocks.requestEditorClose).toHaveBeenCalledTimes(1);
|
expect(mocks.closeModal).toHaveBeenCalled();
|
});
|
|
it('编辑状态回落后关闭不误报未保存，但仍由 onlyoffice 完成关闭', async () => {
|
onlineUtils.openOfficeDocument({ file: FILE });
|
await flush();
|
const editor = wrapper.getComponent({ name: 'OnlyOfficeEditor' });
|
|
editor.vm.$emit('modified', true);
|
editor.vm.$emit('modified', false);
|
await flush();
|
await wrapper.find('button').trigger('click');
|
await flush();
|
|
expect(mocks.confirm).not.toHaveBeenCalled();
|
expect(mocks.requestEditorClose).toHaveBeenCalledTimes(1);
|
expect(mocks.closeModal).toHaveBeenCalled();
|
});
|
|
it('关闭前模板校验期间显示全屏 loading', async () => {
|
let resolveValidation: () => void = () => {};
|
const beforeClose = vi.fn().mockReturnValue(new Promise<void>((resolve) => (resolveValidation = resolve)));
|
|
onlineUtils.openOfficeDocument({ beforeClose, file: FILE });
|
await flush();
|
await wrapper.find('[data-test="onlyoffice-editor"]').trigger('click');
|
await wrapper.find('button').trigger('click');
|
await flush();
|
|
const mask = wrapper.find('[data-test="document-saving-mask"]');
|
expect(mask.exists()).toBe(true);
|
expect(mask.attributes('data-phase')).toBe('validating-close');
|
expect(mask.text()).toContain('模板校验中');
|
|
resolveValidation();
|
await flush();
|
});
|
|
it('编辑器配置加载中关闭也执行必要校验', async () => {
|
let resolveConfig: (value: any) => void = () => {};
|
const beforeClose = vi.fn().mockRejectedValue(new Error('标注未完成：缺少检验结果'));
|
mocks.getOnlyOfficeConfig.mockReturnValue(new Promise((resolve) => (resolveConfig = resolve)));
|
|
onlineUtils.openOfficeDocument({ beforeClose, file: FILE });
|
await flush();
|
await wrapper.find('button').trigger('click');
|
await flush();
|
|
expect(beforeClose).toHaveBeenCalledTimes(1);
|
expect(mocks.confirm).toHaveBeenCalledWith(expect.objectContaining({ content: '标注未完成：缺少检验结果' }));
|
expect(mocks.closeModal).not.toHaveBeenCalled();
|
|
mocks.confirm.mock.calls[0]?.[0].onCancel();
|
resolveConfig(CONFIG_RESPONSE);
|
await flush();
|
});
|
|
it('前一会话只读时不影响下一编辑会话加载期间的关闭校验', async () => {
|
mocks.getOnlyOfficeConfig.mockResolvedValueOnce({
|
data: { ...CONFIG_RESPONSE.data, editorConfig: { ...CONFIG_RESPONSE.data.editorConfig, mode: 'view' } },
|
});
|
onlineUtils.openOfficeDocument({ file: FILE, mode: 'edit' });
|
await flush();
|
|
let resolveConfig: (value: any) => void = () => {};
|
const beforeClose = vi.fn().mockRejectedValue(new Error('标注未完成：缺少检验结果'));
|
mocks.getOnlyOfficeConfig.mockReturnValueOnce(new Promise((resolve) => (resolveConfig = resolve)));
|
onlineUtils.openOfficeDocument({ beforeClose, file: FILE, mode: 'edit' });
|
await flush();
|
await wrapper.find('button').trigger('click');
|
await flush();
|
|
expect(beforeClose).toHaveBeenCalledTimes(1);
|
expect(mocks.confirm).toHaveBeenCalledWith(expect.objectContaining({ content: '标注未完成：缺少检验结果' }));
|
|
mocks.confirm.mock.calls[0]?.[0].onCancel();
|
resolveConfig(CONFIG_RESPONSE);
|
await flush();
|
});
|
|
it('关闭校验期间路由跳转后不再操作已卸载的编辑器', async () => {
|
let resolveValidation: () => void = () => {};
|
const beforeClose = vi.fn().mockReturnValue(new Promise<void>((resolve) => (resolveValidation = resolve)));
|
|
onlineUtils.openOfficeDocument({ beforeClose, file: FILE });
|
await flush();
|
await wrapper.find('button').trigger('click');
|
await flush();
|
|
routeHook({ fullPath: '/b' }, { fullPath: '/a' });
|
resolveValidation();
|
await flush();
|
|
expect(mocks.closeModal).toHaveBeenCalledTimes(1);
|
expect(mocks.requestEditorClose).not.toHaveBeenCalled();
|
expect(wrapper.find('[data-test="onlyoffice-editor"]').exists()).toBe(false);
|
});
|
|
it('关闭校验期间路由跳转后校验失败也不弹出过期确认框', async () => {
|
let rejectValidation: (error: Error) => void = () => {};
|
const beforeClose = vi.fn().mockReturnValue(new Promise<void>((_, reject) => (rejectValidation = reject)));
|
|
onlineUtils.openOfficeDocument({ beforeClose, file: FILE });
|
await flush();
|
await wrapper.find('button').trigger('click');
|
await flush();
|
|
routeHook({ fullPath: '/b' }, { fullPath: '/a' });
|
rejectValidation(new Error('标注未完成：缺少检验结果'));
|
await flush();
|
|
expect(mocks.closeModal).toHaveBeenCalledTimes(1);
|
expect(mocks.confirm).not.toHaveBeenCalled();
|
expect(mocks.requestEditorClose).not.toHaveBeenCalled();
|
});
|
|
it('后端确认新版文件写回后提示保存成功', async () => {
|
mocks.getOnlyOfficeSaveStatus
|
.mockResolvedValueOnce({ data: { lastSaveTime: 1000, version: 1 } })
|
.mockResolvedValueOnce({ data: { lastSaveTime: 2000, version: 1 } });
|
|
onlineUtils.openOfficeDocument({ file: FILE });
|
await flush();
|
await wrapper.find('[data-test="onlyoffice-editor"]').trigger('dblclick');
|
await flush();
|
|
expect(mocks.getOnlyOfficeSaveStatus).toHaveBeenCalledTimes(2);
|
expect(mocks.messageSuccess).toHaveBeenCalledWith('文档保存成功');
|
expect(wrapper.find('[data-test="document-saving-mask"]').exists()).toBe(false);
|
});
|
|
it('签批页保存完成后向 onSave 回传另存为的上传文件对象', async () => {
|
const savedFile = {
|
fileExtension: 'docx',
|
fileId: 'saved-copy.docx',
|
fileSize: 321,
|
name: '检验报告.docx',
|
url: '/api/file/Image/annex/saved-copy.docx',
|
};
|
const onSave = vi.fn();
|
mocks.getOnlyOfficeSaveStatus
|
.mockResolvedValueOnce({ data: { lastSaveTime: 1000, sessionStatus: 'IDLE', version: 1 } })
|
.mockResolvedValueOnce({ data: { file: savedFile, lastSaveTime: 2000, sessionStatus: 'EDITING', version: 1 } })
|
.mockResolvedValueOnce({ data: { file: savedFile, lastSaveTime: 2000, sessionStatus: 'IDLE', version: 2 } });
|
|
onlineUtils.openOfficeDocument({ file: FILE, mode: 'qianpiye', onSave });
|
await flush();
|
const editor = wrapper.find('[data-test="onlyoffice-editor"]');
|
await editor.trigger('contextmenu');
|
await flush();
|
await wrapper.find('button').trigger('click');
|
await flush();
|
|
expect(onSave).toHaveBeenCalledWith({ file: savedFile, modified: true });
|
});
|
|
it('撤销恢复为未修改状态时不显示保存遮罩', async () => {
|
vi.useFakeTimers();
|
mocks.getOnlyOfficeSaveStatus.mockResolvedValue({ data: { lastSaveTime: 1000, version: 1 } });
|
|
onlineUtils.openOfficeDocument({ file: FILE });
|
await flush();
|
const editor = wrapper.find('[data-test="onlyoffice-editor"]');
|
await editor.trigger('click');
|
await editor.trigger('contextmenu');
|
await flush();
|
|
expect(wrapper.find('[data-test="document-saving-mask"]').exists()).toBe(false);
|
await vi.advanceTimersByTimeAsync(60_000);
|
await flush();
|
expect(mocks.messageError).not.toHaveBeenCalled();
|
vi.useRealTimers();
|
});
|
|
it('status 6 延迟三十秒到达时仍能确认保存成功', async () => {
|
vi.useFakeTimers();
|
const callbackAt = Date.now() + 30_000;
|
mocks.getOnlyOfficeSaveStatus.mockImplementation(() => Promise.resolve({ data: { lastSaveTime: Date.now() >= callbackAt ? 2000 : 1000, version: 1 } }));
|
|
onlineUtils.openOfficeDocument({ file: FILE });
|
await flush();
|
await wrapper.find('[data-test="onlyoffice-editor"]').trigger('dblclick');
|
await flush();
|
await vi.advanceTimersByTimeAsync(30_000);
|
await flush();
|
|
expect(mocks.messageSuccess).toHaveBeenCalledWith('文档保存成功');
|
expect(mocks.messageError).not.toHaveBeenCalled();
|
expect(wrapper.find('[data-test="document-saving-mask"]').exists()).toBe(false);
|
vi.useRealTimers();
|
});
|
|
it('保存状态查询在途时路由跳转会取消后续轮询和提示', async () => {
|
let resolveSaveStatus: (value: any) => void = () => {};
|
mocks.getOnlyOfficeSaveStatus
|
.mockResolvedValueOnce({ data: { lastSaveTime: 1000, version: 1 } })
|
.mockReturnValueOnce(new Promise((resolve) => (resolveSaveStatus = resolve)));
|
|
onlineUtils.openOfficeDocument({ file: FILE });
|
await flush();
|
await wrapper.find('[data-test="onlyoffice-editor"]').trigger('dblclick');
|
await flush();
|
|
routeHook({ fullPath: '/b' }, { fullPath: '/a' });
|
resolveSaveStatus({ data: { lastSaveTime: 2000, version: 1 } });
|
await flush();
|
|
expect(mocks.closeModal).toHaveBeenCalledTimes(1);
|
expect(mocks.getOnlyOfficeSaveStatus).toHaveBeenCalledTimes(3);
|
expect(mocks.messageSuccess).not.toHaveBeenCalled();
|
expect(mocks.messageError).not.toHaveBeenCalled();
|
});
|
|
it('手动保存后执行业务校验并以警告提示标注未完成', async () => {
|
const onManualSave = vi.fn().mockRejectedValue(new Error('标注未完成：缺少检验结论'));
|
mocks.getOnlyOfficeSaveStatus
|
.mockResolvedValueOnce({ data: { lastSaveTime: 1000, version: 1 } })
|
.mockResolvedValueOnce({ data: { lastSaveTime: 2000, version: 1 } });
|
|
onlineUtils.openOfficeDocument({ file: FILE, onManualSave });
|
await flush();
|
await wrapper.find('[data-test="onlyoffice-editor"]').trigger('dblclick');
|
await flush();
|
|
expect(onManualSave).toHaveBeenCalledTimes(1);
|
expect(mocks.messageWarning).toHaveBeenCalledWith('标注未完成：缺少检验结论');
|
expect(mocks.messageError).not.toHaveBeenCalled();
|
expect(mocks.messageSuccess).toHaveBeenCalledWith('文档保存成功');
|
expect(wrapper.find('[data-test="onlyoffice-editor"]').exists()).toBe(true);
|
});
|
|
it('业务校验悬挂时不超过保存确认窗口，仍按 status 6 确认结果', async () => {
|
vi.useFakeTimers();
|
const onManualSave = vi.fn().mockReturnValue(new Promise<void>(() => {}));
|
mocks.getOnlyOfficeSaveStatus
|
.mockResolvedValueOnce({ data: { lastSaveTime: 1000, version: 1 } })
|
.mockResolvedValueOnce({ data: { lastSaveTime: 2000, version: 1 } });
|
|
onlineUtils.openOfficeDocument({ file: FILE, onManualSave });
|
await flush();
|
await wrapper.find('[data-test="onlyoffice-editor"]').trigger('dblclick');
|
await flush();
|
await vi.advanceTimersByTimeAsync(60_000);
|
await flush();
|
|
expect(mocks.messageWarning).toHaveBeenCalledWith('模板校验超时，请检查');
|
expect(mocks.messageSuccess).toHaveBeenCalledWith('文档保存成功');
|
expect(wrapper.find('[data-test="document-saving-mask"]').exists()).toBe(false);
|
vi.useRealTimers();
|
});
|
|
it('status 6 到达前不显示保存遮罩，确认写回后才执行模板校验', async () => {
|
let resolveValidation: () => void = () => {};
|
let resolveSaveStatus: (value: any) => void = () => {};
|
const onManualSave = vi.fn().mockReturnValue(new Promise<void>((resolve) => (resolveValidation = resolve)));
|
mocks.getOnlyOfficeSaveStatus
|
.mockResolvedValueOnce({ data: { lastSaveTime: 1000, version: 1 } })
|
.mockReturnValueOnce(new Promise((resolve) => (resolveSaveStatus = resolve)));
|
|
onlineUtils.openOfficeDocument({ file: FILE, onManualSave });
|
await flush();
|
await wrapper.find('[data-test="onlyoffice-editor"]').trigger('dblclick');
|
await flush();
|
|
expect(wrapper.find('[data-test="document-saving-mask"]').exists()).toBe(false);
|
expect(onManualSave).not.toHaveBeenCalled();
|
|
resolveSaveStatus({ data: { lastSaveTime: 2000, version: 1 } });
|
await flush();
|
const mask = wrapper.find('[data-test="document-saving-mask"]');
|
expect(mask.attributes('data-phase')).toBe('validating');
|
expect(mask.text()).toContain('模板校验中');
|
|
resolveValidation();
|
await flush();
|
expect(wrapper.find('[data-test="document-saving-mask"]').exists()).toBe(false);
|
expect(mocks.messageSuccess).toHaveBeenCalledWith('文档保存成功');
|
});
|
|
it('等待 status 6 时不显示保存遮罩且不阻止关闭', async () => {
|
let resolveSaveStatus: (value: any) => void = () => {};
|
mocks.getOnlyOfficeSaveStatus
|
.mockResolvedValueOnce({ data: { lastSaveTime: 1000, version: 1 } })
|
.mockReturnValueOnce(new Promise((resolve) => (resolveSaveStatus = resolve)));
|
|
onlineUtils.openOfficeDocument({ file: FILE });
|
await flush();
|
await wrapper.find('[data-test="onlyoffice-editor"]').trigger('dblclick');
|
await flush();
|
|
expect(wrapper.find('[data-test="document-saving-mask"]').exists()).toBe(false);
|
await wrapper.find('button').trigger('click');
|
expect(mocks.requestEditorClose).toHaveBeenCalledTimes(1);
|
expect(mocks.closeModal).toHaveBeenCalledTimes(1);
|
|
resolveSaveStatus({ data: { lastSaveTime: 2000, version: 1 } });
|
await flush();
|
expect(mocks.messageSuccess).not.toHaveBeenCalled();
|
});
|
|
it('未检测到 status 6 时静默结束观察，不误报保存超时', async () => {
|
vi.useFakeTimers();
|
mocks.getOnlyOfficeSaveStatus.mockResolvedValue({ data: { lastSaveTime: 1000, version: 1 } });
|
|
onlineUtils.openOfficeDocument({ file: FILE });
|
await flush();
|
await wrapper.find('[data-test="onlyoffice-editor"]').trigger('click');
|
await wrapper.find('[data-test="onlyoffice-editor"]').trigger('dblclick');
|
await vi.runAllTimersAsync();
|
await flush();
|
|
expect(wrapper.find('[data-test="document-saving-mask"]').exists()).toBe(false);
|
expect(mocks.messageError).not.toHaveBeenCalled();
|
vi.useRealTimers();
|
});
|
|
it('路由跳走时自动关闭——编辑器占着 DS 编辑锁，不能留在新页面上', async () => {
|
const onClose = vi.fn();
|
onlineUtils.openOfficeDocument({ file: FILE, onClose });
|
await flush();
|
expect(wrapper.find('[data-test="onlyoffice-editor"]').exists()).toBe(true);
|
|
routeHook({ fullPath: '/b' }, { fullPath: '/a' });
|
await flush();
|
|
expect(mocks.closeModal).toHaveBeenCalled();
|
expect(onClose).toHaveBeenCalledTimes(1);
|
expect(wrapper.find('[data-test="onlyoffice-editor"]').exists()).toBe(false);
|
});
|
|
it('导航失败或地址没变时不关——页面根本没动，跟着关是误伤', async () => {
|
onlineUtils.openOfficeDocument({ file: FILE });
|
await flush();
|
|
routeHook({ fullPath: '/b' }, { fullPath: '/a' }, new Error('aborted'));
|
routeHook({ fullPath: '/a' }, { fullPath: '/a' });
|
await flush();
|
|
expect(mocks.closeModal).not.toHaveBeenCalled();
|
expect(wrapper.find('[data-test="onlyoffice-editor"]').exists()).toBe(true);
|
});
|
|
it('组件卸载时摘掉路由钩子', () => {
|
wrapper.unmount();
|
expect(mocks.removeRouteHook).toHaveBeenCalledTimes(1);
|
});
|
|
it('关闭后到达的 config 响应不再打开编辑器（防竞态）', async () => {
|
let resolveConfig: (value: any) => void = () => {};
|
mocks.getOnlyOfficeConfig.mockReturnValue(new Promise((resolve) => (resolveConfig = resolve)));
|
|
onlineUtils.openOfficeDocument({ file: FILE });
|
await flush();
|
await wrapper.find('button').trigger('click'); // 请求还在途中就关闭
|
resolveConfig(CONFIG_RESPONSE);
|
await flush();
|
|
expect(wrapper.find('[data-test="onlyoffice-editor"]').exists()).toBe(false);
|
});
|
});
|
