Files
crank/apps/ui/tests/e2e/openapi-security-mapping.spec.js
T
Hermes DevOps 75fe5a123c [skip ci] wip: preserve Hermes crank development checkpoint
Owner-authorized recovery of accumulated source changes.
Includes accepted work and in-progress changes; NOT a release or acceptance.
Parent baseline 1b6db09bd1. Runtime data, build caches and local credentials excluded.
2026-10-25 10:00:22 +00:00

986 lines
48 KiB
JavaScript

const { test, expect } = require('@playwright/test');
const { browserJson, getCurrentWorkspace, login, localized, uniqueName } = require('./helpers');
const operationKey = 'get:/protected';
const profileId = 'auth_profile_safe_bearer';
const secretCanary = 'SECRET_CANARY_do_not_render_or_store';
function securityPreview() {
return {
job_id: 'job_security_mapping_atdd',
expires_at: '2099-01-01T00:00:00Z',
preview: {
source: { servers: ['https://api.example.test'] },
findings: [],
groups: [{
title: 'protected operations',
operations: [{
key: operationKey,
method: 'GET',
path: '/protected',
suggested_name: 'protected_operation',
suggested_display_name: 'Protected operation',
input_fields: 0,
output_fields: 0,
draft: { input_mapping: { rules: [] }, output_mapping: { rules: [] } },
findings: [{
code: 'unsupported_security_scheme',
severity: 'warning',
message: 'Unsupported scheme details are intentionally opaque',
construct_id: 'security_scheme_unsupported',
location: { path: '/paths/~1protected/get/security' },
operation_key: operationKey,
}],
security_requirements: {
source: 'document',
alternatives: [
{ schemes: ['bearerAuth'], supported: true, findings: [] },
{ schemes: [], supported: true, findings: [] },
{ schemes: ['oauthAuth', 'apiKeyAuth'], supported: false, findings: ['unsupported_security_and_requirement'] },
],
},
}],
}],
},
security_profile_choices: [
{
operation_key: operationKey,
alternative_index: 0,
schemes: ['bearerAuth'],
profiles: [{ id: profileId, name: 'Production bearer', kind: 'bearer' }],
},
],
};
}
function protectedOperation(key, suggestedName, alternatives) {
return {
key,
method: 'GET',
path: '/' + key.split('/').pop(),
suggested_name: suggestedName,
suggested_display_name: suggestedName,
input_fields: 0,
output_fields: 0,
draft: { input_mapping: { rules: [] }, output_mapping: { rules: [] } },
findings: [],
security_requirements: { source: 'document', alternatives },
};
}
function previewWith(operations, choices) {
return {
job_id: 'job_security_multi_atdd',
expires_at: '2099-01-01T00:00:00Z',
preview: {
source: { servers: ['https://api.example.test'] },
findings: [],
groups: [{ title: 'protected operations', operations }],
},
security_profile_choices: choices,
};
}
async function dismissOnboardingIfOpen(page) {
// Same harness hygiene as openapi-import-plan.spec.js and operations.spec.js:
// the overlay intercepts pointer events on a fresh E2E stack.
await page.locator('#crank-onboarding-panel').waitFor({ state: 'attached' });
await page.locator('[data-testid="onboarding-dismiss"]').waitFor({ state: 'attached' });
await page.evaluate(() => {
const dismiss = document.querySelector('[data-testid="onboarding-dismiss"]');
if (dismiss) dismiss.click();
});
await expect(page.locator('#crank-onboarding-panel')).toBeHidden();
}
async function openSecurityPreview(page, locale = 'en', previewPayload = securityPreview()) {
// Register the preview boundary before navigation so the upload is deterministic.
await page.route('**/imports/openapi/preview', async (route) => {
await route.fulfill({
contentType: 'application/json',
body: JSON.stringify(previewPayload),
});
});
await login(page);
await dismissOnboardingIfOpen(page);
await page.evaluate((language) => window.setLang(language), locale);
await page.getByRole('button', { name: localized('Import OpenAPI', 'Импорт OpenAPI') }).click();
await page.locator('#openapi-import-file').setInputFiles({
name: 'security-mapping.yaml',
mimeType: 'application/yaml',
buffer: Buffer.from('openapi: 3.0.3\ninfo: { title: Security mapping, version: "1" }\npaths: {}\n'),
});
await page.locator('#openapi-import-preview').click();
await expect(page.locator('#openapi-import-preview-panel')).toBeVisible();
// The panel becomes visible before the operations/security controls are
// rendered; wait for the final ready state so a later re-render cannot
// detach the focused control mid-assertion.
await expect(page.locator('#openapi-import-status')).toHaveText(
localized('Document is ready. Select methods to import.', 'Документ готов. Выберите методы для импорта.'),
);
}
function actionablePlan(decision) {
return {
plan_reference: 'plan_security_mapping_atdd',
plan_digest: 'c'.repeat(64),
expires_at: '2099-01-01T00:00:00Z',
selection_mode: 'full',
counts: { selected: 1, excluded: 0, actionable: 1, blocked: 0 },
candidates: [{
key: operationKey,
name: 'protected_operation',
state: 'actionable',
action: decision.action,
target_operation_id: null,
confirmed_name: null,
auth_profile_id: decision.auth_profile_id || null,
security_alternative_index: decision.security_alternative_index,
reason: null,
}],
};
}
function containsCredentialField(value) {
if (!value || typeof value !== 'object') return false;
return Object.entries(value).some(([key, nested]) =>
/^(password|access_token|refresh_token|secret_value|credential_value|raw_credentials?)$/i.test(key)
|| containsCredentialField(nested));
}
test('[P1] AC-1 sends the selected OR alternative and Auth Profile, then renders API authority', async ({ page }) => {
// Given an OpenAPI preview with OR security choices and safe workspace profile metadata
const planRequests = [];
await page.route('**/imports/openapi/*/plans', async (route) => {
const payload = route.request().postDataJSON();
planRequests.push(payload);
await route.fulfill({ contentType: 'application/json', body: JSON.stringify(actionablePlan(payload.decisions[0])) });
});
await openSecurityPreview(page);
// When an administrator selects a supported alternative and its compatible profile
await page.getByLabel(localized('Security alternative', 'Вариант безопасности')).selectOption('0');
await page.getByLabel(localized('Auth Profile', 'Профиль авторизации')).selectOption(profileId);
await page.locator('#openapi-import-create').click();
// Then the existing plan API receives only the typed profile reference and alternative index
await expect.poll(() => planRequests.length).toBe(1);
expect(planRequests[0].decisions[0]).toMatchObject({
operation_key: operationKey,
auth_profile_id: profileId,
security_alternative_index: 0,
});
await expect(page.getByTestId('openapi-security-status')).toHaveText(localized('Resolved', 'Разрешено'));
expect(JSON.stringify(planRequests[0])).not.toContain(secretCanary);
expect(containsCredentialField(planRequests[0])).toBe(false);
});
test('[P1] AC-2 replaces a prior resolved plan with a blocker after profile revalidation fails', async ({ page }) => {
// Given an API-confirmed resolved plan for a profile that becomes unavailable before revalidation
const planRequests = [];
await page.route('**/imports/openapi/*/plans', async (route) => {
const payload = route.request().postDataJSON();
planRequests.push(payload);
if (planRequests.length === 1) {
await route.fulfill({ contentType: 'application/json', body: JSON.stringify(actionablePlan(payload.decisions[0])) });
return;
}
await route.fulfill({
status: 422,
contentType: 'application/json',
body: JSON.stringify({ error: { code: 'import_plan_auth_unavailable', message: secretCanary } }),
});
});
await openSecurityPreview(page);
await page.getByLabel(localized('Security alternative', 'Вариант безопасности')).selectOption('0');
await page.getByLabel(localized('Auth Profile', 'Профиль авторизации')).selectOption(profileId);
// When the API first confirms the selection and then rejects the stale profile
await page.locator('#openapi-import-create').click();
await expect(page.locator('#openapi-import-plan-confirmation')).toBeVisible();
await expect(page.getByTestId('openapi-security-status')).toHaveText(localized('Resolved', 'Разрешено'));
await page.locator('#openapi-import-plan-back').click();
await page.locator('#openapi-import-create').click();
// Then the old resolved value is replaced by the exact API-authoritative blocker state
await expect.poll(() => planRequests.length).toBe(2);
await expect(page.getByTestId('openapi-security-status')).toHaveText(localized('Blocked', 'Заблокировано'));
await expect(page.locator('body')).not.toContainText(secretCanary);
expect(planRequests[0].decisions[0]).toMatchObject({ auth_profile_id: profileId, security_alternative_index: 0 });
});
test('[P1] AC-3 shows safe security guidance in RU and EN without exposing error or secret canaries', async ({ page }) => {
// Given safe profile metadata and an unsupported AND alternative in the preview
let previewCalls = 0;
await page.route('**/imports/openapi/preview', async (route) => {
previewCalls += 1;
await route.fulfill({ contentType: 'application/json', body: JSON.stringify(securityPreview()) });
});
await page.route('**/imports/openapi/*/plans', async (route) => {
await route.fulfill({
status: 422,
contentType: 'application/json',
body: JSON.stringify({ error: { code: 'import_plan_security_alternative_required', message: secretCanary } }),
});
});
await login(page);
await dismissOnboardingIfOpen(page);
await page.evaluate(() => window.setLang('ru'));
await page.getByRole('button', { name: localized('Import OpenAPI', 'Импорт OpenAPI') }).click();
await page.locator('#openapi-import-file').setInputFiles({
name: 'security-mapping.yaml',
mimeType: 'application/yaml',
buffer: Buffer.from('openapi: 3.0.3\ninfo: { title: Security mapping, version: "1" }\npaths: {}\n'),
});
await page.locator('#openapi-import-preview').click();
await expect(page.locator('#openapi-import-preview-panel')).toBeVisible();
// When the administrator inspects both locales, the unsupported AND alternative is visible but disabled
// Native option elements are not visually visible inside a select; the safe
// metadata must be present and selectable.
await expect(page.getByLabel(localized('Auth Profile', 'Профиль авторизации')).locator('option[value="' + profileId + '"]')).toBeAttached();
await expect(page.getByLabel(localized('Security alternative', 'Вариант безопасности')).locator('option[value="2"]')).toHaveAttribute('disabled', '');
await page.getByLabel(localized('Security alternative', 'Вариант безопасности')).selectOption('0');
await page.getByLabel(localized('Auth Profile', 'Профиль авторизации')).selectOption(profileId);
await page.locator('#openapi-import-create').click();
await expect(page.getByTestId('openapi-security-status')).toHaveText(localized('Blocked', 'Заблокировано'));
await expect(page.locator('body')).not.toContainText(secretCanary);
await page.evaluate(() => window.setLang('en'));
await expect(page.locator('#openapi-import-retry')).toBeVisible();
await page.locator('#openapi-import-retry').click();
await expect.poll(() => previewCalls).toBe(2);
await expect(page.locator('#openapi-import-preview-panel')).toBeVisible();
// A fresh preview resets the selection, so the operation is required again,
// never a leftover unresolved/resolved binding from the rejected plan.
await expect(page.getByTestId('openapi-security-status')).toHaveText(
localized('Authentication required', 'Требуется аутентификация'),
);
await expect(page.locator('body')).not.toContainText(secretCanary);
const exposed = await page.evaluate(() => ({
html: document.documentElement.innerText,
local: JSON.stringify(localStorage),
session: JSON.stringify(sessionStorage),
}));
expect(JSON.stringify(exposed)).not.toContain(secretCanary);
});
/* ── Mandatory matrix branches (green phase) ─────────────────────────── */
test('[P1] anonymous alternative submits only the OR index, never an unrequested profile', async ({ page }) => {
const planRequests = [];
await page.route('**/imports/openapi/*/plans', async (route) => {
const payload = route.request().postDataJSON();
planRequests.push(payload);
const decision = payload.decisions[0];
await route.fulfill({
contentType: 'application/json',
body: JSON.stringify(actionablePlan({
action: decision.action,
auth_profile_id: decision.auth_profile_id || null,
security_alternative_index: decision.security_alternative_index === undefined ? null : decision.security_alternative_index,
})),
});
});
await openSecurityPreview(page, 'en');
// The anonymous (empty-scheme) alternative is selectable; selecting it must
// keep the profile unbound.
const alternative = page.getByLabel(localized('Security alternative', 'Вариант безопасности'));
await alternative.selectOption('1');
// The anonymous alternative must not offer any Auth Profile control.
await expect(page.getByLabel(localized('Auth Profile', 'Профиль авторизации'))).toHaveCount(0);
await page.locator('#openapi-import-create').click();
await expect.poll(() => planRequests.length).toBe(1);
const decision = planRequests[0].decisions[0];
expect(decision).toMatchObject({ operation_key: operationKey, security_alternative_index: 1 });
expect(decision).not.toHaveProperty('auth_profile_id');
// A confirmed anonymous alternative is no-auth, never a resolved auth binding.
await expect(page.locator('[data-openapi-security-op-status="' + operationKey + '"]')).toHaveText('No authentication');
await expect(page.getByTestId('openapi-security-status')).toHaveText(localized('No authentication', 'Без аутентификации'));
expect(JSON.stringify(planRequests[0])).not.toContain(profileId);
});
test('[P1] changing the alternative clears the profile and invalidates a prior plan', async ({ page }) => {
const planRequests = [];
await page.route('**/imports/openapi/*/plans', async (route) => {
const payload = route.request().postDataJSON();
planRequests.push(payload);
const decision = payload.decisions[0];
await route.fulfill({
contentType: 'application/json',
body: JSON.stringify(actionablePlan({
action: decision.action,
auth_profile_id: decision.auth_profile_id || null,
security_alternative_index: decision.security_alternative_index === undefined ? null : decision.security_alternative_index,
})),
});
});
await openSecurityPreview(page, 'en');
const alternative = page.getByLabel(localized('Security alternative', 'Вариант безопасности'));
const profile = page.getByLabel(localized('Auth Profile', 'Профиль авторизации'));
await alternative.selectOption('0');
await profile.selectOption(profileId);
// A confirmed plan exists for (alternative 0, profile).
await page.locator('#openapi-import-create').click();
await expect(page.locator('#openapi-import-plan-confirmation')).toBeVisible();
await expect(page.getByTestId('openapi-security-status')).toHaveText('Resolved');
// Back to editing: the selection survives, the plan does not.
await page.locator('#openapi-import-plan-back').click();
await expect(page.locator('#openapi-import-plan-confirmation')).toBeHidden();
await expect(page.getByTestId('openapi-security-status')).toHaveText('Unresolved');
// Switching the alternative drops the bound profile; the anonymous choice
// hides the profile control entirely and the new plan carries only the index.
await alternative.selectOption('1');
await expect(profile).toHaveCount(0);
await page.locator('#openapi-import-create').click();
await expect.poll(() => planRequests.length).toBe(2);
const decision = planRequests[1].decisions[0];
expect(decision).toMatchObject({ operation_key: operationKey, security_alternative_index: 1 });
expect(decision).not.toHaveProperty('auth_profile_id');
await expect(page.locator('[data-openapi-security-op-status="' + operationKey + '"]')).toHaveText('No authentication');
await expect(page.getByTestId('openapi-security-status')).toHaveText(localized('No authentication', 'Без аутентификации'));
});
test('[P1] empty compatible-profile list keeps the selection safe and the API blocker authoritative', async ({ page }) => {
const emptyPreview = securityPreview();
emptyPreview.security_profile_choices = [];
const planRequests = [];
await page.route('**/imports/openapi/*/plans', async (route) => {
planRequests.push(route.request().postDataJSON());
// Actual public contract: a 200 plan whose candidate is blocked with the
// safe reason the API owns, not a synthesized top-level error code.
await route.fulfill({
contentType: 'application/json',
body: JSON.stringify({
plan_reference: 'plan_empty_profiles_atdd',
plan_digest: 'f'.repeat(64),
expires_at: '2099-01-01T00:00:00Z',
selection_mode: 'full',
counts: { selected: 1, excluded: 0, actionable: 0, blocked: 1 },
candidates: [{
key: operationKey,
name: 'protected_operation',
state: 'blocked',
action: 'create',
target_operation_id: null,
confirmed_name: null,
auth_profile_id: null,
security_alternative_index: 0,
reason: 'auth_profile_required',
}],
}),
});
});
await openSecurityPreview(page, 'en', emptyPreview);
// The empty compatible-profile list disables the profile control and shows
// safe localized guidance instead of offering an arbitrary error payload.
const alternative = page.getByLabel(localized('Security alternative', 'Вариант безопасности'));
const profileSelect = page.getByLabel(localized('Auth Profile', 'Профиль авторизации'));
await expect(profileSelect.locator('option')).toHaveCount(1);
await alternative.selectOption('0');
await expect(profileSelect).toBeDisabled();
await expect(page.locator('.openapi-import-security-guidance')).toHaveText(
'No compatible Auth Profiles for the selected alternative. Choose another alternative or create a plan to revalidate.');
await page.locator('#openapi-import-create').click();
await expect.poll(() => planRequests.length).toBe(1);
expect(planRequests[0].decisions[0]).toMatchObject({
operation_key: operationKey,
security_alternative_index: 0,
});
expect(planRequests[0].decisions[0]).not.toHaveProperty('auth_profile_id');
// The API candidate is authoritative: blocked, with safe translated guidance.
await expect(page.locator('.openapi-import-security-op-status')).toHaveText('Blocked');
await expect(page.getByTestId('openapi-security-status')).toHaveText('Blocked');
await expect(page.locator('.openapi-import-plan-reason')).toHaveText(
'This operation requires an Auth Profile. Choose a compatible profile and create a new plan.');
await expect(page.locator('#openapi-import-plan-confirmation')).toBeVisible();
});
test('[P2] security controls keep accessible names, keyboard focus and a live status', async ({ page }) => {
await openSecurityPreview(page, 'en');
const alternative = page.getByLabel(localized('Security alternative', 'Вариант безопасности'));
const profile = page.getByLabel(localized('Auth Profile', 'Профиль авторизации'));
await expect(alternative).toBeEditable();
await expect(profile).toBeEditable();
// Keyboard-only selection: focus the native select and change it with keys,
// never programmatically.
await alternative.focus();
expect(await alternative.evaluate((el) => el === document.activeElement)).toBe(true);
await alternative.press('ArrowDown');
await expect(alternative).toHaveValue('0');
await profile.focus();
expect(await profile.evaluate((el) => el === document.activeElement)).toBe(true);
await profile.press('ArrowDown');
await expect(profile).toHaveValue(profileId);
const status = page.getByTestId('openapi-security-status');
await expect(status).toHaveAttribute('role', 'status');
await expect(status).toHaveAttribute('aria-live', 'polite');
const opStatus = page.locator('.openapi-import-security-op-status');
await expect(opStatus).toHaveAttribute('role', 'status');
await expect(opStatus).toHaveAttribute('aria-live', 'polite');
await page.locator('body').press('Escape');
await expect(page.locator('#openapi-import-modal')).toBeHidden();
});
test('[P1] a delayed preview response cannot restore state after the user cancelled', async ({ page }) => {
let releasePreview;
const previewReleased = new Promise((resolve) => {
releasePreview = resolve;
});
let previewFulfilled = false;
await page.route('**/imports/openapi/preview', async (route) => {
await previewReleased;
await route.fulfill({
contentType: 'application/json',
body: JSON.stringify(securityPreview()),
});
previewFulfilled = true;
});
await login(page);
await dismissOnboardingIfOpen(page);
await page.evaluate(() => window.setLang('en'));
await page.getByRole('button', { name: localized('Import OpenAPI', 'Импорт OpenAPI') }).click();
await page.locator('#openapi-import-file').setInputFiles({
name: 'security-mapping.yaml',
mimeType: 'application/yaml',
buffer: Buffer.from('openapi: 3.0.3\ninfo: { title: Security mapping, version: "1" }\npaths: {}\n'),
});
const previewRequest = page.waitForRequest((request) =>
request.method() === 'POST' && request.url().includes('/imports/openapi/preview'));
await page.locator('#openapi-import-preview').click();
await previewRequest;
await page.locator('#openapi-import-cancel').click();
// Release the stale response and wait for the handler to settle instead of a
// fixed timeout, then prove it could not restore the panel.
releasePreview();
await expect.poll(() => previewFulfilled).toBe(true);
await expect(page.locator('#openapi-import-preview-panel')).toBeHidden();
await expect(page.locator('#openapi-import-cancel')).toBeHidden();
});
/* ── Per-operation authority and selection lifecycle ────────────────── */
test('[P1] offers only profiles compatible with the chosen OR alternative and hides them for anonymous', async ({ page }) => {
const key = 'get:/multi';
await openSecurityPreview(page, 'en', previewWith([
protectedOperation(key, 'multi_operation', [
{ schemes: ['bearerAuth'], supported: true, findings: [] },
{ schemes: ['basicAuth'], supported: true, findings: [] },
{ schemes: [], supported: true, findings: [] },
{ schemes: ['oauthAuth'], supported: false, findings: ['unsupported_security_and_requirement'] },
]),
], [
{ operation_key: key, alternative_index: 0, schemes: ['bearerAuth'], profiles: [{ id: 'prof_bearer', name: 'Bearer profile', kind: 'bearer' }] },
{ operation_key: key, alternative_index: 1, schemes: ['basicAuth'], profiles: [{ id: 'prof_basic', name: 'Basic profile', kind: 'basic' }] },
]));
const row = page.locator('.openapi-import-operation').filter({ hasText: 'multi_operation' });
const alternative = row.getByLabel(localized('Security alternative', 'Вариант безопасности'));
const profile = row.getByLabel(localized('Auth Profile', 'Профиль авторизации'));
// Profile-first selection may offer the safe union while no alternative is chosen.
await expect(profile.locator('option[value="prof_bearer"]')).toBeAttached();
await expect(profile.locator('option[value="prof_basic"]')).toBeAttached();
await expect(alternative.locator('option[value="3"]')).toHaveAttribute('disabled', '');
await alternative.selectOption('0');
await expect(profile.locator('option[value="prof_bearer"]')).toBeAttached();
await expect(profile.locator('option[value="prof_basic"]')).toHaveCount(0);
await alternative.selectOption('1');
await expect(profile.locator('option[value="prof_basic"]')).toBeAttached();
await expect(profile.locator('option[value="prof_bearer"]')).toHaveCount(0);
// An anonymous alternative must offer no profile control at all.
await alternative.selectOption('2');
await expect(row.locator('.openapi-import-security-controls select')).toHaveCount(1);
await expect(row.getByLabel(localized('Auth Profile', 'Профиль авторизации'))).toHaveCount(0);
});
test('[P1] reports per-operation resolved and blocked authority for a mixed plan', async ({ page }) => {
const keyA = 'get:/alpha';
const keyB = 'get:/beta';
await page.route('**/imports/openapi/*/plans', async (route) => {
await route.fulfill({
contentType: 'application/json',
body: JSON.stringify({
plan_reference: 'plan_multi_mixed_atdd',
plan_digest: 'd'.repeat(64),
expires_at: '2099-01-01T00:00:00Z',
selection_mode: 'full',
counts: { selected: 2, excluded: 0, actionable: 1, blocked: 1 },
candidates: [
{ key: keyA, name: 'alpha_operation', state: 'actionable', action: 'create', auth_profile_id: 'prof_a', security_alternative_index: 0, reason: null },
{ key: keyB, name: 'beta_operation', state: 'blocked', action: 'create', auth_profile_id: 'prof_b', security_alternative_index: 0, reason: 'auth_profile_required' },
],
}),
});
});
await openSecurityPreview(page, 'en', previewWith([
protectedOperation(keyA, 'alpha_operation', [{ schemes: ['bearerAuth'], supported: true, findings: [] }]),
protectedOperation(keyB, 'beta_operation', [{ schemes: ['bearerAuth'], supported: true, findings: [] }]),
], [
{ operation_key: keyA, alternative_index: 0, schemes: ['bearerAuth'], profiles: [{ id: 'prof_a', name: 'A profile', kind: 'bearer' }] },
{ operation_key: keyB, alternative_index: 0, schemes: ['bearerAuth'], profiles: [{ id: 'prof_b', name: 'B profile', kind: 'bearer' }] },
]));
// Before the plan both protected operations require an explicit binding.
await expect(page.getByTestId('openapi-security-status')).toHaveText('Authentication required');
const rowA = page.locator('.openapi-import-operation').filter({ hasText: 'alpha_operation' });
const rowB = page.locator('.openapi-import-operation').filter({ hasText: 'beta_operation' });
await rowA.getByLabel(localized('Security alternative', 'Вариант безопасности')).selectOption('0');
await rowA.getByLabel(localized('Auth Profile', 'Профиль авторизации')).selectOption('prof_a');
await rowB.getByLabel(localized('Security alternative', 'Вариант безопасности')).selectOption('0');
await rowB.getByLabel(localized('Auth Profile', 'Профиль авторизации')).selectOption('prof_b');
await page.locator('#openapi-import-create').click();
await expect(page.locator('#openapi-import-plan-confirmation')).toBeVisible();
await expect(page.locator('[data-openapi-security-op-status="' + keyA + '"]')).toHaveText('Resolved');
await expect(page.locator('[data-openapi-security-op-status="' + keyB + '"]')).toHaveText('Blocked');
// The summary must surface the blocked operation, not mask it behind a resolved one.
await expect(page.getByTestId('openapi-security-status')).toHaveText('Blocked');
});
test('[P1] editing the alternative after an authoritative blocker clears the blocked authority', async ({ page }) => {
const key = 'get:/reset';
await page.route('**/imports/openapi/*/plans', async (route) => {
await route.fulfill({
status: 422,
contentType: 'application/json',
body: JSON.stringify({ error: { code: 'import_plan_auth_unavailable', message: secretCanary } }),
});
});
await openSecurityPreview(page, 'en', previewWith([
protectedOperation(key, 'reset_operation', [
{ schemes: ['bearerAuth'], supported: true, findings: [] },
{ schemes: ['basicAuth'], supported: true, findings: [] },
]),
], [
{ operation_key: key, alternative_index: 0, schemes: ['bearerAuth'], profiles: [{ id: 'prof_bearer', name: 'Bearer profile', kind: 'bearer' }] },
{ operation_key: key, alternative_index: 1, schemes: ['basicAuth'], profiles: [{ id: 'prof_basic', name: 'Basic profile', kind: 'basic' }] },
]));
const row = page.locator('.openapi-import-operation').filter({ hasText: 'reset_operation' });
await row.getByLabel(localized('Security alternative', 'Вариант безопасности')).selectOption('0');
await row.getByLabel(localized('Auth Profile', 'Профиль авторизации')).selectOption('prof_bearer');
await page.locator('#openapi-import-create').click();
await expect(page.locator('[data-openapi-security-op-status="' + key + '"]')).toHaveText('Blocked');
await expect(page.getByTestId('openapi-security-status')).toHaveText('Blocked');
// Editing must void the blocked authority and clear the bound profile.
await row.getByLabel(localized('Security alternative', 'Вариант безопасности')).selectOption('1');
await expect(row.getByLabel(localized('Auth Profile', 'Профиль авторизации'))).toHaveValue('');
await expect(page.locator('[data-openapi-security-op-status="' + key + '"]')).toHaveText('Authentication required');
await expect(page.getByTestId('openapi-security-status')).toHaveText('Authentication required');
await expect(page.locator('body')).not.toContainText(secretCanary);
});
test('[P1] binding then choosing skip removes the auth fields from the plan payload', async ({ page }) => {
const suggestedName = 'protected_operation';
const planRequests = [];
await page.route('**/api/admin/workspaces/*/operations', async (route) => {
await route.fulfill({
contentType: 'application/json',
body: JSON.stringify({
items: [{ id: 'op_skip_target', name: suggestedName, protocol: 'rest', status: 'draft' }],
page: 1,
page_size: 1,
total: 1,
}),
});
});
await page.route('**/imports/openapi/*/plans', async (route) => {
planRequests.push(route.request().postDataJSON());
await route.fulfill({
contentType: 'application/json',
body: JSON.stringify({
plan_reference: 'plan_skip_atdd',
plan_digest: 'e'.repeat(64),
expires_at: '2099-01-01T00:00:00Z',
selection_mode: 'full',
counts: { selected: 1, excluded: 0, actionable: 0, blocked: 0 },
candidates: [{
key: operationKey,
name: suggestedName,
state: 'excluded',
action: 'skip',
target_operation_id: 'op_skip_target',
confirmed_name: null,
auth_profile_id: null,
security_alternative_index: null,
reason: 'skipped',
}],
}),
});
});
await openSecurityPreview(page, 'en');
const row = page.locator('.openapi-import-operation').filter({ hasText: suggestedName });
await row.getByLabel(localized('Security alternative', 'Вариант безопасности')).selectOption('0');
await row.getByLabel(localized('Auth Profile', 'Профиль авторизации')).selectOption(profileId);
await row.locator('[data-openapi-decision-action]').selectOption('skip');
await expect(row.locator('.openapi-import-security-controls')).toHaveCount(0);
await page.locator('#openapi-import-create').click();
await expect.poll(() => planRequests.length).toBe(1);
const decision = planRequests[0].decisions[0];
expect(decision).toMatchObject({ operation_key: operationKey, action: 'skip', target_operation_id: 'op_skip_target' });
expect(decision).not.toHaveProperty('auth_profile_id');
expect(decision).not.toHaveProperty('security_alternative_index');
});
test('[P1] language change during a pending Apply keeps security controls disabled', async ({ page }) => {
let releaseApply;
const applyHeld = new Promise((resolve) => {
releaseApply = resolve;
});
await page.route('**/imports/openapi/*/plans', async (route) => {
const payload = route.request().postDataJSON();
await route.fulfill({ contentType: 'application/json', body: JSON.stringify(actionablePlan(payload.decisions[0])) });
});
await page.route('**/imports/openapi/*/apply', async (route) => {
await applyHeld;
try {
await route.fulfill({
contentType: 'application/json',
body: JSON.stringify({
plan_digest: 'c'.repeat(64),
counts: { created: 1 },
outcomes: [{ key: operationKey, name: 'protected_operation', status: 'created' }],
}),
});
} catch (_error) {
// The context change aborts the request; it must not update the modal.
}
});
await openSecurityPreview(page, 'en');
const row = page.locator('.openapi-import-operation').filter({ hasText: 'protected_operation' });
const alternative = row.getByLabel(localized('Security alternative', 'Вариант безопасности'));
const profile = row.getByLabel(localized('Auth Profile', 'Профиль авторизации'));
await alternative.selectOption('0');
await profile.selectOption(profileId);
await page.locator('#openapi-import-create').click();
await expect(page.getByTestId('openapi-security-status')).toHaveText('Resolved');
await page.locator('#openapi-import-plan-apply').click();
await expect(alternative).toBeDisabled();
// A language change while Apply is in flight must not re-render and re-enable
// the security controls.
await page.evaluate(() => window.setLang('ru'));
await expect(alternative).toBeDisabled();
await expect(profile).toBeDisabled();
await expect(page.locator('#openapi-import-file-select')).toBeDisabled();
releaseApply();
});
test('[P1] a rejected Apply clears a previously resolved security authority', async ({ page }) => {
await page.route('**/imports/openapi/*/plans', async (route) => {
const payload = route.request().postDataJSON();
await route.fulfill({ contentType: 'application/json', body: JSON.stringify(actionablePlan(payload.decisions[0])) });
});
await page.route('**/imports/openapi/*/apply', async (route) => {
await route.fulfill({
status: 422,
contentType: 'application/json',
body: JSON.stringify({ error: { code: 'import_plan_auth_unavailable', message: secretCanary }, recovery: 'repreview_required' }),
});
});
await openSecurityPreview(page, 'en');
const row = page.locator('.openapi-import-operation').filter({ hasText: 'protected_operation' });
await row.getByLabel(localized('Security alternative', 'Вариант безопасности')).selectOption('0');
await row.getByLabel(localized('Auth Profile', 'Профиль авторизации')).selectOption(profileId);
await page.locator('#openapi-import-create').click();
await expect(page.getByTestId('openapi-security-status')).toHaveText('Resolved');
await page.locator('#openapi-import-plan-apply').click();
// The rejected Apply must not retain the prior resolved authority.
await expect(page.getByTestId('openapi-security-status')).toHaveText('Unresolved');
await expect(page.locator('body')).not.toContainText(secretCanary);
});
test('[P1] a delayed plan response cannot restore authority after cancel', async ({ page }) => {
let releasePlan;
const planHeld = new Promise((resolve) => {
releasePlan = resolve;
});
let planFulfilled = false;
await page.route('**/imports/openapi/*/plans', async (route) => {
await planHeld;
await route.fulfill({
contentType: 'application/json',
body: JSON.stringify(actionablePlan({ action: 'create', auth_profile_id: profileId, security_alternative_index: 0 })),
});
planFulfilled = true;
});
await openSecurityPreview(page, 'en');
const row = page.locator('.openapi-import-operation').filter({ hasText: 'protected_operation' });
await row.getByLabel(localized('Security alternative', 'Вариант безопасности')).selectOption('0');
await row.getByLabel(localized('Auth Profile', 'Профиль авторизации')).selectOption(profileId);
const planRequest = page.waitForRequest((request) =>
request.method() === 'POST' && /\/imports\/openapi\/[^/]+\/plans$/.test(request.url()));
await page.locator('#openapi-import-create').click();
await planRequest;
await page.locator('#openapi-import-cancel').click();
releasePlan();
await expect.poll(() => planFulfilled).toBe(true);
await expect(page.locator('#openapi-import-plan-confirmation')).toBeHidden();
await expect(page.getByTestId('openapi-security-status')).toHaveText('Unresolved');
});
test('[P1] a quoted or backslash operation key cannot break per-operation status', async ({ page }) => {
const key = 'get:/quoted"path\\segment';
const planRequests = [];
await page.route('**/imports/openapi/*/plans', async (route) => {
planRequests.push(route.request().postDataJSON());
await route.fulfill({
contentType: 'application/json',
body: JSON.stringify({
plan_reference: 'plan_quoted_key_atdd',
plan_digest: 'a'.repeat(64),
expires_at: '2099-01-01T00:00:00Z',
selection_mode: 'full',
counts: { selected: 1, excluded: 0, actionable: 1, blocked: 0 },
candidates: [{
key,
name: 'quoted_operation',
state: 'actionable',
action: 'create',
target_operation_id: null,
confirmed_name: null,
auth_profile_id: profileId,
security_alternative_index: 0,
reason: null,
}],
}),
});
});
await openSecurityPreview(page, 'en', previewWith([
protectedOperation(key, 'quoted_operation', [{ schemes: ['bearerAuth'], supported: true, findings: [] }]),
], [
{ operation_key: key, alternative_index: 0, schemes: ['bearerAuth'], profiles: [{ id: profileId, name: 'Bearer profile', kind: 'bearer' }] },
]));
// Rendering a CSS-hostile key must not throw and the preview must render.
await expect(page.locator('#openapi-import-preview-panel')).toBeVisible();
const row = page.locator('.openapi-import-operation').filter({ hasText: 'quoted_operation' });
await row.getByLabel(localized('Security alternative', 'Вариант безопасности')).selectOption('0');
await row.getByLabel(localized('Auth Profile', 'Профиль авторизации')).selectOption(profileId);
await page.locator('#openapi-import-create').click();
await expect.poll(() => planRequests.length).toBe(1);
expect(planRequests[0].decisions[0].operation_key).toBe(key);
// Status is matched by dataset value, never by interpolating the key into CSS.
await expect(row.locator('.openapi-import-security-op-status')).toHaveText('Resolved');
await expect(page.getByTestId('openapi-security-status')).toHaveText('Resolved');
});
test('[P1] localizes unsupported findings and empty-profile guidance in RU and EN', async ({ page }) => {
const key = 'get:/locale';
await openSecurityPreview(page, 'ru', previewWith([
protectedOperation(key, 'locale_operation', [
{ schemes: ['bearerAuth'], supported: true, findings: [] },
{ schemes: ['oauthAuth', 'apiKeyAuth'], supported: false, findings: ['unsupported_security_and_requirement'] },
]),
], []));
const row = page.locator('.openapi-import-operation').filter({ hasText: 'locale_operation' });
const alternative = row.getByLabel(localized('Security alternative', 'Вариант безопасности'));
const profile = row.getByLabel(localized('Auth Profile', 'Профиль авторизации'));
// RU: exact unsupported finding copy and empty-profile guidance.
await expect(row.locator('.openapi-import-security-findings')).toContainText(
'Это security requirement невозможно выполнить со схемой, поддержанной Crank, или доступным профилем авторизации.');
await alternative.selectOption('0');
await expect(profile).toBeDisabled();
await expect(row.locator('.openapi-import-security-guidance')).toHaveText(
'Для выбранного варианта нет совместимых профилей авторизации. Выберите другой вариант или создайте план для повторной проверки.');
const opStatus = row.locator('.openapi-import-security-op-status');
await expect(opStatus).toHaveAttribute('role', 'status');
await expect(opStatus).toHaveAttribute('aria-live', 'polite');
// EN: switching language invalidates an unconfirmed preview, so re-preview
// and assert the exact translated copy in the second locale.
await page.evaluate(() => window.setLang('en'));
await page.locator('#openapi-import-preview').click();
await expect(page.locator('#openapi-import-preview-panel')).toBeVisible();
await row.getByLabel(localized('Security alternative', 'Вариант безопасности')).selectOption('0');
await expect(row.locator('.openapi-import-security-findings')).toContainText(
'This security requirement cannot be satisfied with a supported scheme or an available Auth Profile.');
await expect(row.getByLabel(localized('Auth Profile', 'Профиль авторизации'))).toBeDisabled();
await expect(row.locator('.openapi-import-security-guidance')).toHaveText(
'No compatible Auth Profiles for the selected alternative. Choose another alternative or create a plan to revalidate.');
});
test('[P1] a stale security plan cannot restore authority after a language or workspace change', async ({ page }) => {
const releases = [];
let planReleased = 0;
await page.route('**/imports/openapi/*/plans', async (route) => {
await new Promise((resolve) => releases.push(resolve));
planReleased += 1;
try {
await route.fulfill({
contentType: 'application/json',
body: JSON.stringify(actionablePlan({ action: 'create', auth_profile_id: profileId, security_alternative_index: 0 })),
});
} catch (_error) {
// The context change aborts the request; it must not update the modal.
}
});
await openSecurityPreview(page, 'en');
async function bindSelection() {
const row = page.locator('.openapi-import-operation').filter({ hasText: 'protected_operation' });
await row.getByLabel(localized('Security alternative', 'Вариант безопасности')).selectOption('0');
await row.getByLabel(localized('Auth Profile', 'Профиль авторизации')).selectOption(profileId);
}
async function startPlan() {
const request = page.waitForRequest((r) => r.method() === 'POST' && /\/imports\/openapi\/[^/]+\/plans$/.test(r.url()));
await page.locator('#openapi-import-create').click();
await request;
await expect.poll(() => releases.length).toBeGreaterThanOrEqual(1);
}
// 1) Language change while a security plan is pending.
await bindSelection();
await startPlan();
await page.evaluate(() => window.setLang('ru'));
releases.shift()();
await expect.poll(() => planReleased).toBeGreaterThanOrEqual(1);
await expect(page.getByTestId('openapi-security-status')).toHaveText('Не разрешено');
await expect(page.locator('.openapi-import-security-controls')).toHaveCount(0);
// 2) Workspace change while a security plan is pending.
await page.locator('#openapi-import-preview').click();
await expect(page.locator('#openapi-import-preview-panel')).toBeVisible();
await bindSelection();
await startPlan();
await page.evaluate(() => {
window.dispatchEvent(new CustomEvent('crank:workspacechange', { detail: { id: 'ws-stale-security' } }));
});
releases.shift()();
await expect.poll(() => planReleased).toBeGreaterThanOrEqual(2);
await expect(page.getByTestId('openapi-security-status')).toHaveText('Не разрешено');
await expect(page.locator('.openapi-import-security-controls')).toHaveCount(0);
await expect(page.locator('#openapi-import-preview-panel')).toBeHidden();
});
/* ── Real API evidence ───────────────────────────────────────────────── */
test('[P1][api] real preview/plan round-trip resolves a typed reference (real secret + bearer profile)', async ({ page }) => {
await login(page);
await dismissOnboardingIfOpen(page);
await page.evaluate(() => window.setLang('en'));
const workspace = await getCurrentWorkspace(page);
const prefix = uniqueName('secmap');
const secretValue = 'secmap-bearer-' + prefix;
const secret = await browserJson(
page,
'POST',
`/api/admin/workspaces/${encodeURIComponent(workspace.id)}/secrets`,
{ name: prefix + '_secret', kind: 'token', value: secretValue },
);
let profile = null;
try {
profile = await browserJson(
page,
'POST',
`/api/admin/workspaces/${encodeURIComponent(workspace.id)}/auth-profiles`,
{
name: prefix + '_profile',
kind: 'bearer',
config: { bearer: { header_name: 'Authorization', secret_id: secret.id } },
},
);
expect(String(profile.id)).toMatch(/^auth_/);
await page.getByRole('button', { name: localized('Import OpenAPI', 'Импорт OpenAPI') }).click();
await page.locator('#openapi-import-file').setInputFiles({
name: 'security-mapping-real.yaml',
mimeType: 'application/yaml',
buffer: Buffer.from([
'openapi: 3.0.3',
'info: { title: Security mapping real, version: "1" }',
'servers: [{ url: "https://api.example.test" }]',
'paths:',
' /' + prefix + ':',
' get:',
' operationId: ' + prefix + '_operation',
' security:',
' - bearerAuth: []',
' - {}',
' responses:',
' \'200\': { description: OK }',
'components:',
' securitySchemes:',
' bearerAuth: { type: http, scheme: bearer }',
].join('\n')),
});
await page.locator('#openapi-import-preview').click();
await expect(page.locator('#openapi-import-preview-panel')).toBeVisible();
const alternative = page.getByLabel(localized('Security alternative', 'Вариант безопасности'));
const profileSelect = page.getByLabel(localized('Auth Profile', 'Профиль авторизации'));
const bearerOption = alternative.locator('option', { hasText: 'bearerAuth' });
await bearerOption.waitFor({ state: 'attached' });
const bearerIndex = await bearerOption.getAttribute('value');
expect(bearerIndex).toMatch(/^\d+$/); // option value, not the select's current value
await alternative.selectOption(bearerIndex);
const realProfileOption = profileSelect.locator('option[value="' + profile.id + '"]');
await expect(realProfileOption).toBeAttached();
await profileSelect.selectOption(profile.id);
const planRequest = page.waitForRequest((request) =>
request.method() === 'POST' && /\/imports\/openapi\/[^/]+\/plans$/.test(request.url()),
);
await page.locator('#openapi-import-create').click();
const sent = await planRequest;
const response = await sent.response();
// Happy path is deterministic: the created profile matches the bearer
// scheme, so the real API must accept the typed reference.
expect(response.status()).toBe(200);
const payload = await sent.postDataJSON();
const planDecision = (payload.decisions || [])[0];
expect(planDecision).toMatchObject({ auth_profile_id: profile.id, security_alternative_index: Number(bearerIndex) });
await expect(page.locator('#openapi-import-plan-confirmation')).toBeVisible();
await expect(page.getByTestId('openapi-security-status')).toHaveText('Resolved');
await expect(page.locator('body')).not.toContainText(secretValue);
} finally {
// Best-effort cleanup. The Secret is guarded (409) while the live profile
// references it; the referenced Auth Profile has no delete endpoint, so we
// only attempt to release the Secret and never widen the backend surface.
try {
await browserJson(
page,
'DELETE',
`/api/admin/workspaces/${encodeURIComponent(workspace.id)}/secrets/${encodeURIComponent(secret.id)}`,
[],
[404, 409],
);
} catch (_error) {}
}
});