230 lines
10 KiB
JavaScript
230 lines
10 KiB
JavaScript
const fs = require('node:fs/promises');
|
|
const path = require('node:path');
|
|
const { test, expect } = require('@playwright/test');
|
|
const { getCurrentWorkspace, login, localized, uniqueName } = require('./helpers');
|
|
|
|
const controlDirectory = path.resolve(__dirname, '../../../../.tmp/ui-e2e');
|
|
|
|
async function dismissOnboardingIfOpen(page) {
|
|
await page.locator('#crank-onboarding-panel').waitFor({ state: 'attached' });
|
|
await page.locator('[data-testid="onboarding-dismiss"]').waitFor({ state: 'attached' });
|
|
await page.evaluate(() => document.querySelector('[data-testid="onboarding-dismiss"]').click());
|
|
await expect(page.locator('#crank-onboarding-panel')).toBeHidden();
|
|
}
|
|
|
|
function openApiDocument(operationId) {
|
|
return [
|
|
'openapi: 3.0.3',
|
|
`info: { title: '${operationId}', version: '1' }`,
|
|
'servers: [{ url: https://api.example.test }]',
|
|
'paths:',
|
|
` /${operationId}:`,
|
|
' get:',
|
|
` operationId: ${operationId}`,
|
|
' summary: Recovery test operation',
|
|
' responses:',
|
|
" '200': { description: OK }",
|
|
'',
|
|
].join('\n');
|
|
}
|
|
|
|
async function operationSnapshot(page, workspaceId) {
|
|
return page.evaluate(async (id) => {
|
|
const response = await window.CrankApi.listOperations(id);
|
|
if (!response || !Array.isArray(response.items)) throw new Error('Operations API returned no item list');
|
|
return response.items;
|
|
}, workspaceId);
|
|
}
|
|
|
|
async function requestAdminControl(command) {
|
|
const requestFile = path.join(controlDirectory, 'admin-control.request');
|
|
const ackFile = path.join(controlDirectory, 'admin-control.ack');
|
|
await fs.mkdir(controlDirectory, { recursive: true });
|
|
await fs.rm(ackFile, { force: true });
|
|
const temporaryFile = `${requestFile}.${process.pid}.${Date.now()}.tmp`;
|
|
await fs.writeFile(temporaryFile, `${command}\n`, { mode: 0o600 });
|
|
await fs.rename(temporaryFile, requestFile);
|
|
await expect.poll(async () => {
|
|
try {
|
|
return (await fs.readFile(ackFile, 'utf8')).trim();
|
|
} catch (_error) {
|
|
return '';
|
|
}
|
|
}, { timeout: 30_000, message: `Admin API did not acknowledge ${command}` }).toBe(command);
|
|
}
|
|
|
|
async function adminApiPid() {
|
|
return (await fs.readFile(path.join(controlDirectory, 'admin-api.pid'), 'utf8')).trim();
|
|
}
|
|
|
|
async function storageCounts(workspaceId) {
|
|
await requestAdminControl(`counts ${workspaceId}`);
|
|
return JSON.parse(await fs.readFile(path.join(controlDirectory, 'storage-counts.json'), 'utf8'));
|
|
}
|
|
|
|
async function openImport(page, operationId) {
|
|
await page.getByRole('button', { name: localized('Import OpenAPI', 'Импорт OpenAPI') }).click();
|
|
await page.locator('#openapi-import-file').setInputFiles({
|
|
name: `${operationId}.yaml`,
|
|
mimeType: 'application/yaml',
|
|
buffer: Buffer.from(openApiDocument(operationId)),
|
|
});
|
|
const previewResponse = page.waitForResponse((response) =>
|
|
response.request().method() === 'POST'
|
|
&& response.url().includes('/imports/openapi/preview'));
|
|
await page.locator('#openapi-import-preview').click();
|
|
const response = await previewResponse;
|
|
expect(response.ok()).toBe(true);
|
|
await expect(page.locator('#openapi-import-preview-panel')).toBeVisible();
|
|
return response;
|
|
}
|
|
|
|
test('[P1] AC03 real invalid preview shows the exact canonical correlation headers', async ({ page }) => {
|
|
await login(page);
|
|
await dismissOnboardingIfOpen(page);
|
|
await page.getByRole('button', { name: localized('Import OpenAPI', 'Импорт OpenAPI') }).click();
|
|
await page.locator('#openapi-import-file').setInputFiles({
|
|
name: 'invalid-openapi.yaml',
|
|
mimeType: 'application/yaml',
|
|
buffer: Buffer.from('openapi: [\n'),
|
|
});
|
|
|
|
const rejectedPreview = page.waitForResponse((response) =>
|
|
response.request().method() === 'POST'
|
|
&& response.url().includes('/imports/openapi/preview'));
|
|
await page.locator('#openapi-import-preview').click();
|
|
const response = await rejectedPreview;
|
|
expect(response.status()).toBeGreaterThanOrEqual(400);
|
|
expect(response.status()).toBeLessThan(500);
|
|
|
|
const requestId = response.headers()['x-request-id'];
|
|
const traceId = response.headers()['x-trace-id'];
|
|
expect(requestId).toBeTruthy();
|
|
expect(traceId).toMatch(/^[a-f0-9]{32}$/i);
|
|
const status = page.locator('#openapi-import-status');
|
|
await expect(status).toBeFocused();
|
|
await expect(status).toHaveAttribute('role', 'status');
|
|
await expect(status).toHaveAttribute('aria-live', 'polite');
|
|
await expect(status).toHaveAttribute('aria-atomic', 'true');
|
|
await expect(status).toContainText(requestId);
|
|
await expect(status).toContainText(traceId);
|
|
await expect(status).toContainText('Request ID:');
|
|
await expect(status).toContainText('Trace ID:');
|
|
});
|
|
|
|
test('[P1] AC05 real preview and plan do not mutate Operations; reduced-motion Apply replay survives reload and API restart', async ({ page }) => {
|
|
// This journey includes bounded process stop/start and several database observations.
|
|
test.setTimeout(120_000);
|
|
await page.emulateMedia({ reducedMotion: 'reduce' });
|
|
await login(page);
|
|
await dismissOnboardingIfOpen(page);
|
|
expect(await page.evaluate(() => window.matchMedia('(prefers-reduced-motion: reduce)').matches)).toBe(true);
|
|
|
|
const workspace = await getCurrentWorkspace(page);
|
|
expect(workspace && workspace.id).toBeTruthy();
|
|
const initialOperations = await operationSnapshot(page, workspace.id);
|
|
const initialCounts = await storageCounts(workspace.id);
|
|
expect(initialCounts).toMatchObject({
|
|
sources: expect.any(Number),
|
|
operations: expect.any(Number),
|
|
versions: expect.any(Number),
|
|
});
|
|
const operationId = uniqueName('recovery_import').replace(/[^a-zA-Z0-9_]/g, '_');
|
|
const applyRequests = [];
|
|
const apiRequests = { preview: 0, createPlan: 0, apply: 0 };
|
|
page.on('request', (request) => {
|
|
if (request.method() !== 'POST') return;
|
|
const url = request.url();
|
|
if (url.includes('/imports/openapi/preview')) apiRequests.preview += 1;
|
|
if (/\/imports\/openapi\/[^/]+\/plans(?:\?|$)/.test(url)) apiRequests.createPlan += 1;
|
|
if (/\/imports\/openapi\/[^/]+\/apply(?:\?|$)/.test(url)) apiRequests.apply += 1;
|
|
});
|
|
await page.route('**/imports/openapi/*/apply', async (route) => {
|
|
applyRequests.push({
|
|
url: route.request().url(),
|
|
body: route.request().postData(),
|
|
});
|
|
if (applyRequests.length === 1) {
|
|
// Send the real request to Admin API, then lose only its browser response.
|
|
const response = await route.fetch();
|
|
expect(response.ok()).toBe(true);
|
|
await route.abort('connectionreset');
|
|
return;
|
|
}
|
|
await route.continue();
|
|
});
|
|
|
|
await openImport(page, operationId);
|
|
expect(await operationSnapshot(page, workspace.id)).toEqual(initialOperations);
|
|
expect(apiRequests.preview).toBe(1);
|
|
const afterPreviewCounts = await storageCounts(workspace.id);
|
|
expect(afterPreviewCounts).toEqual({
|
|
...initialCounts,
|
|
sources: initialCounts.sources + 1,
|
|
});
|
|
const dialogMotion = await page.locator('.openapi-import-dialog').evaluate((node) => getComputedStyle(node).transitionDuration);
|
|
expect(dialogMotion.split(',').every((duration) => Number.parseFloat(duration) === 0)).toBe(true);
|
|
await page.locator('#openapi-import-server-custom').fill('https://api.example.test');
|
|
await page.locator('#openapi-import-create').click();
|
|
await expect(page.locator('[data-testid="openapi-import-apply-confirmation"]')).toBeVisible();
|
|
expect(await operationSnapshot(page, workspace.id)).toEqual(initialOperations);
|
|
expect(apiRequests.createPlan).toBe(1);
|
|
expect(await storageCounts(workspace.id)).toEqual(afterPreviewCounts);
|
|
|
|
await page.locator('#openapi-import-plan-apply').click();
|
|
await expect.poll(() => applyRequests.length).toBe(1);
|
|
expect(apiRequests.apply).toBe(1);
|
|
const applyStatus = page.locator('#openapi-import-status');
|
|
await expect(applyStatus).toBeFocused();
|
|
await expect(applyStatus).toHaveAttribute('role', 'status');
|
|
await expect(applyStatus).toHaveAttribute('aria-live', 'polite');
|
|
await expect(applyStatus).toHaveAttribute('aria-atomic', 'true');
|
|
await expect(applyStatus).toContainText(localized('Apply result is unknown', 'Результат применения неизвестен'));
|
|
await expect(page.locator('#openapi-import-retry')).toBeVisible();
|
|
const committedOperations = await operationSnapshot(page, workspace.id);
|
|
expect(committedOperations).toHaveLength(initialOperations.length + 1);
|
|
expect(committedOperations.some((operation) => operation.name === operationId
|
|
|| operation.operation_id === operationId)).toBe(true);
|
|
const committedCounts = await storageCounts(workspace.id);
|
|
expect(committedCounts).toEqual({
|
|
...afterPreviewCounts,
|
|
operations: afterPreviewCounts.operations + 1,
|
|
versions: afterPreviewCounts.versions + 1,
|
|
});
|
|
|
|
const pidBeforeRestart = await adminApiPid();
|
|
let adminMayBeStopped = true;
|
|
try {
|
|
await requestAdminControl('stop');
|
|
await requestAdminControl('start');
|
|
adminMayBeStopped = false;
|
|
} finally {
|
|
if (adminMayBeStopped) await requestAdminControl('start');
|
|
}
|
|
expect(await adminApiPid()).not.toBe(pidBeforeRestart);
|
|
expect(await storageCounts(workspace.id)).toEqual(committedCounts);
|
|
await page.reload();
|
|
await page.getByRole('button', { name: localized('Import OpenAPI', 'Импорт OpenAPI') }).click();
|
|
await expect(page.locator('#openapi-import-retry')).toBeVisible();
|
|
await expect(page.locator('#openapi-import-status')).toContainText(localized('Apply result is unknown', 'Результат применения неизвестен'));
|
|
|
|
const retryResponse = page.waitForResponse((response) =>
|
|
response.request().method() === 'POST'
|
|
&& response.url().includes('/imports/openapi/')
|
|
&& response.url().endsWith('/apply'));
|
|
await page.locator('#openapi-import-retry').click();
|
|
const response = await retryResponse;
|
|
expect(response.status()).toBe(200);
|
|
await expect(page.locator('#openapi-import-result')).toContainText(operationId);
|
|
await expect.poll(() => applyRequests.length).toBe(2);
|
|
expect(applyRequests[1].url).toBe(applyRequests[0].url);
|
|
expect(applyRequests[1].body).toBe(applyRequests[0].body);
|
|
expect(apiRequests).toEqual({ preview: 1, createPlan: 1, apply: 2 });
|
|
|
|
const finalOperations = await operationSnapshot(page, workspace.id);
|
|
expect(finalOperations).toHaveLength(initialOperations.length + 1);
|
|
expect(finalOperations.filter((operation) => operation.name === operationId
|
|
|| operation.operation_id === operationId)).toHaveLength(1);
|
|
expect(await storageCounts(workspace.id)).toEqual(committedCounts);
|
|
});
|