Files
crank/apps/admin-api/tests/integration/resources/helpers.rs
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

922 lines
34 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! Общие хелперы ATDD-набора Story 3.6 (typed static Resource Drafts).
//!
//! Источник: SPEC v4 (`resource-drafts-story36-spec.md`, run85) §2 (mapping AC → имена
//! тестов), §3 (D-3…D-20), §7 (таргет A). Файл подготовлен стадией Dev ATDD и не является
//! продуктовым кодом: production-типы `Resource`/`ResourceLimits` здесь не используются,
//! поэтому набор остаётся компилируемым при отсутствующей реализации.
//!
//! Содержимое: session/CSRF-клиенты, multipart Draft flow (`metadata` + `content`),
//! обёртки HTTP-ответов, наблюдение состояния реестра и таблица границ грамматик
//! D-10/D-11/D-4/D-5 вместе с прогонщиком матрицы.
#![allow(dead_code)]
use super::super::common::{
TestServer, authorized_client, build_test_app, spawn_admin_api, test_auth_settings,
test_registry, test_storage_root,
};
use crank_core::{MembershipRole, Workspace, WorkspaceId, WorkspaceStatus};
use crank_registry::{CreateWorkspaceRequest, PostgresRegistry};
use reqwest::StatusCode;
use reqwest::header::HeaderMap;
use reqwest::multipart::{Form, Part};
use serde_json::{Value, json};
use time::OffsetDateTime;
/// Рабочее пространство, к которому привязан `TestServer` из `integration::common`.
pub(super) const DEFAULT_WORKSPACE_ID: &str = "ws_default";
/// Синтетическое рабочее пространство без членства вызывающего пользователя
/// (негатив «workspace без доступа»).
pub(super) const FOREIGN_WORKSPACE_ID: &str = "ws_story36_foreign";
/// Синтетическое WorkspaceB с Owner-membership вызывающего аккаунта: workspace доступен,
/// а принадлежащий ему Resource — чужая сущность (entity-level негатив D-18).
pub(super) const OWNED_WORKSPACE_ID: &str = "ws_story36_owned";
/// Потолок хранения (`ArtifactStore::MAX_ARTIFACT_BYTES`, D-3): default `ResourceLimits` = потолок.
pub(super) const CONTENT_LIMIT: usize = 256 * 1024;
/// Synthetic-аккаунт из `integration::common` (константы того модуля приватны).
pub(super) const TEST_AUTH_EMAIL: &str = "owner@crank.local";
pub(super) const TEST_AUTH_PASSWORD: &str = "test-password";
/// Корень API без workspace-префикса (для запросов логина).
pub(super) fn api_root(workspace_base_url: &str) -> String {
workspace_base_url
.split("/api/admin/workspaces/")
.next()
.expect("workspace base url must contain the admin workspace prefix")
.to_owned()
}
// ---------------------------------------------------------------------------
// Multipart Draft flow
// ---------------------------------------------------------------------------
/// Метаданные Draft в форме, которую принимает `POST/PUT .../resources`
/// (D-16: часть `metadata` — JSON).
pub(super) fn draft_metadata(
uri: &str,
name: &str,
kind: &str,
mime: &str,
sensitivity: &str,
) -> Value {
json!({
"uri": uri,
"name": name,
"description": "",
"kind": kind,
"mime_type": mime,
"sensitivity": sensitivity,
})
}
fn json_part(metadata: &Value) -> Part {
Part::bytes(serde_json::to_vec(metadata).expect("metadata must serialize"))
.file_name("metadata.json".to_owned())
.mime_str("application/json")
.expect("json part mime")
}
fn content_part(content: &[u8], filename: &str, mime: &str) -> Part {
Part::bytes(content.to_vec())
.file_name(filename.to_owned())
.mime_str(mime)
.expect("content part mime")
}
/// Multipart-тело Draft flow: часть `metadata` (JSON) + часть `content` (сырые bytes, D-16).
pub(super) fn draft_form(metadata: &Value, content: &[u8], filename: &str, mime: &str) -> Form {
Form::new()
.part("metadata", json_part(metadata))
.part("content", content_part(content, filename, mime))
}
/// Multipart с произвольными имя/тип части содержимого — проверка того, что
/// `Content-Type`/filename content-части игнорируются (D-16, AT-07).
pub(super) fn draft_form_with_content_headers(
metadata: &Value,
content: &[u8],
filename: &str,
content_part_mime: &str,
) -> Form {
Form::new().part("metadata", json_part(metadata)).part(
"content",
content_part(content, filename, content_part_mime),
)
}
/// Часть файла для существующих multipart-роутов (harness-контроль).
pub(super) fn file_part(bytes: &[u8], filename: &str, mime: &str) -> Part {
content_part(bytes, filename, mime)
}
// ---------------------------------------------------------------------------
// Ответы и подписи отказов
// ---------------------------------------------------------------------------
/// Статус + текстовое тело + разобранный JSON (Null, если тело не JSON).
pub(super) async fn read_response(response: reqwest::Response) -> (StatusCode, String, Value) {
let status = response.status();
let text = response.text().await.unwrap_or_default();
let json = serde_json::from_str::<Value>(&text).unwrap_or(Value::Null);
(status, text, json)
}
/// Заголовок ответа или `<absent>` (заголовки измеряются на реальном ответе).
pub(super) fn header_value(headers: &HeaderMap, name: &str) -> String {
headers
.get(name)
.map(|value| value.to_str().unwrap_or_default().to_owned())
.unwrap_or_else(|| "<absent>".to_owned())
}
/// Полная подпись отказа: статус + стабильные `error.code`/`error.context.field`.
pub(super) fn error_signature(status: StatusCode, body: &Value) -> String {
let code = body["error"]["code"].as_str().unwrap_or("<absent>");
let field = body["error"]["context"]["field"]
.as_str()
.unwrap_or("<absent>");
let message = body["error"]["message"].as_str().unwrap_or("<absent>");
format!("status={status} code={code} field={field} message={message}")
}
/// Наблюдаемая политика скачивания (D-6): octet-stream + attachment + nosniff + CSP sandbox.
pub(super) fn assert_download_policy(headers: &HeaderMap) {
assert_eq!(
header_value(headers, "content-type"),
"application/octet-stream",
"declared MIME must never become the HTTP content type (D-6)"
);
let disposition = header_value(headers, "content-disposition");
assert!(
disposition.starts_with("attachment"),
"downloads must be attachments: {disposition}"
);
assert!(
!disposition.contains("..") && !disposition.contains('\n') && !disposition.contains('\r'),
"raw upload filename must not reach the header: {disposition}"
);
assert_eq!(header_value(headers, "x-content-type-options"), "nosniff");
assert_eq!(
header_value(headers, "content-security-policy"),
"default-src 'none'; sandbox"
);
}
/// Независимый оракул содержимого: SHA-256 считается тестом, а не берётся у отвечающего API.
/// Тот же приём уже используется в `crates/crank-registry/tests/integration/resource_drafts.rs`.
pub(super) fn sha256_hex(bytes: &[u8]) -> String {
use sha2::{Digest as _, Sha256};
use std::fmt::Write as _;
let digest = Sha256::digest(bytes);
let mut hex = String::with_capacity(64);
for byte in digest {
write!(&mut hex, "{byte:02x}").expect("hex formatting");
}
hex
}
// ---------------------------------------------------------------------------
// Сессия и CSRF
// ---------------------------------------------------------------------------
/// Сессионный клиент с CSRF-заголовком (`common::authorized_client` для произвольного
/// synthetic-аккаунта).
pub(super) async fn login_client(
server: impl AsRef<str>,
email: &str,
password: &str,
) -> reqwest::Client {
login_client_with(server.as_ref(), email, password, true, None).await
}
/// Тот же клиент без заголовка `x-csrf-token` — негатив F36-A.
pub(super) async fn login_client_without_csrf(
server: impl AsRef<str>,
email: &str,
password: &str,
) -> reqwest::Client {
login_client_with(server.as_ref(), email, password, false, None).await
}
/// Сессионный клиент с поддельным cross-origin заголовком — негатив F36-A.
pub(super) async fn login_client_with_foreign_origin(
server: impl AsRef<str>,
email: &str,
password: &str,
) -> reqwest::Client {
login_client_with(
server.as_ref(),
email,
password,
true,
Some("http://evil.example.test"),
)
.await
}
async fn login_client_with(
server: &str,
email: &str,
password: &str,
csrf: bool,
origin: Option<&'static str>,
) -> reqwest::Client {
let root = api_root(server);
let cookie_jar = std::sync::Arc::new(reqwest::cookie::Jar::default());
let login_client = reqwest::Client::builder()
.cookie_provider(cookie_jar.clone())
.build()
.expect("login client");
let login = login_client
.post(format!("{root}/api/auth/login"))
.json(&json!({ "email": email, "password": password }))
.send()
.await
.expect("login request must complete")
.error_for_status()
.expect("synthetic account must log in")
.json::<Value>()
.await
.expect("login response must be json");
let mut headers = HeaderMap::new();
if csrf {
let token = login["csrf_token"]
.as_str()
.expect("login response must include csrf_token");
headers.insert(
"x-csrf-token",
reqwest::header::HeaderValue::from_str(token).expect("csrf header value"),
);
}
if let Some(origin) = origin {
headers.insert(
reqwest::header::ORIGIN,
reqwest::header::HeaderValue::from_static(origin),
);
}
reqwest::Client::builder()
.cookie_provider(cookie_jar)
.default_headers(headers)
.build()
.expect("session client")
}
// ---------------------------------------------------------------------------
// Стенд, запросы Draft, наблюдение реестра
// ---------------------------------------------------------------------------
pub(super) async fn spawn_authorized(
storage_name: &str,
) -> (PostgresRegistry, TestServer, reqwest::Client) {
let registry = test_registry().await;
let app = build_test_app(registry.clone(), test_storage_root(storage_name));
let server = spawn_admin_api(app).await;
let client = authorized_client(&server).await;
(registry, server, client)
}
/// Создаёт synthetic workspace, к которому у вызывающего пользователя нет доступа
/// (негатив «workspace без доступа»).
pub(super) async fn create_foreign_workspace(registry: &PostgresRegistry) -> WorkspaceId {
create_workspace(
registry,
FOREIGN_WORKSPACE_ID,
"story36-foreign",
"Story 3.6 Foreign",
)
.await
}
/// Создаёт WorkspaceB и выдаёт вызывающему аккаунту Owner-membership в нём.
///
/// Нужен для entity-level негатива: workspace доступен той же сессии, но Resource принадлежит
/// другой сущности. Сессию для новых прав тест логинит уже после создания workspace.
pub(super) async fn create_owned_workspace(registry: &PostgresRegistry) -> WorkspaceId {
let workspace_id = create_workspace(
registry,
OWNED_WORKSPACE_ID,
"story36-owned",
"Story 3.6 Owned",
)
.await;
let password_hash =
admin_api::auth::hash_password(TEST_AUTH_PASSWORD, &test_auth_settings().password_pepper)
.expect("owner password hash");
let owner_id = registry
.upsert_bootstrap_user(TEST_AUTH_EMAIL, "Test Owner", &password_hash)
.await
.expect("owner account");
registry
.ensure_membership(&workspace_id, &owner_id, MembershipRole::Owner)
.await
.expect("owner membership in WorkspaceB");
workspace_id
}
async fn create_workspace(
registry: &PostgresRegistry,
id: &str,
slug: &str,
display_name: &str,
) -> WorkspaceId {
let now = OffsetDateTime::now_utc();
let workspace_id = WorkspaceId::new(id);
registry
.create_workspace(CreateWorkspaceRequest {
workspace: &Workspace {
id: workspace_id.clone(),
slug: slug.to_owned(),
display_name: display_name.to_owned(),
status: WorkspaceStatus::Active,
settings: json!({}),
created_at: now,
updated_at: now,
},
})
.await
.expect("synthetic workspace must be created");
workspace_id
}
/// Создаёт synthetic Viewer-аккаунт в `ws_default` (негатив F36-A «non-owner mutation»)
/// и возвращает его email/password для логина.
pub(super) async fn ensure_viewer_membership(
registry: &PostgresRegistry,
) -> (&'static str, &'static str) {
const VIEWER_EMAIL: &str = "story36-viewer@crank.local";
const VIEWER_PASSWORD: &str = "story36-viewer-password";
let password_hash =
admin_api::auth::hash_password(VIEWER_PASSWORD, &test_auth_settings().password_pepper)
.expect("viewer password hash");
let viewer_id = registry
.upsert_bootstrap_user(VIEWER_EMAIL, "Story 3.6 Viewer", &password_hash)
.await
.expect("viewer account");
registry
.ensure_membership(
&WorkspaceId::new(DEFAULT_WORKSPACE_ID),
&viewer_id,
MembershipRole::Viewer,
)
.await
.expect("viewer membership");
(VIEWER_EMAIL, VIEWER_PASSWORD)
}
/// Сырой POST-ответ Draft: статус, наличие `x-trace-id`, текстовое тело, разобранный JSON.
pub(super) async fn post_draft_raw(
client: &reqwest::Client,
server: impl AsRef<str>,
metadata: &Value,
content: &[u8],
mime: &str,
) -> (StatusCode, bool, String, Value) {
let server = server.as_ref();
let response = client
.post(format!("{server}/resources"))
.multipart(draft_form(metadata, content, "draft.bin", mime))
.send()
.await
.expect("draft request must complete");
let status = response.status();
let traceable = response.headers().contains_key("x-trace-id");
let text = response.text().await.unwrap_or_default();
let body = serde_json::from_str::<Value>(&text).unwrap_or(Value::Null);
(status, traceable, text, body)
}
/// Создание Draft с ожиданием 201: при отсутствии реализации сообщение называет
/// фактический ответ, поэтому RED остаётся поведенческим.
pub(super) async fn create_draft(
client: &reqwest::Client,
server: impl AsRef<str>,
metadata: &Value,
content: &[u8],
filename: &str,
mime: &str,
) -> Value {
let server = server.as_ref();
let (status, text, body) = read_response(
client
.post(format!("{server}/resources"))
.multipart(draft_form(metadata, content, filename, mime))
.send()
.await
.expect("create request must complete"),
)
.await;
assert_eq!(
status,
StatusCode::CREATED,
"POST /resources must create a Draft (AT-3.6-02); observed {} body={text}",
error_signature(status, &body)
);
body
}
/// `resource_id` созданного Draft.
pub(super) fn created_resource_id(body: &Value) -> String {
body["resource"]["resource_id"]
.as_str()
.or_else(|| body["resource"]["id"].as_str())
.expect("201 response must carry the created Resource identifier")
.to_owned()
}
/// Утверждает неизменяемую идентичность Draft (uri/name/kind).
pub(super) fn assert_draft_identity(body: &Value, uri: &str, name: &str, kind: &str) {
assert_eq!(body["resource"]["uri"], json!(uri), "uri must be stable");
assert_eq!(body["resource"]["name"], json!(name), "name must be stable");
assert_eq!(body["resource"]["kind"], json!(kind), "kind must be stable");
}
pub(super) async fn get_card(
client: &reqwest::Client,
server: impl AsRef<str>,
resource_id: &str,
) -> Value {
let server = server.as_ref();
let (status, text, body) = read_response(
client
.get(format!("{server}/resources/{resource_id}"))
.send()
.await
.expect("card request must complete"),
)
.await;
assert_eq!(
status,
StatusCode::OK,
"GET /resources/{resource_id} must return the Draft card (AT-3.6-02); observed {} body={text}",
error_signature(status, &body)
);
body
}
/// Optimistic-precondition timestamp карточки Draft (D-16 `expected_updated_at`).
/// SPEC не фиксирует имя контейнера, поэтому перебираются согласованные варианты,
/// а отсутствие значения — явная ошибка oracle-а.
pub(super) fn draft_updated_at(body: &Value) -> String {
for pointer in ["/resource/updated_at", "/version/updated_at", "/updated_at"] {
if let Some(value) = body.pointer(pointer).and_then(Value::as_str) {
return value.to_owned();
}
}
panic!("Draft card must expose the precondition timestamp `updated_at`; body={body}");
}
pub(super) async fn list_resources(
client: &reqwest::Client,
server: impl AsRef<str>,
) -> (StatusCode, String, Value) {
let server = server.as_ref();
read_response(
client
.get(format!("{server}/resources"))
.send()
.await
.expect("list request must complete"),
)
.await
}
/// Байты текущей версии через `GET .../content`.
pub(super) async fn read_content(
client: &reqwest::Client,
server: impl AsRef<str>,
resource_id: &str,
) -> Vec<u8> {
let server = server.as_ref();
let response = client
.get(format!("{server}/resources/{resource_id}/content"))
.send()
.await
.expect("content request must complete");
assert_eq!(
response.status(),
StatusCode::OK,
"content must be readable"
);
response
.bytes()
.await
.expect("content body must be readable")
.to_vec()
}
/// `preview` вместе со статусом и текстом ответа.
pub(super) async fn read_preview(
client: &reqwest::Client,
server: impl AsRef<str>,
resource_id: &str,
) -> (StatusCode, String, Value) {
let server = server.as_ref();
read_response(
client
.get(format!("{server}/resources/{resource_id}/preview"))
.send()
.await
.expect("preview request must complete"),
)
.await
}
/// Количество строк в таблице реестра; отсутствие таблицы V16 — наблюдаемое
/// отсутствие реализации, поэтому паника называет первопричину явно.
pub(super) async fn table_row_count(pool: &sqlx::PgPool, table: &str) -> i64 {
let sql = format!("select count(*) from {table}");
sqlx::query_scalar::<_, i64>(sqlx::AssertSqlSafe(sql))
.fetch_one(pool)
.await
.unwrap_or_else(|error| {
panic!("Story 3.6 persistence `{table}` is not queryable yet: {error}")
})
}
// ---------------------------------------------------------------------------
// Границы грамматик D-10/D-11/D-4/D-5 (матрица AT-3.6-02)
// ---------------------------------------------------------------------------
pub(super) struct GrammarCase {
metadata: Value,
mime: &'static str,
label: &'static str,
expected_status: StatusCode,
expected_code: &'static str,
expected_field: &'static str,
}
fn case(
label: &'static str,
metadata: Value,
mime: &'static str,
status: StatusCode,
code: &'static str,
field: &'static str,
) -> GrammarCase {
GrammarCase {
metadata,
mime,
label,
expected_status: status,
expected_code: code,
expected_field: field,
}
}
fn accepted(label: &'static str, uri: &str, name: &str) -> GrammarCase {
case(
label,
draft_metadata(uri, name, "text", "text/plain", "internal"),
"text/plain",
StatusCode::CREATED,
"",
"",
)
}
fn uri_rejected(label: &'static str, uri: &str, name: &str) -> GrammarCase {
case(
label,
draft_metadata(uri, name, "text", "text/plain", "internal"),
"text/plain",
StatusCode::BAD_REQUEST,
"resource_uri_invalid",
"uri",
)
}
fn name_rejected(label: &'static str, uri: &str, name: &str) -> GrammarCase {
case(
label,
draft_metadata(uri, name, "text", "text/plain", "internal"),
"text/plain",
StatusCode::BAD_REQUEST,
"resource_name_invalid",
"name",
)
}
fn mime_rejected(
label: &'static str,
uri: &str,
name: &str,
mime: &'static str,
code: &'static str,
field: &'static str,
) -> GrammarCase {
case(
label,
draft_metadata(uri, name, "text", mime, "internal"),
mime,
StatusCode::BAD_REQUEST,
code,
field,
)
}
/// Точные границы, закреплённые в SPEC D-10 (URI), D-11 (name), D-4 (синтаксис MIME),
/// D-5 (allowlist/kind), D-20 (description bounds).
pub(super) fn story36_grammar_cases() -> Vec<GrammarCase> {
let uri_192 = format!("crank://{}", "a".repeat(192));
let uri_193 = format!("crank://{}", "a".repeat(193));
let name_64 = "a".repeat(64);
let name_65 = "a".repeat(65);
let long_description = "d".repeat(1025);
let mut cases = vec![
// D-10: длина 10..=200 включительно, `_` внутри разрешён
accepted("uri-min-10-bytes", "crank://ab", "uri_min"),
accepted("uri-max-200-bytes", &uri_192, "uri_max"),
accepted("uri-inner-underscore", "crank://a_b", "uri_underscore"),
accepted("uri-dots", "crank://a.b", "uri_dots"),
accepted("uri-slashes", "crank://a/b", "uri_slashes"),
accepted("uri-dash", "crank://a-b", "uri_dash"),
accepted("uri-tilde", "crank://a~b", "uri_tilde"),
accepted("uri-double-dot-segment", "crank://a..b", "uri_double_dot"),
uri_rejected("uri-9-bytes", "crank://a", "uri_short"),
uri_rejected("uri-201-bytes", &uri_193, "uri_long"),
uri_rejected("uri-trailing-slash", "crank://a/", "uri_trailing"),
uri_rejected("uri-empty-segment", "crank://a//b", "uri_empty_segment"),
uri_rejected("uri-dot-segment", "crank://a/.", "uri_dot_segment"),
uri_rejected("uri-dotdot-segment", "crank://a/../b", "uri_dotdot"),
uri_rejected(
"uri-trailing-underscore",
"crank://a_",
"uri_underscore_end",
),
uri_rejected("uri-trailing-dash", "crank://a-", "uri_dash_end"),
uri_rejected("uri-space", "crank://a b", "uri_space"),
uri_rejected("uri-non-ascii", "crank://éé", "uri_non_ascii"),
uri_rejected("uri-uppercase-scheme", "CRANK://a", "uri_scheme_case"),
uri_rejected("uri-single-slash", "crank:/a", "uri_single_slash"),
uri_rejected("uri-query", "crank://a?x=1", "uri_query"),
uri_rejected("uri-fragment", "crank://a#f", "uri_fragment"),
uri_rejected("uri-percent-encoding", "crank://a%2Fb", "uri_percent"),
// D-11: 1..=64 символа, нижний регистр, начинается с буквы
accepted("name-minimum", "crank://n/min", "a"),
accepted("name-64-chars", "crank://n/max", &name_64),
accepted("name-trailing-dash", "crank://n/dash", "a-"),
accepted("name-trailing-underscore", "crank://n/under", "a_"),
name_rejected("name-empty", "crank://n/empty", ""),
name_rejected("name-65-chars", "crank://n/long", &name_65),
name_rejected("name-uppercase", "crank://n/upper", "A"),
name_rejected("name-leading-digit", "crank://n/digit", "1a"),
name_rejected("name-leading-dash", "crank://n/lead-dash", "-a"),
name_rejected("name-leading-underscore", "crank://n/lead-under", "_a"),
name_rejected("name-space", "crank://n/space", "a b"),
name_rejected("name-dot", "crank://n/dot", "a.b"),
name_rejected("name-slash", "crank://n/slash", "a/b"),
name_rejected("name-non-ascii", "crank://n/non-ascii", "é"),
// D-4/D-5: синтаксис → allowlist → несовместимость с kind
mime_rejected(
"mime-charset-parameter",
"crank://mime/syntax",
"mime_syntax",
"text/plain; charset=utf-8",
"resource_mime_syntax_invalid",
"mime_type",
),
mime_rejected(
"mime-not-in-allowlist",
"crank://mime/unlisted",
"mime_unlisted",
"application/zip",
"resource_mime_not_allowed",
"mime_type",
),
mime_rejected(
"mime-json-as-text",
"crank://mime/kind-text",
"mime_kind_text",
"application/json",
"resource_kind_mismatch",
"kind",
),
mime_rejected(
"mime-active-content-as-text",
"crank://mime/kind-html",
"mime_kind_html",
"text/html",
"resource_kind_mismatch",
"kind",
),
];
let mut description_case = draft_metadata(
"crank://description/bound",
"description_bound",
"text",
"text/plain",
"internal",
);
description_case["description"] = json!(long_description);
cases.push(case(
"description-1025-bytes",
description_case,
"text/plain",
StatusCode::BAD_REQUEST,
"resource_description_invalid",
"description",
));
cases
}
/// Прогоняет матрицу целиком: каждый кейс получает собственный запрос, а расхождения
/// накапливаются, поэтому один отказ не скрывает остальные кейсы.
pub(super) async fn run_grammar_matrix(client: &reqwest::Client, server: impl AsRef<str>) {
let server = server.as_ref();
let cases = story36_grammar_cases();
let mut mismatches = Vec::new();
for case in &cases {
let (status, text, body) = read_response(
client
.post(format!("{server}/resources"))
.multipart(draft_form(
&case.metadata,
b"payload",
"draft.txt",
case.mime,
))
.send()
.await
.expect("grammar case request must complete"),
)
.await;
let label = case.label;
if status != case.expected_status {
mismatches.push(format!(
"{label}: expected {}, observed {} (body={text})",
case.expected_status,
error_signature(status, &body)
));
continue;
}
if case.expected_code.is_empty() {
continue;
}
let code = body["error"]["code"].as_str().unwrap_or("<absent>");
let field = body["error"]["context"]["field"]
.as_str()
.unwrap_or("<absent>");
if code != case.expected_code || field != case.expected_field {
mismatches.push(format!(
"{label}: expected {}/{}, observed {code}/{field} (body={text})",
case.expected_code, case.expected_field
));
}
}
assert!(
mismatches.is_empty(),
"AT-3.6-02 identifier grammar mismatches ({}/{}):\n{}",
mismatches.len(),
cases.len(),
mismatches.join("\n")
);
}
// ---------------------------------------------------------------------------
// Матрица AT-3.6-04 (malformed JSON) и кейс AT-3.6-07 (инертное скачивание)
// ---------------------------------------------------------------------------
/// Точные malformed-JSON кейсы (D-8/D-8.1): не-JSON токены, повреждённая кодировка,
/// числа вне представимости выбранного парсера.
pub(super) fn malformed_json_cases() -> Vec<(&'static str, Vec<u8>)> {
vec![
("truncated-object", b"{".to_vec()),
("trailing-garbage", b"{\"a\":1} trailing".to_vec()),
("incomplete-escape", b"\"\\u12\"".to_vec()),
("nan-literal", b"NaN".to_vec()),
("infinity-literal", b"Infinity".to_vec()),
("leading-plus", b"+1".to_vec()),
("leading-zero", b"01".to_vec()),
("invalid-encoding", vec![0xFF, 0x80]),
("number-out-of-range-1e309", b"1e309".to_vec()),
("number-out-of-range-1.8e308", b"1.8e308".to_vec()),
]
}
/// Прогоняет malformed-JSON матрицу целиком и возвращает (расхождения, всего кейсов).
/// Ожидание: 422 `resource_content_invalid_json` с `error.context.field = content`.
pub(super) async fn run_malformed_json_matrix(
client: &reqwest::Client,
server: impl AsRef<str>,
) -> (Vec<String>, usize) {
let server = server.as_ref();
let cases = malformed_json_cases();
let mut mismatches = Vec::new();
for (index, (label, bytes)) in cases.iter().enumerate() {
let meta = draft_metadata(
&format!("crank://json/{index}"),
&format!("json_case_{index}"),
"json",
"application/json",
"internal",
);
let (status, _, text, body) =
post_draft_raw(client, server, &meta, bytes, "application/json").await;
let is_expected = status == StatusCode::UNPROCESSABLE_ENTITY
&& body["error"]["code"] == serde_json::json!("resource_content_invalid_json")
&& body["error"]["context"]["field"] == serde_json::json!("content");
if !is_expected {
mismatches.push(format!(
"{label}: observed {} body={text}",
error_signature(status, &body)
));
}
}
(mismatches, cases.len())
}
/// AT-3.6-07: скачивание инертно, заголовки content-части бессильны (D-6/D-16),
/// binary preview не отдаёт bytes.
pub(super) async fn run_inert_download_case(client: &reqwest::Client, server: impl AsRef<str>) {
let server = server.as_ref();
let markup = b"<html><body><script>window.__c36='active'</script></body></html>";
let meta = draft_metadata(
"crank://download/active",
"download_active",
"binary",
"text/html",
"internal",
);
let created = create_draft(client, server, &meta, markup, "../../x.svg", "text/html").await;
let id = created_resource_id(&created);
let response = client
.get(format!("{server}/resources/{id}/content"))
.send()
.await
.expect("content request must complete");
assert_eq!(response.status(), StatusCode::OK);
let headers = response.headers().clone();
assert_download_policy(&headers);
let bytes = response
.bytes()
.await
.expect("content body must be readable");
assert_eq!(
bytes.to_vec(),
markup.to_vec(),
"content bytes stay unchanged and inert"
);
// предпросмотр: для binary bytes не отдаются вообще (D-6)
let (status, text, preview) = read_preview(client, server, &id).await;
assert_eq!(status, StatusCode::OK, "preview must exist: {text}");
assert!(
preview["preview"]["text"].is_null(),
"declared `text/html` stays kind=binary and must not be served as text (D-5): {text}"
);
// агрессивные заголовки/имя content-части не меняют политику (D-16)
let hostile = draft_metadata(
"crank://download/second",
"download_second",
"binary",
"image/svg+xml",
"public",
);
let hostile_markup = b"<svg xmlns=\"http://www.w3.org/2000/svg\" onload=\"alert(1)\"></svg>";
let (status, text, body) = read_response(
client
.post(format!("{server}/resources"))
.multipart(draft_form_with_content_headers(
&hostile,
hostile_markup,
"..\\..\\evil.svg",
"text/html",
))
.send()
.await
.expect("hostile draft request must complete"),
)
.await;
assert_eq!(
status,
StatusCode::CREATED,
"hostile content-part headers must not affect creation (D-16); observed {} body={text}",
error_signature(status, &body)
);
let second_id = created_resource_id(&body);
let response = client
.get(format!("{server}/resources/{second_id}/content"))
.send()
.await
.expect("content request must complete");
assert_eq!(response.status(), StatusCode::OK);
assert_download_policy(response.headers());
}