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.
524 lines
18 KiB
Rust
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"
|
|
);
|
|
}
|