//! 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) { 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| { 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" ); }