cesnimda
388 lines
29 KiB
TypeScript
388 lines
29 KiB
TypeScript
import { expect, test, type APIRequest, type APIRequestContext, type APIResponse, type BrowserContext, type Locator, type Page, type TestInfo } from '@playwright/test';
|
|
import AxeBuilder from '@axe-core/playwright';
|
|
import { createHash } from 'node:crypto';
|
|
import { readFile } from 'node:fs/promises';
|
|
import path from 'node:path';
|
|
import type { CvOutline, CvVariant } from '../src/cvBuilder';
|
|
import type { CoverLetter, SubmittedPackage, SubmittedPackageDetail } from '../src/applicationWorkspace';
|
|
import type { StructuredCvProfile } from '../src/profileCv';
|
|
import { translations } from '../src/i18n/translations';
|
|
|
|
const apiUrl = 'http://localhost:5302/api';
|
|
const password = 'E2ePassword123!';
|
|
type Language = 'en' | 'nb';
|
|
type Headers = Record<string, string>;
|
|
type BrowserTools = { request: APIRequest };
|
|
type Snapshot = { revision: number; profile: StructuredCvProfile };
|
|
type Block = { id: string; text: string; page: number | null };
|
|
type Review = { runId: number; status: string; revision: number; sourceBlocks: Block[]; groups: { category: string; fields: { id: string }[] }[] };
|
|
type Run = { id: number; status: string; parserVersion: string; operation: { progressStage: string } };
|
|
type Timings = Record<string, number>;
|
|
type MappedValue = { name: string; value: string; evidence?: string; corrected?: boolean };
|
|
type Scenario = { language: Language; mode: 'light' | 'dark'; width: number; file: string; kind: 'job' | 'education' | 'repeated'; theme: 'minimal' | 'technical'; package?: boolean };
|
|
|
|
async function json<T>(response: APIResponse, status = 200): Promise<T> {
|
|
expect(response.status(), response.url()).toBe(status);
|
|
return response.json();
|
|
}
|
|
async function login(api: APIRequestContext, email: string): Promise<Headers> {
|
|
await json(await api.post(`${apiUrl}/auth/login`, { data: { email, password } }));
|
|
const me = await json<{ sessionContext: string }>(await api.get(`${apiUrl}/auth/me`));
|
|
const csrf = (await api.storageState()).cookies.find(cookie => cookie.name === 'XSRF-TOKEN');
|
|
expect(csrf).toBeDefined();
|
|
return { 'X-CSRF-TOKEN': csrf!.value, 'X-Session-Context': me.sessionContext };
|
|
}
|
|
async function career(api: APIRequestContext) { return json<Snapshot>(await api.get(`${apiUrl}/career/profile`)); }
|
|
async function versions(api: APIRequestContext) { return json<unknown[]>(await api.get(`${apiUrl}/career/profile/versions`)); }
|
|
async function readVariant(api: APIRequestContext, id: number) { return json<CvVariant>(await api.get(`${apiUrl}/cv/variants/${id}`)); }
|
|
const sha = (bytes: Buffer) => createHash('sha256').update(bytes).digest('hex').toUpperCase();
|
|
const clean = (text: string) => text.replace(/\s+/g, ' ').trim();
|
|
const numbered = (text: string, number: number) => text.replace('{number}', String(number));
|
|
function panel(page: Page, runId: number) { return page.locator(`#cv-import-${runId}-review-panel`); }
|
|
async function keyboardClick(page: Page, button: Locator) { await button.focus(); await page.keyboard.press('Enter'); }
|
|
|
|
async function owner(page: Page, context: BrowserContext, playwright: BrowserTools, sample: Scenario, info: TestInfo) {
|
|
const admin = await playwright.request.newContext();
|
|
const email = `cv-qa-${Date.now()}-${info.testId.replace(/[^a-z0-9]/gi, '').slice(-14)}@example.test`;
|
|
try {
|
|
const adminHeaders = await login(admin, 'e2e@example.test');
|
|
await json(await admin.post(`${apiUrl}/users`, { headers: adminHeaders, data: { email, password, roles: ['Premium'] } }));
|
|
} finally { await admin.dispose(); }
|
|
const headers = await login(page.request, email);
|
|
expect((await page.request.put(`${apiUrl}/auth/preferences/language`, { headers, data: { language: sample.language === 'nb' ? 'nb-NO' : 'en' } })).status()).toBe(204);
|
|
await context.addInitScript(({ language, mode }) => {
|
|
localStorage.setItem('uiLanguage', language); localStorage.setItem('jobtracker.themeMode', mode);
|
|
}, sample);
|
|
await context.route('**/*', route => {
|
|
const url = new URL(route.request().url());
|
|
return ['localhost', '127.0.0.1'].includes(url.hostname) || ['data:', 'blob:', 'about:'].includes(url.protocol) ? route.continue() : route.abort();
|
|
});
|
|
await page.setViewportSize({ width: sample.width, height: 900 });
|
|
await page.emulateMedia({ reducedMotion: 'reduce' });
|
|
return { email, headers };
|
|
}
|
|
|
|
async function upload(page: Page, playwright: BrowserTools, language: Language, fileName: string, info: TestInfo, timings: Timings, stageName: string) {
|
|
const t = translations[language];
|
|
const before = await career(page.request);
|
|
const historyBefore = await versions(page.request);
|
|
const existing = new Set((await json<Run[]>(await page.request.get(`${apiUrl}/profile-cv/runs`))).map(run => run.id));
|
|
const fixture = path.resolve(process.env.CV_QA_FIXTURE_ROOT!, fileName);
|
|
const fixtureHash = sha(await readFile(fixture));
|
|
await page.goto('/career?section=import');
|
|
await expect(page.getByRole('button', { name: t.profileUploadCv, exact: true })).toBeEnabled();
|
|
const started = Date.now();
|
|
const accepted = page.waitForResponse(response => response.url() === `${apiUrl}/profile-cv/import` && response.request().method() === 'POST');
|
|
await page.locator('input[type=file][accept*=".pdf"]').setInputFiles(fixture);
|
|
expect((await accepted).status()).toBe(202);
|
|
const observed: { status: string; stage: string | null; elapsedMs: number }[] = [];
|
|
let pending: Run | undefined;
|
|
await expect.poll(async () => {
|
|
pending = (await json<Run[]>(await page.request.get(`${apiUrl}/profile-cv/runs`))).find(run => !existing.has(run.id));
|
|
if (pending) observed.push({ status: pending.status, stage: pending.operation?.progressStage ?? null, elapsedMs: Date.now() - started });
|
|
return pending?.status;
|
|
}, { timeout: 90_000, message: 'A real owned Docling run must reach persisted pending_review' }).toBe('pending_review');
|
|
timings[`${stageName}.uploadToPendingReviewMs`] = Date.now() - started;
|
|
expect(pending!.parserVersion).toBe('docling-v1');
|
|
expect(pending!.operation.progressStage).toBe('cv_review_ready');
|
|
expect(await career(page.request)).toEqual(before);
|
|
expect(await versions(page.request)).toEqual(historyBefore);
|
|
await page.reload();
|
|
await expect(page.locator('html')).toHaveAttribute('lang', language === 'nb' ? 'nb-NO' : 'en');
|
|
const review = await json<Review>(await page.request.get(`${apiUrl}/profile-cv/runs/${pending!.id}/review`));
|
|
expect(review.status).toBe('pending_review');
|
|
expect(review.revision).toBe(before.revision);
|
|
expect(review.sourceBlocks.length).toBeGreaterThan(0);
|
|
await expect(panel(page, pending!.id).getByRole('button', { name: t.cvImportApplyReviewed, exact: true })).toBeDisabled();
|
|
expect(await career(page.request)).toEqual(before);
|
|
expect(await versions(page.request)).toEqual(historyBefore);
|
|
const source = await page.request.get(`${apiUrl}/profile-cv/runs/${pending!.id}/source`);
|
|
expect(source.status()).toBe(200);
|
|
expect(source.headers()['cache-control']).toContain('no-store');
|
|
expect(sha(await source.body())).toBe(fixtureHash);
|
|
const stranger = await playwright.request.newContext();
|
|
try {
|
|
await login(stranger, 'e2e@example.test');
|
|
for (const suffix of ['source', 'review']) expect((await stranger.get(`${apiUrl}/profile-cv/runs/${pending!.id}/${suffix}`)).status()).toBe(404);
|
|
} finally { await stranger.dispose(); }
|
|
await info.attach(`${stageName}-persisted-stages`, { body: JSON.stringify({ runId: pending!.id, parserVersion: pending!.parserVersion, observed, fixtureHash,
|
|
boundary: 'Only sampled persisted stages are claimed; intermediate stages can complete between polls. Real local Docling, no extraction/model mocks.' }), contentType: 'application/json' });
|
|
return { runId: pending!.id, review, before, fixtureHash };
|
|
}
|
|
|
|
async function rejectOriginal(page: Page, runId: number) {
|
|
// Mapping editor selectors have cv-mapping IDs, so this addresses only extracted decisions.
|
|
for (const select of await panel(page, runId).locator('select[id^="cv-import-"]').all()) await select.selectOption('keep');
|
|
}
|
|
async function approveExtracted(page: Page, runId: number, language: Language) {
|
|
const buttons = panel(page, runId).getByRole('button', { name: translations[language].cvImportUseGroup, exact: true });
|
|
expect(await buttons.count()).toBeGreaterThanOrEqual(3);
|
|
for (const button of await buttons.all()) await button.click();
|
|
}
|
|
function evidence(review: Review, literal: string) {
|
|
const block = review.sourceBlocks.find(item => clean(item.text).includes(clean(literal)));
|
|
expect(block, `Original source block for literal ${JSON.stringify(literal)}`).toBeDefined();
|
|
return block!;
|
|
}
|
|
async function author(page: Page, runId: number, review: Review, language: Language, category: 'jobs' | 'education', fields: MappedValue[], target: number | null = null) {
|
|
const t = translations[language];
|
|
const reviewPanel = panel(page, runId);
|
|
await keyboardClick(page, reviewPanel.getByRole('button', { name: t.cvImportMapMissing, exact: true }));
|
|
const mapping = reviewPanel.getByRole('group', { name: numbered(t.cvImportMappingRecord, 1), exact: true });
|
|
await mapping.getByRole('combobox', { name: t.cvImportMappingCategory, exact: true }).selectOption(category);
|
|
await mapping.getByRole('combobox', { name: t.cvImportMappingTarget, exact: true }).selectOption(target === null ? '' : String(target));
|
|
const selected: { name: string; value: string; block: Block; corrected: boolean }[] = [];
|
|
for (const [index, field] of fields.entries()) {
|
|
const number = index + 1;
|
|
if (index >= 2) await mapping.getByRole('button', { name: t.cvImportMappingAddField, exact: true }).click();
|
|
await mapping.getByRole('combobox', { name: numbered(t.cvImportMappingField, number), exact: true }).selectOption(field.name);
|
|
const block = evidence(review, field.evidence ?? field.value);
|
|
const value = mapping.getByRole('textbox', { name: numbered(t.cvImportMappingValue, number), exact: true });
|
|
await mapping.getByRole('combobox', { name: numbered(t.cvImportMappingSource, number), exact: true }).selectOption(block.id);
|
|
await expect(value).toHaveValue(block.text);
|
|
await value.fill(field.value);
|
|
if (field.corrected) await mapping.getByRole('checkbox', { name: t.cvImportMappingCorrection, exact: true }).nth(index).check();
|
|
selected.push({ name: field.name, value: field.value, block, corrected: field.corrected ?? false });
|
|
}
|
|
await keyboardClick(page, mapping.getByRole('button', { name: t.cvImportMappingConfirm, exact: true }));
|
|
await expect(mapping.getByText(t.cvImportMappingConfirmed, { exact: true })).toBeVisible();
|
|
return { mapping, selected };
|
|
}
|
|
|
|
async function accessibility(page: Page, runId: number, info: TestInfo, name: string) {
|
|
const result = await new AxeBuilder({ page }).include(`#cv-import-${runId}-review-panel`).withTags(['wcag2a', 'wcag2aa', 'wcag21a', 'wcag21aa']).analyze();
|
|
await info.attach(`${name}-axe`, { body: JSON.stringify({ scope: `#cv-import-${runId}-review-panel`, violations: result.violations, incomplete: result.incomplete }), contentType: 'application/json' });
|
|
expect(result.violations).toEqual([]);
|
|
await page.screenshot({ path: info.outputPath(`${name}.png`), fullPage: true, animations: 'disabled' });
|
|
}
|
|
|
|
async function apply(page: Page, headers: Headers, runId: number, language: Language, before: Snapshot, timings: Timings, name: string) {
|
|
const endpoint = `${apiUrl}/profile-cv/runs/${runId}/apply-reviewed`;
|
|
const started = Date.now();
|
|
const response = page.waitForResponse(result => result.url() === endpoint && result.request().method() === 'POST');
|
|
await keyboardClick(page, panel(page, runId).getByRole('button', { name: translations[language].cvImportApplyReviewed, exact: true }));
|
|
const applied = await response;
|
|
expect(applied.status()).toBe(200);
|
|
await expect(page.locator(`#career-import-run-${runId}`).getByText(translations[language].cvImportSaved, { exact: true })).toBeVisible();
|
|
await expect.poll(async () => (await career(page.request)).revision).toBe(before.revision + 1);
|
|
const snapshot = await career(page.request);
|
|
timings[`${name}.applyToDurableReadbackMs`] = Date.now() - started;
|
|
const history = await versions(page.request);
|
|
const replay = await page.request.post(endpoint, { headers, data: applied.request().postDataJSON() });
|
|
expect(replay.status()).toBe(200);
|
|
expect(await career(page.request)).toEqual(snapshot);
|
|
expect(await versions(page.request)).toEqual(history);
|
|
return snapshot;
|
|
}
|
|
|
|
async function createVariant(api: APIRequestContext, headers: Headers, name: string, theme = 'minimal') {
|
|
return json<CvVariant>(await api.post(`${apiUrl}/cv/variants`, { headers, data: { name, settings: { themeId: theme } } }));
|
|
}
|
|
async function editAndExport(page: Page, headers: Headers, sample: Scenario, sibling: CvVariant, info: TestInfo, timings: Timings) {
|
|
const t = translations[sample.language];
|
|
const source = await career(page.request);
|
|
const sectionKey = sample.kind === 'education' ? 'education' : 'experience';
|
|
const sectionName = sample.kind === 'education' ? t.cvSectionEducation : t.cvSectionExperience;
|
|
const outline = await json<CvOutline>(await page.request.get(`${apiUrl}/cv/outline`));
|
|
const entries = outline.sections.find(section => section.key === sectionKey)!.entries;
|
|
expect(entries.length).toBeGreaterThan(0);
|
|
const first = entries[0];
|
|
const canonical = sample.kind === 'education' ? source.profile.education[0] : source.profile.jobs[0];
|
|
expect(canonical.id).toBeTruthy();
|
|
expect(first.key).toBe(canonical.id);
|
|
const cv = await json<CvVariant>(await page.request.post(`${apiUrl}/cv/variants`, { headers, data: {
|
|
name: `QA ${sample.language} ${sample.kind} CV`, settings: { themeId: sample.theme, sections: [{ key: sectionKey, itemOrder: entries.map(entry => entry.key!) }] },
|
|
} }));
|
|
const started = Date.now();
|
|
await page.goto(`/career/builder/${cv.id}`);
|
|
await expect(page.getByLabel(t.cvEditorName, { exact: true })).toHaveValue(cv.name);
|
|
await page.getByRole('button', { name: t.cvEditorExpandSection.replace('{section}', sectionName), exact: true }).click();
|
|
const section = page.getByRole('group', { name: sectionName, exact: true });
|
|
const entry = section.getByRole('group', { name: first.title!, exact: true }).first();
|
|
const tailoredTitle = `CV-only ${first.title}`;
|
|
await entry.getByLabel(t.cvEditorEntryTitle, { exact: true }).fill(tailoredTitle);
|
|
await expect.poll(async () => (await readVariant(page.request, cv.id)).settings.overrides[first.key!]?.title).toBe(tailoredTitle);
|
|
await expect(page.getByText(t.cvEditorSaved, { exact: true })).toBeVisible();
|
|
expect((await readVariant(page.request, cv.id)).version).toBeGreaterThan(cv.version);
|
|
expect(await career(page.request)).toEqual(source);
|
|
expect(await readVariant(page.request, sibling.id)).toEqual(sibling);
|
|
if (sample.width < 900) await page.getByRole('button', { name: t.cvEditorPreview, exact: true }).click();
|
|
const title = t.cvEditorPreviewPage.replace('{page}', '1');
|
|
await expect(page.getByTitle(title, { exact: true })).toBeVisible();
|
|
await expect(page.frameLocator(`iframe[title=${JSON.stringify(title)}]`).locator('body')).toContainText(tailoredTitle);
|
|
timings.editorOpenEditToPreviewMs = Date.now() - started;
|
|
await page.screenshot({ path: info.outputPath('tailored-preview.png'), fullPage: true, animations: 'disabled' });
|
|
const exportStarted = Date.now();
|
|
const download = page.waitForEvent('download');
|
|
await page.getByRole('button', { name: t.cvEditorDownloadPdf, exact: true }).click();
|
|
const pdf = await download;
|
|
expect(pdf.suggestedFilename()).toMatch(/\.pdf$/);
|
|
const pdfPath = info.outputPath(`cv-qa-${sample.language}-${sample.kind}-${sample.theme}.pdf`);
|
|
await pdf.saveAs(pdfPath);
|
|
expect(await pdf.failure()).toBeNull();
|
|
const bytes = await readFile(pdfPath);
|
|
expect(bytes.subarray(0, 5).toString()).toBe('%PDF-');
|
|
timings.pdfExportToSavedBytesMs = Date.now() - exportStarted;
|
|
expect(await career(page.request)).toEqual(source);
|
|
expect(await readVariant(page.request, sibling.id)).toEqual(sibling);
|
|
const markers = sample.kind === 'education' ? [tailoredTitle, 'Example Learning Centre', '2015', '2017']
|
|
: sample.kind === 'repeated' ? [tailoredTitle, 'Repeat AS', 'Built first service.', 'Built second service.', 'Reviewed third service.', '2018', '2020', '2022', '2023']
|
|
: [tailoredTitle, 'Ambiguous Labs', '2019', '2022'];
|
|
await info.attach('pdf-semantic-oracle-input', { body: JSON.stringify({ pdfPath, sha256: sha(bytes), expectedLiteralMarkers: markers,
|
|
canonicalEntryKey: first.key, canonicalTitle: first.title, cvOnlyTitle: tailoredTitle, theme: sample.theme,
|
|
boundary: 'Actual downloaded PDF bytes; semantic extraction and physical/render oracle are separate root-run gates.' }), contentType: 'application/json' });
|
|
await info.attach('actual-cv-pdf', { path: pdfPath, contentType: 'application/pdf' });
|
|
return { cv: await readVariant(page.request, cv.id), tailoredTitle, source };
|
|
}
|
|
|
|
async function freezeApplication(page: Page, headers: Headers, cv: CvVariant, tailoredTitle: string) {
|
|
const company = await json<{ id: number }>(await page.request.post(`${apiUrl}/companies`, { headers, data: { name: 'CV QA synthetic application company', source: 'User' } }), 201);
|
|
const job = await json<{ id: number }>(await page.request.post(`${apiUrl}/jobapplications`, { headers, data: {
|
|
companyId: company.id, jobTitle: 'Reviewed QA engineering application', status: 'Saved', description: 'Synthetic source-backed qualification. No external delivery.',
|
|
} }), 201);
|
|
const url = `${apiUrl}/jobapplications/${job.id}`;
|
|
await json(await page.request.put(`${url}/cv`, { headers, data: { variantId: cv.id } }));
|
|
const initial = await json<CoverLetter>(await page.request.get(`${url}/cover-letter`));
|
|
const text = 'Manually reviewed frozen application letter — æøå. Preserve this exact text across later import and CV edits.';
|
|
await json(await page.request.put(`${url}/cover-letter`, { headers, data: { expectedVersion: initial.revision, text, source: 'manual' } }));
|
|
const captured = await json<SubmittedPackage>(await page.request.post(`${url}/submitted-packages`, { headers }));
|
|
const detailUrl = `${url}/submitted-packages/${captured.id}`;
|
|
const detail = await json<SubmittedPackageDetail>(await page.request.get(detailUrl));
|
|
expect(detail.coverLetterText).toBe(text);
|
|
expect(detail.renderedCvHtml).toContain(tailoredTitle);
|
|
expect(captured.cvVariantId).toBe(cv.id);
|
|
return { jobId: job.id, url, detailUrl, detail, text, letter: await json<CoverLetter>(await page.request.get(`${url}/cover-letter`)) };
|
|
}
|
|
|
|
const scenarios: Scenario[] = [
|
|
{ language: 'en', mode: 'light', width: 1440, file: 'frozen-ambiguous-employer-first.docx', kind: 'job', theme: 'minimal', package: true },
|
|
{ language: 'nb', mode: 'dark', width: 390, file: 'frozen-ambiguous-title-first.pdf', kind: 'job', theme: 'technical' },
|
|
{ language: 'en', mode: 'light', width: 768, file: 'frozen-ambiguous-education.docx', kind: 'education', theme: 'minimal' },
|
|
{ language: 'en', mode: 'dark', width: 768, file: 'frozen-repeated-overlapping-roles.docx', kind: 'repeated', theme: 'technical' },
|
|
];
|
|
|
|
for (const sample of scenarios) {
|
|
test(`[CV-QA] real Docling ${sample.file} ${sample.language}/${sample.mode}/${sample.width}: source, explicit review, canonical persistence, scoped CV and PDF`, async ({ page, context, playwright }, info) => {
|
|
const timings: Timings = {};
|
|
try {
|
|
const { email, headers } = await owner(page, context, playwright, sample, info);
|
|
const t = translations[sample.language];
|
|
const sibling = await createVariant(page.request, headers, 'Untouched pre-import sibling');
|
|
const first = await upload(page, playwright, sample.language, sample.file, info, timings, 'first');
|
|
let current: Snapshot;
|
|
if (sample.kind === 'repeated') {
|
|
await approveExtracted(page, first.runId, sample.language);
|
|
await accessibility(page, first.runId, info, 'extracted-review');
|
|
current = await apply(page, headers, first.runId, sample.language, first.before, timings, 'first');
|
|
expect(current.revision).toBe(1);
|
|
expect(current.profile.jobs).toHaveLength(3);
|
|
expect(current.profile.jobs.map(job => [job.company, job.title, job.start, job.end])).toEqual([
|
|
['Repeat AS', 'Engineer', '2018', '2021'], ['Repeat AS', 'Engineer', '2020', '2023'], ['Repeat AS', 'Lead', '2022', 'Present'],
|
|
]);
|
|
expect(current.profile.jobs.map(job => job.bullets)).toEqual([['Built first service.'], ['Built second service.'], ['Reviewed third service.']]);
|
|
expect(current.profile.jobs[2].isCurrent).toBe(true);
|
|
const origins = current.profile.jobs.map((_, index) => current.profile.metadata.fields[`jobs.${index}.company`]);
|
|
expect(new Set(origins.map(origin => origin.sourceBlockId)).size).toBe(3);
|
|
for (const [index, origin] of origins.entries()) {
|
|
expect(origin.sourceExtractionRunId).toBe(first.runId);
|
|
expect(origin.sourceArtifactId).toBeGreaterThan(0);
|
|
expect(origin.sourceFileSha256).toBe(first.fixtureHash);
|
|
expect(clean(first.review.sourceBlocks.find(block => block.id === origin.sourceBlockId)!.text)).toContain('Repeat AS');
|
|
expect(first.review.sourceBlocks.find(block => block.id === current.profile.metadata.fields[`jobs.${index}.bullets.0`].sourceBlockId)!.text).toContain(current.profile.jobs[index].bullets[0]);
|
|
}
|
|
} else {
|
|
expect(first.review.groups.some(group => group.category === 'jobs' || group.category === 'education')).toBe(false);
|
|
await rejectOriginal(page, first.runId);
|
|
const category = sample.kind === 'education' ? 'education' : 'jobs';
|
|
const fields: MappedValue[] = sample.kind === 'education'
|
|
? [{ name: 'qualification', value: 'Advanced Computing' }, { name: 'institution', value: 'Example Learning Centre' }, { name: 'start', value: '2015', evidence: '2015 - 2017' }, { name: 'end', value: '2017', evidence: '2015 - 2017' }]
|
|
: [{ name: 'title', value: 'Principal Engineer' }, { name: 'company', value: 'Ambiguous Labs' }, { name: 'start', value: '2019', evidence: '2019 - 2022' }, { name: 'end', value: '2022', evidence: '2019 - 2022' }];
|
|
const mapped = await author(page, first.runId, first.review, sample.language, category, fields);
|
|
await accessibility(page, first.runId, info, 'mapped-review');
|
|
current = await apply(page, headers, first.runId, sample.language, first.before, timings, 'first');
|
|
expect(current.revision).toBe(1);
|
|
expect(current.profile.otherSections).toEqual([]);
|
|
expect(current.profile.jobs).toHaveLength(sample.kind === 'education' ? 0 : 1);
|
|
expect(current.profile.education).toHaveLength(sample.kind === 'education' ? 1 : 0);
|
|
const record = sample.kind === 'education' ? current.profile.education[0] : current.profile.jobs[0];
|
|
expect(record.id).toBeTruthy();
|
|
for (const field of mapped.selected) {
|
|
expect(record).toHaveProperty(field.name, field.value);
|
|
expect(current.profile.metadata.fields[`${category}.0.${field.name}`]).toMatchObject({ method: 'user-source-mapping', sourceBlockId: field.block.id, sourceExtractionRunId: first.runId, sourceFileSha256: first.fixtureHash, reviewState: 'accepted' });
|
|
expect(current.profile.metadata.fields[`${category}.0.${field.name}`].sourceArtifactId).toBeGreaterThan(0);
|
|
}
|
|
expect((await versions(page.request))).toHaveLength(1);
|
|
}
|
|
const stableIds = [...current.profile.jobs, ...current.profile.education].map(record => record.id);
|
|
expect(stableIds.every(Boolean)).toBe(true);
|
|
expect(new Set(stableIds).size).toBe(stableIds.length);
|
|
expect(await readVariant(page.request, sibling.id)).toEqual(sibling);
|
|
const edited = await editAndExport(page, headers, sample, sibling, info, timings);
|
|
|
|
if (sample.kind === 'repeated') {
|
|
const repeated = await upload(page, playwright, sample.language, sample.file, info, timings, 'same-source');
|
|
await approveExtracted(page, repeated.runId, sample.language);
|
|
const reapplied = await apply(page, headers, repeated.runId, sample.language, repeated.before, timings, 'same-source');
|
|
expect(reapplied.revision).toBe(2);
|
|
expect(reapplied.profile.jobs).toHaveLength(3);
|
|
expect(reapplied.profile.jobs.map(job => job.id)).toEqual(stableIds);
|
|
expect(reapplied.profile.jobs.map(job => job.bullets)).toEqual(current.profile.jobs.map(job => job.bullets));
|
|
expect(new Set(reapplied.profile.jobs.map((_, index) => reapplied.profile.metadata.fields[`jobs.${index}.company`].sourceBlockId)).size).toBe(3);
|
|
for (const index of [0, 1, 2]) expect(reapplied.profile.metadata.fields[`jobs.${index}.company`].sourceExtractionRunId).toBe(repeated.runId);
|
|
expect(await versions(page.request)).toHaveLength(2);
|
|
}
|
|
|
|
if (sample.package) {
|
|
const frozen = await freezeApplication(page, headers, edited.cv, edited.tailoredTitle);
|
|
const next = await upload(page, playwright, sample.language, sample.file, info, timings, 'target-conflict');
|
|
await rejectOriginal(page, next.runId);
|
|
const draft = await author(page, next.runId, next.review, sample.language, 'jobs', [{ name: 'title', value: 'Principal Engineer' }, { name: 'company', value: 'Ambiguous Labs' }], 0);
|
|
await expect(draft.mapping.getByText(t.careerImportCurrentValue.replace('{value}', 'Principal Engineer'), { exact: true })).toBeVisible();
|
|
const concurrent = await playwright.request.newContext();
|
|
let changed: Snapshot;
|
|
try {
|
|
const concurrentHeaders = await login(concurrent, email);
|
|
const latest = await career(concurrent);
|
|
const profile = { ...latest.profile, jobs: latest.profile.jobs.map((job, index) => index === 0 ? { ...job, title: 'Concurrent owner-reviewed Engineer' } : job) };
|
|
await json(await concurrent.put(`${apiUrl}/career/profile`, { headers: concurrentHeaders, data: { expectedVersion: latest.revision, profile } }));
|
|
changed = await career(concurrent);
|
|
} finally { await concurrent.dispose(); }
|
|
const conflict = page.waitForResponse(response => response.url() === `${apiUrl}/profile-cv/runs/${next.runId}/apply-reviewed` && response.request().method() === 'POST');
|
|
await keyboardClick(page, panel(page, next.runId).getByRole('button', { name: t.cvImportApplyReviewed, exact: true }));
|
|
expect((await conflict).status()).toBe(409);
|
|
await expect(page.getByText(t.cvImportStaleReview, { exact: true })).toBeVisible();
|
|
expect(await career(page.request)).toEqual(changed!);
|
|
await expect(draft.mapping.getByRole('textbox', { name: numbered(t.cvImportMappingValue, 1), exact: true })).toHaveValue('Principal Engineer');
|
|
const target = draft.mapping.getByRole('combobox', { name: t.cvImportMappingTarget, exact: true });
|
|
await expect(target).toHaveValue('');
|
|
await expect(panel(page, next.runId).getByRole('button', { name: t.cvImportApplyReviewed, exact: true })).toBeDisabled();
|
|
await target.selectOption('0');
|
|
await expect(draft.mapping.getByText(t.careerImportCurrentValue.replace('{value}', 'Concurrent owner-reviewed Engineer'), { exact: true })).toBeVisible();
|
|
await rejectOriginal(page, next.runId);
|
|
await draft.mapping.getByRole('button', { name: t.cvImportMappingConfirm, exact: true }).click();
|
|
const final = await apply(page, headers, next.runId, sample.language, changed!, timings, 'target-reconfirmed');
|
|
expect(final.revision).toBe(3);
|
|
expect(final.profile.jobs).toHaveLength(1);
|
|
expect(final.profile.jobs[0].id).toBe(stableIds[0]);
|
|
expect(final.profile.jobs[0]).toMatchObject({ title: 'Principal Engineer', company: 'Ambiguous Labs', start: '2019', end: '2022' });
|
|
expect(final.profile.metadata.fields['jobs.0.start'].sourceExtractionRunId).toBe(first.runId);
|
|
expect(final.profile.metadata.fields['jobs.0.title'].sourceExtractionRunId).toBe(next.runId);
|
|
const latestCv = await readVariant(page.request, edited.cv.id);
|
|
await json(await page.request.put(`${apiUrl}/cv/variants/${latestCv.id}`, { headers, data: { name: latestCv.name, settings: { ...latestCv.settings, headline: 'Later CV-only headline' }, expectedVersion: latestCv.version, source: 'manual' } }));
|
|
expect(await json(await page.request.get(frozen.detailUrl))).toEqual(frozen.detail);
|
|
expect(await json(await page.request.get(`${frozen.url}/cover-letter`))).toEqual(frozen.letter);
|
|
expect(await versions(page.request)).toHaveLength(3);
|
|
await page.goto(`/jobs/${frozen.jobId}?section=application&sub=letter`);
|
|
await expect(page.getByRole('textbox', { name: t.jobDetailsCoverLetter, exact: true })).toHaveValue(frozen.text);
|
|
await info.attach('frozen-application-preservation', { body: JSON.stringify({ packageId: frozen.detail.summary.id, renderedCvSha256: createHash('sha256').update(frozen.detail.renderedCvHtml!).digest('hex'), sourceRevisions: [1, changed!.revision, final.revision], letter: 'Exact DTO/text/history unchanged', packageDetail: 'Exact immutable detail unchanged', delivery: 'No send or external email endpoint called' }), contentType: 'application/json' });
|
|
}
|
|
expect(await readVariant(page.request, sibling.id)).toEqual(sibling);
|
|
const sourceAfter = await page.request.get(`${apiUrl}/profile-cv/runs/${first.runId}/source`);
|
|
expect(sourceAfter.status()).toBe(200);
|
|
expect(sha(await sourceAfter.body())).toBe(first.fixtureHash);
|
|
} finally {
|
|
await info.attach('actual-latencies', { body: JSON.stringify({ measurementsMs: timings, boundary: 'Measured local scenario samples, not an SLA, production load claim, live model result or human/device acceptance.' }), contentType: 'application/json' });
|
|
}
|
|
});
|
|
}
|