//! Story 3.6 · AT-3.6-08 · phase A (ATDD, test-only) — реальные HTTP-метрики Resource. //! //! Отдельный тест-бинарь (фикстура F7'): общий `integration`-бинарь уже держит //! глобальные `DebuggingRecorder`/tracing dispatcher, второй глобальный install в //! том же процессе падает. Здесь свой процесс, свой рекордер и свой //! `#[path = "integration/common.rs"] mod common;` — прецедент `product_metrics.rs`. //! //! Содержимое фазы A: только A-селекторы (`TD-H1..H6`, `TD-H7b`, `TD-H7c`, `TD-H8`) //! на существующем API. Binding/family-gate/per-process projections добавляются в //! этот же таргет только build-карточкой, когда появится их API. //! //! `DebuggingRecorder::snapshot()` — **дренирующий** дельта-снимок //! (`metrics-util::debugging`: counter.swap(0), histogram.clear): снимок отдаёт //! ровно то, что записано с момента предыдущего. Поэтому окно измерения — //! «drain → запрос → drain», и второй снимок является точной дельтой запроса. //! //! Общие хелперы, типы и фикстуры вынесены в подмодуль `support` (тот же //! таргет, без второго Cargo-таргета); восемь AT-08-селекторов остаются здесь. #[path = "integration/common.rs"] mod common; #[path = "resource_metrics_http/support.rs"] mod support; use common::*; use crank_metrics::DURATION_BUCKETS_SECONDS; use reqwest::{Method, StatusCode}; use serde_json::json; use serial_test::serial; use support::*; // --------------------------------------------------------------------------- // TD-H1 — коллекция: POST /resources (создание) // --------------------------------------------------------------------------- #[tokio::test(flavor = "multi_thread")] #[serial] async fn story36_at08_metrics_resource_collection() { let (server, client) = spawn_stack("story36_metrics_collection").await; let _ = drain(); let metadata = draft_metadata("crank://metrics/collection", "metrics_collection"); let response = client .post(format!("{server}/resources")) .multipart(draft_form(&metadata, b"collection payload canary_9f3a")) .send() .await .expect("create request must complete"); let status = response.status(); let class = status_class(status); let delta = drain_delta(); assert_eq!( status, StatusCode::CREATED, "TD-H1: POST /resources обязан создать Draft" ); assert_exact_request_delta( &delta, RESOURCE_COLLECTION, "POST", &class, 1, "TD-H1 POST /resources", ); assert_eq!( delta.counter(RESOURCE_COLLECTION, "POST", "2xx"), 1, "TD-H1: создание обязано попасть в 2xx" ); assert_no_raw_tokens( &delta, &[ "crank://metrics/collection", "collection payload", "canary_9f3a", ], "TD-H1", ); } // --------------------------------------------------------------------------- // TD-H2 — коллекция: GET /resources (список) // --------------------------------------------------------------------------- #[tokio::test(flavor = "multi_thread")] #[serial] async fn story36_at08_metrics_resource_list() { let (server, client) = spawn_stack("story36_metrics_list").await; let _ = drain(); let response = client .get(format!("{server}/resources")) .send() .await .expect("list request must complete"); let status = response.status(); let class = status_class(status); let delta = drain_delta(); assert_eq!(status, StatusCode::OK, "TD-H2: список обязан отвечать 200"); assert_exact_request_delta( &delta, RESOURCE_COLLECTION, "GET", &class, 1, "TD-H2 GET /resources", ); } // --------------------------------------------------------------------------- // TD-H3 — item: GET /resources/{resource_id} // --------------------------------------------------------------------------- #[tokio::test(flavor = "multi_thread")] #[serial] async fn story36_at08_metrics_resource_item_get() { let (server, client) = spawn_stack("story36_metrics_item_get").await; let resource_id = create_draft( &client, &server, "crank://metrics/item-get", "metrics_item_get", b"payload", ) .await; let _ = drain(); let response = client .get(format!("{server}/resources/{resource_id}")) .send() .await .expect("item request must complete"); let status = response.status(); let class = status_class(status); let delta = drain_delta(); assert_eq!( status, StatusCode::OK, "TD-H3: карточка обязана отвечать 200" ); assert_exact_request_delta( &delta, RESOURCE_ITEM, "GET", &class, 1, "TD-H3 GET /resources/{resource_id}", ); assert_no_raw_tokens(&delta, &[resource_id.as_str()], "TD-H3"); } // --------------------------------------------------------------------------- // TD-H4 — item: PUT /resources/{resource_id} // --------------------------------------------------------------------------- #[tokio::test(flavor = "multi_thread")] #[serial] async fn story36_at08_metrics_resource_item_put() { let (server, client) = spawn_stack("story36_metrics_item_put").await; let resource_id = create_draft( &client, &server, "crank://metrics/item-put", "metrics_item_put", b"first body", ) .await; let card = get_card(&client, &server, &resource_id).await; let precondition = updated_at(&card); let update = json!({ "description": "updated by TD-H4", "mime_type": "text/plain", "sensitivity": "internal", "expected_updated_at": precondition, }); let _ = drain(); let response = client .put(format!("{server}/resources/{resource_id}")) .multipart(draft_form(&update, b"second body")) .send() .await .expect("update request must complete"); let status = response.status(); let class = status_class(status); let delta = drain_delta(); assert!( status.is_success(), "TD-H4: PUT со свежим precondition обязан успешно обновить Draft; observed {status}" ); assert_exact_request_delta( &delta, RESOURCE_ITEM, "PUT", &class, 1, "TD-H4 PUT /resources/{resource_id}", ); assert_no_raw_tokens( &delta, &[resource_id.as_str(), precondition.as_str()], "TD-H4", ); } // --------------------------------------------------------------------------- // TD-H5 — preview и content: два разных точных route // --------------------------------------------------------------------------- #[tokio::test(flavor = "multi_thread")] #[serial] async fn story36_at08_metrics_resource_preview_and_content() { let (server, client) = spawn_stack("story36_metrics_preview_content").await; let content = b"preview content body"; let resource_id = create_draft( &client, &server, "crank://metrics/preview-content", "metrics_preview_content", content, ) .await; let _ = drain(); let preview = client .get(format!("{server}/resources/{resource_id}/preview")) .send() .await .expect("preview request must complete"); let preview_status = preview.status(); let preview_delta = drain_delta(); let _ = drain(); let download = client .get(format!("{server}/resources/{resource_id}/content")) .send() .await .expect("content request must complete"); let download_status = download.status(); let download_bytes = download.bytes().await.expect("content bytes").to_vec(); let download_delta = drain_delta(); // Все наблюдения собраны до первого assertion: RED обязан показать состояние // **обоих** route, а не только первого. let mut failures = Vec::new(); if preview_status != StatusCode::OK { failures.push(format!( "TD-H5 preview: ожидался 200, observed {preview_status}" )); } if download_status != StatusCode::OK { failures.push(format!( "TD-H5 content: ожидался 200, observed {download_status}" )); } if download_bytes != content.to_vec() { failures.push(format!( "TD-H5 content: ожидались байты текущей версии, observed {} bytes", download_bytes.len() )); } for (label, delta, route, status) in [ ( "TD-H5 GET …/preview", &preview_delta, RESOURCE_PREVIEW, preview_status, ), ( "TD-H5 GET …/content", &download_delta, RESOURCE_CONTENT, download_status, ), ] { let class = status_class(status); if let Err(message) = check_exact_request_delta(delta, route, "GET", &class, 1, label) { failures.push(message); } // Ни один concrete id не становится значением label. if let Err(message) = check_no_raw_tokens( delta, &[resource_id.as_str(), "preview content body"], label, ) { failures.push(message); } } assert!( failures.is_empty(), "TD-H5: точные route preview/content не подтверждены:\n{}", failures.join("\n") ); } // --------------------------------------------------------------------------- // TD-H6 — отказы сохраняют точный template и status_class // --------------------------------------------------------------------------- #[tokio::test(flavor = "multi_thread")] #[serial] async fn story36_at08_metrics_resource_refusals_keep_exact_route() { prime_metrics_fixture(); let registry = test_registry().await; create_foreign_workspace(®istry).await; let app = build_test_app(registry, test_storage_root("story36_metrics_refusals")); let server = spawn_admin_api(app).await; let client = authorized_client(&server).await; let root = api_root(server.as_ref()); struct Refusal { label: &'static str, route: &'static str, method: &'static str, status: StatusCode, expected: StatusCode, delta: Delta, } let mut refusals: Vec = Vec::new(); // (1) anonymous → клиентский отказ на точном collection-template let anonymous = reqwest::Client::new(); let _ = drain(); let status = anonymous .get(format!("{server}/resources")) .send() .await .expect("anonymous request must complete") .status(); refusals.push(Refusal { label: "anonymous GET /resources", route: RESOURCE_COLLECTION, method: "GET", status, expected: StatusCode::UNAUTHORIZED, delta: drain_delta(), }); // (2) foreign workspace без membership → клиентский отказ на том же template let _ = drain(); let status = client .get(format!( "{root}/api/admin/workspaces/{FOREIGN_WORKSPACE_ID}/resources" )) .send() .await .expect("foreign workspace request must complete") .status(); refusals.push(Refusal { label: "foreign workspace GET /resources", route: RESOURCE_COLLECTION, method: "GET", status, expected: StatusCode::FORBIDDEN, delta: drain_delta(), }); // (3) malformed metadata → клиентский отказ на точном template let malformed = json!({ "uri": "crank://a", "name": "metrics_malformed", "description": "", "kind": "text", "mime_type": "text/plain", "sensitivity": "internal", }); let _ = drain(); let status = client .post(format!("{server}/resources")) .multipart(draft_form(&malformed, b"payload")) .send() .await .expect("malformed request must complete") .status(); refusals.push(Refusal { label: "malformed POST /resources", route: RESOURCE_COLLECTION, method: "POST", status, expected: StatusCode::BAD_REQUEST, delta: drain_delta(), }); // (4) duplicate uri → клиентский отказ (409) на точном template create_draft( &client, &server, "crank://metrics/duplicate", "metrics_duplicate", b"payload", ) .await; let _ = drain(); let status = client .post(format!("{server}/resources")) .multipart(draft_form( &draft_metadata("crank://metrics/duplicate", "metrics_duplicate_two"), b"payload", )) .send() .await .expect("duplicate request must complete") .status(); refusals.push(Refusal { label: "duplicate POST /resources", route: RESOURCE_COLLECTION, method: "POST", status, expected: StatusCode::CONFLICT, delta: drain_delta(), }); // (5) oversized content → клиентский отказ (413) на точном template let oversized = vec![b'a'; CONTENT_TOO_LARGE]; let _ = drain(); let status = client .post(format!("{server}/resources")) .multipart(draft_form( &draft_metadata("crank://metrics/oversized", "metrics_oversized"), &oversized, )) .send() .await .expect("oversized request must complete") .status(); refusals.push(Refusal { label: "oversized POST /resources", route: RESOURCE_COLLECTION, method: "POST", status, expected: StatusCode::PAYLOAD_TOO_LARGE, delta: drain_delta(), }); // (6) неизвестный resource_id → клиентский отказ на точном item-template let _ = drain(); let status = client .get(format!("{server}/resources/res_missing_story36_metrics")) .send() .await .expect("missing resource request must complete") .status(); refusals.push(Refusal { label: "missing GET /resources/{resource_id}", route: RESOURCE_ITEM, method: "GET", status, expected: StatusCode::NOT_FOUND, delta: drain_delta(), }); // Все отказы предъявлены до первого assertion: RED показывает состояние // каждого кейса, а не только первого. for case in &refusals { record_measurement( &format!( "td_h6_refusal_{}", case.label.replace([' ', '/', '{', '}'], "_") ), &format!( "status={}; observed={}", case.status, case.delta .counter_routes(case.method, &status_class(case.status)) ), ); } let mut failures = Vec::new(); for case in &refusals { if case.status != case.expected { failures.push(format!( "TD-H6 {}: ожидался точный отказ {}, observed {}", case.label, case.expected, case.status )); } let class = status_class(case.status); if let Err(message) = check_exact_request_delta( &case.delta, case.route, case.method, &class, 1, &format!("TD-H6 {}", case.label), ) { failures.push(message); } } if let Some(last) = refusals.last() && let Err(message) = check_no_raw_tokens( &last.delta, &["res_missing_story36_metrics"], "TD-H6 missing item", ) { failures.push(message); } assert_eq!( refusals .iter() .map(|case| case.status) .collect::>() .len(), 6, "TD-H6 обязан предъявить ровно шесть отказов" ); assert!( failures.is_empty(), "TD-H6: отказы обязаны сохранять точный template и status_class:\n{}", failures.join("\n") ); } // --------------------------------------------------------------------------- // TD-H7b — HEAD / 405 / known unsupported methods / unknown token OTHER // --------------------------------------------------------------------------- #[tokio::test(flavor = "multi_thread")] #[serial] async fn story36_at08_metrics_head_405_and_known_unsupported_methods() { let (server, client) = spawn_stack("story36_metrics_methods").await; // Все измерения предъявляются до первого assertion, поэтому RED показывает // состояние каждого метода, а не только первого. struct MethodCase { label: &'static str, status: StatusCode, delta: Delta, } // (i) HEAD на GET-only collection route: axum `get` обслуживает HEAD. let _ = drain(); let head_status = client .head(format!("{server}/resources")) .send() .await .expect("HEAD request must complete") .status(); let head_delta = drain_delta(); // (ii)-(iv) router-generated 405 на том же template: known-but-unsupported verb // сохраняет своё enum-значение, OTHER — только действительно неизвестный token. let mut method_cases: Vec = Vec::new(); for (label, request_method) in [ ("DELETE", Method::DELETE), ("OPTIONS", Method::OPTIONS), ("PATCH", Method::PATCH), ( "OTHER", Method::from_bytes(b"FOO").expect("extension method token"), ), ] { let _ = drain(); let status = client .request(request_method, format!("{server}/resources")) .send() .await .expect("405 request must complete") .status(); method_cases.push(MethodCase { label, status, delta: drain_delta(), }); } // (v) TD-H7c: однозначный замер MatchedPath на router-generated 405 — // известный **домену** route (`operations`). Ожидание не подменяется на // `unmatched` втихую: результат фиксируется как evidence. let _ = drain(); let domain_status = client .delete(format!("{server}/operations")) .send() .await .expect("domain 405 probe must complete") .status(); let domain_delta = drain_delta(); for case in &method_cases { let class = status_class(case.status); let route_label = case .delta .nonzero_counters() .first() .map(|series| series.route.clone()) .unwrap_or_default(); record_measurement( &format!("td_h7c_route_label_on_405_{}", case.label.to_lowercase()), &format!( "route_label={route_label}; status={}; observed={}", case.status, case.delta.counter_routes(case.label, &class) ), ); } let domain_route = domain_delta .nonzero_counters() .first() .map(|series| series.route.clone()) .unwrap_or_default(); record_measurement( "td_h7c_known_domain_route_label_on_405", &format!( "route_label={domain_route}; status={domain_status}; observed={}", domain_delta.counter_routes("DELETE", &status_class(domain_status)) ), ); record_measurement( "td_h7c_matched_path_present_on_router_405", if domain_route == OPERATIONS_ROUTE { "yes" } else { "no (route label is not the known domain template)" }, ); let mut failures = Vec::new(); if !head_status.is_success() { failures.push(format!( "TD-H7b(i) HEAD /resources: HEAD на GET-only route обязан обслуживаться, observed {head_status}" )); } else if let Err(message) = check_exact_request_delta( &head_delta, RESOURCE_COLLECTION, "HEAD", &status_class(head_status), 1, "TD-H7b(i) HEAD /resources", ) { failures.push(message); } for case in &method_cases { if case.status != StatusCode::METHOD_NOT_ALLOWED { failures.push(format!( "TD-H7b {} /resources: ожидался 405, observed {}", case.label, case.status )); } if let Err(message) = check_method_delta( &case.delta, case.label, &status_class(case.status), &format!("TD-H7b {} /resources", case.label), ) { failures.push(message); } } if domain_status != StatusCode::METHOD_NOT_ALLOWED { failures.push(format!( "TD-H7c DELETE /operations: ожидался 405, observed {domain_status}" )); } else if let Err(message) = check_method_delta( &domain_delta, "DELETE", &status_class(domain_status), "TD-H7c DELETE /operations", ) { failures.push(message); } assert!( failures.is_empty(), "TD-H7b/H7c: method identity и 405 не подтверждены:\n{}", failures.join("\n") ); } // --------------------------------------------------------------------------- // TD-H8 — routed concrete id/query сохраняют template, unknown URI → unmatched // --------------------------------------------------------------------------- #[tokio::test(flavor = "multi_thread")] #[serial] async fn story36_at08_metrics_routed_ids_keep_template_and_unknown_is_unmatched() { let (server, client) = spawn_stack("story36_metrics_routed_ids").await; let root = api_root(server.as_ref()); // Положительный контроль: auth-логин сохраняет свою известную identity. let login = Delta::from_samples(drain()); assert!( login .nonzero_counters() .contains(&counter_series(LOGIN_ROUTE, "POST", "2xx", 1)), "known route `/api/auth/login` обязан сохранять свою identity; observed {:#?}", login.nonzero_counters() ); // 100 разных concrete id + query по **одному** router template. let _ = drain(); let mut routed_statuses = Vec::new(); for index in 0..100_u32 { let status = client .get(format!( "{server}/resources/res_metrics_{index}?page={index}&filter=canary_{index}" )) .send() .await .expect("routed concrete id request must complete") .status(); routed_statuses.push(status); } let routed = Delta::from_samples(drain()); // 100 разных unknown URI → ровно одна `unmatched` series (серий не прибавляется). let _ = drain(); let mut unknown_statuses = Vec::new(); for index in 0..100_u32 { let status = client .get(format!( "{root}/unknown/customer_secret_{index}?probe={index}" )) .send() .await .expect("unknown uri request must complete") .status(); unknown_statuses.push(status); } let unknown = Delta::from_samples(drain()); // Оба batch'а предъявлены до assertion: RED показывает состояние обоих. let mut failures = Vec::new(); if let Some(status) = routed_statuses .iter() .find(|status| !status.is_client_error()) { failures.push(format!( "TD-H8 routed: несуществующий concrete id обязан дать клиентский отказ, observed {status}" )); } if let Some(status) = unknown_statuses .iter() .find(|status| **status != StatusCode::NOT_FOUND) { failures.push(format!( "TD-H8 unknown: неизвестный URI обязан быть 404, observed {status}" )); } if routed.nonzero_counters() != vec![counter_series(RESOURCE_ITEM, "GET", "4xx", 100)] { failures.push(format!( "TD-H8 routed: 100 concrete id обязаны дать ровно одну series route={RESOURCE_ITEM} method=GET status_class=4xx с delta 100; observed {:#?}", routed.nonzero_counters() )); } if routed.durations_for(RESOURCE_ITEM, "GET").len() != 100 { failures.push(format!( "TD-H8 routed: duration обязан получить ровно 100 наблюдений того же template, observed {}", routed.durations_for(RESOURCE_ITEM, "GET").len() )); } if unknown.nonzero_counters() != vec![counter_series(UNMATCHED, "GET", "4xx", 100)] { failures.push(format!( "TD-H8 unknown: 100 разных unknown URI обязаны схлопнуться в одну `{UNMATCHED}` series с delta 100; observed {:#?}", unknown.nonzero_counters() )); } if unknown.durations_for(UNMATCHED, "GET").len() != 100 { failures.push(format!( "TD-H8 unknown: duration unknown URI обязан идти в ту же `{UNMATCHED}` series, observed {}", unknown.durations_for(UNMATCHED, "GET").len() )); } if let Err(message) = check_no_raw_tokens( &routed, &["res_metrics_", "page=", "filter=", "canary_"], "TD-H8 routed ids", ) { failures.push(message); } if let Err(message) = check_no_raw_tokens( &unknown, &["customer_secret_", "probe="], "TD-H8 unknown uri", ) { failures.push(message); } for (label, delta) in [("routed", &routed), ("unknown", &unknown)] { for series in delta.nonzero_durations() { for sample in &series.samples { if !DURATION_BUCKETS_SECONDS.iter().any(|bound| sample <= bound) { failures.push(format!( "TD-H8 {label}: duration {sample}s обязана попасть в объявленный bucket" )); } } } } assert!( failures.is_empty(), "TD-H8: concrete id/query и unknown URI не подтверждены:\n{}", failures.join("\n") ); }