import { flushPromises, mount } from '@vue/test-utils';
|
import { defineComponent, h, reactive } from 'vue';
|
|
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
|
|
import { workflowFileSubmitPendingKey } from '#/components/Jnpf/upload/src/filePermissionContext';
|
|
import { refreshConfiguredFilePermissions, useFilePermissions } from './useFilePermissions';
|
|
const mocks = vi.hoisted(() => ({ get: vi.fn() }));
|
vi.mock('#/api/workFlow/task', () => ({ getFlowFilePermissions: mocks.get }));
|
const view = (taskId = 'task', revision = 'v1') => ({ enabled: true, taskId, formId: 'form', status: 'ready', revision, fields: {} });
|
const wrappers: ReturnType<typeof mount>[] = [];
|
function setup(initial = view()) {
|
const config = reactive({ id: initial.taskId, formId: 'form', filePermissions: initial });
|
const submission = reactive({ pending: false });
|
let permissions!: ReturnType<typeof useFilePermissions>;
|
const wrapper = mount(
|
defineComponent({
|
setup() {
|
permissions = useFilePermissions(() => config);
|
return () => h('div');
|
},
|
}),
|
{ global: { provide: { [workflowFileSubmitPendingKey as symbol]: () => submission.pending } } },
|
);
|
wrappers.push(wrapper);
|
return { config, permissions, wrapper, submission };
|
}
|
beforeEach(() => {
|
vi.useFakeTimers();
|
mocks.get.mockReset();
|
});
|
afterEach(() => {
|
wrappers.splice(0).forEach((w) => w.unmount());
|
vi.useRealTimers();
|
});
|
describe('flow file permissions refresh', () => {
|
it('updates configured permissions immediately after workflow state changes', async () => {
|
const config = reactive({ id: 'record', formId: 'form', filePermissions: view() });
|
mocks.get.mockResolvedValue({ data: view('task', 'started') });
|
|
await expect(refreshConfiguredFilePermissions(() => config)).resolves.toBe(true);
|
|
expect(mocks.get).toHaveBeenCalledWith('task', { formId: 'form' });
|
expect(config.filePermissions.revision).toBe('started');
|
});
|
it('does not apply an immediate refresh response after switching records', async () => {
|
let resolve!: (value: any) => void;
|
mocks.get.mockReturnValueOnce(
|
new Promise((done) => {
|
resolve = done;
|
}),
|
);
|
const config = reactive({ id: 'record', formId: 'form', filePermissions: view() });
|
const refresh = refreshConfiguredFilePermissions(() => config);
|
config.id = 'other-record';
|
config.filePermissions = view('other-task', 'current');
|
resolve({ data: view('task', 'stale') });
|
|
await expect(refresh).resolves.toBe(false);
|
expect(config.filePermissions.taskId).toBe('other-task');
|
expect(config.filePermissions.revision).toBe('current');
|
});
|
it('keeps an unsaved form native and applies instance permissions after reopening the saved record', async () => {
|
const config = reactive({ id: '', formId: 'form', filePermissions: undefined as ReturnType<typeof view> | undefined });
|
let permissions!: ReturnType<typeof useFilePermissions>;
|
wrappers.push(
|
mount(
|
defineComponent({
|
setup() {
|
permissions = useFilePermissions(() => config);
|
return () => h('div');
|
},
|
}),
|
),
|
);
|
window.dispatchEvent(new Event('focus'));
|
await vi.advanceTimersByTimeAsync(30_000);
|
expect(permissions.value).toBeUndefined();
|
expect(mocks.get).not.toHaveBeenCalled();
|
|
config.id = 'saved-record';
|
config.filePermissions = view();
|
await flushPromises();
|
expect(permissions.value?.enabled).toBe(true);
|
mocks.get.mockRejectedValueOnce(new Error('offline'));
|
window.dispatchEvent(new Event('focus'));
|
await flushPromises();
|
expect(mocks.get).toHaveBeenCalledWith('task', { formId: 'form' });
|
expect(permissions.value?.status).toBe('error');
|
expect(permissions.value?.enabled).toBe(true);
|
|
config.id = '';
|
config.filePermissions = undefined;
|
await flushPromises();
|
expect(permissions.value).toBeUndefined();
|
});
|
it('does not query old workflows or leave listeners after unmount', async () => {
|
const state = setup({ ...view(), enabled: false });
|
window.dispatchEvent(new Event('focus'));
|
await vi.advanceTimersByTimeAsync(30_000);
|
expect(mocks.get).not.toHaveBeenCalled();
|
state.wrapper.unmount();
|
expect(vi.getTimerCount()).toBe(0);
|
window.dispatchEvent(new Event('focus'));
|
expect(mocks.get).not.toHaveBeenCalled();
|
});
|
it('fails closed on request failure and recovers on the next focus', async () => {
|
const state = setup();
|
mocks.get.mockRejectedValueOnce(new Error('offline'));
|
window.dispatchEvent(new Event('focus'));
|
await flushPromises();
|
expect(state.permissions.value?.status).toBe('error');
|
mocks.get.mockResolvedValue({ data: view('task', 'v2') });
|
window.dispatchEvent(new Event('focus'));
|
await flushPromises();
|
expect(state.permissions.value?.revision).toBe('v2');
|
expect(state.permissions.value?.status).toBe('ready');
|
});
|
it('ignores an old response after a form switch and prevents duplicate in-flight requests', async () => {
|
let resolve!: (value: any) => void;
|
mocks.get.mockReturnValueOnce(
|
new Promise((done) => {
|
resolve = done;
|
}),
|
);
|
const state = setup();
|
window.dispatchEvent(new Event('focus'));
|
window.dispatchEvent(new Event('focus'));
|
expect(mocks.get).toHaveBeenCalledTimes(1);
|
state.config.id = 'other';
|
state.config.filePermissions = view('other');
|
await flushPromises();
|
mocks.get.mockResolvedValue({ data: view('other', 'new') });
|
window.dispatchEvent(new Event('focus'));
|
await flushPromises();
|
resolve({ data: view('task', 'stale') });
|
await flushPromises();
|
expect(state.permissions.value?.taskId).toBe('other');
|
expect(state.permissions.value?.revision).toBe('new');
|
});
|
it('rejects another workflow response and controlled-to-legacy downgrade', async () => {
|
const state = setup();
|
mocks.get.mockResolvedValue({ data: view('other') });
|
window.dispatchEvent(new Event('focus'));
|
await flushPromises();
|
expect(state.permissions.value?.status).toBe('error');
|
mocks.get.mockResolvedValue({ data: { ...view(), enabled: false } });
|
window.dispatchEvent(new Event('focus'));
|
await flushPromises();
|
expect(state.permissions.value?.status).toBe('error');
|
expect(state.permissions.value?.enabled).toBe(true);
|
});
|
it('refreshes using the resolved task id rather than the native record alias', async () => {
|
const state = setup();
|
state.config.id = 'business-record';
|
await flushPromises();
|
mocks.get.mockResolvedValue({ data: view() });
|
window.dispatchEvent(new Event('focus'));
|
await flushPromises();
|
expect(mocks.get).toHaveBeenCalledWith('task', { formId: 'form' });
|
expect(state.permissions.value?.status).toBe('ready');
|
});
|
it('fences in-flight permissions while approval submits and refreshes after failure recovery', async () => {
|
const state = setup();
|
let reject!: (error: Error) => void;
|
mocks.get.mockReturnValueOnce(
|
new Promise((_resolve, fail) => {
|
reject = fail;
|
}),
|
);
|
window.dispatchEvent(new Event('focus'));
|
state.submission.pending = true;
|
await vi.advanceTimersByTimeAsync(30_000);
|
window.dispatchEvent(new Event('focus'));
|
expect(mocks.get).toHaveBeenCalledTimes(1);
|
mocks.get.mockResolvedValue({ data: view('task', 'next-node') });
|
state.submission.pending = false;
|
await flushPromises();
|
expect(state.permissions.value?.revision).toBe('next-node');
|
reject(new Error('stale transition failure'));
|
await flushPromises();
|
expect(state.permissions.value?.status).toBe('ready');
|
expect(state.permissions.value?.revision).toBe('next-node');
|
});
|
});
|
