import { flushPromises, mount } from '@vue/test-utils';
|
import { defineComponent, h, provide, reactive, ref } from 'vue';
|
|
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
|
|
import { workflowFileSubmitPendingKey } from './filePermissionContext';
|
import { uploadEditFormKey } from './uploadEditContext';
|
import { provideUploadEditLoading } from './uploadEditLoading';
|
import { useUploadOnlineEdit } from './useUploadOnlineEdit';
|
|
const mocks = vi.hoisted(() => ({
|
options: vi.fn(),
|
load: vi.fn(),
|
change: vi.fn(),
|
begin: vi.fn(),
|
cleanup: vi.fn(),
|
revisionResult: vi.fn(),
|
shared: vi.fn(),
|
lease: vi.fn(),
|
open: vi.fn(),
|
confirm: vi.fn(),
|
error: vi.fn(),
|
}));
|
vi.mock('#/api/onlineDev/uploadEdit', () => ({
|
getUploadOfficeOptions: mocks.options,
|
loadUploadEdit: mocks.load,
|
loadSharedUploadEdit: mocks.shared,
|
updateUploadEditLease: mocks.lease,
|
changeUploadEdit: mocks.change,
|
beginTemporaryUploadEdit: mocks.begin,
|
cleanupTemporaryUploadEdit: mocks.cleanup,
|
loadRevisionTemporaryResult: mocks.revisionResult,
|
}));
|
vi.mock('#/components/OnlyOfficeEditor/src/loadDocsApi', () => ({ getDocumentServerUrl: () => 'http://office' }));
|
vi.mock('#/utils/jnpf', () => ({ onlineUtils: { openOfficeDocument: mocks.open } }));
|
vi.mock('ant-design-vue', () => ({ message: { error: mocks.error }, Modal: { confirm: mocks.confirm } }));
|
const file = (id: string) => ({
|
fileId: id,
|
name: `${id}.docx`,
|
url: `/file/${id}`,
|
thumbUrl: '',
|
fileSize: 1,
|
fileExtension: 'docx',
|
uploadReceipt: 'receipt',
|
});
|
const result = (files = [file('A')], revision = 0) => ({ data: { draftId: 'draft', files, revision, canDiscard: revision > 0 } });
|
const wrappers: ReturnType<typeof mount>[] = [];
|
function setup(overrides: any = {}, recordId = 'record', initialFiles = [file('A')]) {
|
const props = reactive({ onlineEdit: true, type: 'annex', editField: 'biz_files', ...overrides });
|
const context = reactive({ modelId: 'model', recordId, ...(overrides.dmsAudit ? { dmsAudit: true } : {}) });
|
const submission = reactive({ pending: false });
|
let participant: any;
|
const current = ref(initialFiles);
|
let edit!: ReturnType<typeof useUploadOnlineEdit>;
|
let windowLoading!: ReturnType<typeof provideUploadEditLoading>;
|
const child = defineComponent({
|
setup() {
|
edit = useUploadOnlineEdit(
|
props,
|
() => current.value,
|
(next) => {
|
current.value = next as typeof initialFiles;
|
},
|
);
|
return () => h('div');
|
},
|
});
|
const wrapper = mount(
|
defineComponent({
|
setup() {
|
windowLoading = provideUploadEditLoading();
|
provide(workflowFileSubmitPendingKey, () => submission.pending);
|
provide(uploadEditFormKey, {
|
context: () => context,
|
register: (item) => {
|
participant = item;
|
return vi.fn();
|
},
|
});
|
return () => h(child);
|
},
|
}),
|
);
|
wrappers.push(wrapper);
|
return {
|
edit,
|
props,
|
context,
|
submission,
|
windowLoading: () => windowLoading.value,
|
current: () => current.value,
|
prepare: () => participant.prepare(),
|
wrapper,
|
};
|
}
|
beforeEach(() => {
|
vi.resetAllMocks();
|
mocks.options.mockResolvedValue({ data: { previewEnabled: true, editEnabled: true } });
|
mocks.load.mockResolvedValue(result());
|
mocks.cleanup.mockResolvedValue({});
|
mocks.shared.mockImplementation((context) => mocks.load(context));
|
mocks.lease.mockResolvedValue({});
|
mocks.change.mockImplementation(async (_action, command) => result(command.files || [file('A')], command.revision + 1));
|
});
|
afterEach(() => wrappers.splice(0).forEach((wrapper) => wrapper.unmount()));
|
describe('upload control online editing', () => {
|
it('keeps template provenance with the selected file and removes it on delete then ordinary upload', async () => {
|
const state = setup({ editField: 'wenjian', limit: 1 }, '');
|
await flushPromises();
|
const template = { ...file('template'), laiyuan_muban_id: 'A' };
|
await state.edit.replaceFrom(async () => [template]);
|
expect(state.current()[0]).toMatchObject({ laiyuan_muban_id: 'A' });
|
await state.edit.replace([]);
|
await state.edit.add({ ...file('uploaded'), name: template.name });
|
expect(state.current()[0]).not.toHaveProperty('laiyuan_muban_id');
|
});
|
it('opens a review-only lease without granting attachment replacement', async () => {
|
mocks.change.mockResolvedValue({ data: { ...result().data, leaseId: 'review_lease', mode: 'review', source: file('A') } });
|
const state = setup({ fileAccess: { status: 'ready', actions: { VIEW: true, EDIT: false, REVIEW: true } } });
|
await flushPromises();
|
expect(state.edit.reviewOnly.value).toBe(true);
|
expect(state.edit.canEdit({ ...file('A'), name: 'A.doc' })).toBe(false);
|
expect(state.edit.canEdit(file('A'))).toBe(true);
|
await state.edit.open(file('A'));
|
expect(mocks.change).toHaveBeenCalledWith('begin', expect.objectContaining({ mode: 'review' }));
|
expect(mocks.open).toHaveBeenCalledWith(expect.objectContaining({ mode: 'review' }));
|
await expect(state.edit.replace([file('C')])).rejects.toThrow();
|
mocks.open.mock.calls[0]?.[0].onClose();
|
});
|
it('leaves ordinary uploads usable when the field switch is off', async () => {
|
mocks.options.mockReturnValue(new Promise(() => {}));
|
const state = setup({ onlineEdit: false });
|
await state.edit.add(file('C'));
|
expect(state.current().map((item) => item.fileId)).toEqual(['A', 'C']);
|
expect(state.edit.canEdit(file('A'))).toBe(false);
|
expect(mocks.load).not.toHaveBeenCalled();
|
await expect(state.prepare()).resolves.toBeUndefined();
|
});
|
it('blocks modification and submission until configuration loads', async () => {
|
mocks.options.mockReturnValue(new Promise(() => {}));
|
const state = setup();
|
expect(state.edit.blocked.value).toBe(true);
|
await expect(state.prepare()).rejects.toThrow('配置尚未加载');
|
await expect(state.edit.replace([file('C')])).rejects.toThrow('不可修改');
|
});
|
it('restores the persisted work file and permits DOC and DOCX only', async () => {
|
mocks.load.mockResolvedValue(result([file('B')], 4));
|
const state = setup();
|
await flushPromises();
|
expect(state.current()[0]?.fileId).toBe('B');
|
expect(state.edit.canEdit(file('B'))).toBe(true);
|
for (const name of ['B.doc', 'B.DOC', 'B.DOCX']) expect(state.edit.canEdit({ ...file('B'), name })).toBe(true);
|
for (const name of ['B.pdf', 'B.docm', 'B.xlsx', 'B.doc.exe']) expect(state.edit.canEdit({ ...file('B'), name })).toBe(false);
|
expect(await state.prepare()).toEqual({ draftId: 'draft', revision: 4 });
|
});
|
it('opens DOC and refreshes the converted DOCX attachment after saving', async () => {
|
const source = { ...file('legacy'), name: 'legacy.doc', fileExtension: 'doc' };
|
mocks.load.mockResolvedValue(result([source]));
|
const state = setup();
|
await flushPromises();
|
mocks.change.mockResolvedValue({ data: { ...result([source]).data, leaseId: 'lease', source } });
|
await state.edit.open(source);
|
expect(mocks.open).toHaveBeenCalledWith(expect.objectContaining({ mode: 'edit', file: expect.objectContaining({ name: 'legacy.doc' }) }));
|
mocks.load.mockResolvedValue(result([{ ...file('converted'), name: 'legacy.docx' }], 2));
|
mocks.open.mock.calls[0]?.[0].onClose();
|
await flushPromises();
|
expect(state.current()[0]).toMatchObject({ fileId: 'converted', name: 'legacy.docx', fileExtension: 'docx' });
|
expect(await state.prepare()).toEqual({ draftId: 'draft', revision: 2 });
|
});
|
it('queues concurrent upload completions without losing files', async () => {
|
const state = setup();
|
await flushPromises();
|
const uploads = [state.edit.add(file('C')), state.edit.add(file('D'))];
|
await expect(state.prepare()).rejects.toThrow('等待保存');
|
await Promise.all(uploads);
|
expect(state.current().map((item) => item.fileId)).toEqual(['A', 'C', 'D']);
|
expect(mocks.change.mock.calls[1]?.[1].revision).toBe(1);
|
});
|
it('fences form save while editing and refreshes the saved result on close', async () => {
|
const state = setup();
|
await flushPromises();
|
mocks.change.mockResolvedValue({ data: { ...result().data, leaseId: 'lease', source: file('A') } });
|
await state.edit.open(file('A'));
|
await expect(state.prepare()).rejects.toThrow('关闭附件编辑器');
|
expect(mocks.open.mock.calls[0]?.[0].file.fileId).toBe('lease');
|
mocks.load.mockResolvedValue(result([file('B')], 2));
|
mocks.open.mock.calls[0]?.[0].onClose();
|
await flushPromises();
|
expect(state.current()[0]?.fileId).toBe('B');
|
expect(await state.prepare()).toEqual({ draftId: 'draft', revision: 2 });
|
});
|
it('supplies the saved size after editing an initially zero-byte attachment', async () => {
|
const empty = { ...file('A'), fileSize: 0 };
|
mocks.load.mockResolvedValue(result([empty]));
|
const state = setup();
|
await flushPromises();
|
expect(state.current()[0]?.fileSize).toBe(0);
|
mocks.change.mockResolvedValue({ data: { ...result([empty]).data, leaseId: 'lease', source: empty } });
|
await state.edit.open(empty);
|
await expect(state.prepare()).rejects.toThrow('关闭附件编辑器');
|
mocks.load.mockResolvedValue(result([{ ...file('B'), fileSize: 2048 }], 2));
|
mocks.open.mock.calls[0]?.[0].onClose();
|
await flushPromises();
|
expect(await state.prepare()).toEqual({ draftId: 'draft', revision: 2 });
|
expect(state.current()[0]).toMatchObject({ fileId: 'B', fileSize: 2048 });
|
});
|
it('ignores an old editor close after changing records', async () => {
|
const state = setup();
|
await flushPromises();
|
mocks.change.mockResolvedValue({ data: { ...result().data, leaseId: 'lease', source: file('A') } });
|
await state.edit.open(file('A'));
|
const close = mocks.open.mock.calls[0]?.[0].onClose;
|
mocks.load.mockResolvedValue(result([file('C')], 5));
|
state.context.recordId = 'other-record';
|
await flushPromises();
|
const calls = mocks.load.mock.calls.length;
|
close();
|
await flushPromises();
|
expect(mocks.load).toHaveBeenCalledTimes(calls);
|
expect(state.current()[0]?.fileId).toBe('C');
|
});
|
it('unlocks uploads and form save when the document window cannot open', async () => {
|
const state = setup();
|
await flushPromises();
|
mocks.change.mockResolvedValue({ data: { ...result().data, leaseId: 'lease', source: file('A') } });
|
mocks.open.mockImplementation((config) => config.onOpenError(new Error('window unavailable')));
|
await state.edit.open(file('A'));
|
expect(state.edit.blocked.value).toBe(false);
|
await expect(state.prepare()).resolves.toEqual({ draftId: 'draft', revision: 0 });
|
});
|
it('unlocks uploads after a synchronous document open failure', async () => {
|
const state = setup();
|
await flushPromises();
|
mocks.change.mockResolvedValue({ data: { ...result().data, leaseId: 'lease', source: file('A') } });
|
mocks.open.mockImplementation(() => {
|
throw new Error('open failed');
|
});
|
await state.edit.open(file('A'));
|
expect(state.edit.blocked.value).toBe(false);
|
await expect(state.prepare()).resolves.toBeDefined();
|
});
|
it('discards untracked edits and cleans the temporary session', async () => {
|
const state = setup({}, '');
|
await flushPromises();
|
mocks.begin.mockResolvedValue({ data: { ...result().data, leaseId: 'temporary', source: file('A') } });
|
await state.edit.open(file('A'));
|
expect(state.edit.canDiscard.value).toBe(false);
|
mocks.open.mock.calls[0]?.[0].onClose({ file: file('B') });
|
await flushPromises();
|
expect(state.current()[0]?.fileId).toBe('A');
|
expect(mocks.cleanup).toHaveBeenCalledWith('temporary');
|
expect(mocks.load).not.toHaveBeenCalled();
|
});
|
it('restores the server baseline on discard', async () => {
|
mocks.load.mockResolvedValue(result([file('B')], 4));
|
const state = setup();
|
await flushPromises();
|
state.edit.discard();
|
mocks.change.mockResolvedValue(result([file('A')], 5));
|
await mocks.confirm.mock.calls[0]?.[0].onOk();
|
expect(mocks.change).toHaveBeenCalledWith('discard', { draftId: 'draft', revision: 4 });
|
expect(state.current()[0]?.fileId).toBe('A');
|
});
|
it('uses the draft restore decision for a controlled attachment', async () => {
|
mocks.load.mockResolvedValue(result([file('B')], 4));
|
const state = setup({ fileAccess: { status: 'ready', actions: { VIEW: true, EDIT: true } } });
|
await flushPromises();
|
expect(state.edit.canDiscard.value).toBe(true);
|
state.edit.discard();
|
mocks.change.mockResolvedValue({ data: { ...result([file('A')], 5).data, canDiscard: false } });
|
await mocks.confirm.mock.calls[0]?.[0].onOk();
|
expect(state.current()[0]?.fileId).toBe('A');
|
expect(state.edit.canDiscard.value).toBe(false);
|
});
|
it('refreshes restoration after replacement permission changes without overwriting form files', async () => {
|
mocks.load.mockResolvedValue(result([file('B')], 4));
|
const state = setup({ fileAccess: { status: 'ready', actions: { VIEW: true, EDIT: true, REPLACE: true } } });
|
await flushPromises();
|
state.edit.discard();
|
const confirm = mocks.confirm.mock.calls[0]?.[0].onOk;
|
mocks.load.mockResolvedValue({ data: { ...result([file('C')], 4).data, canDiscard: false } });
|
state.props.fileAccess.actions.REPLACE = false;
|
expect(state.edit.canDiscard.value).toBe(false);
|
await flushPromises();
|
expect(mocks.load).toHaveBeenCalledTimes(2);
|
expect(state.edit.canDiscard.value).toBe(false);
|
expect(state.current()[0]?.fileId).toBe('B');
|
mocks.load.mockResolvedValue(result([file('B')], 4));
|
state.props.fileAccess.actions.REPLACE = true;
|
await flushPromises();
|
expect(state.edit.canDiscard.value).toBe(true);
|
await confirm();
|
expect(mocks.change).not.toHaveBeenCalled();
|
});
|
it('ignores an old restoration decision after switching child rows', async () => {
|
mocks.load.mockResolvedValue(result([file('B')], 4));
|
const state = setup({ editParentField: 'rows', editRowId: 'row-1', fileAccess: { status: 'ready', actions: { VIEW: true, EDIT: true, ADD: true } } });
|
await flushPromises();
|
let resolve!: (value: any) => void;
|
mocks.load.mockReturnValueOnce(
|
new Promise((done) => {
|
resolve = done;
|
}),
|
);
|
state.props.fileAccess.actions.ADD = false;
|
await flushPromises();
|
mocks.load.mockResolvedValue({ data: { ...result([file('C')], 2).data, draftId: 'other', canDiscard: false } });
|
state.props.editRowId = 'row-2';
|
await flushPromises();
|
resolve(result([file('B')], 4));
|
await flushPromises();
|
expect(state.edit.canDiscard.value).toBe(false);
|
expect(state.current()[0]?.fileId).toBe('C');
|
});
|
it('closes restoration on a failed permission refresh', async () => {
|
mocks.load.mockResolvedValue(result([file('B')], 4));
|
const state = setup({ fileAccess: { status: 'ready', actions: { VIEW: true, EDIT: true, REMOVE: true } } });
|
await flushPromises();
|
mocks.load.mockRejectedValue(new Error('offline'));
|
state.props.fileAccess.actions.REMOVE = false;
|
await flushPromises();
|
expect(state.edit.canDiscard.value).toBe(false);
|
expect(state.current()[0]?.fileId).toBe('B');
|
expect(await state.prepare()).toEqual({ draftId: 'draft', revision: 4 });
|
});
|
it('keeps editor completion when only restoration permissions change', async () => {
|
const state = setup({ fileAccess: { status: 'ready', actions: { VIEW: true, EDIT: true, REPLACE: true } } });
|
await flushPromises();
|
mocks.change.mockResolvedValue({ data: { ...result().data, leaseId: 'lease', source: file('A') } });
|
await state.edit.open(file('A'));
|
state.props.fileAccess.actions.REPLACE = false;
|
await flushPromises();
|
expect(mocks.load).toHaveBeenCalledTimes(1);
|
await expect(state.prepare()).rejects.toThrow('关闭附件编辑器');
|
mocks.load.mockResolvedValue(result([file('B')], 2));
|
mocks.open.mock.calls[0]?.[0].onClose();
|
await flushPromises();
|
expect(state.current()[0]?.fileId).toBe('B');
|
expect(state.edit.canDiscard.value).toBe(true);
|
expect(await state.prepare()).toEqual({ draftId: 'draft', revision: 2 });
|
});
|
it('rejects a restore confirmation for an earlier draft revision', async () => {
|
mocks.load.mockResolvedValue(result([file('B')], 4));
|
const state = setup();
|
await flushPromises();
|
state.edit.discard();
|
await state.edit.replace([file('C')]);
|
mocks.change.mockClear();
|
await mocks.confirm.mock.calls[0]?.[0].onOk();
|
expect(mocks.change).not.toHaveBeenCalled();
|
expect(state.current()[0]?.fileId).toBe('C');
|
});
|
it('honors remove and replacement separately even without online editing', async () => {
|
const state = setup({ onlineEdit: false, fileAccess: { status: 'ready', actions: { ADD: true } } });
|
await flushPromises();
|
await state.edit.add(file('C'));
|
expect(state.current().map((item) => item.fileId)).toEqual(['A', 'C']);
|
await expect(state.edit.replace([])).rejects.toThrow('没有附件操作权限');
|
await expect(state.edit.replace([file('D')])).rejects.toThrow('没有附件操作权限');
|
expect(mocks.change).not.toHaveBeenCalled();
|
});
|
it('rechecks permission after a pending open request', async () => {
|
const state = setup({ fileAccess: { status: 'ready', actions: { VIEW: true, EDIT: true } } });
|
await flushPromises();
|
let resolve!: (value: any) => void;
|
mocks.change.mockReturnValue(
|
new Promise((done) => {
|
resolve = done;
|
}),
|
);
|
const opening = state.edit.open(file('A'));
|
state.props.fileAccess = { status: 'ready', actions: { EDIT: false } };
|
resolve({ data: { ...result([file('B')]).data, leaseId: 'lease', source: file('A') } });
|
await opening;
|
expect(mocks.open).not.toHaveBeenCalled();
|
expect(state.current()[0]?.fileId).toBe('A');
|
});
|
it('rechecks discard permission after confirmation is opened', async () => {
|
mocks.load.mockResolvedValue(result([file('B')], 4));
|
const state = setup({ fileAccess: { status: 'ready', actions: { VIEW: true, EDIT: true } } });
|
await flushPromises();
|
state.edit.discard();
|
expect(mocks.confirm).toHaveBeenCalledTimes(1);
|
state.props.fileAccess = { status: 'loading' };
|
await mocks.confirm.mock.calls[0]?.[0].onOk();
|
expect(mocks.change).not.toHaveBeenCalled();
|
});
|
it('permits native upload and save when editing is denied', async () => {
|
const state = setup({ fileAccess: { status: 'ready', actions: { ADD: true, REMOVE: true } } });
|
await flushPromises();
|
expect(mocks.load).not.toHaveBeenCalled();
|
await state.edit.add(file('C'));
|
await state.edit.replace([file('C')]);
|
expect(state.current().map((item) => item.fileId)).toEqual(['C']);
|
await expect(state.prepare()).resolves.toBeUndefined();
|
expect(mocks.change).not.toHaveBeenCalled();
|
});
|
it('loads a work draft when editing is granted but not on equivalent refreshes', async () => {
|
const state = setup({ fileAccess: { status: 'ready', actions: { EDIT: false } } });
|
await flushPromises();
|
state.props.fileAccess = { status: 'ready', actions: { VIEW: true, EDIT: true } };
|
await flushPromises();
|
expect(mocks.load).toHaveBeenCalledTimes(1);
|
expect(state.edit.canEdit(file('A'))).toBe(true);
|
state.props.fileAccess = { status: 'ready', actions: { VIEW: true, EDIT: true, DOWNLOAD: false } };
|
await flushPromises();
|
expect(mocks.load).toHaveBeenCalledTimes(1);
|
});
|
it('activates child editing at an allowed node and blocks reopening after revocation', async () => {
|
const state = setup({ editParentField: 'rows', editRowId: 'row-1', fileAccess: { status: 'ready', actions: { VIEW: true, EDIT: false } } });
|
await flushPromises();
|
expect(state.edit.canEdit(file('A'))).toBe(false);
|
state.props.fileAccess = { status: 'ready', actions: { VIEW: true, EDIT: true, DOWNLOAD: false } };
|
await flushPromises();
|
expect(state.edit.canEdit(file('A'))).toBe(true);
|
expect(mocks.load).toHaveBeenCalledWith(expect.objectContaining({ parentField: 'rows', rowId: 'row-1' }));
|
mocks.change.mockResolvedValue({ data: { ...result().data, leaseId: 'lease', source: file('A') } });
|
await state.edit.open(file('A'));
|
expect(mocks.open).toHaveBeenCalledOnce();
|
mocks.open.mock.calls[0]?.[0].onClose();
|
await flushPromises();
|
state.props.fileAccess = { status: 'ready', actions: { VIEW: true, EDIT: false, DOWNLOAD: true } };
|
await flushPromises();
|
expect(state.edit.canEdit(file('A'))).toBe(false);
|
await state.edit.open(file('A'));
|
expect(mocks.open).toHaveBeenCalledOnce();
|
});
|
it('ignores a load crossing revocation even when permission is restored', async () => {
|
let resolve!: (value: any) => void;
|
mocks.load.mockReturnValueOnce(
|
new Promise((done) => {
|
resolve = done;
|
}),
|
);
|
const state = setup({ fileAccess: { status: 'ready', actions: { VIEW: true, EDIT: true } } });
|
await flushPromises();
|
state.props.fileAccess = { status: 'ready', actions: { EDIT: false } };
|
await flushPromises();
|
mocks.load.mockResolvedValue(result([file('C')], 3));
|
state.props.fileAccess = { status: 'ready', actions: { VIEW: true, EDIT: true } };
|
await flushPromises();
|
resolve(result([file('B')], 2));
|
await flushPromises();
|
expect(state.current()[0]?.fileId).toBe('C');
|
});
|
it('keeps the editor close guard during revocation and releases it on close', async () => {
|
const state = setup({ fileAccess: { status: 'ready', actions: { VIEW: true, EDIT: true } } });
|
await flushPromises();
|
mocks.change.mockResolvedValue({ data: { ...result().data, leaseId: 'lease', source: file('A') } });
|
await state.edit.open(file('A'));
|
state.props.fileAccess = { status: 'ready', actions: { EDIT: false } };
|
await flushPromises();
|
await expect(state.prepare()).rejects.toThrow('关闭附件编辑器');
|
const calls = mocks.load.mock.calls.length;
|
mocks.open.mock.calls[0]?.[0].onClose();
|
await flushPromises();
|
expect(mocks.load).toHaveBeenCalledTimes(calls);
|
expect(state.edit.blocked.value).toBe(false);
|
});
|
|
it('does not overwrite native unsaved uploads when edit permission becomes available', async () => {
|
const state = setup({ fileAccess: { status: 'ready', actions: { ADD: true } } });
|
await flushPromises();
|
await state.edit.add(file('C'));
|
state.props.fileAccess = { status: 'ready', actions: { ADD: true, VIEW: true, EDIT: true } };
|
await flushPromises();
|
expect(mocks.load).not.toHaveBeenCalled();
|
expect(state.current().map((item) => item.fileId)).toEqual(['A', 'C']);
|
expect(state.edit.canEdit(file('C'))).toBe(false);
|
await expect(state.prepare()).resolves.toBeUndefined();
|
});
|
it('requires view permission as well as edit permission to load an editor draft', async () => {
|
const state = setup({ fileAccess: { status: 'ready', actions: { EDIT: true, VIEW: false } } });
|
await flushPromises();
|
expect(state.edit.canEdit(file('A'))).toBe(false);
|
expect(mocks.load).not.toHaveBeenCalled();
|
});
|
});
|
|
describe('workflow shared working files', () => {
|
const viewOnly = { status: 'ready', actions: { VIEW: true, EDIT: false } };
|
it('keeps ordinary preview on the last adopted attachment', async () => {
|
mocks.shared.mockResolvedValue({
|
data: { ...result([file('B')], 2).data, baselineFiles: [file('A')], editOrigins: { B: 'A' }, shared: true },
|
});
|
const state = setup({ disabled: true, detailed: true, fileAccess: viewOnly });
|
await flushPromises();
|
expect(state.current()[0]?.fileId).toBe('B');
|
expect(state.edit.formalFile(file('B'))?.fileId).toBe('A');
|
expect(state.edit.formalFile(file('C'))).toBeUndefined();
|
});
|
it('loads the shared result for a read-only viewer and carries its version into native save', async () => {
|
mocks.shared.mockResolvedValue({ data: { ...result([file('B')], 7).data, shared: true } });
|
const state = setup({ disabled: true, detailed: true, fileAccess: viewOnly });
|
await flushPromises();
|
expect(state.current()[0]?.fileId).toBe('B');
|
expect(state.edit.canEdit(file('B'))).toBe(false);
|
expect(await state.prepare()).toEqual({ draftId: 'draft', revision: 7 });
|
expect(mocks.load).not.toHaveBeenCalled();
|
});
|
it('allows explicitly granted editing in a read-only field without allowing upload replacement', async () => {
|
const state = setup({ disabled: true, detailed: true, fileAccess: { status: 'ready', actions: { VIEW: true, EDIT: true } } });
|
await flushPromises();
|
expect(state.edit.canEdit(file('A'))).toBe(true);
|
await expect(state.edit.replace([file('C')])).rejects.toThrow();
|
});
|
it('releases a shared lease before loading its saved result', async () => {
|
const state = setup({ fileAccess: { status: 'ready', actions: { VIEW: true, EDIT: true } } });
|
await flushPromises();
|
mocks.change.mockResolvedValue({ data: { ...result().data, shared: true, leaseId: 'lease', source: file('A') } });
|
await state.edit.open(file('A'));
|
let finish!: () => void;
|
mocks.lease.mockImplementation(
|
() =>
|
new Promise<void>((resolve) => {
|
finish = resolve;
|
}),
|
);
|
mocks.shared.mockClear();
|
mocks.open.mock.calls[0]?.[0].onClose();
|
await flushPromises();
|
expect(mocks.lease).toHaveBeenCalledWith('close', 'draft', 'lease');
|
expect(mocks.shared).not.toHaveBeenCalled();
|
await expect(state.prepare()).rejects.toThrow('关闭附件编辑器');
|
finish();
|
await flushPromises();
|
expect(mocks.shared).toHaveBeenCalledOnce();
|
});
|
it('does not load shared content without VIEW', async () => {
|
const state = setup({ fileAccess: { status: 'ready', actions: { VIEW: false, EDIT: true } } });
|
await flushPromises();
|
expect(mocks.shared).not.toHaveBeenCalled();
|
expect(state.edit.canEdit(file('A'))).toBe(false);
|
});
|
it('refreshes shared content while idle and renews an open edit lease', async () => {
|
vi.useFakeTimers();
|
try {
|
const state = setup({ fileAccess: { status: 'ready', actions: { VIEW: true, EDIT: true } } });
|
await flushPromises();
|
mocks.shared.mockResolvedValue({ data: { ...result([file('B')], 2).data, shared: true } });
|
await vi.advanceTimersByTimeAsync(15_000);
|
expect(state.current()[0]?.fileId).toBe('B');
|
mocks.change.mockResolvedValue({ data: { ...result([file('B')], 3).data, shared: true, leaseId: 'lease', source: file('B') } });
|
await state.edit.open(file('B'));
|
mocks.shared.mockClear();
|
await vi.advanceTimersByTimeAsync(30_000);
|
expect(mocks.lease).toHaveBeenCalledWith('heartbeat', 'draft', 'lease');
|
expect(mocks.shared).not.toHaveBeenCalled();
|
state.wrapper.unmount();
|
} finally {
|
vi.useRealTimers();
|
}
|
});
|
it('ignores an in-flight heartbeat failure after the editor releases its lease', async () => {
|
vi.useFakeTimers();
|
try {
|
const state = setup({ fileAccess: { status: 'ready', actions: { VIEW: true, EDIT: true } } });
|
await flushPromises();
|
mocks.change.mockResolvedValue({ data: { ...result().data, shared: true, leaseId: 'lease', source: file('A') } });
|
await state.edit.open(file('A'));
|
let rejectHeartbeat!: (error: Error) => void;
|
mocks.lease.mockImplementation((action) => {
|
if (action !== 'heartbeat') return Promise.resolve({});
|
return new Promise((_resolve, reject) => {
|
rejectHeartbeat = reject;
|
});
|
});
|
await vi.advanceTimersByTimeAsync(30_000);
|
expect(mocks.lease).toHaveBeenCalledWith('heartbeat', 'draft', 'lease');
|
mocks.open.mock.calls[0]?.[0].onClose();
|
await flushPromises();
|
expect(mocks.lease).toHaveBeenCalledWith('close', 'draft', 'lease');
|
rejectHeartbeat(new Error('lease already released'));
|
await flushPromises();
|
expect(state.edit.failure.value).toBe('');
|
expect(mocks.error).not.toHaveBeenCalled();
|
} finally {
|
vi.useRealTimers();
|
}
|
});
|
it('pauses shared polling during approval and ignores a failure from before submission', async () => {
|
vi.useFakeTimers();
|
try {
|
const state = setup({ fileAccess: { status: 'ready', actions: { VIEW: true, EDIT: true } } });
|
await flushPromises();
|
let reject!: (error: Error) => void;
|
mocks.shared.mockReturnValueOnce(
|
new Promise((_resolve, fail) => {
|
reject = fail;
|
}),
|
);
|
await vi.advanceTimersByTimeAsync(15_000);
|
expect(mocks.shared).toHaveBeenLastCalledWith(expect.any(Object), true);
|
state.submission.pending = true;
|
mocks.shared.mockClear();
|
await vi.advanceTimersByTimeAsync(30_000);
|
expect(mocks.shared).not.toHaveBeenCalled();
|
state.submission.pending = false;
|
reject(new Error('permission transitioning'));
|
await flushPromises();
|
expect(state.edit.failure.value).toBe('');
|
expect(state.current()[0]?.fileId).toBe('A');
|
mocks.shared.mockResolvedValue({ data: { ...result([file('B')], 2).data, shared: true } });
|
await vi.advanceTimersByTimeAsync(15_000);
|
expect(state.current()[0]?.fileId).toBe('B');
|
} finally {
|
vi.useRealTimers();
|
}
|
});
|
it('still blocks edits on a genuine idle synchronization failure', async () => {
|
vi.useFakeTimers();
|
try {
|
const state = setup({ fileAccess: { status: 'ready', actions: { VIEW: true, EDIT: true } } });
|
await flushPromises();
|
mocks.shared.mockRejectedValueOnce(new Error('permission unavailable'));
|
await vi.advanceTimersByTimeAsync(15_000);
|
expect(state.edit.failure.value).toContain('共享附件同步失败');
|
expect(state.edit.blocked.value).toBe(true);
|
await expect(state.prepare()).rejects.toThrow('共享附件同步失败');
|
} finally {
|
vi.useRealTimers();
|
}
|
});
|
});
|
|
describe('template reference replacement', () => {
|
it('does not request a template when online editing is unavailable', async () => {
|
const state = setup({ onlineEdit: false });
|
await flushPromises();
|
const load = vi.fn();
|
await expect(state.edit.replaceFrom(load)).rejects.toThrow('不可修改');
|
expect(load).not.toHaveBeenCalled();
|
expect(state.current().map((f) => f.fileId)).toEqual(['A']);
|
});
|
it('replaces the full attachment set and blocks submission during authorization', async () => {
|
const state = setup();
|
await flushPromises();
|
let resolve!: (files: ReturnType<typeof file>[]) => void;
|
const selected = state.edit.replaceFrom(
|
() =>
|
new Promise((done) => {
|
resolve = done;
|
}),
|
);
|
expect(state.edit.blocked.value).toBe(true);
|
await expect(state.prepare()).rejects.toThrow('等待保存');
|
resolve([file('template')]);
|
await selected;
|
expect(state.current().map((f) => f.fileId)).toEqual(['template']);
|
expect(await state.prepare()).toEqual({ draftId: 'draft', revision: 1 });
|
});
|
it('ignores authorization completed after switching records', async () => {
|
const state = setup();
|
await flushPromises();
|
let resolve!: (files: ReturnType<typeof file>[]) => void;
|
const selected = state.edit.replaceFrom(
|
() =>
|
new Promise((done) => {
|
resolve = done;
|
}),
|
);
|
state.context.recordId = 'other';
|
await flushPromises();
|
resolve([file('template')]);
|
await expect(selected).rejects.toThrow('已变化');
|
expect(mocks.change).not.toHaveBeenCalled();
|
});
|
it('preserves existing attachments and releases the barrier when authorization fails', async () => {
|
const state = setup();
|
await flushPromises();
|
await expect(
|
state.edit.replaceFrom(async () => {
|
throw new Error('denied');
|
}),
|
).rejects.toThrow('denied');
|
expect(state.current().map((f) => f.fileId)).toEqual(['A']);
|
expect(state.edit.blocked.value).toBe(false);
|
expect(mocks.change).not.toHaveBeenCalled();
|
});
|
});
|
|
describe('unsaved DMS revision copies', () => {
|
const source = () => ({ ...file('A'), uploadReceipt: undefined, revisionEditReceipt: 'source-receipt' });
|
function lease() {
|
mocks.begin.mockResolvedValue({ data: { ...result().data, revisionTemporary: true, leaseId: 'revision-lease', source: source() } });
|
}
|
const saved = () => ({ data: { revisionTemporary: true, leaseId: 'revision-lease', files: [{ ...file('copy'), revisionEditReceipt: 'copy-receipt' }] } });
|
it('shows opening immediately and isolates late failures after a context switch', async () => {
|
let rejectOld!: (error: Error) => void;
|
let rejectNew!: (error: Error) => void;
|
mocks.begin
|
.mockReturnValueOnce(
|
new Promise((_done, fail) => {
|
rejectOld = fail;
|
}),
|
)
|
.mockReturnValueOnce(
|
new Promise((_done, fail) => {
|
rejectNew = fail;
|
}),
|
);
|
const state = setup({}, '');
|
expect(state.edit.editStatus.value).toBe('');
|
await flushPromises();
|
const oldOpening = state.edit.open(source());
|
expect(state.edit.editStatus.value).toBe('正在打开文档…');
|
expect(mocks.open).not.toHaveBeenCalled();
|
state.context.modelId = 'other-model';
|
expect(state.edit.editStatus.value).toBe('');
|
await flushPromises();
|
const newOpening = state.edit.open(source());
|
rejectOld(new Error('old request'));
|
await oldOpening;
|
expect(state.edit.editStatus.value).toBe('正在打开文档…');
|
rejectNew(new Error('new request'));
|
await newOpening;
|
expect(state.edit.editStatus.value).toBe('');
|
expect(state.edit.busy.value).toBe(false);
|
});
|
it('keeps synchronization visible through result retrieval and cleanup', async () => {
|
lease();
|
let resolveResult!: (value: any) => void;
|
let resolveCleanup!: (value: any) => void;
|
mocks.revisionResult.mockReturnValue(
|
new Promise((done) => {
|
resolveResult = done;
|
}),
|
);
|
mocks.cleanup.mockReturnValue(
|
new Promise((done) => {
|
resolveCleanup = done;
|
}),
|
);
|
const state = setup({}, '');
|
await flushPromises();
|
await state.edit.open(source());
|
expect(state.edit.editStatus.value).toBe('');
|
mocks.open.mock.calls[0][0].onClose();
|
expect(state.edit.editStatus.value).toBe('正在同步编辑结果…');
|
resolveResult(saved());
|
await flushPromises();
|
expect(state.current()[0].fileId).toBe('copy');
|
expect(state.edit.editStatus.value).toBe('正在同步编辑结果…');
|
resolveCleanup({});
|
await flushPromises();
|
expect(state.edit.editStatus.value).toBe('');
|
await expect(state.prepare()).resolves.toBeUndefined();
|
});
|
it('offers imported files editing and adopts saved copy before native submit', async () => {
|
lease();
|
mocks.revisionResult.mockResolvedValue(saved());
|
const state = setup({}, '');
|
await flushPromises();
|
expect(state.edit.canEdit(source())).toBe(true);
|
await state.edit.open(source());
|
await expect(state.prepare()).rejects.toThrow();
|
mocks.open.mock.calls[0][0].onClose();
|
await flushPromises();
|
expect(state.current()[0].fileId).toBe('copy');
|
expect(state.current()[0]).toHaveProperty('revisionEditReceipt', 'copy-receipt');
|
await expect(state.prepare()).resolves.toBeUndefined();
|
expect(mocks.cleanup).toHaveBeenCalledWith('revision-lease');
|
});
|
it('keeps failed result synchronization retryable and blocks native save', async () => {
|
lease();
|
mocks.revisionResult.mockRejectedValueOnce(new Error('network'));
|
const state = setup({}, '');
|
await flushPromises();
|
await state.edit.open(source());
|
mocks.open.mock.calls[0][0].onClose();
|
await flushPromises();
|
expect(state.current()[0].fileId).toBe('A');
|
expect(state.edit.pendingRevisionResult.value).toBeDefined();
|
expect(state.edit.editStatus.value).toBe('');
|
await expect(state.prepare()).rejects.toThrow('同步');
|
mocks.revisionResult.mockResolvedValue(saved());
|
const retry = state.edit.retryRevisionResult();
|
expect(state.edit.editStatus.value).toBe('正在同步编辑结果…');
|
await retry;
|
expect(state.edit.editStatus.value).toBe('');
|
expect(state.current()[0].fileId).toBe('copy');
|
await expect(state.prepare()).resolves.toBeUndefined();
|
});
|
it('does not apply a late result after source files changed', async () => {
|
lease();
|
let resolve!: (value: any) => void;
|
mocks.revisionResult.mockReturnValue(
|
new Promise((done) => {
|
resolve = done;
|
}),
|
);
|
const state = setup({}, '');
|
await flushPromises();
|
await state.edit.open(source());
|
mocks.open.mock.calls[0][0].onClose();
|
state.current().splice(0, 1, file('new-source'));
|
resolve(saved());
|
await flushPromises();
|
expect(state.current()[0].fileId).toBe('new-source');
|
expect(state.edit.pendingRevisionResult.value).toBeUndefined();
|
});
|
it('does not create a pending result when an old editor closes after context switch', async () => {
|
lease();
|
const state = setup({}, '');
|
await flushPromises();
|
await state.edit.open(source());
|
state.context.modelId = 'other-model';
|
await flushPromises();
|
mocks.open.mock.calls[0][0].onClose();
|
await flushPromises();
|
expect(mocks.revisionResult).not.toHaveBeenCalled();
|
expect(state.edit.pendingRevisionResult.value).toBeUndefined();
|
});
|
it('cleans its revision lease on unmount', async () => {
|
lease();
|
const state = setup({}, '');
|
await flushPromises();
|
await state.edit.open(source());
|
state.wrapper.unmount();
|
expect(mocks.cleanup).toHaveBeenCalledWith('revision-lease');
|
});
|
});
|
|
describe('upload submit guard diagnostics', () => {
|
afterEach(() => vi.restoreAllMocks());
|
|
it('identifies initial shared loading without editing and records the field and request stage', async () => {
|
const warn = vi.spyOn(console, 'warn').mockImplementation(() => undefined);
|
let complete!: (value: ReturnType<typeof result>) => void;
|
mocks.shared.mockImplementation(
|
() =>
|
new Promise((resolve) => {
|
complete = resolve;
|
}),
|
);
|
const state = setup({ editField: 'wenjian', editParentField: 'records', editRowId: 'row-1', fileAccess: { status: 'ready', actions: { VIEW: true } } });
|
await flushPromises();
|
await expect(state.prepare()).rejects.toThrow('请关闭附件编辑器并等待保存完成后再提交表单');
|
expect(warn).toHaveBeenCalledTimes(1);
|
const [prefix, serialized] = warn.mock.calls[0]!;
|
expect(prefix).toBe('[UploadEditSubmitGuard]');
|
const diagnostic = JSON.parse(serialized as string);
|
expect(diagnostic).toMatchObject({ version: 1, reason: 'busy', prepareAttempt: 1 });
|
expect(diagnostic.history.at(-1)).toMatchObject({
|
event: 'prepare:blocked',
|
context: { field: 'wenjian', parentField: 'records', rowId: 'row-1', recordId: 'record' },
|
state: { editorOpen: false, busy: true, sharedReadable: true, pendingUploads: 0 },
|
});
|
expect(diagnostic.history.some((item: any) => item.event === 'load:draft-request')).toBe(true);
|
expect(diagnostic.history.some((item: any) => item.event === 'editor:open-start')).toBe(false);
|
// 快照不包含原始附件及其上传凭据，且不会随后续状态变化改变。
|
expect(serialized).not.toContain('uploadReceipt');
|
expect(serialized).not.toContain('/file/A');
|
complete(result());
|
await flushPromises();
|
await expect(state.prepare()).resolves.toEqual({ draftId: 'draft', revision: 0 });
|
expect(JSON.parse(serialized as string).history.at(-1).state.busy).toBe(true);
|
expect(warn).toHaveBeenCalledTimes(1);
|
});
|
|
it('distinguishes an open editor and preserves the close callback in the bounded history', async () => {
|
const warn = vi.spyOn(console, 'warn').mockImplementation(() => undefined);
|
const state = setup({ fileAccess: { status: 'ready', actions: { VIEW: true, EDIT: true } } });
|
await flushPromises();
|
mocks.change.mockResolvedValue({ data: { ...result().data, shared: true, leaseId: 'private-lease', source: file('A') } });
|
await state.edit.open(file('A'));
|
await expect(state.prepare()).rejects.toThrow('关闭附件编辑器');
|
expect(JSON.parse(warn.mock.calls[0]![1] as string).reason).toBe('editor-open');
|
let close!: () => void;
|
mocks.lease.mockImplementation(
|
() =>
|
new Promise<void>((resolve) => {
|
close = resolve;
|
}),
|
);
|
mocks.open.mock.calls[0]![0].onClose();
|
await flushPromises();
|
await expect(state.prepare()).rejects.toThrow('关闭附件编辑器');
|
const serialized = warn.mock.calls[1]![1] as string;
|
const diagnostic = JSON.parse(serialized);
|
expect(diagnostic.history.some((item: any) => item.event === 'editor:close-callback')).toBe(true);
|
expect(diagnostic.history.at(-1).state).toMatchObject({ editorOpen: true, busy: true, editPhase: 'syncing' });
|
expect(serialized).not.toContain('private-lease');
|
for (let i = 0; i < 25; i++) await expect(state.prepare()).rejects.toThrow('关闭附件编辑器');
|
expect(JSON.parse(warn.mock.calls.at(-1)![1] as string).history).toHaveLength(40);
|
close();
|
await flushPromises();
|
await expect(state.prepare()).resolves.toEqual({ draftId: 'draft', revision: 0 });
|
});
|
|
it('distinguishes queued uploads from a busy operation without opening an editor', async () => {
|
const warn = vi.spyOn(console, 'warn').mockImplementation(() => undefined);
|
const state = setup();
|
await flushPromises();
|
const upload = state.edit.add(file('B'));
|
await expect(state.prepare()).rejects.toThrow('关闭附件编辑器');
|
const diagnostic = JSON.parse(warn.mock.calls[0]![1] as string);
|
expect(diagnostic.reason).toBe('pending-uploads');
|
expect(diagnostic.history.at(-1).state).toMatchObject({ editorOpen: false, busy: false, pendingUploads: 1 });
|
expect(diagnostic.history.some((item: any) => item.event === 'upload:queued')).toBe(true);
|
await upload;
|
await expect(state.prepare()).resolves.toBeDefined();
|
});
|
|
it('preserves the original guard error even when console logging fails', async () => {
|
vi.spyOn(console, 'warn').mockImplementation(() => {
|
throw new Error('console unavailable');
|
});
|
const state = setup();
|
await flushPromises();
|
mocks.change.mockResolvedValue({ data: { ...result().data, leaseId: 'lease', source: file('A') } });
|
await state.edit.open(file('A'));
|
await expect(state.prepare()).rejects.toThrow('请关闭附件编辑器并等待保存完成后再提交表单');
|
});
|
});
|
|
describe('shared attachment window loading', () => {
|
const shared = { fileAccess: { status: 'ready', actions: { VIEW: true, EDIT: true } } };
|
|
it('covers configuration and initial shared loading, then releases on failure', async () => {
|
let configured!: (value: any) => void;
|
mocks.options.mockReturnValue(new Promise((resolve) => (configured = resolve)));
|
const state = setup(shared);
|
expect(state.windowLoading()).toBe(true);
|
mocks.shared.mockRejectedValueOnce(new Error('unavailable'));
|
configured({ data: { previewEnabled: true, editEnabled: true } });
|
await flushPromises();
|
expect(state.windowLoading()).toBe(false);
|
expect(state.edit.failure.value).toBe('工作附件加载失败，请重新打开表单');
|
});
|
|
it('does not let an obsolete load hide a newer load and releases when the field unmounts', async () => {
|
const completions: ((value: any) => void)[] = [];
|
mocks.shared.mockImplementation(() => new Promise((resolve) => completions.push(resolve)));
|
const state = setup(shared);
|
await flushPromises();
|
state.context.recordId = 'other-record';
|
await flushPromises();
|
expect(completions).toHaveLength(2);
|
completions[0]!(result());
|
await flushPromises();
|
expect(state.windowLoading()).toBe(true);
|
state.wrapper.unmount();
|
expect(state.windowLoading()).toBe(false);
|
completions[1]!(result());
|
await flushPromises();
|
expect(state.windowLoading()).toBe(false);
|
});
|
|
it('keeps background polling quiet and shows loading only while closing the shared editor', async () => {
|
vi.useFakeTimers();
|
try {
|
const state = setup(shared);
|
await flushPromises();
|
expect(state.windowLoading()).toBe(false);
|
let polled!: (value: any) => void;
|
mocks.shared.mockReturnValueOnce(new Promise((resolve) => (polled = resolve)));
|
await vi.advanceTimersByTimeAsync(15_000);
|
expect(state.windowLoading()).toBe(false);
|
polled(result());
|
await flushPromises();
|
mocks.change.mockResolvedValue({ data: { ...result().data, shared: true, leaseId: 'lease', source: file('A') } });
|
await state.edit.open(file('A'));
|
expect(state.windowLoading()).toBe(false);
|
let closed!: () => void;
|
mocks.lease.mockReturnValueOnce(new Promise<void>((resolve) => (closed = resolve)));
|
mocks.open.mock.calls[0]![0].onClose();
|
expect(state.windowLoading()).toBe(true);
|
closed();
|
await flushPromises();
|
expect(state.windowLoading()).toBe(false);
|
} finally {
|
vi.useRealTimers();
|
}
|
});
|
|
it('does not show the shared window overlay for an ordinary attachment load', async () => {
|
let complete!: (value: any) => void;
|
mocks.load.mockReturnValueOnce(new Promise((resolve) => (complete = resolve)));
|
const state = setup();
|
await flushPromises();
|
expect(state.edit.busy.value).toBe(true);
|
expect(state.windowLoading()).toBe(false);
|
complete(result());
|
await flushPromises();
|
});
|
});
|
|
describe('online edit preparation entry conditions', () => {
|
const ordinary = { ...file('text'), name: 'text.txt', fileExtension: 'txt' };
|
|
it.each(['txt', 'pdf', 'xlsx'])('does not block an unedited %s attachment during configuration or draft recovery', async (extension) => {
|
const files = [{ ...ordinary, name: `ordinary.${extension}`, fileExtension: extension }];
|
let configure!: (value: any) => void;
|
let recover!: (value: any) => void;
|
mocks.options.mockReturnValue(new Promise((resolve) => (configure = resolve)));
|
mocks.load.mockReturnValue(new Promise((resolve) => (recover = resolve)));
|
const state = setup({}, 'record', files);
|
expect(state.edit.busy.value).toBe(false);
|
expect(state.edit.blocked.value).toBe(false);
|
await expect(state.prepare()).resolves.toBeUndefined();
|
configure({ data: { previewEnabled: true, editEnabled: true } });
|
await flushPromises();
|
expect(mocks.load).toHaveBeenCalledTimes(1);
|
expect(state.edit.busy.value).toBe(false);
|
expect(state.edit.blocked.value).toBe(false);
|
expect(state.windowLoading()).toBe(false);
|
await expect(state.prepare()).resolves.toBeUndefined();
|
recover(result(files));
|
await flushPromises();
|
expect(state.edit.canEdit(files[0]!)).toBe(false);
|
await expect(state.prepare()).resolves.toEqual({ draftId: 'draft', revision: 0 });
|
});
|
|
it('does not block an empty field or show an editing failure when its background recovery fails', async () => {
|
mocks.load.mockRejectedValue(new Error('unavailable'));
|
const state = setup({}, 'record', []);
|
expect(state.edit.busy.value).toBe(false);
|
await expect(state.prepare()).resolves.toBeUndefined();
|
await flushPromises();
|
expect(state.edit.failure.value).toBe('');
|
expect(state.edit.blocked.value).toBe(false);
|
await expect(state.prepare()).resolves.toBeUndefined();
|
});
|
|
it('does not enter editing busy or window loading for an ordinary shared attachment', async () => {
|
mocks.shared.mockReturnValue(new Promise(() => {}));
|
const state = setup({ fileAccess: { status: 'ready', actions: { VIEW: true, EDIT: true } } }, 'record', [ordinary]);
|
await flushPromises();
|
expect(state.edit.busy.value).toBe(false);
|
expect(state.edit.blocked.value).toBe(false);
|
expect(state.windowLoading()).toBe(false);
|
await expect(state.prepare()).resolves.toBeUndefined();
|
});
|
|
it('does not enter editing busy when the field editing switch is off', async () => {
|
mocks.options.mockReturnValue(new Promise(() => {}));
|
const state = setup({ onlineEdit: false });
|
expect(state.edit.busy.value).toBe(false);
|
expect(state.edit.blocked.value).toBe(false);
|
await expect(state.prepare()).resolves.toBeUndefined();
|
});
|
|
it('restores an existing Word draft even when the persisted attachment is ordinary', async () => {
|
mocks.load.mockResolvedValue(result([file('restored')], 4));
|
const state = setup({}, 'record', [ordinary]);
|
await flushPromises();
|
expect(state.current()[0]?.fileId).toBe('restored');
|
expect(state.edit.canEdit(state.current()[0]!)).toBe(true);
|
await expect(state.prepare()).resolves.toEqual({ draftId: 'draft', revision: 4 });
|
mocks.change.mockResolvedValue({ data: { ...result([file('restored')], 4).data, leaseId: 'lease', source: file('restored') } });
|
await state.edit.open(state.current()[0]!);
|
await expect(state.prepare()).rejects.toThrow('关闭附件编辑器');
|
});
|
|
it('loads the draft version before applying a real upload during background recovery', async () => {
|
let recover!: (value: any) => void;
|
mocks.load.mockReturnValue(new Promise((resolve) => (recover = resolve)));
|
const state = setup({}, 'record', [ordinary]);
|
await flushPromises();
|
const uploading = state.edit.add(file('new-word'));
|
await expect(state.prepare()).rejects.toThrow('附件正在上传或更新');
|
recover(result([ordinary]));
|
await uploading;
|
await flushPromises();
|
expect(state.current().map((item) => item.fileId)).toEqual(['text', 'new-word']);
|
expect(mocks.change).toHaveBeenCalledWith('files', expect.objectContaining({ draftId: 'draft', revision: 0 }));
|
expect(state.edit.blocked.value).toBe(false);
|
await expect(state.prepare()).resolves.toEqual({ draftId: 'draft', revision: 1 });
|
});
|
|
it('allows template selection from an empty field without losing the selection to draft recovery', async () => {
|
let recover!: (value: any) => void;
|
mocks.load.mockReturnValue(new Promise((resolve) => (recover = resolve)));
|
const state = setup({}, 'record', []);
|
await flushPromises();
|
expect(state.edit.enabled.value).toBe(true);
|
const selecting = state.edit.replaceFrom(async () => [file('template')]);
|
await flushPromises();
|
recover(result([]));
|
await selecting;
|
await flushPromises();
|
expect(state.current()[0]?.fileId).toBe('template');
|
await expect(state.prepare()).resolves.toEqual({ draftId: 'draft', revision: 1 });
|
});
|
|
it('does not overwrite a recovered edit with a replacement based on older ordinary files', async () => {
|
let recover!: (value: any) => void;
|
mocks.load.mockReturnValue(new Promise((resolve) => (recover = resolve)));
|
const state = setup({}, 'record', [ordinary]);
|
await flushPromises();
|
const replacing = state.edit.replace([file('replacement')]);
|
const rejected = expect(replacing).rejects.toThrow('表单或附件已变化');
|
recover(result([file('restored')], 4));
|
await rejected;
|
expect(mocks.change).not.toHaveBeenCalled();
|
expect(state.current()[0]?.fileId).toBe('restored');
|
await expect(state.prepare()).resolves.toEqual({ draftId: 'draft', revision: 4 });
|
});
|
|
it('cancels a pending ordinary attachment replacement when its field unmounts', async () => {
|
mocks.load.mockReturnValue(new Promise(() => {}));
|
const state = setup({}, 'record', [ordinary]);
|
await flushPromises();
|
const replacing = state.edit.replace([file('replacement')]);
|
const rejected = expect(replacing).rejects.toThrow('表单或附件已变化');
|
state.wrapper.unmount();
|
await rejected;
|
expect(mocks.change).not.toHaveBeenCalled();
|
});
|
|
it('retains draft version protection after replacing the last Word file with an ordinary attachment', async () => {
|
const state = setup();
|
await flushPromises();
|
await state.edit.replace([ordinary]);
|
expect(state.current()[0]?.name).toBe('text.txt');
|
await expect(state.prepare()).resolves.toEqual({ draftId: 'draft', revision: 1 });
|
});
|
});
|
|
describe('dms shared content confirmation', () => {
|
const snapshot = (id = 'A', revision = 0) => ({
|
data: {
|
...result([file(id)], revision).data,
|
shared: true,
|
dmsAudit: true,
|
contentToken: `content-${id}`,
|
baselineFiles: [file('A')],
|
editOrigins: id === 'A' ? {} : { [id]: 'A' },
|
},
|
});
|
const create = () =>
|
setup({
|
dmsAudit: true,
|
editField: 'wenjian',
|
fileAccess: {
|
status: 'ready',
|
actions: { VIEW: true, EDIT: true, DOWNLOAD: false },
|
},
|
});
|
it.each([{ editField: 'wenjian' }, { editField: 'jilu_wenjian', editParentField: 'jilu_mingxi', editRowId: 'row' }])(
|
'rejects incompatible saved DMS attachments without a private-draft fallback: %j',
|
async (field) => {
|
const state = setup({ dmsAudit: true, ...field });
|
await flushPromises();
|
expect(mocks.load).not.toHaveBeenCalled();
|
expect(mocks.shared).not.toHaveBeenCalled();
|
expect(state.edit.failure.value).toContain('不符合当前共享附件协议');
|
expect(state.edit.blocked.value).toBe(true);
|
expect(state.edit.canEdit(file('A'))).toBe(false);
|
await expect(state.prepare()).rejects.toThrow('不符合当前共享附件协议');
|
await expect(state.edit.replace([file('B')])).rejects.toThrow('不符合当前共享附件协议');
|
await state.edit.open(file('A'));
|
expect(mocks.change).not.toHaveBeenCalled();
|
},
|
);
|
it('updates a same-file template source without demanding another content preview', async () => {
|
const first = { data: { ...snapshot().data, metadataToken: 'template-A', files: [{ ...file('A'), laiyuan_muban_id: 'A', contentSavedAt: 100 }] } };
|
mocks.shared.mockResolvedValue(first);
|
const state = create();
|
await flushPromises();
|
mocks.shared.mockResolvedValue({ data: { ...first.data, metadataToken: 'template-B', files: [{ ...file('A'), laiyuan_muban_id: 'B', contentSavedAt: 100 }] } });
|
await expect(state.prepare()).resolves.toMatchObject({ contentToken: 'content-A', metadataToken: 'template-B' });
|
expect(state.current()[0]).toMatchObject({ laiyuan_muban_id: 'B', contentSavedAt: 100 });
|
});
|
it('recovers when current workflow permissions finish loading', async () => {
|
mocks.shared.mockResolvedValue(snapshot());
|
const state = setup({ dmsAudit: true, editField: 'wenjian' });
|
await flushPromises();
|
expect(state.edit.blocked.value).toBe(true);
|
state.props.fileAccess = { status: 'ready', actions: { VIEW: true, EDIT: true } };
|
await flushPromises();
|
expect(state.edit.failure.value).toBe('');
|
expect(state.edit.canEdit(file('A'))).toBe(true);
|
await expect(state.prepare()).resolves.toMatchObject({ contentToken: 'content-A' });
|
});
|
it('allows current temporary editing for new unsaved DMS forms', async () => {
|
const state = setup({ dmsAudit: true, editField: 'wenjian' }, '');
|
await flushPromises();
|
expect(state.edit.failure.value).toBe('');
|
expect(state.edit.blocked.value).toBe(false);
|
expect(state.edit.canEdit(file('A'))).toBe(true);
|
await expect(state.prepare()).resolves.toBeUndefined();
|
expect(mocks.load).not.toHaveBeenCalled();
|
});
|
it('allows untouched submission when editor options fail, after verifying shared content', async () => {
|
mocks.options.mockRejectedValue(new Error('office offline'));
|
mocks.shared.mockResolvedValue(snapshot());
|
const state = create();
|
await flushPromises();
|
expect(state.edit.blocked.value).toBe(false);
|
await expect(state.prepare()).resolves.toMatchObject({ contentToken: 'content-A' });
|
expect(mocks.begin).not.toHaveBeenCalled();
|
expect(mocks.change).not.toHaveBeenCalled();
|
});
|
it('does not overwrite a replacement with a delayed initial shared response', async () => {
|
let resolve!: (value: ReturnType<typeof snapshot>) => void;
|
mocks.shared.mockReturnValueOnce(new Promise((done) => (resolve = done)));
|
const state = setup({ dmsAudit: true, editField: 'wenjian', fileAccess: { status: 'ready', actions: { VIEW: true, EDIT: true, REPLACE: true } } });
|
const replacement = state.edit.replace([file('C')]);
|
expect(mocks.change).not.toHaveBeenCalled();
|
resolve(snapshot('B', 3));
|
await expect(replacement).rejects.toThrow('附件已变化');
|
expect(state.current()[0]?.fileId).toBe('B');
|
await state.edit.replace([file('C')]);
|
expect(state.current()[0]?.fileId).toBe('C');
|
});
|
it('uses shared B for access and exposes adopted A separately', async () => {
|
mocks.shared.mockResolvedValue(snapshot('B', 3));
|
const state = create();
|
await flushPromises();
|
expect(state.current()[0]?.fileId).toBe('B');
|
expect(state.edit.sharedSource(file('B'))).toEqual({ fileId: 'B', draftId: 'draft', contentToken: 'content-B' });
|
expect(state.edit.previousFile(file('B'))?.fileId).toBe('A');
|
await expect(state.prepare()).resolves.toMatchObject({ contentToken: 'content-B' });
|
});
|
it('exposes the adopted attachment after a single-file upload replacement without edit ancestry', async () => {
|
mocks.shared.mockResolvedValue({ data: { ...snapshot('B', 3).data, editOrigins: {} } });
|
const state = create();
|
await flushPromises();
|
expect(state.edit.previousFile(file('B'))?.fileId).toBe('A');
|
expect(state.edit.sharedSource(file('B'))).toMatchObject({ fileId: 'B', contentToken: 'content-B' });
|
});
|
it('does not guess an adopted attachment when multiple replaced files have no ancestry', async () => {
|
mocks.shared.mockResolvedValue({ data: { ...snapshot('B', 3).data, files: [file('B'), file('C')], editOrigins: {} } });
|
const state = create();
|
await flushPromises();
|
expect(state.edit.previousFile(file('B'))).toBeUndefined();
|
});
|
it('rejects submit when shared content changed and presents it for another confirmation', async () => {
|
mocks.shared.mockResolvedValueOnce(snapshot()).mockResolvedValue(snapshot('B', 3));
|
const state = create();
|
await flushPromises();
|
await expect(state.prepare()).rejects.toThrow('重新预览确认');
|
expect(state.current()[0]?.fileId).toBe('B');
|
await expect(state.prepare()).resolves.toMatchObject({ contentToken: 'content-B' });
|
});
|
it('requires confirmation after background polling has already displayed changed content', async () => {
|
vi.useFakeTimers();
|
try {
|
mocks.shared.mockResolvedValueOnce(snapshot()).mockResolvedValue(snapshot('B', 3));
|
const state = create();
|
await flushPromises();
|
await vi.advanceTimersByTimeAsync(15_000);
|
expect(state.current()[0]?.fileId).toBe('B');
|
await expect(state.prepare()).rejects.toThrow('重新预览确认');
|
await expect(state.prepare()).resolves.toMatchObject({ contentToken: 'content-B' });
|
} finally {
|
vi.useRealTimers();
|
}
|
});
|
it('does not require confirmation after a background session-only change', async () => {
|
vi.useFakeTimers();
|
try {
|
mocks.shared.mockResolvedValueOnce(snapshot()).mockResolvedValue(snapshot('A', 2));
|
const state = create();
|
await flushPromises();
|
await vi.advanceTimersByTimeAsync(15_000);
|
await expect(state.prepare()).resolves.toMatchObject({ revision: 2, contentToken: 'content-A' });
|
} finally {
|
vi.useRealTimers();
|
}
|
});
|
it('accepts a session-only revision change with the same content', async () => {
|
mocks.shared.mockResolvedValueOnce(snapshot('A', 0)).mockResolvedValue(snapshot('A', 2));
|
const state = create();
|
await flushPromises();
|
await expect(state.prepare()).resolves.toMatchObject({ revision: 2, contentToken: 'content-A' });
|
});
|
it('recovers a read failure on submit without adopting unseen changed content', async () => {
|
mocks.shared.mockRejectedValueOnce(new Error('offline')).mockResolvedValue(snapshot('B', 3));
|
const state = create();
|
await flushPromises();
|
expect(state.edit.blocked.value).toBe(false);
|
expect(state.edit.syncWarning.value).toContain('提交时');
|
await expect(state.prepare()).rejects.toThrow('重新预览确认');
|
});
|
it('fails closed if the final shared-content check is unavailable', async () => {
|
mocks.shared.mockResolvedValueOnce(snapshot()).mockRejectedValue(new Error('offline'));
|
const state = create();
|
await flushPromises();
|
await expect(state.prepare()).rejects.toThrow('无法核验');
|
});
|
it('binds begin to the content and full native attachment position', async () => {
|
mocks.shared.mockResolvedValue(snapshot());
|
mocks.change.mockResolvedValue({ data: { ...snapshot().data, leaseId: 'lease', source: file('A') } });
|
const state = create();
|
await flushPromises();
|
await state.edit.open(file('A'));
|
expect(mocks.change).toHaveBeenCalledWith(
|
'begin',
|
expect.objectContaining({ contentToken: 'content-A', context: expect.objectContaining({ modelId: 'model', recordId: 'record', field: 'wenjian' }) }),
|
);
|
});
|
});
|
