Files
crank/apps/ui/tests/e2e/helpers.js
T
bsodfather 54ce770682
CI / Rust Checks (pull_request) Failing after 13m41s
CI / UI Checks (pull_request) Skipped
CI / Frontend E2E (pull_request) Skipped
CI / Community Image Smoke (pull_request) Skipped
CI / Deploy (pull_request) Skipped
Community Release / release (push) Failing after 13m33s
feat(epic3): deliver the accepted Epic 3 scope through Story 3.17
Recovery delivery of the accumulated, TL-accepted Epic 3 work that had never been
committed to Git (stories 3.6-3.17, see the crank board). Story 3.18 is not accepted
yet and is deliberately excluded: its logging surface, its capability registration,
its oracle projections and its tests are not part of this tree.

Accepted scope
- 3.6 typed static Resource Drafts; 3.7 publication and exact binding of static
  Resource Versions; 3.8 MCP discovery/read and revocation of static Resources;
- 3.9 Resource import/export in API and UI plus TLS dependency maintenance;
  3.10 REST-backed Resource templates; 3.11 shared REST read runtime and the MCP
  revision/capability foundation;
- 3.12 parameterised Prompt Drafts with preview; 3.13 Prompt publication and exact
  version binding to Agents; 3.14 MCP prompts; 3.15 Prompt import/export;
- 3.16 composite Prompts with published Resources (dependency content scan plus
  dynamic read through the accepted 3.11 runtime, admin preview and MCP prompts/get);
- 3.17 bounded MCP completion suggestions from typed published schemas and the
  resources/list admission fix for bound template publications.

Accepted evidence being reused (unchanged code paths)
- 3.16 candidate: core 7, admin-api 22, registry 4, mcp-server 4, UI 6; one final
  `just verify` run 1651 passed / 0 failed / 2 ignored.
- 3.17 candidate: full run 1672 passed / 0 failed / 2 ignored, QA targeted reruns and
  a real MCP Inspector 2.12.0 client smoke.

Delivery engineering in this commit
- CI: one event per change (feature branches are gated by their pull request, push
  runs only on main), story events run the changed packages, the full workspace suite
  stays the feature/release gate; no cache/sharding without a measured runner check.
- Release: the packaged archives, checksums and SBOM are now uploaded to the Gitea
  release entry of the tag instead of dying with the runner workspace.

Not included on purpose: Story 3.18 work, build caches, runtime databases, local
credentials and scratch evidence.

Refs: crank kanban t_e39d7263; baseline 1b6db09bd1.
2026-10-25 09:08:22 +00:00

339 lines
12 KiB
JavaScript

