Files
crank/apps/admin-api/tests/resource_metrics_http.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

800 lines
27 KiB
Rust
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! 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(&registry).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")
);
}