/* @vitest-environment happy-dom */
|
|
import { config, flushPromises, mount, shallowMount } from '@vue/test-utils';
|
|
import { beforeEach, describe, expect, it, vi } from 'vitest';
|
|
import VersionDrawer from '../VersionDrawer.vue';
|
import drawerSource from '../VersionDrawer.vue?raw';
|
|
config.global.stubs = { 'a-button': { template: '<button><slot /></button>' } };
|
|
function deferred<T>() {
|
let resolve!: (value: T) => void;
|
const promise = new Promise<T>((promiseResolve) => {
|
resolve = promiseResolve;
|
});
|
return { promise, resolve };
|
}
|
|
const apiMocks = vi.hoisted(() => ({ getFieldDetail: vi.fn(), getProviderProperties: vi.fn(), updateFieldVersion: vi.fn() }));
|
const sourceApiMocks = vi.hoisted(() => ({ getSourceReference: vi.fn() }));
|
const navigationMocks = vi.hoisted(() => ({ route: vi.fn() }));
|
const drawerState = vi.hoisted(() => ({ init: undefined as any }));
|
const formState = vi.hoisted(() => ({ config: undefined as any, setFieldsValue: vi.fn(), updateSchema: vi.fn(), validate: vi.fn() }));
|
const tableState = vi.hoisted(() => ({ config: undefined as any }));
|
|
vi.mock('#/api/x/eln/fields', () => ({
|
cancelFieldVersion: vi.fn(),
|
createFieldVersion: vi.fn(),
|
getFieldDetail: apiMocks.getFieldDetail,
|
getProviderProperties: apiMocks.getProviderProperties,
|
preReleaseFieldVersion: vi.fn(),
|
publishFieldVersion: vi.fn(),
|
switchCurrentFieldVersion: vi.fn(),
|
updateFieldVersion: apiMocks.updateFieldVersion,
|
}));
|
|
vi.mock('#/api/x/eln/sources', () => ({ getSourceReference: sourceApiMocks.getSourceReference }));
|
vi.mock('#/utils/jnpf', () => ({ getJnpfAppEnCode: () => '', onlineUtils: navigationMocks }));
|
|
vi.mock('@jnpf/hooks', () => ({
|
useMessage: () => ({ createMessage: { success: vi.fn(), warning: vi.fn() } }),
|
}));
|
|
vi.mock('@jnpf/ui/drawer', () => ({
|
BasicDrawer: { name: 'BasicDrawer', template: '<div><slot /></div>' },
|
useDrawerInner: (init: any) => {
|
drawerState.init = init;
|
return [vi.fn(), { changeLoading: vi.fn(), closeDrawer: vi.fn() }];
|
},
|
}));
|
|
vi.mock('@jnpf/ui/form', () => ({
|
BasicForm: { name: 'BasicForm', template: '<div />' },
|
useForm: (config: any) => {
|
formState.config = config;
|
return [vi.fn(), { resetFields: vi.fn(), setFieldsValue: formState.setFieldsValue, updateSchema: formState.updateSchema, validate: formState.validate }];
|
},
|
}));
|
|
vi.mock('@jnpf/ui/modal', () => ({
|
BasicModal: { name: 'BasicModal', props: ['title'], template: '<div :data-title="title"><slot /></div>' },
|
useModal: () => [vi.fn(), { closeModal: vi.fn(), openModal: vi.fn() }],
|
}));
|
|
vi.mock('@jnpf/ui/vxeTable', () => ({
|
BasicVxeTable: {
|
name: 'BasicVxeTable',
|
props: ['dataSource'],
|
template:
|
'<div><slot v-for="record in dataSource" :record="record" name="shujuLeixing" /><slot v-for="record in dataSource" :record="record" name="action" /></div>',
|
},
|
TableAction: { name: 'TableAction', props: ['actions'], template: '<div>{{ actions.map((action) => action.label).join(" ") }}</div>' },
|
useVxeTable: (config: any) => {
|
tableState.config = config;
|
return [vi.fn()];
|
},
|
}));
|
|
describe('eLN field version drawer', () => {
|
beforeEach(() => {
|
vi.clearAllMocks();
|
apiMocks.getProviderProperties.mockResolvedValue({ data: [] });
|
sourceApiMocks.getSourceReference.mockResolvedValue({ data: undefined });
|
apiMocks.updateFieldVersion.mockResolvedValue({ data: {} });
|
apiMocks.getFieldDetail.mockResolvedValue({
|
data: {
|
bizEnabled: 'enabled',
|
dangqianZiduanBanbenId: 'v1',
|
id: 'field-1',
|
versions: [
|
{
|
banbenHao: 1,
|
binding: { read: { source: 'LIMS_TASK' } },
|
bizStatus: 'PUBLISHED',
|
id: 'v1',
|
shujuLeixing: 'TEXT',
|
ziduanDingyiId: 'field-1',
|
},
|
{
|
banbenHao: 2,
|
binding: { read: { source: 'NONE' } },
|
bizStatus: 'DRAFT',
|
id: 'v2',
|
shujuLeixing: 'DECIMAL',
|
ziduanDingyiId: 'field-1',
|
},
|
],
|
ziduanBianma: 'sample_code_ab12cd34',
|
zuoyongFanwei: 'GLOBAL',
|
},
|
});
|
});
|
|
it('loads and saves arbitrary checkbox selection group recommendations', async () => {
|
apiMocks.getFieldDetail.mockResolvedValue({
|
data: {
|
bizEnabled: 'enabled',
|
id: 'field-1',
|
versions: [
|
{
|
banbenHao: 1,
|
binding: { read: { source: 'NONE' } },
|
bizStatus: 'DRAFT',
|
id: 'v1',
|
recommendedCheckboxGroupCode: 'review_result',
|
recommendedCheckboxMaxSelected: null,
|
recommendedCheckboxMinSelected: 2,
|
shujuLeixing: 'CHECKBOX',
|
ziduanDingyiId: 'field-1',
|
ziduanMingcheng: '复核结论',
|
},
|
],
|
ziduanBianma: 'review_result_ab12cd34',
|
zuoyongFanwei: 'GLOBAL',
|
},
|
});
|
formState.validate.mockResolvedValue({
|
checkboxGroupUnlimited: false,
|
piciMoshi: 'RECORD_PRIVATE',
|
readSource: 'NONE',
|
recommendedCheckboxGroupCode: 'review_result',
|
recommendedCheckboxMaxSelected: 8,
|
recommendedCheckboxMinSelected: 3,
|
shifouBitian: false,
|
shujuLeixing: 'CHECKBOX',
|
ziduanMingcheng: '复核结论',
|
});
|
const wrapper = mount(VersionDrawer, {
|
global: { stubs: { 'a-alert': true, 'a-descriptions': true, 'a-descriptions-item': true, 'a-form-item': true, 'a-tag': true, 'a-textarea': true } },
|
});
|
await drawerState.init({ fieldId: 'field-1' });
|
await flushPromises();
|
const actions = wrapper.findComponent({ name: 'TableAction' }).props('actions') as any[];
|
await actions.find((action) => action.label === '编辑').onClick();
|
await flushPromises();
|
|
expect(formState.setFieldsValue).toHaveBeenCalledWith(
|
expect.objectContaining({
|
checkboxGroupUnlimited: true,
|
recommendedCheckboxGroupCode: 'review_result',
|
recommendedCheckboxMinSelected: 2,
|
}),
|
);
|
wrapper.findAllComponents({ name: 'BasicModal' })[0]!.vm.$emit('ok');
|
await flushPromises();
|
expect(apiMocks.updateFieldVersion).toHaveBeenCalledWith(
|
'v1',
|
expect.objectContaining({
|
recommendedCheckboxGroupCode: 'review_result',
|
recommendedCheckboxMaxSelected: 8,
|
recommendedCheckboxMinSelected: 3,
|
}),
|
);
|
});
|
|
it('shows field data types in Chinese', async () => {
|
const wrapper = mount(VersionDrawer, {
|
global: {
|
stubs: {
|
'a-alert': true,
|
'a-descriptions': true,
|
'a-descriptions-item': true,
|
'a-form-item': true,
|
'a-tag': true,
|
'a-textarea': true,
|
},
|
},
|
});
|
await drawerState.init({ fieldId: 'field-1' });
|
await flushPromises();
|
|
expect(wrapper.text()).toContain('单行文本');
|
expect(wrapper.text()).toContain('数值');
|
expect(wrapper.text()).not.toContain('TEXT');
|
expect(wrapper.text()).not.toContain('DECIMAL');
|
});
|
|
it('loads independent V1/V2 history into the platform table', async () => {
|
shallowMount(VersionDrawer, {
|
global: {
|
stubs: {
|
'a-alert': true,
|
'a-descriptions': true,
|
'a-descriptions-item': true,
|
'a-form-item': true,
|
'a-tag': true,
|
'a-textarea': true,
|
},
|
},
|
});
|
await drawerState.init({ fieldId: 'field-1' });
|
await flushPromises();
|
|
expect(apiMocks.getFieldDetail).toHaveBeenCalledWith('field-1');
|
expect(tableState.config.dataSource.value).toHaveLength(2);
|
expect(tableState.config.pagination).toBe(false);
|
});
|
|
it('allows published versions to be viewed without exposing a save action', async () => {
|
const wrapper = mount(VersionDrawer, {
|
global: {
|
stubs: {
|
'a-alert': true,
|
'a-descriptions': true,
|
'a-descriptions-item': true,
|
'a-form-item': true,
|
'a-tag': true,
|
'a-textarea': true,
|
},
|
},
|
});
|
await drawerState.init({ fieldId: 'field-1' });
|
await flushPromises();
|
|
expect(wrapper.text()).toContain('查看');
|
expect(drawerSource).toContain(':disabled="isViewingVersion"');
|
expect(drawerSource).toContain(':show-ok-btn="!isViewingVersion"');
|
});
|
|
it('keeps every field read-only and shows the version number when viewing a published version', async () => {
|
const wrapper = mount(VersionDrawer, {
|
global: {
|
stubs: {
|
'a-alert': true,
|
'a-descriptions': true,
|
'a-descriptions-item': true,
|
'a-form-item': true,
|
'a-tag': true,
|
'a-textarea': true,
|
},
|
},
|
});
|
await drawerState.init({ fieldId: 'field-1' });
|
await flushPromises();
|
|
const publishedVersion = tableState.config.dataSource.value[0];
|
const actions = wrapper.findComponent({ name: 'TableAction' }).props('actions') as any[];
|
await actions.find((action) => action.label === '查看').onClick();
|
await flushPromises();
|
|
const providerProperty = formState.config.schemas.find((schema: any) => schema.field === 'providerProperty');
|
expect(providerProperty.dynamicDisabled({ model: { readSource: 'LIMS_TASK' } })).toBe(true);
|
expect(wrapper.findAll('[data-title]').map((element) => element.attributes('data-title'))).toContain(`查看字段版本 - V${publishedVersion.banbenHao}`);
|
});
|
|
it('does not validate a source property before an external source is selected', () => {
|
shallowMount(VersionDrawer, {
|
global: {
|
stubs: {
|
'a-alert': true,
|
'a-descriptions': true,
|
'a-descriptions-item': true,
|
'a-form-item': true,
|
'a-tag': true,
|
'a-textarea': true,
|
},
|
},
|
});
|
const providerProperty = formState.config.schemas.find((schema: any) => schema.field === 'providerProperty');
|
|
expect(providerProperty.dynamicRules({ model: { readSource: undefined } })).toEqual([]);
|
expect(providerProperty.dynamicRules({ model: { readSource: 'NONE' } })).toEqual([]);
|
expect(providerProperty.dynamicRules({ model: { readSource: 'LIMS_TASK' } })).toHaveLength(1);
|
expect(providerProperty.dynamicRules({ model: { readSource: 'SYSTEM' } })).toHaveLength(1);
|
});
|
|
it('uses shared status actions and keeps template fields away from external sources', () => {
|
expect(drawerSource).toContain('versionActions({');
|
expect(drawerSource).toContain("field.value?.zuoyongFanwei === 'GLOBAL'");
|
expect(drawerSource).toContain('READ_SOURCE_OPTIONS');
|
expect(drawerSource).toContain('NONE_READ_SOURCE_OPTIONS');
|
});
|
|
it('presents field ownership and remark in the detail summary', () => {
|
expect(drawerSource).toContain('字段详情');
|
expect(drawerSource).toContain('field.mubanBianhao');
|
expect(drawerSource).toContain('field.beizhu');
|
});
|
|
it('keeps the summary and version table away from the drawer edges', () => {
|
expect(drawerSource).toContain('padding: 16px 24px;');
|
expect(drawerSource).toContain('padding: 12px 24px 0;');
|
});
|
|
it('shows both current and target version numbers in switch confirmation', () => {
|
expect(drawerSource).toContain(`V\${currentVersion.value.banbenHao}`);
|
expect(drawerSource).toContain(`V\${version.banbenHao}`);
|
expect(drawerSource).toContain('switchCurrentFieldVersion');
|
});
|
|
it('keeps the draft form mounted between openings so it can be reset before showing', () => {
|
expect(drawerSource).not.toMatch(/registerVersionModal[^>]*destroy-on-close/);
|
expect(drawerSource).toMatch(/registerVersionModal[^>]*force-render/);
|
});
|
|
it('fills the drawer body so the version table can use the remaining height', () => {
|
expect(drawerSource).toMatch(/<BasicDrawer[^>]*class="full-drawer"/);
|
});
|
|
it('keeps the newest provider options when an older request finishes last', async () => {
|
const limsResponse = deferred<any>();
|
apiMocks.getProviderProperties.mockImplementation((source: string) => {
|
if (source === 'LIMS_TASK') return limsResponse.promise;
|
return Promise.resolve({
|
data: [{ dataType: 'TEXT', label: '当前用户', property: 'user.name', readOnly: true, source: 'SYSTEM' }],
|
});
|
});
|
shallowMount(VersionDrawer, {
|
global: {
|
stubs: {
|
'a-alert': true,
|
'a-descriptions': true,
|
'a-descriptions-item': true,
|
'a-form-item': true,
|
'a-tag': true,
|
'a-textarea': true,
|
},
|
},
|
});
|
const readSource = formState.config.schemas.find((schema: any) => schema.field === 'readSource');
|
|
const limsChange = readSource.componentProps.onChange('LIMS_TASK');
|
await Promise.resolve();
|
await Promise.resolve();
|
const systemChange = readSource.componentProps.onChange('SYSTEM');
|
await systemChange;
|
limsResponse.resolve({
|
data: [{ dataType: 'TEXT', label: '检验依据', property: 'test.basis', readOnly: true, source: 'LIMS_TASK' }],
|
});
|
await limsChange;
|
|
const providerUpdates = formState.updateSchema.mock.calls.map(([schema]) => schema).filter((schema) => schema.field === 'providerProperty');
|
expect(providerUpdates.at(-1).componentProps.options).toEqual([{ fullName: '当前用户', id: 'user.name' }]);
|
});
|
|
it('keeps safe empty provider options when loading fails', async () => {
|
apiMocks.getProviderProperties.mockRejectedValue(new Error('network error'));
|
shallowMount(VersionDrawer, {
|
global: {
|
stubs: {
|
'a-alert': true,
|
'a-descriptions': true,
|
'a-descriptions-item': true,
|
'a-form-item': true,
|
'a-tag': true,
|
'a-textarea': true,
|
},
|
},
|
});
|
const readSource = formState.config.schemas.find((schema: any) => schema.field === 'readSource');
|
|
await expect(readSource.componentProps.onChange('LIMS_TASK')).resolves.toBeUndefined();
|
|
const providerUpdates = formState.updateSchema.mock.calls.map(([schema]) => schema).filter((schema) => schema.field === 'providerProperty');
|
expect(providerUpdates.at(-1).componentProps.options).toEqual([]);
|
});
|
|
it('shows and saves the fixed revision of a configured LIMS property', async () => {
|
apiMocks.getProviderProperties.mockResolvedValue({
|
data: [
|
{
|
dataType: 'TEXT',
|
enabled: true,
|
label: '供试品名称',
|
property: 'verification.sample_name',
|
propertyRevision: 3,
|
readOnly: true,
|
source: 'LIMS_TASK',
|
},
|
],
|
});
|
formState.validate.mockResolvedValue({
|
piciMoshi: 'RECORD_PRIVATE',
|
providerProperty: 'verification.sample_name',
|
readSource: 'LIMS_TASK',
|
shifouBitian: false,
|
shujuLeixing: 'TEXT',
|
ziduanMingcheng: '供试品名称',
|
});
|
const wrapper = mount(VersionDrawer, {
|
global: {
|
stubs: {
|
'a-alert': true,
|
'a-descriptions': true,
|
'a-descriptions-item': true,
|
'a-form-item': true,
|
'a-tag': true,
|
'a-textarea': true,
|
},
|
},
|
});
|
await drawerState.init({ fieldId: 'field-1' });
|
await flushPromises();
|
const actions = wrapper.findAllComponents({ name: 'TableAction' })[1]!.props('actions') as any[];
|
await actions.find((action) => action.label === '编辑').onClick();
|
const readSource = formState.config.schemas.find((schema: any) => schema.field === 'readSource');
|
await readSource.componentProps.onChange('LIMS_TASK');
|
await flushPromises();
|
|
const providerUpdates = formState.updateSchema.mock.calls.map(([schema]) => schema).filter((schema) => schema.field === 'providerProperty');
|
expect(providerUpdates.at(-1).componentProps.options).toEqual([{ fullName: '供试品名称（版本 3）', id: 'verification.sample_name' }]);
|
|
wrapper.findAllComponents({ name: 'BasicModal' })[0]!.vm.$emit('ok');
|
await flushPromises();
|
expect(apiMocks.updateFieldVersion).toHaveBeenCalledWith(
|
'v2',
|
expect.objectContaining({
|
binding: {
|
read: { property: 'verification.sample_name', propertyRevision: 3, source: 'LIMS_TASK' },
|
write: { target: 'ELN_RECORD' },
|
},
|
}),
|
);
|
});
|
|
it('opens the independent LIMS source page from draft field editing', async () => {
|
const wrapper = mount(VersionDrawer, {
|
global: {
|
stubs: {
|
'a-alert': true,
|
'a-descriptions': true,
|
'a-descriptions-item': true,
|
'a-form-item': true,
|
'a-tag': true,
|
'a-textarea': true,
|
},
|
},
|
});
|
await drawerState.init({ fieldId: 'field-1' });
|
await flushPromises();
|
const actions = wrapper.findAllComponents({ name: 'TableAction' })[1]!.props('actions') as any[];
|
await actions.find((action) => action.label === '编辑').onClick();
|
const readSource = formState.config.schemas.find((schema: any) => schema.field === 'readSource');
|
|
expect(wrapper.find('[data-test="maintain-lims-source"]').exists()).toBe(false);
|
await readSource.componentProps.onChange('LIMS_TASK');
|
await flushPromises();
|
expect(wrapper.get('[data-test="maintain-lims-source"]').text()).toContain('维护 LIMS 数据项');
|
await wrapper.get('[data-test="maintain-lims-source"]').trigger('click');
|
expect(navigationMocks.route).toHaveBeenCalledWith('/eln/sources', { title: 'LIMS 数据项' });
|
expect(wrapper.find('[data-test="lims-source-workspace"]').exists()).toBe(false);
|
expect(wrapper.findComponent({ name: 'SourceWorkspace' }).exists()).toBe(false);
|
|
await readSource.componentProps.onChange('SYSTEM');
|
await flushPromises();
|
expect(wrapper.find('[data-test="maintain-lims-source"]').exists()).toBe(false);
|
});
|
|
it('preserves a pinned property revision when the current catalog has moved on', async () => {
|
apiMocks.getFieldDetail.mockResolvedValue({
|
data: {
|
bizEnabled: 'enabled',
|
id: 'field-1',
|
versions: [
|
{
|
banbenHao: 2,
|
binding: { read: { property: 'verification.sample_name', propertyRevision: 3, source: 'LIMS_TASK' } },
|
bizStatus: 'DRAFT',
|
id: 'v2',
|
piciMoshi: 'RECORD_PRIVATE',
|
shifouBitian: 0,
|
shujuLeixing: 'TEXT',
|
ziduanDingyiId: 'field-1',
|
ziduanMingcheng: '供试品名称',
|
},
|
],
|
ziduanBianma: 'sample_name_ab12cd34',
|
zuoyongFanwei: 'GLOBAL',
|
},
|
});
|
apiMocks.getProviderProperties.mockResolvedValue({
|
data: [
|
{
|
dataType: 'TEXT',
|
enabled: true,
|
label: '供试品名称（新规则）',
|
property: 'verification.sample_name',
|
propertyRevision: 4,
|
readOnly: true,
|
source: 'LIMS_TASK',
|
},
|
],
|
});
|
sourceApiMocks.getSourceReference.mockResolvedValue({
|
data: { dataType: 'TEXT', displayName: '供试品名称', enabled: false, propertyCode: 'verification.sample_name', revision: 3 },
|
});
|
formState.validate.mockResolvedValue({
|
piciMoshi: 'RECORD_PRIVATE',
|
providerProperty: 'verification.sample_name',
|
readSource: 'LIMS_TASK',
|
shifouBitian: false,
|
shujuLeixing: 'TEXT',
|
ziduanMingcheng: '供试品名称',
|
});
|
const wrapper = mount(VersionDrawer, {
|
global: {
|
stubs: {
|
'a-alert': true,
|
'a-button': true,
|
'a-descriptions': true,
|
'a-descriptions-item': true,
|
'a-form-item': true,
|
'a-tag': true,
|
'a-textarea': true,
|
},
|
},
|
});
|
await drawerState.init({ fieldId: 'field-1' });
|
await flushPromises();
|
const actions = wrapper.findComponent({ name: 'TableAction' }).props('actions') as any[];
|
await actions.find((action) => action.label === '编辑').onClick();
|
await flushPromises();
|
|
expect(sourceApiMocks.getSourceReference).toHaveBeenCalledWith('verification.sample_name', 3);
|
const providerUpdates = formState.updateSchema.mock.calls.map(([schema]) => schema).filter((schema) => schema.field === 'providerProperty');
|
expect(providerUpdates.at(-1).componentProps.options).toEqual([{ fullName: '供试品名称（版本 3，已停用）', id: 'verification.sample_name' }]);
|
wrapper.findAllComponents({ name: 'BasicModal' })[0]!.vm.$emit('ok');
|
await flushPromises();
|
expect(apiMocks.updateFieldVersion).toHaveBeenCalledWith(
|
'v2',
|
expect.objectContaining({
|
binding: expect.objectContaining({
|
read: { property: 'verification.sample_name', propertyRevision: 3, source: 'LIMS_TASK' },
|
}),
|
}),
|
);
|
});
|
});
|