const { expect } = require('@playwright/test');
const ADMIN_EMAIL = process.env.CRANK_E2E_ADMIN_EMAIL || 'owner@crank.local';
const ADMIN_PASSWORD = process.env.CRANK_E2E_ADMIN_PASSWORD || 'change-me-admin-password';
function localized(en, ru) {
return new RegExp(`(?:${en}|${ru})`, 'i');
}
async function login(page) {
await page.goto('/login');
await expect(page.locator('#login-form')).toBeVisible();
await page.locator('#email').fill(ADMIN_EMAIL);
await page.locator('#password').fill(ADMIN_PASSWORD);
await page.locator('.btn-signin').click();
await expect(page).toHaveURL(/\/$/);
await expect(page.locator('.page-title, .page-heading').first()).toBeVisible();
await page.waitForFunction(() => Boolean(window.CrankAuth && typeof window.CrankAuth.fetchSession === 'function'));
await page.evaluate(async () => {
await window.CrankAuth.fetchSession(false);
});
}
async function browserJson(page, method, urlPath, body, okStatuses = [200]) {
const response = await page.evaluate(async ({ method, urlPath, body }) => {
const request = {
method,
credentials: 'same-origin',
headers: {},
};
if (body !== undefined) {
request.headers['Content-Type'] = 'application/json';
request.body = JSON.stringify(body);
}
if (!['GET', 'HEAD', 'OPTIONS'].includes(method.toUpperCase())) {
let csrfToken = window.CrankAuth && window.CrankAuth.getCsrfToken();
if (!csrfToken && window.CrankApi && window.CrankApi.refreshSessionCsrf) {
const csrf = await window.CrankApi.refreshSessionCsrf();
csrfToken = csrf && csrf.csrf_token;
}
if (csrfToken) request.headers['X-CSRF-Token'] = csrfToken;
}
const result = await fetch(urlPath, request);
const text = await result.text();
let json = null;
try {
json = text ? JSON.parse(text) : null;
} catch (_error) {
json = null;
}
return {
status: result.status,
text,
json,
};
}, { method, urlPath, body });
if (!okStatuses.includes(response.status)) {
throw new Error(`HTTP ${response.status} ${urlPath}: ${response.text}`);
}
return response.json;
}
async function getSession(page) {
return browserJson(page, 'GET', '/api/auth/session');
}
async function getCurrentWorkspace(page) {
const session = await getSession(page);
const workspaceId = session.current_workspace_id
|| (session.memberships && session.memberships[0] && session.memberships[0].workspace.id);
const membership = (session.memberships || []).find((item) => item.workspace.id === workspaceId)
|| (session.memberships || [])[0];
return membership ? membership.workspace : null;
}
async function createAgent(page, workspaceId, payload) {
return page.evaluate(
async ({ workspaceId, payload }) => {
var session = await window.CrankApi.getSession();
if (!session.csrf_token) {
var csrf = await window.CrankApi.refreshSessionCsrf();
session.csrf_token = csrf.csrf_token;
}
window.CrankAuth.replaceSession(session);
return window.CrankApi.createAgent(workspaceId, payload);
},
{ workspaceId, payload },
);
}
function uniqueName(prefix) {
return `${prefix}_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
}
async function createResourceDraft(page, workspaceId, metadata, contentBytes, filename, mimeType) {
return page.evaluate(
async ({ workspaceId, metadata, contentBase64, filename, mimeType }) => {
const form = new FormData();
form.append('metadata', new Blob([JSON.stringify(metadata)], { type: 'application/json' }), 'metadata.json');
const raw = atob(contentBase64);
const bytes = new Uint8Array(raw.length);
for (let index = 0; index < raw.length; index += 1) bytes[index] = raw.charCodeAt(index);
form.append('content', new Blob([bytes], { type: mimeType }), filename);
let csrfToken = window.CrankAuth && window.CrankAuth.getCsrfToken();
if (!csrfToken && window.CrankApi && window.CrankApi.refreshSessionCsrf) {
const csrf = await window.CrankApi.refreshSessionCsrf();
csrfToken = csrf && csrf.csrf_token;
}
const headers = {};
if (csrfToken) headers['X-CSRF-Token'] = csrfToken;
const response = await fetch(`/api/admin/workspaces/${workspaceId}/resources`, {
method: 'POST',
credentials: 'same-origin',
headers,
body: form,
});
const text = await response.text();
let json = null;
try {
json = text ? JSON.parse(text) : null;
} catch (_error) {
json = null;
}
return { status: response.status, text, json };
},
{
workspaceId,
metadata,
contentBase64: Buffer.from(contentBytes).toString('base64'),
filename,
mimeType,
},
);
}
async function updateResourceDraft(page, workspaceId, resourceId, metadata, contentBytes, filename, mimeType) {
return page.evaluate(
async ({ workspaceId, resourceId, metadata, contentBase64, filename, mimeType }) => {
const form = new FormData();
form.append('metadata', new Blob([JSON.stringify(metadata)], { type: 'application/json' }), 'metadata.json');
const raw = atob(contentBase64);
const bytes = new Uint8Array(raw.length);
for (let index = 0; index < raw.length; index += 1) bytes[index] = raw.charCodeAt(index);
form.append('content', new Blob([bytes], { type: mimeType }), filename);
let csrfToken = window.CrankAuth && window.CrankAuth.getCsrfToken();
if (!csrfToken && window.CrankApi && window.CrankApi.refreshSessionCsrf) {
const csrf = await window.CrankApi.refreshSessionCsrf();
csrfToken = csrf && csrf.csrf_token;
}
const headers = {};
if (csrfToken) headers['X-CSRF-Token'] = csrfToken;
const response = await fetch(`/api/admin/workspaces/${workspaceId}/resources/${resourceId}`, {
method: 'PUT',
credentials: 'same-origin',
headers,
body: form,
});
const text = await response.text();
let json = null;
try {
json = text ? JSON.parse(text) : null;
} catch (_error) {
json = null;
}
return { status: response.status, text, json };
},
{
workspaceId,
resourceId,
metadata,
contentBase64: Buffer.from(contentBytes).toString('base64'),
filename,
mimeType,
},
);
}
async function readResourceVersionDownload(page, workspaceId, resourceId, version) {
return page.evaluate(
async ({ workspaceId, resourceId, version }) => {
const response = await fetch(
`/api/admin/workspaces/${workspaceId}/resources/${resourceId}/versions/${version}/content`,
{ credentials: 'same-origin' },
);
const headers = {};
for (const name of ['content-type', 'content-disposition', 'x-content-type-options', 'content-security-policy']) {
headers[name] = response.headers.get(name);
}
const bytes = new Uint8Array(await response.arrayBuffer());
let binary = '';
for (let index = 0; index < bytes.length; index += 1) binary += String.fromCharCode(bytes[index]);
return { status: response.status, headers, size: bytes.length, bodyBase64: btoa(binary) };
},
{ workspaceId, resourceId, version },
);
}
async function readResourcePreview(page, workspaceId, resourceId) {
return page.evaluate(
async ({ workspaceId, resourceId }) => {
const response = await fetch(`/api/admin/workspaces/${workspaceId}/resources/${resourceId}/preview`, {
credentials: 'same-origin',
});
const text = await response.text();
let json = null;
try {
json = text ? JSON.parse(text) : null;
} catch (_error) {
json = null;
}
return { status: response.status, text, json };
},
{ workspaceId, resourceId },
);
}
async function readResourceDownload(page, workspaceId, resourceId) {
return page.evaluate(
async ({ workspaceId, resourceId }) => {
const response = await fetch(`/api/admin/workspaces/${workspaceId}/resources/${resourceId}/content`, {
credentials: 'same-origin',
});
const headers = {};
for (const name of ['content-type', 'content-disposition', 'x-content-type-options', 'content-security-policy']) {
headers[name] = response.headers.get(name);
}
// Байты сравниваются точно (base64), а не через текстовое декодирование.
const bytes = new Uint8Array(await response.arrayBuffer());
let binary = '';
for (let index = 0; index < bytes.length; index += 1) binary += String.fromCharCode(bytes[index]);
return { status: response.status, headers, size: bytes.length, bodyBase64: btoa(binary) };
},
{ workspaceId, resourceId },
);
}
async function createPublishedOperation(page, workspaceId, payload) {
return page.evaluate(
async ({ workspaceId, payload }) => {
let csrfToken = window.CrankAuth && window.CrankAuth.getCsrfToken();
if (!csrfToken && window.CrankApi && window.CrankApi.refreshSessionCsrf) {
const csrf = await window.CrankApi.refreshSessionCsrf();
csrfToken = csrf && csrf.csrf_token;
}
const mutationHeaders = { 'Content-Type': 'application/json' };
if (csrfToken) mutationHeaders['X-CSRF-Token'] = csrfToken;
const base = `/api/admin/workspaces/${workspaceId}/operations`;
const created = await fetch(base, {
method: 'POST',
credentials: 'same-origin',
headers: mutationHeaders,
body: JSON.stringify(payload),
});
const createdText = await created.text();
if (created.status !== 201 && created.status !== 200) {
return { status: created.status, text: createdText };
}
const createdJson = JSON.parse(createdText);
const operationId = createdJson.operation_id;
const detail = await fetch(`${base}/${operationId}`, { credentials: 'same-origin' });
const etag = detail.headers.get('etag');
const published = await fetch(`${base}/${operationId}/publish`, {
method: 'POST',
credentials: 'same-origin',
headers: { ...mutationHeaders, 'If-Match': etag || '' },
body: JSON.stringify({ version: 1 }),
});
const publishedText = await published.text();
return {
status: published.status,
text: publishedText,
operation_id: operationId,
etag,
};
},
{ workspaceId, payload },
);
}
async function createTemplateDraft(page, workspaceId, metadata) {
return page.evaluate(
async ({ workspaceId, metadata }) => {
const form = new FormData();
form.append('metadata', new Blob([JSON.stringify(metadata)], { type: 'application/json' }), 'metadata.json');
let csrfToken = window.CrankAuth && window.CrankAuth.getCsrfToken();
if (!csrfToken && window.CrankApi && window.CrankApi.refreshSessionCsrf) {
const csrf = await window.CrankApi.refreshSessionCsrf();
csrfToken = csrf && csrf.csrf_token;
}
const headers = {};
if (csrfToken) headers['X-CSRF-Token'] = csrfToken;
const response = await fetch(`/api/admin/workspaces/${workspaceId}/resources`, {
method: 'POST',
credentials: 'same-origin',
headers,
body: form,
});
const text = await response.text();
let json = null;
try {
json = text ? JSON.parse(text) : null;
} catch (_error) {
json = null;
}
return { status: response.status, text, json };
},
{ workspaceId, metadata },
);
}
module.exports = {
ADMIN_EMAIL,
ADMIN_PASSWORD,
browserJson,
createAgent,
createPublishedOperation,
createResourceDraft,
createTemplateDraft,
getCurrentWorkspace,
getSession,
localized,
login,
readResourceDownload,
readResourcePreview,
readResourceVersionDownload,
uniqueName,
updateResourceDraft,
};