CI / Rust Checks (pull_request) Failing after 13m41s
CI / UI Checks (pull_request) Skipped
CI / Frontend E2E (pull_request) Skipped
CI / Community Image Smoke (pull_request) Skipped
CI / Deploy (pull_request) Skipped
Community Release / release (push) Failing after 13m33s
Recovery delivery of the accumulated, TL-accepted Epic 3 work that had never been
committed to Git (stories 3.6-3.17, see the crank board). Story 3.18 is not accepted
yet and is deliberately excluded: its logging surface, its capability registration,
its oracle projections and its tests are not part of this tree.
Accepted scope
- 3.6 typed static Resource Drafts; 3.7 publication and exact binding of static
Resource Versions; 3.8 MCP discovery/read and revocation of static Resources;
- 3.9 Resource import/export in API and UI plus TLS dependency maintenance;
3.10 REST-backed Resource templates; 3.11 shared REST read runtime and the MCP
revision/capability foundation;
- 3.12 parameterised Prompt Drafts with preview; 3.13 Prompt publication and exact
version binding to Agents; 3.14 MCP prompts; 3.15 Prompt import/export;
- 3.16 composite Prompts with published Resources (dependency content scan plus
dynamic read through the accepted 3.11 runtime, admin preview and MCP prompts/get);
- 3.17 bounded MCP completion suggestions from typed published schemas and the
resources/list admission fix for bound template publications.
Accepted evidence being reused (unchanged code paths)
- 3.16 candidate: core 7, admin-api 22, registry 4, mcp-server 4, UI 6; one final
`just verify` run 1651 passed / 0 failed / 2 ignored.
- 3.17 candidate: full run 1672 passed / 0 failed / 2 ignored, QA targeted reruns and
a real MCP Inspector 2.12.0 client smoke.
Delivery engineering in this commit
- CI: one event per change (feature branches are gated by their pull request, push
runs only on main), story events run the changed packages, the full workspace suite
stays the feature/release gate; no cache/sharding without a measured runner check.
- Release: the packaged archives, checksums and SBOM are now uploaded to the Gitea
release entry of the tag instead of dying with the runner workspace.
Not included on purpose: Story 3.18 work, build caches, runtime databases, local
credentials and scratch evidence.
Refs: crank kanban t_e39d7263; baseline 1b6db09bd1.
474 lines
17 KiB
Rust
474 lines
17 KiB
Rust
//! AT-3.10-06 (AC6) + F2/F3 — immutable publication с точным source snapshot,
|
||
//! запрет host/scheme injection на definition boundary и definition-only
|
||
//! boundaries для export/content/import/preview.
|
||
//!
|
||
//! Cache key и runtime-подстановка значений — 3.11; здесь проверяется только
|
||
//! definition boundary. RED-состояние: template Draft ещё не создаётся.
|
||
|
||
use super::super::helpers::sha256_hex;
|
||
use super::*;
|
||
use base64::{Engine as _, engine::general_purpose::STANDARD as BASE64};
|
||
|
||
fn text_metadata(uri: &str, name: &str) -> Value {
|
||
draft_metadata(uri, name, "text", "text/plain", "internal")
|
||
}
|
||
|
||
async fn read_body(client: &reqwest::Client, url: String) -> (StatusCode, String, Vec<u8>) {
|
||
let response = client
|
||
.get(url)
|
||
.send()
|
||
.await
|
||
.expect("read request must complete");
|
||
let status = response.status();
|
||
let bytes = response
|
||
.bytes()
|
||
.await
|
||
.map(|value| value.to_vec())
|
||
.unwrap_or_default();
|
||
let text = String::from_utf8_lossy(&bytes).into_owned();
|
||
(status, text, bytes)
|
||
}
|
||
|
||
#[tokio::test(flavor = "multi_thread")]
|
||
#[serial_test::serial]
|
||
async fn story310_at06_publication_pins_exact_source_and_host_scheme_injection() {
|
||
let (_registry, server, client, upstream) = spawn_stand("story310_at06_pin").await;
|
||
let canary = "super-secret-story310-static-header";
|
||
let secret_headers = json!({ "authorization": canary });
|
||
|
||
let first_payload = read_operation_payload(
|
||
"story310_at06_first",
|
||
&upstream,
|
||
read_safety(),
|
||
Value::Null,
|
||
secret_headers.clone(),
|
||
);
|
||
let first_id = create_operation(&client, &server, &first_payload).await;
|
||
publish_operation(&client, &server, &first_id).await;
|
||
let second_id =
|
||
published_read_operation(&client, &server, &upstream, "story310_at06_second").await;
|
||
|
||
let metadata = template_metadata(
|
||
"crank://story310/pin",
|
||
"story310_pin",
|
||
valid_source(&first_id),
|
||
);
|
||
let (status, text, created) = post_template_raw(&client, &server, &metadata).await;
|
||
assert_eq!(
|
||
status,
|
||
StatusCode::CREATED,
|
||
"template Draft create is the premise of pinning; observed {} body={text}",
|
||
error_signature(status, &created)
|
||
);
|
||
assert!(
|
||
!text.contains(canary),
|
||
"create must not expose static_headers: {text}"
|
||
);
|
||
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::OK,
|
||
"the first publication must succeed; observed {} body={text}",
|
||
error_signature(status, &published)
|
||
);
|
||
assert!(
|
||
!text.contains(canary),
|
||
"publish must not expose static_headers: {text}"
|
||
);
|
||
let published_at = draft_updated_at(&published["resource"]).to_string();
|
||
assert_eq!(
|
||
published["published_version"]["source"]["operation_id"],
|
||
json!(first_id)
|
||
);
|
||
assert_eq!(
|
||
published["published_version"]["source"]["operation_version"],
|
||
json!(1)
|
||
);
|
||
|
||
// PUT Draft на другую опубликованную операцию: published snapshot не меняется.
|
||
let mut update_metadata_value = text_metadata("crank://story310/pin", "story310_pin");
|
||
update_metadata_value["description"] = json!("pinned then retargeted");
|
||
update_metadata_value["expected_updated_at"] = json!(published_at);
|
||
update_metadata_value["source"] = valid_source(&second_id);
|
||
let (status, text, updated) =
|
||
put_template_raw(&client, &server, &resource_id, &update_metadata_value).await;
|
||
assert_eq!(
|
||
status,
|
||
StatusCode::OK,
|
||
"the Draft source is editable before the next publication; observed {} body={text}",
|
||
error_signature(status, &updated)
|
||
);
|
||
assert_eq!(updated["source"]["operation_id"], json!(second_id));
|
||
|
||
let (status, text, _) = read_body(
|
||
&client,
|
||
format!("{}/resources/{resource_id}/versions/1", server.as_ref()),
|
||
)
|
||
.await;
|
||
assert_eq!(
|
||
status,
|
||
StatusCode::OK,
|
||
"published v1 must stay readable: {text}"
|
||
);
|
||
let version: Value = serde_json::from_str(&text).expect("published version is json");
|
||
assert_eq!(
|
||
version["source"]["operation_id"],
|
||
json!(first_id),
|
||
"editing the Draft must not mutate the published source snapshot: {version}"
|
||
);
|
||
assert!(
|
||
!text.contains(canary),
|
||
"published version must not expose static_headers: {text}"
|
||
);
|
||
|
||
// Повтор с устаревшим precondition — существующий 428, не новая публикация.
|
||
let (status, text, body) =
|
||
publish_raw(&client, &server, &resource_id, Some(published_at.as_str())).await;
|
||
assert_eq!(
|
||
status,
|
||
StatusCode::PRECONDITION_REQUIRED,
|
||
"a stale precondition must keep the existing lifecycle code; observed {} body={text}",
|
||
error_signature(status, &body)
|
||
);
|
||
assert_eq!(body["error"]["code"], json!("resource_stale"));
|
||
|
||
// Новая публикация пинит новый source, история версии 1 остаётся прежней.
|
||
let (status, text, second_publication) =
|
||
publish_with_card(&client, &server, &resource_id).await;
|
||
assert_eq!(
|
||
status,
|
||
StatusCode::OK,
|
||
"the retargeted Draft must publish as the next version; observed {} body={text}",
|
||
error_signature(status, &second_publication)
|
||
);
|
||
assert_eq!(
|
||
second_publication["published_version"]["source"]["operation_id"],
|
||
json!(second_id)
|
||
);
|
||
let (_, text_v1, _) = read_body(
|
||
&client,
|
||
format!("{}/resources/{resource_id}/versions/1", server.as_ref()),
|
||
)
|
||
.await;
|
||
let v1: Value = serde_json::from_str(&text_v1).expect("published version is json");
|
||
assert_eq!(v1["source"]["operation_id"], json!(first_id));
|
||
|
||
// Host/scheme injection внутри вложенных объектов source — definition boundary.
|
||
let injection_cases: Vec<(&str, Value)> = vec![
|
||
("parameter-url", {
|
||
let mut source = valid_source(&first_id);
|
||
source["parameters"][0]["url"] = json!("https://evil.example/{order_id}");
|
||
source
|
||
}),
|
||
("parameter-schema-host", {
|
||
let mut source = valid_source(&first_id);
|
||
source["parameters"][0]["schema"]["host"] = json!("evil.example");
|
||
source
|
||
}),
|
||
("cache-headers", {
|
||
let mut source = valid_source(&first_id);
|
||
source["cache"]["headers"] = json!({ "host": "evil.example" });
|
||
source
|
||
}),
|
||
("failure-url", {
|
||
let mut source = valid_source(&first_id);
|
||
source["failure"]["url"] = json!("https://evil.example/fallback");
|
||
source
|
||
}),
|
||
];
|
||
for (label, source) in injection_cases {
|
||
let metadata = template_metadata(
|
||
&format!("crank://story310/injection-{label}"),
|
||
&format!("story310_injection_{label}"),
|
||
source,
|
||
);
|
||
let (status, text, body) = post_template_raw(&client, &server, &metadata).await;
|
||
assert_eq!(
|
||
status,
|
||
StatusCode::BAD_REQUEST,
|
||
"nested injection `{label}` must be rejected; observed {} body={text}",
|
||
error_signature(status, &body)
|
||
);
|
||
assert_eq!(body["error"]["code"], json!("resource_source_invalid"));
|
||
assert!(!text.contains(canary));
|
||
}
|
||
}
|
||
|
||
#[tokio::test(flavor = "multi_thread")]
|
||
#[serial_test::serial]
|
||
async fn story310_at06_definition_only_boundaries_for_export_content_and_import() {
|
||
let (_registry, server, client, upstream) = spawn_stand("story310_at06_boundaries").await;
|
||
let read_id =
|
||
published_read_operation(&client, &server, &upstream, "story310_at06_export_read").await;
|
||
// Вторая операция публикуется как POST+write: публикация шаблона с ней блокируется.
|
||
let write_payload = order_operation_payload(
|
||
"story310_at06_blocked",
|
||
&upstream,
|
||
"POST",
|
||
json!({ "class": "write" }),
|
||
Value::Null,
|
||
Value::Null,
|
||
);
|
||
let blocked_id = create_operation(&client, &server, &write_payload).await;
|
||
publish_operation(&client, &server, &blocked_id).await;
|
||
|
||
// 1. Валидный шаблон: Draft export/content и Published export/content — 409.
|
||
let metadata = template_metadata(
|
||
"crank://story310/boundaries",
|
||
"story310_boundaries",
|
||
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();
|
||
for (label, url) in [
|
||
(
|
||
"draft-export",
|
||
format!("{}/resources/{resource_id}/export", server.as_ref()),
|
||
),
|
||
(
|
||
"draft-content",
|
||
format!("{}/resources/{resource_id}/content", server.as_ref()),
|
||
),
|
||
] {
|
||
let (status, text, _) = read_body(&client, url).await;
|
||
assert_eq!(
|
||
status,
|
||
StatusCode::CONFLICT,
|
||
"a source definition is not portable ({label}); observed {status} body={text}"
|
||
);
|
||
assert!(
|
||
text.contains("resource_source_not_portable"),
|
||
"the refusal must use the stable code ({label}): {text}"
|
||
);
|
||
assert!(
|
||
!text.contains(&read_id) && !text.contains("crank://orders/{order_id}"),
|
||
"the refusal must not leak the definition ({label}): {text}"
|
||
);
|
||
}
|
||
|
||
let (status, text, published) = publish_with_card(&client, &server, &resource_id).await;
|
||
assert_eq!(
|
||
status,
|
||
StatusCode::OK,
|
||
"the valid template must publish before version boundaries; observed {} body={text}",
|
||
error_signature(status, &published)
|
||
);
|
||
for (label, url) in [
|
||
(
|
||
"version-export",
|
||
format!(
|
||
"{}/resources/{resource_id}/versions/1/export",
|
||
server.as_ref()
|
||
),
|
||
),
|
||
(
|
||
"version-content",
|
||
format!(
|
||
"{}/resources/{resource_id}/versions/1/content",
|
||
server.as_ref()
|
||
),
|
||
),
|
||
] {
|
||
let (status, text, _) = read_body(&client, url).await;
|
||
assert_eq!(
|
||
status,
|
||
StatusCode::CONFLICT,
|
||
"the published source definition is not downloadable ({label}); observed {status} body={text}"
|
||
);
|
||
assert!(text.contains("resource_source_not_portable"));
|
||
assert!(
|
||
!text.contains(&read_id) && !text.contains("crank://orders/{order_id}"),
|
||
"the refusal must not leak the definition ({label}): {text}"
|
||
);
|
||
}
|
||
|
||
// 2. Блокированный шаблон: preview отдаёт findings и null text, без исполнения REST.
|
||
let blocked_metadata = template_metadata(
|
||
"crank://story310/boundaries-blocked",
|
||
"story310_boundaries_blocked",
|
||
valid_source(&blocked_id),
|
||
);
|
||
let blocked_created = create_template_draft(&client, &server, &blocked_metadata).await;
|
||
let blocked_resource = blocked_created["resource"]["resource_id"]
|
||
.as_str()
|
||
.expect("blocked template Draft id")
|
||
.to_owned();
|
||
let (status, text, preview) = read_preview(&client, &server, &blocked_resource).await;
|
||
assert_eq!(
|
||
status,
|
||
StatusCode::OK,
|
||
"preview of a blocked template must answer 200: {text}"
|
||
);
|
||
assert_has_code(
|
||
&preview_codes(&preview),
|
||
"resource_source_not_read_safe",
|
||
"blocked template preview",
|
||
);
|
||
assert_eq!(
|
||
preview["preview"]["text"],
|
||
Value::Null,
|
||
"a template preview never renders content: {preview}"
|
||
);
|
||
assert!(!text.contains("http://127.0.0.1"));
|
||
|
||
// 3. Import не принимает dynamic envelope (definition не переносится).
|
||
let bytes = b"story310 static portable body\n";
|
||
let envelope = json!({
|
||
"format": "crank-resource-portability",
|
||
"version": 1,
|
||
"resource": {
|
||
"uri": "crank://story310/imported",
|
||
"name": "story310_imported",
|
||
"description": "",
|
||
"kind": "text",
|
||
"mime_type": "text/plain",
|
||
"sensitivity": "internal"
|
||
},
|
||
"source": { "kind": "draft", "version": 1 },
|
||
"content": {
|
||
"size_bytes": bytes.len(),
|
||
"digest": sha256_hex(bytes),
|
||
"base64": BASE64.encode(bytes)
|
||
}
|
||
});
|
||
let mut dynamic_in_resource = envelope.clone();
|
||
dynamic_in_resource["resource"]["source"] = valid_source(&read_id);
|
||
let mut dynamic_source = envelope.clone();
|
||
dynamic_source["source"] = json!({
|
||
"kind": "published",
|
||
"version": 1,
|
||
"operation_id": read_id,
|
||
"uri_template": "crank://orders/{order_id}"
|
||
});
|
||
let (_, _, listed_before) = list_resources(&client, &server).await;
|
||
let before = listed_before["items"].as_array().map(Vec::len).unwrap_or(0);
|
||
for (label, payload) in [
|
||
("dynamic-in-resource", dynamic_in_resource),
|
||
("dynamic-source", dynamic_source),
|
||
] {
|
||
let (status, text, body) = read_response(
|
||
client
|
||
.post(format!("{}/resources/import", server.as_ref()))
|
||
.json(&payload)
|
||
.send()
|
||
.await
|
||
.expect("import request must complete"),
|
||
)
|
||
.await;
|
||
assert_eq!(
|
||
status,
|
||
StatusCode::BAD_REQUEST,
|
||
"a dynamic envelope must not import ({label}); observed {} body={text}",
|
||
error_signature(status, &body)
|
||
);
|
||
assert_eq!(
|
||
body["error"]["code"],
|
||
json!("resource_portability_envelope_invalid")
|
||
);
|
||
assert!(
|
||
!text.contains(&read_id) && !text.contains("crank://orders/{operation_id}"),
|
||
"the import refusal must not leak the definition ({label}): {text}"
|
||
);
|
||
}
|
||
let (_, _, listed_after) = list_resources(&client, &server).await;
|
||
assert_eq!(
|
||
listed_after["items"].as_array().map(Vec::len),
|
||
Some(before),
|
||
"rejected dynamic imports must not create Resources: {listed_after}"
|
||
);
|
||
|
||
// 4. Positive static controls: download/export/import/preview не изменились.
|
||
let static_metadata = text_metadata(
|
||
"crank://story310/boundaries-static",
|
||
"story310_boundaries_static",
|
||
);
|
||
let (status, _traceable, text, static_card) =
|
||
post_draft_raw(&client, &server, &static_metadata, bytes, "text/plain").await;
|
||
assert_eq!(
|
||
status,
|
||
StatusCode::CREATED,
|
||
"static create must stay intact; observed {} body={text}",
|
||
error_signature(status, &static_card)
|
||
);
|
||
let static_id = static_card["resource"]["resource_id"]
|
||
.as_str()
|
||
.expect("static Draft id")
|
||
.to_owned();
|
||
let (status, _, downloaded) = read_body(
|
||
&client,
|
||
format!("{}/resources/{static_id}/content", server.as_ref()),
|
||
)
|
||
.await;
|
||
assert_eq!(status, StatusCode::OK);
|
||
assert_eq!(
|
||
downloaded, bytes,
|
||
"static download must return the exact bytes"
|
||
);
|
||
let (status, text, _exported) = read_body(
|
||
&client,
|
||
format!("{}/resources/{static_id}/export", server.as_ref()),
|
||
)
|
||
.await;
|
||
assert_eq!(
|
||
status,
|
||
StatusCode::OK,
|
||
"static export must stay intact: {text}"
|
||
);
|
||
let exported: Value = serde_json::from_str(&text).expect("static export is json");
|
||
assert_eq!(exported["format"], json!("crank-resource-portability"));
|
||
assert_eq!(exported["source"]["kind"], json!("draft"));
|
||
|
||
let (status, text, static_preview) = read_preview(&client, &server, &static_id).await;
|
||
assert_eq!(
|
||
status,
|
||
StatusCode::OK,
|
||
"static preview must stay intact: {text}"
|
||
);
|
||
assert_eq!(
|
||
static_preview["preview"]["text"],
|
||
json!("story310 static portable body\n")
|
||
);
|
||
|
||
let import_payload = json!({
|
||
"format": "crank-resource-portability",
|
||
"version": 1,
|
||
"resource": {
|
||
"uri": "crank://story310/imported-static",
|
||
"name": "story310_imported_static",
|
||
"description": "",
|
||
"kind": "text",
|
||
"mime_type": "text/plain",
|
||
"sensitivity": "internal"
|
||
},
|
||
"source": { "kind": "draft", "version": 1 },
|
||
"content": {
|
||
"size_bytes": bytes.len(),
|
||
"digest": sha256_hex(bytes),
|
||
"base64": BASE64.encode(bytes)
|
||
}
|
||
});
|
||
let (status, text, imported) = read_response(
|
||
client
|
||
.post(format!("{}/resources/import", server.as_ref()))
|
||
.json(&import_payload)
|
||
.send()
|
||
.await
|
||
.expect("static import must complete"),
|
||
)
|
||
.await;
|
||
assert_eq!(
|
||
status,
|
||
StatusCode::CREATED,
|
||
"static import must stay intact; observed {} body={text}",
|
||
error_signature(status, &imported)
|
||
);
|
||
}
|