//! P2-остаток (TL review run101 R-E / run103 R-E) вынесен в отдельный private //! test-модуль: health-правило ограничивает файл 1000 строками, а helper-ы/типы и //! лон-векторы F4 используют те же фикстуры, что и родительский модуль. //! //! Перенесены только helper-ы/типы (`case_draft`, `ExpectedCode`, `CLIENT_CODES`, //! `record_case`) и тест F4, который их использует; test ID, assertions, данные и //! контроли не менялись. Производственный код, FILE_LIMITS и checker не затронуты //! (R4, TL run113). use super::super::helpers::{ assert_draft_identity, create_draft, created_resource_id, draft_metadata, draft_updated_at, get_card, post_draft_raw, spawn_authorized, table_row_count, }; use super::super::{DraftState, observe_draft_state, put_draft_raw, update_metadata}; use reqwest::StatusCode; use serde_json::{Value, json}; use serial_test::serial; /// Свежий durable Draft для одного независимого случая отказа (F1). /// /// Возвращает собственные `updated_at` (валидную текущую precondition) и полное «до» /// именно этого черновика. Причина: принятый дефект (`"uri": null` применяется как обычное /// обновление) меняет и состояние, и precondition черновика, поэтому общий случай сделал бы /// последующие наблюдения двухфакторными (`null` + `stale`) и сравнил бы их с чужим /// предыдущим PUT (TL run105 F1). pub(super) async fn case_draft( registry: &crank_registry::PostgresRegistry, client: &reqwest::Client, server: impl AsRef, namespace: &str, suffix: &str, ) -> (String, String, DraftState) { let server = server.as_ref(); let uri = format!("crank://immutable/{namespace}/{suffix}"); let name = format!("immutable_{namespace}_{suffix}"); let meta = draft_metadata(&uri, &name, "text", "text/plain", "internal"); let created = create_draft( client, server, &meta, b"first body", "draft.txt", "text/plain", ) .await; let id = created_resource_id(&created); let updated_at = draft_updated_at(&get_card(client, server, &id).await); let before = observe_draft_state(registry, client, server, &id).await; assert_draft_identity(&before.card, &uri, &name, "text"); assert_eq!( before.card["version"]["version"], json!(1), "every case must start from its own accepted Draft version 1: {suffix}" ); assert_eq!(before.bytes, b"first body".to_vec()); // Итоги строк намеренно не сравниваются с абсолютными числами: в одном workspace // теперь несколько черновиков, поэтому проверяется их неизменность после отказа // (через равенство полного состояния), а не «ровно одна строка». assert!( before.versions >= 1 && before.owning_refs >= 1, "the fresh draft must be durable (versions={}, owning_refs={})", before.versions, before.owning_refs ); (id, updated_at, before) } /// Ожидание по коду отказа: либо точный стабильный код D-14, либо «любой клиентский /// код из D-14, кроме перечисленных» — для отказов, у которых D-14 не выделяет /// отдельного Resource-кода, но требует именно клиентского отказа, а не 500. #[derive(Clone, Copy, Debug)] pub(super) enum ExpectedCode { Exact(&'static str), ClientRejectionExcept(&'static [&'static str]), } /// Полный список клиентских кодов D-14 (любой отказ обязан быть одним из них). pub(super) const CLIENT_CODES: &[&str] = &[ "resource_content_empty", "resource_content_too_large", "resource_content_invalid_utf8", "resource_content_invalid_json", "resource_mime_syntax_invalid", "resource_mime_not_allowed", "resource_uri_invalid", "resource_name_invalid", "resource_description_invalid", "resource_kind_mismatch", "resource_uri_duplicate", "resource_name_duplicate", "resource_field_immutable", "validation_error", ]; /// Записывает наблюдение одного отказа в общий отчёт и перечисляет расхождения. /// /// Проверяются вместе: статус, стабильный код (и точное `error.context.field`, когда оно /// определено) и неизменность **полного** состояния черновика — карточки, точных bytes и /// итогов строк/owning-ссылок. #[allow(clippy::too_many_arguments)] pub(super) fn record_case( observations: &mut Vec, mismatches: &mut Vec, label: &str, status: StatusCode, body: &Value, state_unchanged: bool, expected_status: StatusCode, expected_code: ExpectedCode, expected_field: Option<&str>, ) { let code = body["error"]["code"] .as_str() .unwrap_or("") .to_owned(); let field = body["error"]["context"]["field"] .as_str() .unwrap_or("") .to_owned(); let code_ok = match expected_code { ExpectedCode::Exact(expected) => code == expected, ExpectedCode::ClientRejectionExcept(forbidden) => { CLIENT_CODES.contains(&code.as_str()) && !forbidden.contains(&code.as_str()) } }; let field_ok = expected_field.is_none_or(|expected| field == expected); let ok = status == expected_status && code_ok && field_ok && state_unchanged; observations.push(format!( "{label}: status={status} code={code} field={field} state_unchanged={state_unchanged}" )); if !ok { mismatches.push(format!( "{label}: expected status={expected_status} code={expected_code:?} field={expected_field:?} \ state_unchanged=true; observed status={status} code={code} field={field} \ state_unchanged={state_unchanged}" )); } } /// R3/F4: у одиночного generic-отказа (`UnknownMetadataValue`, шаг E) не должно быть /// Resource-специфичного контекста. `expected_field = None` в `record_case` означает /// «поле не проверяется», поэтому отсутствие `error.context` наблюдается явно, без /// ослабления прежних проверок кода и поля у Resource-специфичных отказов. pub(super) fn assert_lone_generic_context(mismatches: &mut Vec, label: &str, body: &Value) { let context = body["error"].get("context"); if context.is_some_and(|value| !value.is_null()) { mismatches.push(format!( "{label}: a lone generic refusal must not carry a Resource-specific \ `error.context`, observed {context:?}" )); } } // --------------------------------------------------------------------------- // F4 (TL run109 CODE-REVIEW): неизвестная `sensitivity` решается на **своём** // шаге E, а не раньше C/D. Порядок D-20: C (разрешение Resource) → D // (неизменяемость) → E (`uri → name → description → kind → mime_type → // sensitivity`). Наблюдаемое требование: клиент видит первый нарушенный шаг, // поэтому «invalid uri + unknown sensitivity» обязан дать `resource_uri_invalid`, // а «нет Resource + unknown sensitivity» — `resource_not_found`, а не generic 400. // Одиночная неизвестная `sensitivity` остаётся generic клиентским 400 (не 500). // --------------------------------------------------------------------------- #[tokio::test(flavor = "multi_thread")] #[serial] pub(super) async fn story36_at02_unknown_sensitivity_is_decided_at_its_own_d20_step() { let (registry, server, client) = spawn_authorized("story36_sensitivity_step").await; let mut observations: Vec = Vec::new(); let mut mismatches: Vec = Vec::new(); // E: побеждает первое нарушение, поэтому у каждого вектора нарушен ровно один // более ранний шаг, а `sensitivity` неизвестна во всех. let mut long_description = draft_metadata( "crank://order/description", "order_description", "text", "text/plain", "top_secret", ); long_description["description"] = json!("d".repeat(1025)); let invalid_name = "n".repeat(65); let create_vectors = [ ( "create-uri-before-sensitivity", draft_metadata("crank://a", "order_uri", "text", "text/plain", "top_secret"), "resource_uri_invalid", "uri", ), ( "create-name-before-sensitivity", draft_metadata( "crank://order/name", &invalid_name, "text", "text/plain", "top_secret", ), "resource_name_invalid", "name", ), ( "create-description-before-sensitivity", long_description, "resource_description_invalid", "description", ), ( "create-mime-before-sensitivity", draft_metadata( "crank://order/mime", "order_mime", "text", "text", "top_secret", ), "resource_mime_syntax_invalid", "mime_type", ), ]; let rows_before = table_row_count(registry.pool(), "resources").await; for (label, metadata, code, field) in create_vectors { let (status, _, _text, body) = post_draft_raw(&client, &server, &metadata, b"payload", "text/plain").await; // «Состояние не изменилось» наблюдается как итог принятых строк: отказ create // не должен оставить Resource (ни одна строка таблицы). let rows_after = table_row_count(registry.pool(), "resources").await; record_case( &mut observations, &mut mismatches, label, status, &body, rows_after == rows_before, StatusCode::BAD_REQUEST, ExpectedCode::Exact(code), Some(field), ); } // Одиночная неизвестная `sensitivity` при валидных остальных полях: generic // клиентский 400 без Resource-кода и без внутренней ошибки хранилища (D-20 E). let lone = draft_metadata( "crank://order/lone", "order_lone", "text", "text/plain", "top_secret", ); let (status, _, _text, body) = post_draft_raw(&client, &server, &lone, b"payload", "text/plain").await; let rows_after_lone = table_row_count(registry.pool(), "resources").await; // Точный код `validation_error` одновременно исключает и Resource-специфичный код, // и внутреннюю ошибку хранилища (`resource_storage_unavailable`). record_case( &mut observations, &mut mismatches, "create-lone-unknown-sensitivity", status, &body, rows_after_lone == rows_before, StatusCode::BAD_REQUEST, ExpectedCode::Exact("validation_error"), None, ); // R3/F4: «не проверять поле» заменяется явным наблюдением отсутствия // Resource-специфичного контекста у одиночного generic-отказа. assert_lone_generic_context(&mut mismatches, "create-lone-unknown-sensitivity", &body); // Неизвестный `kind` остаётся шагом B (форма запроса) и по-прежнему побеждает E. let unknown_kind = draft_metadata( "crank://order/kind", "order_kind", "video", "text/plain", "top_secret", ); let (status, _, _text, body) = post_draft_raw(&client, &server, &unknown_kind, b"payload", "text/plain").await; let rows_after_kind = table_row_count(registry.pool(), "resources").await; record_case( &mut observations, &mut mismatches, "create-unknown-kind-stays-step-b", status, &body, rows_after_kind == rows_before, StatusCode::BAD_REQUEST, ExpectedCode::Exact("validation_error"), None, ); // C до E: неизвестная `sensitivity` не должна опережать разрешение Resource. let missing_meta = update_metadata("", "text/plain", "top_secret", "2026-01-01T00:00:00Z"); let (status, _text, body) = put_draft_raw( &client, &server, "res_missing_story36_order", &missing_meta, b"payload", "text/plain", ) .await; let rows_after_missing = table_row_count(registry.pool(), "resources").await; record_case( &mut observations, &mut mismatches, "update-missing-resource-before-sensitivity", status, &body, rows_after_missing == rows_before, StatusCode::NOT_FOUND, ExpectedCode::Exact("resource_not_found"), Some("resource_id"), ); // Обновление **существующего** Draft с одиночной неизвестной sensitivity: // generic клиентский 400 (не 500) и полное состояние без изменений. let meta = draft_metadata( "crank://order/existing", "order_existing", "text", "text/plain", "internal", ); let created = create_draft( &client, &server, &meta, b"first body", "draft.txt", "text/plain", ) .await; let id = created_resource_id(&created); let updated_at = draft_updated_at(&get_card(&client, &server, &id).await); let before = observe_draft_state(®istry, &client, &server, &id).await; assert_draft_identity( &before.card, "crank://order/existing", "order_existing", "text", ); let (status, _text, body) = put_draft_raw( &client, &server, &id, &update_metadata("", "text/plain", "top_secret", &updated_at), b"second body", "text/plain", ) .await; let after = observe_draft_state(®istry, &client, &server, &id).await; // Точный код `validation_error` одновременно исключает Resource-специфичный код и // внутреннюю ошибку хранилища (не 500) для одиночной неизвестной sensitivity. record_case( &mut observations, &mut mismatches, "update-existing-lone-unknown-sensitivity", status, &body, after == before, StatusCode::BAD_REQUEST, ExpectedCode::Exact("validation_error"), None, ); // R3/F4: тот же явный контроль отсутствия Resource-специфичного контекста на update. assert_lone_generic_context( &mut mismatches, "update-existing-lone-unknown-sensitivity", &body, ); // D до E: присутствие immutable-ключа побеждает неизвестную sensitivity. let mut immutable_meta = update_metadata("", "text/plain", "top_secret", &updated_at); immutable_meta["uri"] = json!("crank://order/renamed"); let (status, _text, body) = put_draft_raw( &client, &server, &id, &immutable_meta, b"second body", "text/plain", ) .await; let after_immutable = observe_draft_state(®istry, &client, &server, &id).await; record_case( &mut observations, &mut mismatches, "update-immutable-presence-before-sensitivity", status, &body, after_immutable == before, StatusCode::BAD_REQUEST, ExpectedCode::Exact("resource_field_immutable"), Some("uri"), ); assert!( mismatches.is_empty(), "the unknown sensitivity must be decided at its own D-20 step and each refusal must \ leave the observed state unchanged; observations: {observations:?}; mismatches: {mismatches:?}" ); }