//! Общие хелперы 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::(&text).unwrap_or(Value::Null); (status, text, json) } /// Заголовок ответа или `` (заголовки измеряются на реальном ответе). 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(|| "".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(""); let field = body["error"]["context"]["field"] .as_str() .unwrap_or(""); let message = body["error"]["message"].as_str().unwrap_or(""); 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, 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, 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, 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::() .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, 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::(&text).unwrap_or(Value::Null); (status, traceable, text, body) } /// Создание Draft с ожиданием 201: при отсутствии реализации сообщение называет /// фактический ответ, поэтому RED остаётся поведенческим. pub(super) async fn create_draft( client: &reqwest::Client, server: impl AsRef, 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, 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, ) -> (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, resource_id: &str, ) -> Vec { 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, 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 { 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) { 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(""); let field = body["error"]["context"]["field"] .as_str() .unwrap_or(""); 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)> { 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, ) -> (Vec, 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) { let server = server.as_ref(); let markup = b""; 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""; 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()); }