Files
crank/apps/admin-api/tests/integration/resources/template_outbound.rs
bsodfather 54ce770682
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
feat(epic3): deliver the accepted Epic 3 scope through Story 3.17
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.
2026-10-25 09:08:22 +00:00

524 lines
18 KiB
Rust

//! AT-3.10 / TL amendment D: create/preview/publish шаблона не делают исходящих
//! вызовов. Оракул — task-owned счётчик на собственном upstream: положительный
//! контроль (прямой запрос к тому же серверу) доказывает, что счётчик реально
//! видит трафик, а не всегда показывает ноль.
use std::sync::{
Arc,
atomic::{AtomicUsize, Ordering},
};
use axum::{Router, extract::Path, routing::get};
use tokio::net::TcpListener;
use super::*;
async fn spawn_counting_upstream() -> (String, Arc<AtomicUsize>) {
let counter = Arc::new(AtomicUsize::new(0));
let state = Arc::clone(&counter);
let fallback_state = Arc::clone(&counter);
let app = Router::new()
.route(
"/orders/{order_id}",
get(move |Path(order_id): Path<String>| {
let state = Arc::clone(&state);
async move {
state.fetch_add(1, Ordering::SeqCst);
axum::Json(json!({ "id": order_id }))
}
}),
)
.fallback(axum::routing::any(move |uri: axum::http::Uri| {
let state = Arc::clone(&fallback_state);
async move {
state.fetch_add(1, Ordering::SeqCst);
(StatusCode::NOT_FOUND, uri.path().to_owned())
}
}));
let listener = TcpListener::bind("127.0.0.1:0")
.await
.expect("upstream bind");
let address = listener.local_addr().expect("upstream address");
tokio::spawn(async move {
axum::serve(listener, app)
.await
.expect("upstream must serve");
});
(format!("http://{address}"), counter)
}
#[tokio::test(flavor = "multi_thread")]
#[serial_test::serial]
async fn story311_admin_test_read_runs_only_after_explicit_confirmation_request() {
let (registry, server, client, _unused_upstream) = spawn_stand("story311_test_read").await;
let (upstream, counter) = spawn_counting_upstream().await;
let mut operation = read_operation_payload(
"story311_read",
&upstream,
read_safety(),
Value::Null,
Value::Null,
);
operation["input_schema"]["fields"]["order_id"] = json!({ "type": "string", "required": true });
let operation_id = create_operation(&client, &server, &operation).await;
publish_operation(&client, &server, &operation_id).await;
let mut plain_string_source = valid_source(&operation_id);
plain_string_source["parameters"][0]["schema"] = json!({ "type": "string", "required": true });
let mut metadata = template_metadata(
"crank://story311/orders",
"story311_orders",
plain_string_source.clone(),
);
metadata["kind"] = json!("json");
metadata["mime_type"] = json!("application/json");
let created = create_template_draft(&client, &server, &metadata).await;
assert_eq!(
counter.load(Ordering::SeqCst),
0,
"creation must remain no-outbound"
);
let resource_id = created["resource"]["resource_id"].as_str().unwrap();
let expected = json!({
"version": created["version"]["version"],
"digest": created["version"]["digest"],
"updated_at": created["resource"]["updated_at"],
"parameters": { "order_id": "order-1" }
});
let invalid = json!({
"version": expected["version"],
"digest": expected["digest"],
"updated_at": expected["updated_at"],
"parameters": { "order_id": 17 }
});
let (invalid_status, _, _) = read_response(
client
.post(format!(
"{}/resources/{resource_id}/test-runs",
server.as_ref()
))
.json(&invalid)
.send()
.await
.expect("invalid Resource parameter must be rejected"),
)
.await;
assert!(
matches!(
invalid_status,
StatusCode::BAD_REQUEST | StatusCode::UNPROCESSABLE_ENTITY
),
"invalid Resource parameter must be rejected: {invalid_status}"
);
assert_eq!(
counter.load(Ordering::SeqCst),
0,
"invalid Resource schema must be rejected before outbound"
);
for dot_segment in [".", ".."] {
let mut traversal = expected.clone();
traversal["parameters"]["order_id"] = json!(dot_segment);
let (traversal_status, traversal_text, traversal_result) = read_response(
client
.post(format!(
"{}/resources/{resource_id}/test-runs",
server.as_ref()
))
.json(&traversal)
.send()
.await
.expect("dot-segment test-read must be rejected"),
)
.await;
assert_eq!(
traversal_status,
StatusCode::OK,
"runtime path rejection is returned as a test-run result: {traversal_status} {traversal_text}"
);
assert_eq!(
traversal_result["ok"],
json!(false),
"dot-segment must fail during outbound request preparation: {traversal_text}"
);
assert_eq!(
traversal_result["error"]["code"],
json!("prepared_request_invalid")
);
assert_eq!(
counter.load(Ordering::SeqCst),
0,
"dot-segment rejection must happen before any upstream request"
);
}
let (status, text, result) = read_response(
client
.post(format!(
"{}/resources/{resource_id}/test-runs",
server.as_ref()
))
.json(&expected)
.send()
.await
.expect("admin test-read request completes"),
)
.await;
assert_eq!(
status,
StatusCode::OK,
"explicit test-read should run: {text}"
);
assert_eq!(
result["ok"],
json!(true),
"the pinned GET should succeed: {result}"
);
assert_eq!(result["output"]["id"], json!("order-1"));
assert_eq!(
counter.load(Ordering::SeqCst),
1,
"only explicit test-read may call upstream"
);
let encoded_output = serde_json::to_vec(&json!({
"id": "order-1"
}))
.expect("the positive JSON representation is serializable");
let mut boundary_metadata = template_metadata(
"crank://story311/orders-boundary",
"story311_orders_boundary",
plain_string_source.clone(),
);
boundary_metadata["kind"] = json!("json");
boundary_metadata["mime_type"] = json!("application/json");
boundary_metadata["source"]["cache"]["max_bytes"] = json!(encoded_output.len());
let boundary = create_template_draft(&client, &server, &boundary_metadata).await;
let boundary_resource_id = boundary["resource"]["resource_id"].as_str().unwrap();
let boundary_expected = json!({
"version": boundary["version"]["version"],
"digest": boundary["version"]["digest"],
"updated_at": boundary["resource"]["updated_at"],
"parameters": { "order_id": "order-1" }
});
let (boundary_status, boundary_text, _) = read_response(
client
.post(format!(
"{}/resources/{boundary_resource_id}/test-runs",
server.as_ref()
))
.json(&boundary_expected)
.send()
.await
.expect("exact maximum-size JSON response completes"),
)
.await;
assert_eq!(
boundary_status,
StatusCode::OK,
"JSON representation exactly at max_bytes must succeed: {boundary_text}"
);
assert_eq!(counter.load(Ordering::SeqCst), 2);
let mut too_small_metadata = boundary_metadata.clone();
too_small_metadata["uri"] = json!("crank://story311/orders-oversize");
too_small_metadata["name"] = json!("story311_orders_oversize");
too_small_metadata["source"]["cache"]["max_bytes"] = json!(encoded_output.len() - 1);
let too_small = create_template_draft(&client, &server, &too_small_metadata).await;
let too_small_id = too_small["resource"]["resource_id"].as_str().unwrap();
let too_small_expected = json!({
"version": too_small["version"]["version"],
"digest": too_small["version"]["digest"],
"updated_at": too_small["resource"]["updated_at"],
"parameters": { "order_id": "order-1" }
});
let (oversize_status, oversize_text, _) = read_response(
client
.post(format!(
"{}/resources/{too_small_id}/test-runs",
server.as_ref()
))
.json(&too_small_expected)
.send()
.await
.expect("oversize test-read response completes"),
)
.await;
assert_eq!(
oversize_status,
StatusCode::UNPROCESSABLE_ENTITY,
"a JSON representation larger than max_bytes must fail: {oversize_text}"
);
assert_eq!(counter.load(Ordering::SeqCst), 3);
let mut text_metadata = template_metadata(
"crank://story311/orders-text-mismatch",
"story311_orders_text_mismatch",
plain_string_source.clone(),
);
text_metadata["kind"] = json!("text");
text_metadata["mime_type"] = json!("text/plain");
let text_resource = create_template_draft(&client, &server, &text_metadata).await;
let text_resource_id = text_resource["resource"]["resource_id"].as_str().unwrap();
let text_expected = json!({
"version": text_resource["version"]["version"],
"digest": text_resource["version"]["digest"],
"updated_at": text_resource["resource"]["updated_at"],
"parameters": { "order_id": "order-1" }
});
let (text_status, text_error, _) = read_response(
client
.post(format!(
"{}/resources/{text_resource_id}/test-runs",
server.as_ref()
))
.json(&text_expected)
.send()
.await
.expect("text-vs-object test-read completes"),
)
.await;
assert_eq!(
text_status,
StatusCode::UNPROCESSABLE_ENTITY,
"text Resource must reject object output: {text_error}"
);
assert_eq!(counter.load(Ordering::SeqCst), 4);
let invocation_count: i64 = sqlx::query_scalar(
"select count(*) from invocation_logs where request_id = $1 and source = 'admin_test_run' and agent_id is null",
)
.bind(result["request_id"].as_str().expect("request id"))
.fetch_one(registry.pool())
.await
.expect("admin test-read invocation must be recorded without an Agent identity");
assert_eq!(
invocation_count, 1,
"test-read must persist its admin-scoped invocation"
);
let mut forged = expected.clone();
forged["origin"] = json!("AgentSnapshot");
let (status, _, _) = read_response(
client
.post(format!(
"{}/resources/{resource_id}/test-runs",
server.as_ref()
))
.json(&forged)
.send()
.await
.expect("forged request completes"),
)
.await;
assert_eq!(
status,
StatusCode::BAD_REQUEST,
"client cannot choose execution origin"
);
assert_eq!(
counter.load(Ordering::SeqCst),
4,
"rejected origin must not dispatch"
);
let mut stale = expected.clone();
stale["digest"] = json!("0".repeat(64));
let (status, _, _) = read_response(
client
.post(format!(
"{}/resources/{resource_id}/test-runs",
server.as_ref()
))
.json(&stale)
.send()
.await
.expect("stale request completes"),
)
.await;
assert_eq!(
status,
StatusCode::CONFLICT,
"stale identity must fail before dispatch"
);
assert_eq!(
counter.load(Ordering::SeqCst),
4,
"stale identity must not dispatch"
);
let revoke = client
.post(format!(
"{}/resources/{resource_id}/revoke",
server.as_ref()
))
.send()
.await
.expect("resource revoke completes");
assert_eq!(revoke.status(), StatusCode::NO_CONTENT);
let (status, _, _) = read_response(
client
.post(format!(
"{}/resources/{resource_id}/test-runs",
server.as_ref()
))
.json(&expected)
.send()
.await
.expect("revoked request completes"),
)
.await;
assert_ne!(status, StatusCode::OK, "revoked Resource must be denied");
assert_eq!(
counter.load(Ordering::SeqCst),
4,
"revoked Resource must be rejected before dispatch"
);
}
#[tokio::test(flavor = "multi_thread")]
#[serial_test::serial]
async fn story311_upstream_counter_observes_root_and_collection_paths() {
let (upstream, counter) = spawn_counting_upstream().await;
for (path, expected_count) in [("/", 1), ("/orders/", 2)] {
let response = reqwest::get(format!("{upstream}{path}"))
.await
.expect("fallback positive control completes");
assert_eq!(response.status(), StatusCode::NOT_FOUND);
assert_eq!(
counter.load(Ordering::SeqCst),
expected_count,
"counter must observe {path}"
);
}
}
#[tokio::test(flavor = "multi_thread")]
#[serial_test::serial]
async fn story311_resource_enum_rejects_value_allowed_by_published_operation() {
let (_registry, server, client, _unused_upstream) = spawn_stand("story311_enum").await;
let (upstream, counter) = spawn_counting_upstream().await;
let first = "11111111-1111-4111-8111-111111111111";
let second = "22222222-2222-4222-8222-222222222222";
let mut operation = read_operation_payload(
"story311_enum_read",
&upstream,
read_safety(),
Value::Null,
Value::Null,
);
operation["input_schema"]["fields"]["order_id"] = json!({ "type": "string", "required": true, "format": "uuid", "enum_values": [first, second] });
let operation_id = create_operation(&client, &server, &operation).await;
publish_operation(&client, &server, &operation_id).await;
let mut source = valid_source(&operation_id);
source["parameters"][0]["schema"] =
json!({ "type": "string", "required": true, "format": "uuid", "enum_values": [first] });
let created = create_template_draft(
&client,
&server,
&template_metadata("crank://story311/enum", "story311_enum", source),
)
.await;
let resource_id = created["resource"]["resource_id"].as_str().unwrap();
let (publish_status, publish_text, _) = publish_with_card(&client, &server, resource_id).await;
assert_eq!(
publish_status,
StatusCode::OK,
"enum fixture must publish: {publish_text}"
);
let published = get_card(&client, &server, resource_id).await;
let request = json!({
"version": published["version"]["version"],
"digest": published["version"]["digest"],
"updated_at": published["resource"]["updated_at"],
"parameters": { "order_id": second }
});
let (status, text, _) = read_response(
client
.post(format!(
"{}/resources/{resource_id}/test-runs",
server.as_ref()
))
.json(&request)
.send()
.await
.expect("enum mismatch request completes"),
)
.await;
assert!(
matches!(
status,
StatusCode::BAD_REQUEST | StatusCode::UNPROCESSABLE_ENTITY
),
"Resource enum must reject value allowed by Operation: {status} {text}"
);
assert_eq!(
counter.load(Ordering::SeqCst),
0,
"enum rejection must precede dispatch"
);
}
#[tokio::test(flavor = "multi_thread")]
#[serial_test::serial]
async fn story310_at00_create_preview_publish_make_no_outbound_call() {
let (_registry, server, client, _unused_upstream) = spawn_stand("story310_outbound").await;
let (upstream, counter) = spawn_counting_upstream().await;
let payload = order_operation_payload(
"story310_outbound_read",
&upstream,
"GET",
read_safety(),
Value::Null,
Value::Null,
);
let operation_id = create_operation(&client, &server, &payload).await;
publish_operation(&client, &server, &operation_id).await;
assert_eq!(
counter.load(Ordering::SeqCst),
0,
"operation publish itself is not a read"
);
// create → preview → publish шаблона — чисто definition operations.
let metadata = template_metadata(
"crank://story310/outbound",
"story310_outbound",
valid_source(&operation_id),
);
let created = create_template_draft(&client, &server, &metadata).await;
assert_eq!(
counter.load(Ordering::SeqCst),
0,
"create must not call upstream"
);
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 succeed: {text}");
assert_eq!(
counter.load(Ordering::SeqCst),
0,
"preview must not call upstream"
);
let (status, text, _) = publish_with_card(&client, &server, &resource_id).await;
assert_eq!(status, StatusCode::OK, "publish must succeed: {text}");
assert_eq!(
counter.load(Ordering::SeqCst),
0,
"publish must not call upstream"
);
// Positive control: тот же счётчик замечает прямой запрос к upstream.
let direct = reqwest::get(format!("{upstream}/orders/order-1"))
.await
.expect("direct control request must complete");
assert_eq!(direct.status(), StatusCode::OK);
assert_eq!(
counter.load(Ordering::SeqCst),
1,
"the counter must observe a direct request"
);
}