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.
405 lines
17 KiB
Rust
405 lines
17 KiB
Rust
//! 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<str>,
|
||
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<String>,
|
||
mismatches: &mut Vec<String>,
|
||
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("<absent>")
|
||
.to_owned();
|
||
let field = body["error"]["context"]["field"]
|
||
.as_str()
|
||
.unwrap_or("<absent>")
|
||
.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<String>, 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<String> = Vec::new();
|
||
let mut mismatches: Vec<String> = 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:?}"
|
||
);
|
||
}
|