import type { FormulaRule } from '#/api/x/eln/formulas';
|
|
import { flushPromises, mount } from '@vue/test-utils';
|
import { defineComponent } from 'vue';
|
|
import { afterEach, describe, expect, it, vi } from 'vitest';
|
|
import { useFormulaValidation } from '../useFormulaValidation';
|
|
const apiMocks = vi.hoisted(() => ({ validateFormula: vi.fn() }));
|
|
vi.mock('#/api/x/eln/formulas', () => ({ validateFormula: apiMocks.validateFormula }));
|
|
function deferred<T>() {
|
let resolve!: (value: T) => void;
|
const promise = new Promise<T>((promiseResolve) => {
|
resolve = promiseResolve;
|
});
|
return { promise, resolve };
|
}
|
|
function rule(expression = 'a + b'): FormulaRule {
|
return { biaodashi: expression, jieguoLeixing: 'DECIMAL', parameters: [] };
|
}
|
|
function mountValidation() {
|
let validation!: ReturnType<typeof useFormulaValidation>;
|
const wrapper = mount(
|
defineComponent({
|
setup() {
|
validation = useFormulaValidation();
|
return () => null;
|
},
|
}),
|
);
|
return { validation, wrapper };
|
}
|
|
describe('useFormulaValidation', () => {
|
afterEach(() => {
|
vi.useRealTimers();
|
vi.clearAllMocks();
|
});
|
|
it('waits 400ms before validating a scheduled edit', async () => {
|
vi.useFakeTimers();
|
apiMocks.validateFormula.mockResolvedValue({ data: { diagnostics: [], latex: 'a+b' } });
|
const { validation } = mountValidation();
|
|
validation.schedule(rule());
|
await vi.advanceTimersByTimeAsync(399);
|
expect(apiMocks.validateFormula).not.toHaveBeenCalled();
|
await vi.advanceTimersByTimeAsync(1);
|
await flushPromises();
|
|
expect(apiMocks.validateFormula).toHaveBeenCalledTimes(1);
|
});
|
|
it('aborts an active request when a newer validation starts', async () => {
|
const first = deferred<any>();
|
const second = deferred<any>();
|
apiMocks.validateFormula
|
.mockImplementationOnce((_rule: FormulaRule, signal: AbortSignal) => {
|
expect(signal.aborted).toBe(false);
|
return first.promise;
|
})
|
.mockImplementationOnce(() => second.promise);
|
const { validation } = mountValidation();
|
|
void validation.validateNow(rule('a'));
|
await Promise.resolve();
|
void validation.validateNow(rule('b'));
|
await Promise.resolve();
|
|
expect(apiMocks.validateFormula.mock.calls[0]![1]!.aborted).toBe(true);
|
second.resolve({ data: { diagnostics: [], latex: 'b' } });
|
first.resolve({ data: { diagnostics: [], latex: 'a' } });
|
await flushPromises();
|
});
|
|
it('drops a late response from an older request', async () => {
|
const first = deferred<any>();
|
const second = deferred<any>();
|
apiMocks.validateFormula.mockImplementationOnce(() => first.promise).mockImplementationOnce(() => second.promise);
|
const { validation } = mountValidation();
|
|
void validation.validateNow(rule('a'));
|
void validation.validateNow(rule('b'));
|
second.resolve({ data: { diagnostics: [], latex: 'b' } });
|
await flushPromises();
|
first.resolve({ data: { diagnostics: [], latex: 'a' } });
|
await flushPromises();
|
|
expect(validation.result.value?.latex).toBe('b');
|
});
|
|
it('runs a manual validation immediately and cancels the pending debounce', async () => {
|
vi.useFakeTimers();
|
apiMocks.validateFormula.mockResolvedValue({ data: { diagnostics: [], latex: 'manual' } });
|
const { validation } = mountValidation();
|
|
validation.schedule(rule('scheduled'));
|
await validation.validateNow(rule('manual'));
|
await vi.advanceTimersByTimeAsync(400);
|
|
expect(apiMocks.validateFormula).toHaveBeenCalledTimes(1);
|
expect(apiMocks.validateFormula).toHaveBeenCalledWith(rule('manual'), expect.any(AbortSignal));
|
});
|
|
it('invalidates an active validation as soon as a new edit enters the debounce window', async () => {
|
vi.useFakeTimers();
|
const oldResponse = deferred<any>();
|
apiMocks.validateFormula.mockImplementationOnce((_rule: FormulaRule, signal: AbortSignal) => {
|
expect(signal.aborted).toBe(false);
|
return oldResponse.promise;
|
});
|
const { validation } = mountValidation();
|
|
void validation.validateNow(rule('old_expression'));
|
await Promise.resolve();
|
const oldSignal = apiMocks.validateFormula.mock.calls[0]![1] as AbortSignal;
|
validation.schedule(rule('new_expression'));
|
oldResponse.resolve({ data: { diagnostics: [], latex: 'old_latex' } });
|
await flushPromises();
|
|
expect(oldSignal.aborted).toBe(true);
|
expect(validation.result.value).toBeUndefined();
|
});
|
|
it('keeps a visible retryable failure state instead of rejecting a scheduled validation', async () => {
|
apiMocks.validateFormula
|
.mockRejectedValueOnce(new Error('validation service unavailable'))
|
.mockResolvedValueOnce({ data: { diagnostics: [], latex: 'retry' } });
|
const { validation } = mountValidation();
|
|
await expect(validation.validateNow(rule('first'))).resolves.toBeUndefined();
|
|
expect(validation.error.value).toBe('validation service unavailable');
|
expect(validation.result.value).toEqual({ diagnostics: [], latex: null });
|
await validation.retry();
|
|
expect(apiMocks.validateFormula).toHaveBeenCalledTimes(2);
|
expect(validation.error.value).toBe('');
|
expect(validation.result.value?.latex).toBe('retry');
|
});
|
|
it('clears its timer and aborts an active request on unmount', async () => {
|
vi.useFakeTimers();
|
const pending = deferred<any>();
|
apiMocks.validateFormula.mockReturnValue(pending.promise);
|
const { validation, wrapper } = mountValidation();
|
|
validation.schedule(rule('scheduled'));
|
void validation.validateNow(rule('active'));
|
await Promise.resolve();
|
const signal = apiMocks.validateFormula.mock.calls[0]![1] as AbortSignal;
|
wrapper.unmount();
|
await vi.advanceTimersByTimeAsync(400);
|
|
expect(signal.aborted).toBe(true);
|
expect(apiMocks.validateFormula).toHaveBeenCalledTimes(1);
|
});
|
});
|
