cesnimda
174 lines
11 KiB
TypeScript
174 lines
11 KiB
TypeScript
import React from 'react';
|
|
import '@testing-library/jest-dom';
|
|
import { act, fireEvent, render, screen, waitFor } from '@testing-library/react';
|
|
import { MemoryRouter } from 'react-router-dom';
|
|
import AdminProcessingPage from './views/AdminProcessingPage';
|
|
import { I18nProvider } from './i18n/I18nProvider';
|
|
import { api } from './api';
|
|
import { setAuthUserKey } from './auth';
|
|
|
|
const get = api.get as jest.Mock;
|
|
const item = { id: '11111111-1111-4111-8111-111111111111', owner: { id: 'owner', name: 'Synthetic owner', email: 'owner@example.test' }, taskType: 'cv.process', status: 'running', stage: 'cv_extracting', attemptCount: 1, maxAttempts: 3, createdAtUtc: '2026-10-28T12:00:00Z', startedAtUtc: '2026-10-28T12:00:00Z', completedAtUtc: null, lastHeartbeatAtUtc: null, durationSeconds: 8, worker: 'document', workerEnabled: true, failureCode: null, job: null, document: { importId: 7, name: 'CV.pdf', type: 'application/pdf', bytes: 500, pages: 2, state: 'running' } };
|
|
const listing = { items: [item], total: 1, page: 1, pageSize: 25, counts: { running: 1 }, workers: [{ name: 'AiOperations', flagEnabled: false, individualOperationsRecorded: true }], cvInterpretation: 'deterministic' };
|
|
function open() { return render(<MemoryRouter><I18nProvider><AdminProcessingPage /></I18nProvider></MemoryRouter>); }
|
|
beforeEach(() => {
|
|
localStorage.clear(); setAuthUserKey('admin', false);
|
|
get.mockReset();
|
|
get.mockImplementation((url: string) => Promise.resolve({ data: url.endsWith('/events') || url.includes('/events?')
|
|
? { items: [{ id: '9007199254740993', kind: 'Claimed', status: 'running', stage: null, attempt: 1, failureCode: null, atUtc: '2026-10-28T12:00:00Z' }], hasMore: false, retentionDays: 30 }
|
|
: url.includes(item.id) ? item : listing }));
|
|
});
|
|
afterEach(() => jest.useRealTimers());
|
|
|
|
test('shows safe job metadata and real events with a copyable correlation ID', async () => {
|
|
open();
|
|
expect(await screen.findByText('Synthetic owner')).toBeVisible();
|
|
fireEvent.click(screen.getByRole('button', { name: /View processing details/ }));
|
|
expect(await screen.findByLabelText('Correlation ID')).toHaveValue(item.id);
|
|
expect(await screen.findByText(/^Worker claimed job/)).toBeVisible();
|
|
expect(screen.getAllByText('CV.pdf').length).toBeGreaterThan(0);
|
|
await waitFor(() => expect(screen.getByRole('heading', { name: 'Processing details' })).toHaveFocus());
|
|
expect(screen.queryByText(/SECRET/)).not.toBeInTheDocument();
|
|
});
|
|
|
|
test('submits diagnostic filters and displays explicit owner, import and unrelated-job metadata', async () => {
|
|
open();
|
|
await screen.findByText('Synthetic owner');
|
|
fireEvent.change(screen.getByLabelText('Search users, jobs or task ID'), { target: { value: 'Owned job' } });
|
|
fireEvent.change(screen.getByLabelText('Application ID'), { target: { value: '2' } });
|
|
fireEvent.change(screen.getByLabelText('Submitted from (UTC)'), { target: { value: '2026-10-01' } });
|
|
fireEvent.change(screen.getByLabelText('Submitted before (UTC)'), { target: { value: '2026-11-01' } });
|
|
fireEvent.change(screen.getByLabelText('Worker filter'), { target: { value: 'document' } });
|
|
fireEvent.change(screen.getByLabelText('Failure code'), { target: { value: 'timeout' } });
|
|
fireEvent.click(screen.getByRole('button', { name: 'Apply filters' }));
|
|
await waitFor(() => expect(get.mock.calls.some(([url]) => {
|
|
const query = new URLSearchParams(url.split('?')[1]);
|
|
return query.get('q') === 'Owned job' && query.get('jobId') === '2' && query.get('worker') === 'document'
|
|
&& query.get('failureCode') === 'timeout' && query.get('createdFrom') === '2026-10-01T00:00:00Z'
|
|
&& query.get('createdBefore') === '2026-11-01T00:00:00Z';
|
|
})).toBe(true));
|
|
fireEvent.click(screen.getByRole('button', { name: /View processing details/ }));
|
|
expect(await screen.findByLabelText('Submitting user ID')).toHaveValue('owner');
|
|
expect(screen.getByText('No linked job')).toBeVisible();
|
|
expect(screen.getByText('Import ID: 7')).toBeVisible();
|
|
});
|
|
|
|
test('shows stable failure evidence and links an application only when the server permits it', async () => {
|
|
const selected = { ...item, status: 'failed', failureCode: 'timeout', completedAtUtc: '2026-10-28T12:00:08Z', job: { id: 2, title: 'Owned job', company: 'Synthetic company', canOpen: false } };
|
|
get.mockImplementation((url: string) => Promise.resolve({ data: url.includes('/events') ? { items: [], hasMore: false, retentionDays: 30 }
|
|
: url.includes(item.id) ? selected : listing }));
|
|
open();
|
|
await screen.findByText('Synthetic owner');
|
|
fireEvent.click(screen.getByRole('button', { name: /View processing details/ }));
|
|
expect(await screen.findByRole('alert')).toHaveTextContent('Failure code: timeout');
|
|
expect(screen.getByRole('alert')).toHaveTextContent('Whether this failure is transient or permanent has not been established.');
|
|
expect(screen.queryByRole('link', { name: 'Owned job' })).not.toBeInTheDocument();
|
|
selected.job.canOpen = true;
|
|
fireEvent.click(screen.getByRole('button', { name: 'Refresh' }));
|
|
expect(await screen.findByRole('link', { name: 'Owned job' })).toHaveAttribute('href', '/jobs/2');
|
|
});
|
|
|
|
test('a successful retry keeps prior failure evidence separate from its success timestamp', async () => {
|
|
const failedAt = '2026-10-28T12:01:00Z';
|
|
const completedAt = '2026-10-28T12:05:00Z';
|
|
const selected = { ...item, status: 'succeeded', failureCode: 'timeout', completedAtUtc: completedAt, lastFailureAtUtc: failedAt, lastFailureStage: 'cv_extracting' };
|
|
get.mockImplementation((url: string) => Promise.resolve({ data: url.includes('/events') ? { items: [], hasMore: false, retentionDays: 30 }
|
|
: url.includes(item.id) ? selected : listing }));
|
|
open(); await screen.findByText('Synthetic owner');
|
|
fireEvent.click(screen.getByRole('button', { name: /View processing details/ }));
|
|
const alert = await screen.findByRole('alert');
|
|
expect(alert).toHaveTextContent('Previous failure: Processing timed out.');
|
|
expect(alert).toHaveTextContent(new Date(failedAt).toLocaleString('en-GB'));
|
|
expect(alert).not.toHaveTextContent(new Date(completedAt).toLocaleString('en-GB'));
|
|
});
|
|
|
|
test('pause stops polling and resume uses an exact string event cursor', async () => {
|
|
jest.useFakeTimers(); open();
|
|
await act(async () => { await Promise.resolve(); });
|
|
fireEvent.click(screen.getByRole('button', { name: /View processing details/ }));
|
|
await act(async () => { await Promise.resolve(); });
|
|
await act(async () => { jest.advanceTimersByTime(5100); });
|
|
expect(get.mock.calls.some(([url]) => url.includes('after=9007199254740993'))).toBe(true);
|
|
fireEvent.click(screen.getByRole('button', { name: 'Pause updates' }));
|
|
const count = get.mock.calls.length;
|
|
await act(async () => { jest.advanceTimersByTime(15000); });
|
|
expect(get).toHaveBeenCalledTimes(count);
|
|
fireEvent.click(screen.getByRole('button', { name: 'Resume updates' }));
|
|
await act(async () => { await Promise.resolve(); });
|
|
expect(get.mock.calls.length).toBeGreaterThan(count);
|
|
});
|
|
|
|
test('forbidden responses clear metadata and do not retry automatically', async () => {
|
|
jest.useFakeTimers(); get.mockRejectedValue({ response: { status: 403, data: 'SECRET server error' } });
|
|
open(); await act(async () => { await Promise.resolve(); });
|
|
expect(screen.getByRole('alert')).toHaveTextContent('Administrator access is required.');
|
|
const count = get.mock.calls.length;
|
|
await act(async () => { jest.advanceTimersByTime(30000); });
|
|
expect(get).toHaveBeenCalledTimes(count);
|
|
expect(screen.queryByText('Synthetic owner')).not.toBeInTheDocument();
|
|
expect(screen.queryByText(/SECRET/)).not.toBeInTheDocument();
|
|
});
|
|
|
|
test('malformed successful responses produce a recoverable error instead of rendering raw data', async () => {
|
|
get.mockResolvedValue({ data: 'SECRET malformed body' });
|
|
open();
|
|
expect(await screen.findByRole('alert')).toHaveTextContent('Processing information could not be loaded.');
|
|
expect(screen.queryByText(/SECRET/)).not.toBeInTheDocument();
|
|
});
|
|
|
|
test('invalid filters explain the rejected request and stop automatic retries', async () => {
|
|
jest.useFakeTimers();
|
|
get.mockRejectedValue({ response: { status: 400 } });
|
|
open(); await act(async () => { await Promise.resolve(); });
|
|
expect(screen.getByRole('alert')).toHaveTextContent('Check the filter values');
|
|
const count = get.mock.calls.length;
|
|
await act(async () => { jest.advanceTimersByTime(30000); });
|
|
expect(get).toHaveBeenCalledTimes(count);
|
|
});
|
|
|
|
test('identity changes abort pending reads and clear the previous administrator view', async () => {
|
|
let finish!: (value: unknown) => void;
|
|
get.mockImplementationOnce(() => new Promise(resolve => { finish = resolve; }));
|
|
open(); await waitFor(() => expect(get).toHaveBeenCalled());
|
|
const signal = get.mock.calls[0][1].signal;
|
|
get.mockRejectedValue({ response: { status: 403 } });
|
|
act(() => setAuthUserKey('ordinary'));
|
|
await act(async () => { finish({ data: listing }); });
|
|
expect(signal.aborted).toBe(true);
|
|
expect(screen.queryByText('Synthetic owner')).not.toBeInTheDocument();
|
|
});
|
|
|
|
test('a failed cycle aborts sibling reads and reconnects with bounded backoff', async () => {
|
|
jest.useFakeTimers();
|
|
get.mockRejectedValueOnce(new Error('SECRET transport failure'));
|
|
open(); await act(async () => { await Promise.resolve(); });
|
|
expect(screen.getByRole('alert')).toHaveTextContent('Processing information could not be loaded.');
|
|
expect(get.mock.calls[0][1].signal.aborted).toBe(true);
|
|
const count = get.mock.calls.length;
|
|
await act(async () => { jest.advanceTimersByTime(14999); });
|
|
expect(get).toHaveBeenCalledTimes(count);
|
|
await act(async () => { jest.advanceTimersByTime(1); });
|
|
expect(screen.getByText('Synthetic owner')).toBeVisible();
|
|
expect(screen.queryByText(/SECRET/)).not.toBeInTheDocument();
|
|
});
|
|
|
|
test('older event pages pause updates and retain exact cursors until returning to latest', async () => {
|
|
jest.useFakeTimers();
|
|
get.mockImplementation((url: string) => Promise.resolve({ data: url.includes('/events')
|
|
? { items: [{ id: url.includes('before=') ? '9007199254740992' : '9007199254740993', kind: url.includes('before=') ? 'Created' : 'Claimed', status: 'running', stage: null, attempt: 1, failureCode: null, atUtc: '2026-10-28T12:00:00Z' }], hasMore: true, retentionDays: 30 }
|
|
: url.includes(item.id) ? item : listing }));
|
|
open(); await act(async () => { await Promise.resolve(); });
|
|
fireEvent.click(screen.getByRole('button', { name: /View processing details/ }));
|
|
await act(async () => { await Promise.resolve(); });
|
|
fireEvent.click(screen.getByRole('button', { name: 'Older events' }));
|
|
await act(async () => { await Promise.resolve(); });
|
|
expect(get.mock.calls.some(([url]) => url.includes('before=9007199254740993'))).toBe(true);
|
|
expect(screen.getByText(/^Job created/)).toBeVisible();
|
|
const count = get.mock.calls.length;
|
|
await act(async () => { jest.advanceTimersByTime(30000); });
|
|
expect(get).toHaveBeenCalledTimes(count);
|
|
fireEvent.click(screen.getByRole('button', { name: 'Latest events' }));
|
|
await act(async () => { await Promise.resolve(); });
|
|
expect(screen.getByText(/^Worker claimed job/)).toBeVisible();
|
|
});
|