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.
800 lines
27 KiB
Rust
800 lines
27 KiB
Rust
//! 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<Refusal> = 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::<Vec<_>>()
|
||
.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<MethodCase> = 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")
|
||
);
|
||
}
|