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

922 lines
34 KiB
Rust
Raw Permalink 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());
}