Files
crank/apps/admin-api/tests/integration/resources/template_safety.rs
T
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

352 lines
14 KiB
Rust
Raw 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.
//! AT-3.10-02 (AC2) — publication validator разрешает только read-safe GET/HEAD
//! без destructive semantics и без approval-required side effects.
//!
//! RED-состояние: `metadata.source` пока игнорируется, multipart требует `content`,
//! поэтому create template Draft падает на реальном отсутствии поведения
//! (`400 validation_error` malformed multipart), а не на setup.
use super::super::helpers::sha256_hex;
use super::*;
#[tokio::test(flavor = "multi_thread")]
#[serial_test::serial]
#[allow(clippy::type_complexity)]
async fn story310_at02_read_safety_matrix_blocks_every_non_read_variant() {
let (_registry, server, client, upstream) = spawn_stand("story310_at02_safety").await;
// Два разных реальных канала заголовков: target.static_headers и
// execution_config.headers. Оба обязаны быть в pinned fixture и отсутствовать
// в ответах Resource.
let static_canary = "super-secret-story310-static-header";
let execution_canary = "super-secret-story310-execution-header";
let secret_headers = json!({ "authorization": execution_canary });
let approval = approval_required();
// (метка, method, safety, approval, публикация разрешена)
let matrix: [(&str, &str, Option<Value>, Option<Value>, bool); 11] = [
("get_read", "GET", Some(read_safety()), None, true),
("head_read", "HEAD", Some(read_safety()), None, true),
("post_read", "POST", Some(read_safety()), None, false),
("put_read", "PUT", Some(read_safety()), None, false),
("patch_read", "PATCH", Some(read_safety()), None, false),
("delete_read", "DELETE", Some(read_safety()), None, false),
("options_read", "OPTIONS", Some(read_safety()), None, false),
(
"get_write",
"GET",
Some(json!({ "class": "write" })),
None,
false,
),
(
"get_destructive",
"GET",
Some(json!({ "class": "destructive" })),
None,
false,
),
(
"get_external_message",
"GET",
Some(json!({ "class": "external_message" })),
None,
false,
),
(
"get_financial",
"GET",
Some(json!({ "class": "financial_or_irreversible" })),
None,
false,
),
];
let mut accepted_publications = 0;
for (label, method, safety, approval_policy, publishable) in matrix {
let name = format!("story310_at02_{label}");
let mut payload = order_operation_payload(
&name,
&upstream,
method,
safety.clone().unwrap_or(Value::Null),
approval_policy.clone().unwrap_or(Value::Null),
secret_headers.clone(),
);
payload["target"]["static_headers"] = json!({ "x-static-canary": static_canary });
let operation_id = create_operation(&client, &server, &payload).await;
publish_operation(&client, &server, &operation_id).await;
// Positive control: pinned fixture действительно содержит оба маркера.
let (status, fixture, _) = read_response(
client
.get(format!(
"{}/operations/{operation_id}/versions/1",
server.as_ref()
))
.send()
.await
.expect("version fixture request must complete"),
)
.await;
assert_eq!(status, StatusCode::OK, "pinned fixture must be readable");
assert!(
fixture.contains(static_canary) && fixture.contains(execution_canary),
"the pinned fixture must carry both header canaries: {fixture}"
);
let metadata = template_metadata(
&format!("crank://story310/safety-{label}"),
&name,
valid_source(&operation_id),
);
let (status, text, created) = post_template_raw(&client, &server, &metadata).await;
assert_eq!(
status,
StatusCode::CREATED,
"a structurally valid source with an exact Published version must create a Draft ({label}); observed {} body={text}",
error_signature(status, &created)
);
assert!(
!text.contains(static_canary) && !text.contains(execution_canary),
"the Draft card must not expose operation headers ({label}): {text}"
);
let resource_id = created["resource"]["resource_id"]
.as_str()
.expect("template Draft id")
.to_owned();
let (status, text, preview) = read_preview(&client, &server, &resource_id).await;
assert_eq!(
status,
StatusCode::OK,
"preview must answer 200 ({label}): {text}"
);
assert!(
!text.contains(static_canary) && !text.contains(execution_canary),
"preview must not expose operation headers ({label}): {text}"
);
let (status, text, published) = publish_with_card(&client, &server, &resource_id).await;
if publishable {
assert_eq!(
status,
StatusCode::OK,
"`{method}` with confirmed read safety must publish ({label}); observed {} body={text}",
error_signature(status, &published)
);
assert!(
!text.contains(static_canary) && !text.contains(execution_canary),
"the published snapshot must not expose headers ({label}): {text}"
);
accepted_publications += 1;
} else {
assert_eq!(
status,
StatusCode::UNPROCESSABLE_ENTITY,
"`{method}` with {safety:?} must block publication ({label}); observed {} body={text}",
error_signature(status, &published)
);
assert_eq!(
published["error"]["code"],
json!("resource_source_blocked"),
"blocked publication must use the stable code ({label}): {published}"
);
assert_has_code(
&blocked_codes(&published),
"resource_source_not_read_safe",
&format!("publication blocker ({label})"),
);
assert!(
!text.contains(static_canary) && !text.contains(execution_canary),
"the publication blocker must not expose headers ({label}): {text}"
);
let card = get_card(&client, &server, &resource_id).await;
assert_eq!(card["resource"]["latest_published_version"], Value::Null);
assert_has_code(
&preview_codes(&preview),
"resource_source_not_read_safe",
&format!("preview finding ({label})"),
);
}
}
assert_eq!(
accepted_publications, 2,
"GET+read and HEAD+read must be the only publishable rows (guards 'everything blocks')"
);
// Approval-required при GET+read блокирует публикацию отдельным гейтом.
let approval_payload = read_operation_payload(
"story310_at02_get_approval",
&upstream,
read_safety(),
approval,
Value::Null,
);
let approval_id = create_operation(&client, &server, &approval_payload).await;
publish_operation(&client, &server, &approval_id).await;
let metadata = template_metadata(
"crank://story310/safety-approval",
"story310_safety_approval",
valid_source(&approval_id),
);
let created = create_template_draft(&client, &server, &metadata).await;
let resource_id = created["resource"]["resource_id"]
.as_str()
.expect("template Draft id")
.to_owned();
let (status, text, published) = publish_with_card(&client, &server, &resource_id).await;
assert_eq!(
status,
StatusCode::UNPROCESSABLE_ENTITY,
"approval-required side effects must block publication; observed {} body={text}",
error_signature(status, &published)
);
assert_has_code(
&blocked_codes(&published),
"resource_source_not_read_safe",
"approval-required blocker",
);
// Неподтверждённая read-safety (`safety` отсутствует) — тоже блокер, не «default read».
let unconfirmed_payload = read_operation_payload(
"story310_at02_get_unconfirmed",
&upstream,
Value::Null,
Value::Null,
Value::Null,
);
let unconfirmed_id = create_operation(&client, &server, &unconfirmed_payload).await;
publish_operation(&client, &server, &unconfirmed_id).await;
let metadata = template_metadata(
"crank://story310/safety-unconfirmed",
"story310_safety_unconfirmed",
valid_source(&unconfirmed_id),
);
let created = create_template_draft(&client, &server, &metadata).await;
let resource_id = created["resource"]["resource_id"]
.as_str()
.expect("template Draft id")
.to_owned();
let (status, text, published) = publish_with_card(&client, &server, &resource_id).await;
assert_eq!(
status,
StatusCode::UNPROCESSABLE_ENTITY,
"an absent safety class is unconfirmed and must block; observed {} body={text}",
error_signature(status, &published)
);
assert_has_code(
&blocked_codes(&published),
"resource_source_not_read_safe",
"unconfirmed safety blocker",
);
}
/// Story 3.10 / TL amendment: публикация перепроверяет **сохранённое** определение,
/// а не последний preview. Единственный валидный tamper-канал — прямая запись в
/// version-keyed строку (immutable Operation Version менять нельзя).
#[tokio::test(flavor = "multi_thread")]
#[serial_test::serial]
async fn story310_at02_publish_revalidates_stored_draft_source() {
let (registry, server, client, upstream) = spawn_stand("story310_at02_stored").await;
let read_id =
published_read_operation(&client, &server, &upstream, "story310_at02_stored_read").await;
let unsafe_payload = order_operation_payload(
"story310_at02_stored_unsafe",
&upstream,
"POST",
json!({ "class": "write" }),
Value::Null,
Value::Null,
);
let unsafe_id = create_operation(&client, &server, &unsafe_payload).await;
publish_operation(&client, &server, &unsafe_id).await;
let metadata = template_metadata(
"crank://story310/stored",
"story310_stored",
valid_source(&read_id),
);
let created = create_template_draft(&client, &server, &metadata).await;
let resource_id = created["resource"]["resource_id"]
.as_str()
.expect("template Draft id")
.to_owned();
// До tampering сохранённый Draft чист.
let (status, text, preview) = read_preview(&client, &server, &resource_id).await;
assert_eq!(status, StatusCode::OK, "clean preview must succeed: {text}");
assert!(preview_codes(&preview).is_empty());
// Переписываем сохранённую ссылку на Published, но небезопасную операцию.
let typed_id = crank_core::ids::ResourceId::new(resource_id.clone());
let stored = registry
.get_resource_template_source(DEFAULT_WORKSPACE_ID, &typed_id, 1)
.await
.expect("stored definition must be readable");
let mut value: Value =
serde_json::from_str(&stored.definition_json).expect("stored definition is json");
value["operation_id"] = json!(unsafe_id);
let typed: crank_core::resource::template::TemplateSource =
serde_json::from_value(value).expect("stored definition keeps the template shape");
let tampered = serde_json::to_string(&typed).expect("definition must serialize");
let digest = sha256_hex(tampered.as_bytes());
sqlx::query(
"alter table resource_template_sources
disable trigger crank_guard_resource_template_source_immutable",
)
.execute(registry.pool())
.await
.expect("the immutable guard is reversible for the tamper fixture");
sqlx::query(
"update resource_template_sources
set definition_json = $1, definition_digest = $2
where workspace_id = $3 and resource_id = $4 and version = 1",
)
.bind(&tampered)
.bind(&digest)
.bind(DEFAULT_WORKSPACE_ID)
.bind(&resource_id)
.execute(registry.pool())
.await
.expect("the tamper fixture must rewrite the stored reference");
sqlx::query(
"alter table resource_template_sources
enable trigger crank_guard_resource_template_source_immutable",
)
.execute(registry.pool())
.await
.expect("the immutable guard must be restored");
// Preview и publish читают сохранённое определение и видят небезопасную ссылку.
let (status, text, preview) = read_preview(&client, &server, &resource_id).await;
assert_eq!(
status,
StatusCode::OK,
"tampered preview must answer 200: {text}"
);
assert_has_code(
&preview_codes(&preview),
"resource_source_not_read_safe",
"tampered stored definition",
);
let (status, text, published) = publish_with_card(&client, &server, &resource_id).await;
assert_eq!(
status,
StatusCode::UNPROCESSABLE_ENTITY,
"a tampered stored source must not publish; observed {} body={text}",
error_signature(status, &published)
);
assert_eq!(published["error"]["code"], json!("resource_source_blocked"));
assert_has_code(
&blocked_codes(&published),
"resource_source_not_read_safe",
"stored source revalidation",
);
let card = get_card(&client, &server, &resource_id).await;
assert_eq!(
card["resource"]["latest_published_version"],
Value::Null,
"a blocked publication must not create a version"
);
}