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.
922 lines
34 KiB
Rust
922 lines
34 KiB
Rust
//! Общие хелперы 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());
|
||
}
|