// ATDD для AT-3.6-07, UI-половина Story 3.6 «typed static Resource Drafts». // // Источники: SPEC v4 `resource-drafts-story36-spec.md` §2 (AT-3.6-07), D-6 (инертный текст // через `textContent`, скачивание — только octet-stream attachment), D-5 (text/html и // image/svg+xml разрешены лишь для kind=binary и никогда не рендерятся как активные), // D-16 (uri/name/kind неизменяемы, изменяемы description/MIME/sensitivity/content); // QA test-design run77 (UI-требования); TL review run101:42 (R-B). // // Состояние на этой стадии: страница `/resources` существует только как просмотр, формы // создания/списка/редактирования в ней нет, поэтому первый тест RED на первом отсутствующем // узле (`[data-testid="resource-create-form"]`). Ожидаемые формы здесь описаны тестом, но // production-форма на стадии ATDD не пишется. // // Требуемый UI-контракт, который обязан доставить BUILD (R-B требует проверять весь // обещанный сценарий, а не только первый RED): // * nav `a.nav-link[href="/resources"]` открывает `/resources`; // * `[data-testid="resource-create-form"]` с полями `resource-form-uri`, `-name`, `-kind` // (select), `-mime-type`, `-sensitivity` (select), `-description`, `-content` (textarea) // и submit `-submit`; для kind=binary содержимое загружается реальным файловым полем // `[data-testid="resource-form-file"]` (произвольные, в том числе не-UTF8, bytes); // * `[data-testid="resource-list"]` со строками `[data-testid="resource-list-item"]`; // клик выбирает Draft и отражается в URL (`?resource_id=…`), поэтому reload // восстанавливает тот же Draft; // * `[data-testid="resource-edit-form"]` с полями `resource-edit-description`, // `resource-edit-mime-type`, `resource-edit-sensitivity`, `resource-edit-content` // (для binary — файловое `resource-edit-file`) и submit `resource-edit-submit`; // * карточка просмотра показывает наблюдаемые значения: `resource-meta-uri`, `-name`, // `-kind`, `-mime`, `-size`, `-digest`, `-version`, `-description`, `-sensitivity` // и (только text/json) инертный `resource-preview-text`; // * `[data-testid="resource-preview-error"]` — видимый безопасный отказ preview; // * `[data-testid="resource-download"]` — настоящая ссылка (клик = скачивание). // // Запуск на существующем стенде (один default stack, workers=1, retries строго 0): // npm --prefix apps/ui run e2e -- tests/e2e/resources.spec.js --workers=1 --retries=0 const { test, expect } = require('@playwright/test'); const { browserJson, createResourceDraft, getCurrentWorkspace, login, readResourceDownload, readResourcePreview, uniqueName, } = require('./helpers'); const MARKER_PATH = '/story36-marker'; const MARKER_URL = 'http://127.0.0.1:3311/story36-marker.svg'; const PREVIEW = '[data-testid="resources-preview"]'; const PREVIEW_TEXT = '[data-testid="resource-preview-text"]'; const PREVIEW_ERROR = '[data-testid="resource-preview-error"]'; const META_URI = '[data-testid="resource-meta-uri"]'; const META_NAME = '[data-testid="resource-meta-name"]'; const META_KIND = '[data-testid="resource-meta-kind"]'; const META_MIME = '[data-testid="resource-meta-mime"]'; const META_SIZE = '[data-testid="resource-meta-size"]'; const META_DIGEST = '[data-testid="resource-meta-digest"]'; const META_VERSION = '[data-testid="resource-meta-version"]'; const META_DESCRIPTION = '[data-testid="resource-meta-description"]'; const META_SENSITIVITY = '[data-testid="resource-meta-sensitivity"]'; const CREATE_FORM = '[data-testid="resource-create-form"]'; const FORM_URI = '[data-testid="resource-form-uri"]'; const FORM_NAME = '[data-testid="resource-form-name"]'; const FORM_KIND = '[data-testid="resource-form-kind"]'; const FORM_MIME = '[data-testid="resource-form-mime-type"]'; const FORM_SENSITIVITY = '[data-testid="resource-form-sensitivity"]'; const FORM_DESCRIPTION = '[data-testid="resource-form-description"]'; const FORM_CONTENT = '[data-testid="resource-form-content"]'; const FORM_FILE = '[data-testid="resource-form-file"]'; const FORM_SUBMIT = '[data-testid="resource-form-submit"]'; const LIST_ITEM = '[data-testid="resource-list-item"]'; const EDIT_FORM = '[data-testid="resource-edit-form"]'; const EDIT_DESCRIPTION = '[data-testid="resource-edit-description"]'; const EDIT_MIME = '[data-testid="resource-edit-mime-type"]'; const EDIT_SENSITIVITY = '[data-testid="resource-edit-sensitivity"]'; const EDIT_CONTENT = '[data-testid="resource-edit-content"]'; const EDIT_FILE = '[data-testid="resource-edit-file"]'; const EDIT_SUBMIT = '[data-testid="resource-edit-submit"]'; const EDIT_STATUS = '#resource-edit-status'; const DOWNLOAD = '[data-testid="resource-download"]'; /// Произвольные bytes для binary-ветки: PNG-сигнатура + байты, не являющиеся UTF-8. const BINARY_BYTES = Buffer.from([ 0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0xff, 0xfe, 0x80, 0x01, 0x7f, 0xc3, 0x28, ]); /// Те же bytes после первого редактирования: тоже не UTF-8 и другой длины. const BINARY_BYTES_EDITED = Buffer.concat([BINARY_BYTES, Buffer.from([0xde, 0xad, 0xbe, 0xef])]); const SCENARIOS = [ { label: 'text', kind: 'text', mime: 'text/plain', // Владельцем text/* является kind=text, поэтому MIME действительно меняется. editedMime: 'text/markdown', description: 'text journey description', editedDescription: 'text journey description v2', content: 'journey text body\n', editedContent: 'journey text body\nedited v2\n', thirdContent: 'journey text body\nedited v2\nthird pass\n', expectedExtension: '.md', }, { label: 'json', kind: 'json', mime: 'application/json', // Единственный json-владелец MIME остаётся тем же: смена MIME проверяется явно ниже. editedMime: 'application/json', description: 'json journey description', editedDescription: 'json journey description v2', content: '{"journey":"body"}\n', editedContent: '{"journey":"body","edited":true}\n', // Третья версия — снова ВАЛИДНЫЙ JSON: правильная реализация обязана его принять, // а не отказать (R-B). thirdContent: '{"journey":"body","edited":true,"third":true}\n', expectedExtension: '.json', }, { label: 'binary', kind: 'binary', mime: 'application/octet-stream', editedMime: 'image/png', description: 'binary journey description', editedDescription: 'binary journey description v2', bytes: BINARY_BYTES, editedBytes: BINARY_BYTES_EDITED, thirdBytes: Buffer.concat([BINARY_BYTES_EDITED, Buffer.from([0x11, 0x22])]), expectedExtension: '.png', }, ]; /// Содержимое третьей версии: отдельные валидные bytes/текст, а не конкатенация с мусором. function thirdPayload(scenario) { return scenario.kind === 'binary' ? scenario.thirdBytes : Buffer.from(scenario.thirdContent, 'utf8'); } /// Метаданные части `metadata` из multipart-тела исходящего PUT (наблюдение того, что /// отправляет сама форма, а не того, что ответил сервер). function metadataFromMultipart(body) { const match = /name="metadata"[\s\S]*?\r\n\r\n([\s\S]*?)\r\n--/.exec(body); if (!match) return null; try { return JSON.parse(match[1]); } catch (_error) { return null; } } async function fillCreateForm(page, scenario) { const name = uniqueName(`journey${scenario.label}`); await page.locator(FORM_URI).fill(`crank://e2e/${name}`); await page.locator(FORM_NAME).fill(name); await page.locator(FORM_KIND).selectOption(scenario.kind); await page.locator(FORM_MIME).fill(scenario.mime); await page.locator(FORM_SENSITIVITY).selectOption('internal'); await page.locator(FORM_DESCRIPTION).fill(scenario.description); if (scenario.kind === 'binary') { // Реальная загрузка файла произвольными bytes, а не строка в textarea. await page.locator(FORM_FILE).setInputFiles({ name: 'journey.png', mimeType: scenario.mime, buffer: scenario.bytes, }); } else { await page.locator(FORM_CONTENT).fill(scenario.content); } await page.locator(FORM_SUBMIT).click(); return name; } async function selectFromList(page, name) { const row = page.locator(LIST_ITEM, { hasText: name }).first(); await expect( row, `the Draft \`${name}\` must be selectable from the UI list (P1)`, ).toBeVisible(); await row.click(); const selected = new URL(page.url()).searchParams.get('resource_id'); expect( selected, 'selecting a Draft must be reflected in the URL so reload restores it', ).toBeTruthy(); return selected; } /// SHA-256 независимым оракулом браузера (digest не берётся из ответа API). async function sha256Base64(page, buffer) { return page.evaluate(async (base64) => { const raw = atob(base64); const bytes = new Uint8Array(raw.length); for (let index = 0; index < raw.length; index += 1) bytes[index] = raw.charCodeAt(index); const digest = await crypto.subtle.digest('SHA-256', bytes); return Array.from(new Uint8Array(digest)) .map((byte) => byte.toString(16).padStart(2, '0')) .join(''); }, buffer.toString('base64')); } test('story36_at07_ui_journey_from_operations_creates_selects_edits_and_downloads', async ({ page }) => { // Наблюдение исходящих PUT: проверяется то, что отправляет сама форма (R-B), // а не только отсутствие ошибки в ответе. const observedPuts = []; await page.route('**/resources/*', async (route) => { const request = route.request(); if (request.method() === 'PUT') { const buffer = request.postDataBuffer(); observedPuts.push(buffer ? buffer.toString('utf8') : ''); } await route.continue(); }); await login(page); const workspace = await getCurrentWorkspace(page); expect(workspace && workspace.id, 'an E2E workspace must be available').toBeTruthy(); // 1. Вход из Operations обычной навигацией, а не прямым URL с ID. await page.locator('a.nav-link[href="/resources"]').first().click(); await expect(page).toHaveURL(/\/resources(\?|$)/); await expect( page.locator(CREATE_FORM), 'Operations → Resources must offer a create form (P1): the page currently only renders a seeded preview', ).toBeVisible(); for (const scenario of SCENARIOS) { // 2. Создание каждого kind через реальные клики формы. const name = await fillCreateForm(page, scenario); const selectedId = await selectFromList(page, name); const originalBytes = scenario.kind === 'binary' ? scenario.bytes : Buffer.from(scenario.content, 'utf8'); const editedBytes = scenario.kind === 'binary' ? scenario.editedBytes : Buffer.from(scenario.editedContent, 'utf8'); await expect( page.locator(PREVIEW), `${scenario.label}: selecting must load the Draft preview`, ).toBeVisible(); // Стабильные идентификаторы и точные metadata до редактирования. await expect(page.locator(META_URI), `${scenario.label}: uri is stable`).toHaveText( `crank://e2e/${name}`, ); await expect(page.locator(META_NAME), `${scenario.label}: name is stable`).toHaveText(name); await expect(page.locator(META_KIND), `${scenario.label}: kind is stable`).toHaveText(scenario.kind); await expect(page.locator(META_MIME)).toHaveText(scenario.mime); await expect(page.locator(META_SIZE)).toHaveText(String(originalBytes.length)); await expect(page.locator(META_VERSION), `${scenario.label}: first version`).toHaveText('1'); await expect(page.locator(META_DESCRIPTION)).toHaveText(scenario.description); await expect(page.locator(META_SENSITIVITY)).toHaveText('internal'); const originalDigest = await sha256Base64(page, originalBytes); await expect(page.locator(META_DIGEST), `${scenario.label}: digest of the stored bytes`).toHaveText( originalDigest, ); if (scenario.kind !== 'binary') { await expect( page.locator(PREVIEW_TEXT), `${scenario.label}: preview must show the exact stored bytes`, ).toHaveText(scenario.content); } else { await expect(page.locator(PREVIEW_TEXT)).toHaveText(''); } // 3. Редактирование изменяемых полей: description, MIME, sensitivity, content. await expect( page.locator(EDIT_FORM), `${scenario.label}: the selected Draft must be editable (P1)`, ).toBeVisible(); await page.locator(EDIT_DESCRIPTION).fill(scenario.editedDescription); await page.locator(EDIT_MIME).fill(scenario.editedMime); await page.locator(EDIT_SENSITIVITY).selectOption('public'); if (scenario.kind === 'binary') { await page.locator(EDIT_FILE).setInputFiles({ name: 'journey-edited.png', mimeType: scenario.editedMime, buffer: scenario.editedBytes, }); } else { await page.locator(EDIT_CONTENT).fill(scenario.editedContent); } await page.locator(EDIT_SUBMIT).click(); // 4. reload восстанавливает тот же Draft и показывает новые значения. await page.reload(); await expect(page.locator(PREVIEW), 'reload must restore the selected Draft').toBeVisible(); await expect(page.locator(META_VERSION), `${scenario.label}: the edit must create version 2`).toHaveText( '2', ); await expect(page.locator(META_DESCRIPTION)).toHaveText(scenario.editedDescription); await expect(page.locator(META_SENSITIVITY)).toHaveText('public'); await expect(page.locator(META_MIME)).toHaveText(scenario.editedMime); await expect(page.locator(META_SIZE)).toHaveText(String(editedBytes.length)); const editedDigest = await sha256Base64(page, editedBytes); expect(editedDigest, 'editing the content must change the digest').not.toBe(originalDigest); await expect(page.locator(META_DIGEST)).toHaveText(editedDigest); // uri/name/kind неизменяемы и после обновления. await expect(page.locator(META_URI)).toHaveText(`crank://e2e/${name}`); await expect(page.locator(META_NAME)).toHaveText(name); await expect(page.locator(META_KIND)).toHaveText(scenario.kind); await expect(page.locator(LIST_ITEM, { hasText: name }).first(), 'uri/name/kind stay stable').toBeVisible(); if (scenario.kind !== 'binary') { await expect(page.locator(PREVIEW_TEXT), 'reload must show the edited bytes').toHaveText( scenario.editedContent, ); } // Независимое чтение API подтверждает те же значения, что и страница. const preview = await readResourcePreview(page, workspace.id, selectedId); expect(preview.status, 'the edited Draft must stay readable').toBe(200); expect(preview.json.version.version).toBe(2); expect(preview.json.resource.uri).toBe(`crank://e2e/${name}`); expect(preview.json.resource.name).toBe(name); expect(preview.json.resource.kind).toBe(scenario.kind); expect(preview.json.resource.description).toBe(scenario.editedDescription); expect(preview.json.version.sensitivity).toBe('public'); expect(preview.json.version.mime_type).toBe(scenario.editedMime); expect(preview.json.version.size_bytes).toBe(editedBytes.length); // 5. Действительное скачивание кликом по ссылке — точные bytes и безопасное имя файла. const [download] = await Promise.all([ page.waitForEvent('download'), page.locator(DOWNLOAD).click(), ]); const chunks = []; const stream = await download.createReadStream(); for await (const chunk of stream) chunks.push(chunk); const downloaded = Buffer.concat(chunks); expect( downloaded.toString('base64'), `${scenario.label}: the clicked download must return the exact edited bytes`, ).toBe(editedBytes.toString('base64')); const filename = download.suggestedFilename(); expect( filename.endsWith(scenario.expectedExtension), `${scenario.label}: derived filename must follow the declared MIME: ${filename}`, ).toBe(true); expect( filename.includes('/') || filename.includes('\\') || filename.includes('..'), `${scenario.label}: filename must stay sanitized: ${filename}`, ).toBe(false); // Заголовки скачивания не зависят от заявленного MIME (D-6). const headers = await readResourceDownload(page, workspace.id, selectedId); expect(headers.status).toBe(200); expect(headers.headers['content-type']).toBe('application/octet-stream'); expect(headers.headers['content-disposition']).toMatch(/^attachment/); expect(headers.bodyBase64).toBe(editedBytes.toString('base64')); // 6. Второе редактирование после reload доказывает, что форма отправляет актуальный // precondition и валидное содержимое третьей версии (R-B: валидный отдельный JSON, // а не конкатенация с мусором, которую правильная реализация обязана отвергнуть). const thirdBytes = thirdPayload(scenario); const beforeThird = await readResourcePreview(page, workspace.id, selectedId); expect(beforeThird.status, 'the card must be readable before the third edit').toBe(200); const precondition = beforeThird.json.resource.updated_at; expect(precondition, 'the card must expose its precondition timestamp').toBeTruthy(); const putsBeforeThird = observedPuts.length; if (scenario.kind === 'binary') { await page.locator(EDIT_FILE).setInputFiles({ name: 'journey-third.png', mimeType: scenario.editedMime, buffer: thirdBytes, }); } else { await page.locator(EDIT_CONTENT).fill(scenario.thirdContent); } await page.locator(EDIT_SUBMIT).click(); await page.reload(); await expect(page.locator(META_VERSION), 'a second edit after reload must succeed').toHaveText('3'); // 6a. Наблюдаемый запрос: форма действительно отправила актуальный precondition. expect( observedPuts.length, 'the third edit must be observable as an outgoing PUT request', ).toBeGreaterThan(putsBeforeThird); const thirdMetadata = metadataFromMultipart(observedPuts[observedPuts.length - 1]); expect( thirdMetadata, `the outgoing PUT must carry a metadata part: ${observedPuts[observedPuts.length - 1]}`, ).toBeTruthy(); expect( thirdMetadata.expected_updated_at, 'the form must send the precondition it just read, not a stale or invented value', ).toBe(precondition); expect(thirdMetadata.description).toBe(scenario.editedDescription); expect(thirdMetadata.mime_type).toBe(scenario.editedMime); expect(thirdMetadata.sensitivity).toBe('public'); expect( Object.prototype.hasOwnProperty.call(thirdMetadata, 'uri'), 'an edit must not resend immutable identifiers', ).toBe(false); // 6b. Наблюдаемое состояние: тот же Resource (URL и идентификаторы), новая версия, // точные bytes третьей версии и обновлённый precondition. const urlAfterThird = new URL(page.url()); expect( urlAfterThird.searchParams.get('resource_id'), 'reload must keep the same selected Draft', ).toBe(selectedId); await expect(page.locator(META_URI)).toHaveText(`crank://e2e/${name}`); await expect(page.locator(META_NAME)).toHaveText(name); await expect(page.locator(META_KIND)).toHaveText(scenario.kind); await expect(page.locator(META_SIZE)).toHaveText(String(thirdBytes.length)); const thirdDigest = await sha256Base64(page, thirdBytes); await expect(page.locator(META_DIGEST), 'the third version digest is the stored bytes digest').toHaveText( thirdDigest, ); if (scenario.kind !== 'binary') { await expect(page.locator(PREVIEW_TEXT)).toHaveText(scenario.thirdContent); } const thirdPreview = await readResourcePreview(page, workspace.id, selectedId); expect(thirdPreview.status).toBe(200); expect(thirdPreview.json.version.version).toBe(3); expect(thirdPreview.json.version.size_bytes).toBe(thirdBytes.length); expect(thirdPreview.json.version.digest).toBe(thirdDigest); expect( thirdPreview.json.resource.updated_at, 'an accepted edit must move the precondition timestamp', ).not.toBe(precondition); const thirdDownload = await readResourceDownload(page, workspace.id, selectedId); expect( thirdDownload.bodyBase64, `${scenario.label}: the third version must serve the exact edited bytes`, ).toBe(thirdBytes.toString('base64')); } }); test('story36_at07_card_ok_with_refused_preview_is_a_visible_safe_error', async ({ page }) => { await login(page); const workspace = await getCurrentWorkspace(page); expect(workspace && workspace.id, 'an E2E workspace must be available').toBeTruthy(); // Существующий Draft: карточка читается (200), а отказ preview приходит на самом маршруте // preview (422). Отсутствующий идентификатор не заменяет эту проверку (R-B). const name = uniqueName('preview_refusal'); const metadata = { uri: `crank://e2e/${name}`, name, description: 'preview refusal description', kind: 'text', mime_type: 'text/plain', sensitivity: 'internal', }; // Механизм наблюдения multipart-тела проверяется здесь же на состоявшемся create-запросе: // если браузер не отдаёт тело, оракул третьей версии в основном сценарии был бы // недоказуемым, а не «зелёным». const observedCreateBodies = []; await page.route('**/resources', async (route) => { if (route.request().method() === 'POST') { const buffer = route.request().postDataBuffer(); observedCreateBodies.push(buffer ? buffer.toString('utf8') : ''); } await route.continue(); }); const created = await createResourceDraft(page, workspace.id, metadata, Buffer.from('visible body\n', 'utf8'), 'visible.txt', 'text/plain'); expect(created.status, `seeding the Draft must succeed: ${created.text}`).toBe(201); const resourceId = created.json.resource.resource_id || created.json.resource.id; await page.unroute('**/resources'); expect( observedCreateBodies.length, 'the outgoing multipart create must be observable as a request body', ).toBeGreaterThan(0); const observedCreateMetadata = metadataFromMultipart(observedCreateBodies[0]); expect(observedCreateMetadata, `metadata part of the observed create: ${observedCreateBodies[0]}`).toBeTruthy(); expect(observedCreateMetadata.uri).toBe(metadata.uri); expect(observedCreateMetadata.name).toBe(name); // Первая навигация: preview отвечает безопасным отказом, карточка при этом 200. let intercepted = 0; await page.route('**/resources/*/preview', async (route) => { intercepted += 1; await route.fulfill({ status: 422, contentType: 'application/json', body: JSON.stringify({ error: { code: 'resource_content_invalid_utf8', message: 'resource content is not valid UTF-8', context: { field: 'content' }, }, }), }); }); await page.goto( `/resources?resource_id=${encodeURIComponent(resourceId)}`, ); await expect( page.locator(PREVIEW_ERROR), 'a refused preview must be a visible safe error, not an empty success (P1/F08)', ).toBeVisible(); await expect(page.locator(PREVIEW_ERROR)).not.toHaveText(''); // Карточка при этом действительно загрузилась: отказ preview виден на состоявшемся экране. await expect(page.locator(META_NAME)).toHaveText(name); expect(intercepted, 'the intercepted preview route must have been exercised').toBeGreaterThan(0); // Восстановление: валидный reload без подмены снова показывает содержимое. await page.unroute('**/resources/*/preview'); await page.reload(); await expect(page.locator(PREVIEW_ERROR)).toHaveCount(0); await expect( page.locator(PREVIEW_TEXT), 'a valid reload must recover the preview', ).toHaveText('visible body\n'); }); // --------------------------------------------------------------------------- // Активное содержимое: однофакторные негативы, каждый проверяется безусловно, // плюс рабочий положительный контроль перехватчика маркера. // --------------------------------------------------------------------------- async function createDraft(page, workspace, metadata, bytes, filename, mimeType) { const created = await createResourceDraft(page, workspace.id, metadata, bytes, filename, mimeType); expect( created.status, `${metadata.kind}/${metadata.mime_type}: draft creation must succeed: ${created.text}`, ).toBe(201); return created.json.resource.resource_id || created.json.resource.id; } // Положительный контроль «страница действительно загрузила данные именно этого Resource»: // до него ни один негативный assertion не считается доказательством. async function openLoadedPreview(page, resourceId, { kind, mime, size }) { await page.goto(`/resources?resource_id=${encodeURIComponent(resourceId)}`); await expect(page.locator(PREVIEW)).toBeVisible(); await expect(page.locator(META_KIND)).toHaveText(kind); await expect(page.locator(META_MIME)).toHaveText(mime); await expect(page.locator(META_SIZE)).toHaveText(String(size)); } test('story36_at07_inert_preview_and_attachment_download', async ({ page }) => { const markerRequests = []; const dialogs = []; const mainFrameNavigations = []; page.on('request', (request) => { if (request.url().includes(MARKER_PATH)) markerRequests.push(request.url()); }); await page.route(`**${MARKER_PATH}*`, (route) => { markerRequests.push(route.request().url()); route.fulfill({ status: 200, body: 'marker' }); }); page.on('dialog', async (dialog) => { dialogs.push(dialog.message()); await dialog.dismiss(); }); page.on('framenavigated', (frame) => { if (frame === page.mainFrame()) mainFrameNavigations.push(frame.url()); }); await login(page); const workspace = await getCurrentWorkspace(page); expect(workspace && workspace.id, 'an E2E workspace must be available').toBeTruthy(); const origin = new URL(page.url()).origin; // --------------------------------------------------------------------- // 1. Разрешённая text-ветка: точное видимое содержимое и точные download bytes // --------------------------------------------------------------------- const literal = 'story36 literal'; const textPayload = `before ${literal} after\n`; const textBytes = Buffer.from(textPayload, 'utf8'); const textName = uniqueName('inert'); const textMeta = { uri: `crank://e2e/${textName}`, name: textName, description: '', kind: 'text', mime_type: 'text/plain', sensitivity: 'public', }; const textId = await createDraft(page, workspace, textMeta, textBytes, 'inert.txt', 'text/plain'); await openLoadedPreview(page, textId, { kind: 'text', mime: 'text/plain', size: textBytes.length, }); // Инертный текст: literal markup виден как текст, а не как узел. await expect(page.locator(PREVIEW_TEXT)).toHaveText(textPayload); await expect(page.locator('#story36-literal')).toHaveCount(0); await expect(page.locator(`${PREVIEW} script, ${PREVIEW} img, ${PREVIEW} a`)).toHaveCount(0); expect(await page.evaluate(() => window.__c36_inline), 'inline markup must not execute').toBeUndefined(); const textDownload = await readResourceDownload(page, workspace.id, textId); expect(textDownload.status).toBe(200); expect(textDownload.headers['content-type']).toBe('application/octet-stream'); expect(textDownload.headers['content-disposition']).toMatch(/^attachment/); expect(textDownload.headers['x-content-type-options']).toBe('nosniff'); expect(textDownload.headers['content-security-policy']).toBe("default-src 'none'; sandbox"); expect(textDownload.bodyBase64, 'download must return the exact stored bytes').toBe( textBytes.toString('base64'), ); // --------------------------------------------------------------------- // 2. Разрешённая JSON-ветка: тот же инертный рендер, точные bytes // --------------------------------------------------------------------- const jsonPayload = '{"note":"","n":1}'; const jsonBytes = Buffer.from(jsonPayload, 'utf8'); const jsonName = uniqueName('json'); const jsonMeta = { uri: `crank://e2e/${jsonName}`, name: jsonName, description: '', kind: 'json', mime_type: 'application/json', sensitivity: 'public', }; const jsonId = await createDraft(page, workspace, jsonMeta, jsonBytes, 'payload.json', 'application/json'); await openLoadedPreview(page, jsonId, { kind: 'json', mime: 'application/json', size: jsonBytes.length, }); await expect(page.locator(PREVIEW_TEXT)).toHaveText(jsonPayload); await expect(page.locator(`${PREVIEW} script`)).toHaveCount(0); expect(await page.evaluate(() => window.__c36_json)).toBeUndefined(); const jsonDownload = await readResourceDownload(page, workspace.id, jsonId); expect(jsonDownload.bodyBase64).toBe(jsonBytes.toString('base64')); // --------------------------------------------------------------------- // 3. binary-ветка: bytes не показываются вообще, metadata точная, download инертен // --------------------------------------------------------------------- const binaryCases = [ { label: 'binary-html', mime: 'text/html', filename: '../../evil.html', body: '', }, { label: 'binary-svg', mime: 'image/svg+xml', filename: 'evil.svg', body: '', }, { label: 'binary-octet-stream', // UTF-8-валидная разметка, но kind=binary: ветка выбирается kind, а не разбором байтов. mime: 'application/octet-stream', filename: 'evil.bin', body: ``, }, { label: 'binary-not-utf8', // Реальные произвольные bytes: не-UTF8 последовательности не должны ломать экран. mime: 'image/png', filename: 'raw.png', body: Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x00, 0xff, 0xfe, 0x80, 0xc3, 0x28, 0x7f]), }, ]; for (const scenario of binaryCases) { const bytes = Buffer.isBuffer(scenario.body) ? scenario.body : Buffer.from(scenario.body, 'utf8'); const name = uniqueName('active'); const metadata = { uri: `crank://e2e/${name}`, name, description: '', kind: 'binary', mime_type: scenario.mime, sensitivity: 'public', }; const resourceId = await createDraft(page, workspace, metadata, bytes, scenario.filename, scenario.mime); await openLoadedPreview(page, resourceId, { kind: 'binary', mime: scenario.mime, size: bytes.length, }); // Binary preview не отдаёт bytes (D-6): ни текста, ни активных узлов. await expect( page.locator(`${PREVIEW} script, ${PREVIEW} img, ${PREVIEW} svg, ${PREVIEW} iframe`), `${scenario.label}: no active node may be rendered inside the preview`, ).toHaveCount(0); await expect( page.locator(PREVIEW_TEXT), `${scenario.label}: a binary preview must show no content`, ).toHaveText(''); const previewHtml = await page.locator(PREVIEW).innerHTML(); expect( previewHtml.includes('__c36_active'), `${scenario.label}: preview must not embed the payload bytes: ${previewHtml}`, ).toBe(false); expect( await page.evaluate(() => window.__c36_active), `${scenario.label}: markup must not execute`, ).toBeUndefined(); expect(dialogs, `${scenario.label}: no dialog may open`).toEqual([]); expect(markerRequests, `${scenario.label}: no request to the external marker`).toEqual([]); // Preview-эндпоинт подтверждает отсутствие bytes независимым чтением API. const preview = await readResourcePreview(page, workspace.id, resourceId); expect(preview.status, `${scenario.label}: preview endpoint must answer`).toBe(200); expect(preview.json && preview.json.preview ? preview.json.preview.text : null).toBeNull(); const download = await readResourceDownload(page, workspace.id, resourceId); expect(download.status).toBe(200); expect( download.headers['content-type'], `${scenario.label}: declared MIME must not become the HTTP type`, ).toBe('application/octet-stream'); expect(download.headers['content-disposition']).toMatch(/^attachment/); expect(download.bodyBase64, `${scenario.label}: download must return the exact stored bytes`).toBe( bytes.toString('base64'), ); } // --------------------------------------------------------------------- // 4. javascript: URL безусловно не становится ссылкой и не исполняется (D-5) // --------------------------------------------------------------------- const jsPayload = Buffer.from( `open`, 'utf8', ); const jsName = uniqueName('jsurl'); const jsId = await createDraft( page, workspace, { uri: `crank://e2e/${jsName}`, name: jsName, description: '', kind: 'binary', mime_type: 'text/html', sensitivity: 'public', }, jsPayload, 'link.html', 'text/html', ); await openLoadedPreview(page, jsId, { kind: 'binary', mime: 'text/html', size: jsPayload.length, }); await expect( page.locator('#story36-js-link'), 'raw bytes must never become a link node inside the preview', ).toHaveCount(0); await expect( page.locator(`${PREVIEW} a[href^="javascript:"]`), 'no javascript: URL may reach a link inside the preview', ).toHaveCount(0); expect(await page.evaluate(() => window.__c36_active), 'javascript: URL must not execute').toBeUndefined(); expect(markerRequests, 'an inert preview must not fetch the external marker').toEqual([]); // Тот же payload как text обязан остаться инертным текстом, а не узлом-ссылкой. const jsAsText = uniqueName('jsurl_text'); const jsAsTextId = await createDraft( page, workspace, { uri: `crank://e2e/${jsAsText}`, name: jsAsText, description: '', kind: 'text', mime_type: 'text/plain', sensitivity: 'public', }, jsPayload, 'link.txt', 'text/plain', ); await openLoadedPreview(page, jsAsTextId, { kind: 'text', mime: 'text/plain', size: jsPayload.length, }); await expect(page.locator(PREVIEW_TEXT)).toHaveText(jsPayload.toString('utf8')); await expect(page.locator('#story36-js-link')).toHaveCount(0); await expect(page.locator(`${PREVIEW} a`)).toHaveCount(0); expect(await page.evaluate(() => window.__c36_active)).toBeUndefined(); // --------------------------------------------------------------------- // 5. Origin/navigation подтверждены: активное содержимое не увело страницу // --------------------------------------------------------------------- expect(new URL(page.url()).origin).toBe(origin); expect(page.url()).toContain('/resources'); for (const url of mainFrameNavigations) { expect(new URL(url).origin, `main frame must stay on the Crank origin: ${url}`).toBe(origin); } // 6. Положительный контроль sink-а: при настоящем внедрении перехватчик маркера сработал бы. await page.evaluate((markerUrl) => { const probe = document.createElement('img'); probe.src = markerUrl; document.body.appendChild(probe); }, MARKER_URL); await expect .poll(() => markerRequests.length, 'marker interception must observe a real request') .toBeGreaterThan(0); }); // --------------------------------------------------------------------------- // F1–F3 (TL run109 CODE-REVIEW): один снимок ответа на экране, допуск поздних // ответов только к актуальному выбору и форма, которая не переносит payload // между двумя черновиками. Проверки идут на неизменённом actual `resources.js`; // порядок ответов управляется через `page.route`, а не паузами в тесте. // --------------------------------------------------------------------------- const { createHash } = require('crypto'); function sha256HexUtf8(text) { return createHash('sha256').update(Buffer.from(text, 'utf8')).digest('hex'); } function textMetadata(uri, name, description, sensitivity = 'internal') { return { uri, name, description, kind: 'text', mime_type: 'text/plain', sensitivity, }; } function binaryMetadata(uri, name, description) { return { uri, name, description, kind: 'binary', mime_type: 'application/octet-stream', sensitivity: 'internal', }; } /// Захват исходящих PUT: наблюдается то, что реально отправляет форма. function observePuts(page, observed) { return page.route('**/resources/*', async (route) => { const request = route.request(); if (request.method() === 'PUT') { const buffer = request.postDataBuffer(); observed.push({ url: request.url(), body: buffer ? buffer.toString('utf8') : '' }); } await route.continue(); }); } /// F1: экран не смешивает metadata одного ответа с текстом другого. /// /// Карточка отвечает снимком версии N (реальный ответ API до обновления), а /// `preview` — снимком N+1 с другим текстом/digest/size/description/updated_at. /// Ожидание: все отображаемые metadata, precondition формы и текст относятся к /// **одному** из двух снимков, а не к разным. test('story36_f1_the_screen_shows_metadata_and_text_of_one_single_snapshot', async ({ page }) => { await login(page); const workspace = await getCurrentWorkspace(page); expect(workspace && workspace.id, 'an E2E workspace must be available').toBeTruthy(); const name = uniqueName('f1_snapshot'); const textV1 = 'f1 text of version one\n'; const created = await createResourceDraft( page, workspace.id, textMetadata(`crank://e2e/${name}`, name, 'f1 description v1'), Buffer.from(textV1, 'utf8'), 'f1.txt', 'text/plain', ); expect(created.status, `seeding the Draft must succeed: ${created.text}`).toBe(201); const resourceId = created.json.resource.resource_id || created.json.resource.id; // Реальные ответы API: снимок N берётся как есть, снимок N+1 отличается всеми // наблюдаемыми полями и остаётся внутренне согласованным. const previewN = await readResourcePreview(page, workspace.id, resourceId); expect(previewN.status, 'the seeded snapshot must be readable').toBe(200); const cardFixture = { resource: previewN.json.resource, version: previewN.json.version, findings: previewN.json.findings || [], }; const textN1 = 'f1 text of the later snapshot\n'; const descriptionN1 = 'f1 description v2'; const updatedAtN1 = '2026-01-02T03:04:05Z'; const digestN1 = sha256HexUtf8(textN1); const previewFixture = { resource: { ...previewN.json.resource, description: descriptionN1, current_draft_version: previewN.json.version.version + 1, updated_at: updatedAtN1, }, version: { ...previewN.json.version, version: previewN.json.version.version + 1, digest: digestN1, size_bytes: Buffer.byteLength(textN1, 'utf8'), created_at: updatedAtN1, superseded_at: null, }, findings: previewN.json.findings || [], preview: { text: textN1 }, }; const observedPuts = []; await page.route('**/resources/*', async (route) => { const request = route.request(); const path = new URL(request.url()).pathname; if (request.method() === 'GET' && path.endsWith(`/resources/${resourceId}`)) { await route.fulfill({ status: 200, contentType: 'application/json', body: JSON.stringify(cardFixture), }); return; } if (request.method() === 'PUT') { const buffer = request.postDataBuffer(); observedPuts.push({ url: request.url(), body: buffer ? buffer.toString('utf8') : '' }); } await route.continue(); }); await page.route('**/resources/*/preview', async (route) => { if (route.request().method() === 'GET') { await route.fulfill({ status: 200, contentType: 'application/json', body: JSON.stringify(previewFixture), }); return; } await route.continue(); }); await page.goto(`/resources?resource_id=${encodeURIComponent(resourceId)}`); await expect(page.locator(PREVIEW_TEXT), 'the later snapshot text must be displayed').toHaveText( textN1, ); const displayed = { version: ((await page.locator(META_VERSION).textContent()) || '').trim(), digest: ((await page.locator(META_DIGEST).textContent()) || '').trim(), size: ((await page.locator(META_SIZE).textContent()) || '').trim(), description: ((await page.locator(META_DESCRIPTION).textContent()) || '').trim(), text: (await page.locator(PREVIEW_TEXT).textContent()) || '', }; const snapshotN = { version: String(cardFixture.version.version), digest: cardFixture.version.digest, size: String(cardFixture.version.size_bytes), description: cardFixture.resource.description, updated_at: cardFixture.resource.updated_at, text: previewN.json.preview.text, }; const snapshotN1 = { version: String(previewFixture.version.version), digest: digestN1, size: String(Buffer.byteLength(textN1, 'utf8')), description: descriptionN1, updated_at: updatedAtN1, text: textN1, }; const same = (snapshot) => displayed.version === snapshot.version && displayed.digest === snapshot.digest && displayed.size === snapshot.size && displayed.description === snapshot.description && displayed.text === snapshot.text; const matchesN = same(snapshotN); const matchesN1 = same(snapshotN1); expect( matchesN || matchesN1, 'every displayed metadata field and the text must belong to one single API snapshot (F1); ' + `observed ${JSON.stringify(displayed)}`, ).toBe(true); // Precondition формы обязан быть precondition того же снимка, что показан на экране. const shownUpdatedAt = matchesN1 ? updatedAtN1 : snapshotN.updated_at; await page.locator(EDIT_DESCRIPTION).fill(displayed.description || ''); await page.locator(EDIT_SUBMIT).click(); await expect .poll(() => observedPuts.length, 'the edit form must be observable as an outgoing PUT') .toBeGreaterThan(0); const metadata = metadataFromMultipart(observedPuts[observedPuts.length - 1].body); expect(metadata, `the outgoing PUT must carry metadata: ${observedPuts[observedPuts.length - 1].body}`).toBeTruthy(); expect( metadata.expected_updated_at, 'the precondition must come from the same snapshot as the displayed metadata and text (F1)', ).toBe(shownUpdatedAt); }); /// F2: поздний ответ прежнего выбора не меняет ни экран, ни цель редактирования. /// /// Сценарий: A выбран, его карточка удерживается; затем выбирается B и его карточка /// тоже удерживается (пока текущий выбор не загружен, редактировать нельзя); после /// загрузки B отпускается ответ A. Ожидание: экран, ссылка скачивания и следующая /// правка относятся к актуальному выбору B, а поздний ответ A действительно получен и /// прочитан страницей — иначе «экран не изменился» доказывало бы лишь то, что ответ не /// дошёл (TL run111: `route.continue()` сам по себе — не барьер обработки). test('story36_f2_a_late_response_of_a_previous_selection_must_not_change_the_edit_target', async ({ page, }) => { await login(page); const workspace = await getCurrentWorkspace(page); expect(workspace && workspace.id, 'an E2E workspace must be available').toBeTruthy(); const nameA = uniqueName('f2_late_a'); const nameB = uniqueName('f2_late_b'); const draftA = await createResourceDraft( page, workspace.id, textMetadata(`crank://e2e/${nameA}`, nameA, 'f2 draft a'), Buffer.from('f2 body a\n', 'utf8'), 'a.txt', 'text/plain', ); const draftB = await createResourceDraft( page, workspace.id, textMetadata(`crank://e2e/${nameB}`, nameB, 'f2 draft b'), Buffer.from('f2 body b\n', 'utf8'), 'b.txt', 'text/plain', ); expect(draftA.status, `seed A: ${draftA.text}`).toBe(201); expect(draftB.status, `seed B: ${draftB.text}`).toBe(201); const idA = draftA.json.resource.resource_id; const idB = draftB.json.resource.resource_id; // Наблюдатель чтения тела ответа: он ставится до навигации и фиксирует момент, когда // именно страница (а не тест) прочитала тело позднего ответа. await page.addInitScript(() => { const observed = {}; Object.defineProperty(window, '__crankF2', { value: { observed } }); const realFetch = window.fetch.bind(window); window.fetch = function (input, init) { const url = typeof input === 'string' ? input : (input && input.url) || ''; const pending = realFetch(input, init); pending .then((response) => { const originalText = response.text.bind(response); response.text = function () { const body = originalText(); body.then(() => { observed[url] = (observed[url] || 0) + 1; }); return body; }; }) .catch(() => {}); return pending; }; }); let releaseA = () => {}; const holdA = new Promise((resolve) => { releaseA = resolve; }); let releaseB = () => {}; const holdB = new Promise((resolve) => { releaseB = resolve; }); let seenA = () => {}; const aRequestSeen = new Promise((resolve) => { seenA = resolve; }); let holdFirstB = true; const observedPuts = []; await page.route('**/resources/*', async (route) => { const request = route.request(); const path = new URL(request.url()).pathname; if (request.method() === 'GET' && path.endsWith(`/resources/${idA}`)) { seenA(); await holdA; await route.continue(); return; } if (request.method() === 'GET' && path.endsWith(`/resources/${idB}`) && holdFirstB) { holdFirstB = false; await holdB; await route.continue(); return; } if (request.method() === 'PUT') { const buffer = request.postDataBuffer(); observedPuts.push({ url: request.url(), body: buffer ? buffer.toString('utf8') : '' }); } await route.continue(); }); await page.goto('/resources'); await selectFromList(page, nameA); await aRequestSeen; await selectFromList(page, nameB); // Текущий выбор ещё не загружен: форма редактирования должна быть недоступна. await expect( page.locator(EDIT_DESCRIPTION), 'editing must stay unavailable until the current selection is loaded (F2)', ).toBeDisabled(); releaseB(); await expect(page.locator(META_NAME), 'the current selection must be loaded').toHaveText(nameB); await expect(page.locator(EDIT_DESCRIPTION)).toBeEnabled(); releaseA(); // Барьер: поздний ответ A реально получен и его тело прочитано самой страницей. await expect .poll( () => page.evaluate((suffix) => { const observed = window.__crankF2.observed; return Object.keys(observed) .filter((url) => url.endsWith(suffix)) .reduce((total, url) => total + observed[url], 0); }, `/resources/${idA}`), 'the late response of the previous selection must really be received and read by the page', ) .toBeGreaterThan(0); // Микротаски страницы (включая обработчик загрузки) завершаются до следующего кадра, // поэтому это детерминированный барьер без произвольной задержки. await page.evaluate(() => new Promise((resolve) => requestAnimationFrame(() => resolve()))); await expect( page.locator(META_NAME), 'a late response of a previous selection must not replace the current one (F2)', ).toHaveText(nameB); // R1/R3: и инертный текст предпросмотра обязан остаться текстом текущего выбора — // поздний ответ A не должен подменить ни metadata, ни видимое содержимое. await expect( page.locator(PREVIEW_TEXT), 'the inert preview text must stay the current selection snapshot (F2/R1)', ).toHaveText('f2 body b\n'); expect( new URL(page.url()).searchParams.get('resource_id'), 'the selected Draft in the URL must stay the current one', ).toBe(idB); expect( await page.locator(DOWNLOAD).getAttribute('href'), 'the download link must belong to the current selection (F2)', ).toBe(`/api/admin/workspaces/${workspace.id}/resources/${idB}/content`); await page.locator(EDIT_DESCRIPTION).fill('f2 edited description'); await page.locator(EDIT_SUBMIT).click(); await expect .poll(() => observedPuts.length, 'the edit must be observable as an outgoing PUT') .toBeGreaterThan(0); expect( observedPuts[observedPuts.length - 1].url.endsWith(`/resources/${idB}`), 'the edit must go to the currently selected Draft, not to the late one (F2): ' + observedPuts[observedPuts.length - 1].url, ).toBe(true); }); /// F3a: форма редактирования показывает bytes текущего снимка и не переносит /// введённый текст предыдущего выбора в следующий Draft. test('story36_f3a_the_editor_shows_the_bytes_of_the_selected_snapshot', async ({ page }) => { await login(page); const workspace = await getCurrentWorkspace(page); expect(workspace && workspace.id, 'an E2E workspace must be available').toBeTruthy(); const firstTextName = uniqueName('f3_text_one'); const secondTextName = uniqueName('f3_text_two'); const firstText = 'f3 stored text one\n'; const secondText = 'f3 stored text two\n'; const firstTextDraft = await createResourceDraft( page, workspace.id, textMetadata(`crank://e2e/${firstTextName}`, firstTextName, 'f3 text one'), Buffer.from(firstText, 'utf8'), 'f3-one.txt', 'text/plain', ); const secondTextDraft = await createResourceDraft( page, workspace.id, textMetadata(`crank://e2e/${secondTextName}`, secondTextName, 'f3 text two'), Buffer.from(secondText, 'utf8'), 'f3-two.txt', 'text/plain', ); for (const seeded of [firstTextDraft, secondTextDraft]) { expect(seeded.status, `seeding the Draft must succeed: ${seeded.text}`).toBe(201); } const firstTextId = firstTextDraft.json.resource.resource_id; // (1) Выбор Draft заполняет редактор его текущими bytes, без повторного ручного ввода. await page.goto(`/resources?resource_id=${encodeURIComponent(firstTextId)}`); await expect(page.locator(PREVIEW_TEXT)).toHaveText(firstText); await expect( page.locator(EDIT_CONTENT), 'the editor must show the bytes of the selected snapshot (F3)', ).toHaveValue(firstText); // (2) Введённый текст предыдущего выбора не остаётся в редакторе другого Draft. await page.goto('/resources'); await selectFromList(page, firstTextName); await expect(page.locator(META_NAME)).toHaveText(firstTextName); await expect(page.locator(EDIT_CONTENT)).toHaveValue(firstText); await page.locator(EDIT_CONTENT).fill('f3 text typed for the previous selection'); await selectFromList(page, secondTextName); await expect(page.locator(META_NAME)).toHaveText(secondTextName); await expect( page.locator(EDIT_CONTENT), 'text typed for a previous selection must not stay in the editor of another Draft (F3)', ).toHaveValue(secondText); }); /// F3b: выбранный файл замены не переносится в следующий Draft; явно выбранный /// файл текущего Draft при этом действительно отправляется. test('story36_f3b_a_replacement_file_must_not_be_carried_between_drafts', async ({ page }) => { await login(page); const workspace = await getCurrentWorkspace(page); expect(workspace && workspace.id, 'an E2E workspace must be available').toBeTruthy(); const binaryAName = uniqueName('f3_binary_a'); const binaryBName = uniqueName('f3_binary_b'); const markerA = 'C36-F3-FILE-FOR-A-MARKER'; const markerB = 'C36-F3-FILE-FOR-B-MARKER'; const binaryADraft = await createResourceDraft( page, workspace.id, binaryMetadata(`crank://e2e/${binaryAName}`, binaryAName, 'f3 binary a'), Buffer.from(`${markerA}\n`, 'utf8'), 'f3-a.bin', 'application/octet-stream', ); const binaryBDraft = await createResourceDraft( page, workspace.id, binaryMetadata(`crank://e2e/${binaryBName}`, binaryBName, 'f3 binary b'), Buffer.from(`${markerB}\n`, 'utf8'), 'f3-b.bin', 'application/octet-stream', ); for (const seeded of [binaryADraft, binaryBDraft]) { expect(seeded.status, `seeding the Draft must succeed: ${seeded.text}`).toBe(201); } const binaryBId = binaryBDraft.json.resource.resource_id; const observedPuts = []; await observePuts(page, observedPuts); await page.goto('/resources'); await selectFromList(page, binaryAName); await expect(page.locator(META_NAME)).toHaveText(binaryAName); await page.locator(EDIT_FILE).setInputFiles({ name: 'for-a.bin', mimeType: 'application/octet-stream', buffer: Buffer.from(`${markerA}-SELECTED\n`, 'utf8'), }); expect( await page.locator(EDIT_FILE).inputValue(), 'the chosen replacement file must be observable before the selection changes', ).toContain('for-a.bin'); await selectFromList(page, binaryBName); await expect(page.locator(META_NAME)).toHaveText(binaryBName); expect( await page.locator(EDIT_FILE).inputValue(), 'a replacement file chosen for another Draft must not stay selected for this one (F3)', ).toBe(''); // R3 (TL run113): binary-черновик не сохраняется «без файла». Пока файл замены не выбран // заново, submit обязан дать видимый отказ, не отправить ни одного PUT и не изменить // состояние B (ни версию, ни bytes). Промолчавшее сохранение считалось бы потерей данных. const beforeRefusal = observedPuts.length; await page.locator(EDIT_SUBMIT).click(); await expect( page.locator(EDIT_STATUS), 'saving a binary draft without a chosen replacement file must show a visible refusal', ).toHaveText(/file|файл/i); await page.evaluate(() => new Promise((resolve) => requestAnimationFrame(() => resolve()))); expect( observedPuts.length, 'a refused binary save without a replacement file must not send any PUT', ).toBe(beforeRefusal); await expect( page.locator(META_VERSION), 'a refused binary save must not create a new version of the selected draft', ).toHaveText('1'); const refusedBytes = await readResourceDownload(page, workspace.id, binaryBId); expect(refusedBytes.status, 'the refused draft must still be downloadable').toBe(200); expect( Buffer.from(refusedBytes.bodyBase64, 'base64').toString('utf8'), 'a refused binary save must leave the selected draft bytes exactly as they were', ).toBe(`${markerB}\n`); // Положительный контроль канала наблюдения: явно выбранный файл текущего Draft // действительно уходит в PUT именно этого Draft. await page.locator(EDIT_FILE).setInputFiles({ name: 'for-b.bin', mimeType: 'application/octet-stream', buffer: Buffer.from(`${markerB}-SELECTED\n`, 'utf8'), }); const before = observedPuts.length; await page.locator(EDIT_SUBMIT).click(); await expect .poll(() => observedPuts.length, 'the explicit replacement must be observable as a PUT') .toBeGreaterThan(before); const explicit = observedPuts[observedPuts.length - 1]; expect( explicit.url.endsWith(`/resources/${binaryBId}`), `the explicit replacement must go to the current Draft: ${explicit.url}`, ).toBe(true); expect( explicit.body.includes(`${markerB}-SELECTED`), 'an explicitly chosen file must be sent for the current Draft', ).toBe(true); expect( explicit.body.includes(markerA), 'the payload of a previously selected Draft must never be sent for this one (F3)', ).toBe(false); }); /// R3 (TL run113 F3a): обычное редактирование обязано действительно сохраняться. /// /// Для kind=text И kind=json редактор уже содержит действующие bytes выбранного /// черновика; меняется только metadata (описание), содержимое не вводится заново. /// Принятая версия проверяется независимо: карточкой API, текстом предпросмотра и /// точными bytes скачивания, а не только наблюдаемым исходящим PUT. test('story36_f3a_metadata_only_edit_is_accepted_and_keeps_exact_bytes', async ({ page }) => { await login(page); const workspace = await getCurrentWorkspace(page); expect(workspace && workspace.id, 'an E2E workspace must be available').toBeTruthy(); const scenarios = [ { label: 'text', mime: 'text/plain', extension: 'txt', body: 'metadata only text body\n' }, { label: 'json', mime: 'application/json', extension: 'json', body: '{"metadata":"only"}\n', }, ]; for (const scenario of scenarios) { const name = uniqueName(`f3_meta_${scenario.label}`); const metadata = scenario.label === 'json' ? { uri: `crank://e2e/${name}`, name, description: `f3 metadata-only ${scenario.label}`, kind: 'json', mime_type: 'application/json', sensitivity: 'internal', } : textMetadata(`crank://e2e/${name}`, name, `f3 metadata-only ${scenario.label}`); const seeded = await createResourceDraft( page, workspace.id, metadata, Buffer.from(scenario.body, 'utf8'), `${name}.${scenario.extension}`, scenario.mime, ); expect(seeded.status, `seeding the ${scenario.label} draft: ${seeded.text}`).toBe(201); const id = seeded.json.resource.resource_id; const observedPuts = []; await observePuts(page, observedPuts); await page.goto(`/resources?resource_id=${encodeURIComponent(id)}`); await expect(page.locator(PREVIEW_TEXT)).toHaveText(scenario.body); await expect( page.locator(EDIT_CONTENT), 'the editor must already contain the stored bytes of the selected draft (F3/R3)', ).toHaveValue(scenario.body); const editedDescription = `metadata only ${scenario.label} v2`; await page.locator(EDIT_DESCRIPTION).fill(editedDescription); const before = observedPuts.length; await page.locator(EDIT_SUBMIT).click(); await expect( page.locator(EDIT_STATUS), 'an accepted metadata-only edit must be observable as a successful save', ).toHaveText(/saved|сохранен/i); await expect( page.locator(META_VERSION), 'a metadata-only edit must create the next version, not silently do nothing', ).toHaveText('2'); await expect(page.locator(META_DESCRIPTION)).toHaveText(editedDescription); await expect( page.locator(PREVIEW_TEXT), 'the inert preview must still show the exact stored bytes after the edit', ).toHaveText(scenario.body); await expect( page.locator(EDIT_CONTENT), 'the editor must keep showing the accepted bytes after the edit', ).toHaveValue(scenario.body); // Содержимое не вводилось заново: на провод ушли именно прежние bytes редактора. expect( observedPuts.length, `the metadata-only edit must be sent as a PUT for the selected draft (${scenario.label})`, ).toBeGreaterThan(before); const sent = observedPuts[observedPuts.length - 1]; expect( sent.url.endsWith(`/resources/${id}`), `the metadata-only edit must go to the selected draft: ${sent.url}`, ).toBe(true); expect( sent.body.includes(scenario.body.trim()), 'the pre-filled editor bytes must be sent without retyping them', ).toBe(true); // Независимая проверка принятой версии: карточка и точные bytes скачивания. const card = await browserJson( page, 'GET', `/api/admin/workspaces/${workspace.id}/resources/${id}`, undefined, [200], ); expect(card.version.version, 'the stored version must be the next one').toBe(2); expect(card.resource.description).toBe(editedDescription); expect(card.version.size_bytes).toBe(Buffer.byteLength(scenario.body)); const download = await readResourceDownload(page, workspace.id, id); expect(download.status, 'the new version must stay downloadable').toBe(200); expect( Buffer.from(download.bodyBase64, 'base64').toString('utf8'), 'a metadata-only edit must keep the exact original bytes', ).toBe(scenario.body); } }); /// R1 (TL run113 BH2): пока новый выбор не загружен (или его загрузка отказала), экран /// не должен оставлять доступным действие прежнего выбора — ссылку скачивания A. /// /// Маршрут: A загружен полностью (ссылка A видна как положительный контроль) → выбор B /// удержан → ссылка A недоступна → загрузка B отказала → ссылка A по-прежнему недоступна /// и виден отказ → успешный выбор B даёт ссылку/идентичность/фактические bytes B → /// поздний ответ предпросмотра A не подменяет снимок B. test('story36_r1_a_pending_or_failed_selection_must_not_leave_the_previous_download_reachable', async ({ page, }) => { await login(page); const workspace = await getCurrentWorkspace(page); expect(workspace && workspace.id, 'an E2E workspace must be available').toBeTruthy(); const nameA = uniqueName('r1_prev_a'); const nameB = uniqueName('r1_next_b'); const bodyA = 'r1 body a\n'; const bodyB = 'r1 body b\n'; const draftA = await createResourceDraft( page, workspace.id, textMetadata(`crank://e2e/${nameA}`, nameA, 'r1 draft a'), Buffer.from(bodyA, 'utf8'), 'r1-a.txt', 'text/plain', ); const draftB = await createResourceDraft( page, workspace.id, textMetadata(`crank://e2e/${nameB}`, nameB, 'r1 draft b'), Buffer.from(bodyB, 'utf8'), 'r1-b.txt', 'text/plain', ); expect(draftA.status, `seed A: ${draftA.text}`).toBe(201); expect(draftB.status, `seed B: ${draftB.text}`).toBe(201); const idA = draftA.json.resource.resource_id; const idB = draftB.json.resource.resource_id; // Наблюдатель чтения тела ответа: фиксирует момент, когда страница действительно // прочитала поздний ответ предпросмотра A (не только получила его по сети). await page.addInitScript(() => { const observed = {}; Object.defineProperty(window, '__crankR1', { value: { observed } }); const realFetch = window.fetch.bind(window); window.fetch = function (input, init) { const url = typeof input === 'string' ? input : (input && input.url) || ''; const pending = realFetch(input, init); pending .then((response) => { const originalText = response.text.bind(response); response.text = function () { const body = originalText(); body.then(() => { observed[url] = (observed[url] || 0) + 1; }); return body; }; }) .catch(() => {}); return pending; }; }); const control = { holdB: true, failB: true }; let releaseB = () => {}; const holdB = new Promise((resolve) => { releaseB = resolve; }); let releasePreviewA = () => {}; const holdPreviewA = new Promise((resolve) => { releasePreviewA = resolve; }); let seenPreviewA = () => {}; const previewASeen = new Promise((resolve) => { seenPreviewA = resolve; }); await page.route('**/resources/**', async (route) => { const request = route.request(); const path = new URL(request.url()).pathname; if (request.method() === 'GET' && path.endsWith(`/resources/${idA}/preview`)) { seenPreviewA(); await holdPreviewA; await route.continue(); return; } if (request.method() === 'GET' && path.endsWith(`/resources/${idB}`) && control.holdB) { control.holdB = false; await holdB; if (control.failB) { await route.fulfill({ status: 500, contentType: 'application/json', body: JSON.stringify({ error: { code: 'internal_error', message: 'forced e2e failure' }, }), }); return; } } await route.continue(); }); const downloadHrefA = `/api/admin/workspaces/${workspace.id}/resources/${idA}/content`; const downloadHrefB = `/api/admin/workspaces/${workspace.id}/resources/${idB}/content`; await page.goto('/resources'); // (1) A загружен: карточка применена, а ссылка скачивания A доступна — это // положительный контроль того, что «недоступно» ниже действительно наблюдение. await selectFromList(page, nameA); await previewASeen; await expect(page.locator(META_NAME)).toHaveText(nameA); await expect( page.locator(DOWNLOAD), 'a loaded selection must offer its own download', ).toBeVisible(); expect(await page.locator(DOWNLOAD).getAttribute('href')).toBe(downloadHrefA); // (2) Выбор B удержан: наблюдается, осталась ли доступной ссылка прежнего выбора. // Наблюдение не прерывает тест: иначе непроверяемыми остались бы ветки отказа и успеха. await selectFromList(page, nameB); const pendingVisible = await page.locator(DOWNLOAD).isVisible(); const pendingHref = await page.locator(DOWNLOAD).getAttribute('href'); // (3) Загрузка B отказала: отказ виден, ссылка прежнего выбора наблюдается снова. releaseB(); await expect( page.locator('#resources-status'), 'a failed selection must be visible as an error state', ).toHaveText('forced e2e failure'); const failedVisible = await page.locator(DOWNLOAD).isVisible(); const failedHref = await page.locator(DOWNLOAD).getAttribute('href'); // (4) Успешный выбор B: ссылка, идентичность и фактические bytes относятся к B. control.failB = false; await selectFromList(page, nameB); await expect(page.locator(META_NAME)).toHaveText(nameB); await expect(page.locator(PREVIEW_TEXT)).toHaveText(bodyB); await expect(page.locator(DOWNLOAD)).toBeVisible(); expect( await page.locator(DOWNLOAD).getAttribute('href'), 'the download link must belong to the current selection (R1)', ).toBe(downloadHrefB); const downloadB = await readResourceDownload(page, workspace.id, idB); expect(downloadB.status, 'the current selection must be downloadable').toBe(200); expect( Buffer.from(downloadB.bodyBase64, 'base64').toString('utf8'), 'the download must serve the bytes of the current selection (R1)', ).toBe(bodyB); // (5) Поздний ответ предпросмотра A (он был удержан) действительно получен и прочитан // страницей, но снимок текущего выбора B не подменяет. releasePreviewA(); await expect .poll( () => page.evaluate((suffix) => { const observed = window.__crankR1.observed; return Object.keys(observed) .filter((url) => url.endsWith(suffix)) .reduce((total, url) => total + observed[url], 0); }, `/resources/${idA}/preview`), 'the late preview of the previous selection must really be received and read by the page', ) .toBeGreaterThan(0); await page.evaluate(() => new Promise((resolve) => requestAnimationFrame(() => resolve()))); await expect( page.locator(PREVIEW_TEXT), 'a late preview of the previous selection must not replace the current snapshot (R1)', ).toHaveText(bodyB); await expect(page.locator(META_NAME)).toHaveText(nameB); expect(await page.locator(DOWNLOAD).getAttribute('href')).toBe(downloadHrefB); // Итоговый вердикт R1: в обоих состояниях нового выбора доступной ссылки прежнего // черновика быть не должно. Все наблюдения перечислены в сообщении. const observations = [ `while the new selection was pending: visible=${pendingVisible} href=${pendingHref}`, `after the new selection failed: visible=${failedVisible} href=${failedHref}`, ]; expect( pendingVisible || failedVisible, 'the download of the previous selection must not stay reachable while the newly selected ' + `draft is pending or its load has failed (R1); observations: ${observations.join('; ')}`, ).toBe(false); });