Files
crank/apps/admin-api/src/app/resource_test_support.rs
T
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

961 lines
38 KiB
Rust
Raw 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.
//! AT-3.6-02/06: приватная `#[cfg(test)]` composition fixture для HTTP guard-путей Story 3.6.
//!
//! Источник полномочий: FINAL-DISPOSITION run99:47 (Q1) — принимается рекомендованный ARC
//! test-only composition fixture **вне** сервиса: точный путь
//! `apps/admin-api/src/app/resource_test_support.rs`, регистрация `#[cfg(test)] pub(crate)
//! mod resource_test_support;` в `app.rs`. TL review run101 R-A требует: fixture возвращает
//! готовый `PostgresRegistry`/изолированный router context (не raw pool в сервисе), а
//! драйвер/миграция/SQL-наблюдения состояния живут только здесь, в composition root.
//!
//! Модуль собирается исключительно для `cfg(test)`: в non-test сборке `admin-api` его нет
//! (регистрация в `app.rs` под тем же `cfg`), поэтому production API и boundary-проверки
//! не меняются. Пять исходных service-счётчиков `service::resources::tests` остаются
//! отдельным, неизменённым набором; этот файл даёт **реальный HTTP** поверх настоящих
//! middleware-ов (`require_session`, `require_workspace_session`,
//! `require_csrf_for_browser_mutations`, `enforce_browser_security`), поэтому отказ,
//! случившийся до сервиса, наблюдается как нулевые счётчики put/read физического хранилища.
//!
//! Проверки, которые опираются на этот fixture, лежат рядом с ним:
//! `crate::service::resources::tests::guard_path`.
#![allow(dead_code)]
use std::{
net::SocketAddr,
path::PathBuf,
sync::Arc,
time::{SystemTime, UNIX_EPOCH},
};
use axum::Router;
use crank_core::{MembershipRole, Workspace, WorkspaceId, WorkspaceStatus};
use crank_registry::{
CreateWorkspaceRequest, MASTER_KEY_CIPHER_CONTRACT, MasterKeyIdentityCandidate,
PostgresRegistry,
};
use crank_runtime::SecretCrypto;
use reqwest::StatusCode;
use reqwest::header::{HeaderMap, HeaderValue};
use reqwest::multipart::{Form, Part};
use serde_json::{Value, json};
use sqlx::Row as _;
use tokio::net::{TcpListener, TcpStream};
use crate::{
app::build_app,
auth::{AuthSettings, BootstrapAdminConfig, hash_password},
service::AdminServiceBuilder,
state::AppState,
};
pub(crate) const DEFAULT_WORKSPACE_ID: &str = "ws_default";
pub(crate) const OWNER_EMAIL: &str = "owner@crank.local";
pub(crate) const OWNER_PASSWORD: &str = "test-password";
/// Синтетическое WorkspaceB без членства вызывающего пользователя (workspace-негатив).
pub(crate) const FOREIGN_WORKSPACE_ID: &str = "ws_story36_guard_foreign";
/// Synthetic Viewer в `ws_default`: доступ на чтение есть, мутация запрещена (Owner-only).
pub(crate) const VIEWER_EMAIL: &str = "story36_guard_viewer@crank.local";
pub(crate) const VIEWER_PASSWORD: &str = "story36-guard-viewer-password";
/// Owner чужого WorkspaceB: создаёт и читает существующий ResourceB в своём workspace.
pub(crate) const FOREIGN_OWNER_EMAIL: &str = "story36_guard_foreign_owner@crank.local";
pub(crate) const FOREIGN_OWNER_PASSWORD: &str = "story36-guard-foreign-password";
const PASSWORD_PEPPER: &str = "test-password-pepper";
const SESSION_SECRET: &str = "test-session-secret";
const MASTER_KEY: &str = "test-master-key-00000000000000000000000000000000";
const FOREIGN_ORIGIN: &str = "http://evil.example.test";
const FOREIGN_HOST: &str = "evil.example.test";
/// Однофакторные вариации стенда: срок жизни сессии, Viewer-членство, чужое workspace,
/// настраиваемый предел содержимого.
#[derive(Clone, Copy, Debug)]
pub(crate) struct GuardOptions {
pub session_ttl_hours: i64,
pub viewer_membership: bool,
pub foreign_workspace: bool,
/// Owner-членство отдельного аккаунта в чужом WorkspaceB (существующий ResourceB).
pub foreign_workspace_owner: bool,
/// Настроенный предел содержимого Resource (`ResourceLimits::uniform`); `None` — default.
pub resource_limit: Option<usize>,
}
impl Default for GuardOptions {
fn default() -> Self {
Self {
session_ttl_hours: 24,
viewer_membership: false,
foreign_workspace: false,
foreign_workspace_owner: false,
resource_limit: None,
}
}
}
/// Изолированный стенд: собственная PG-схема на тест, приватный artifact root, реальный router.
pub(crate) struct GuardHarness {
pub registry: PostgresRegistry,
pub auth: AuthSettings,
/// Корень API без workspace-префикса — точка входа `/api/auth/login`.
pub root_url: String,
/// Workspace-scoped база `ws_default` — точка входа `/resources...`.
pub base_url: String,
/// Loopback-адрес стенда: нужен для настоящих фрагментированных HTTP-запросов
/// (chunked/absent Content-Length), которые нельзя выразить `reqwest`-клиентом.
pub addr: SocketAddr,
/// Приватный artifact root стенда: по нему проверяются физические отказы чтения.
pub storage_root: PathBuf,
shutdown: Option<tokio::sync::oneshot::Sender<()>>,
handle: Option<tokio::task::JoinHandle<()>>,
}
impl Drop for GuardHarness {
fn drop(&mut self) {
let shutdown = self.shutdown.take();
let handle = self.handle.take();
tokio::task::block_in_place(|| {
if let Some(shutdown) = shutdown {
let _ = shutdown.send(());
}
if let Some(handle) = handle {
let _ = tokio::runtime::Handle::current().block_on(handle);
}
});
}
}
impl GuardHarness {
/// Стенд по умолчанию: 24-часовые сессии, только Owner-членство, без чужого workspace.
pub(crate) async fn spawn(name: &str) -> Self {
Self::spawn_with(name, GuardOptions::default()).await
}
pub(crate) async fn spawn_with(name: &str, options: GuardOptions) -> Self {
let (database_url, pool) = resource_schema(&format!("story36_guard_{name}")).await;
crank_registry::MigrationAuthority::apply(&pool)
.await
.expect("real V16 migrations must apply to the isolated schema");
drop(pool);
let registry = PostgresRegistry::connect(&database_url)
.await
.expect("fixture registry must connect");
let secret_crypto = SecretCrypto::new(MASTER_KEY).expect("static master key must be valid");
registry
.verify_or_register_master_key_identity(MasterKeyIdentityCandidate {
epoch: secret_crypto.master_key_epoch(),
fingerprint: secret_crypto.master_key_fingerprint(),
cipher_contract: MASTER_KEY_CIPHER_CONTRACT,
observed_at: &time::OffsetDateTime::now_utc(),
})
.await
.expect("master key identity must be registered");
seed_owner(&registry).await;
if options.viewer_membership {
seed_viewer(&registry).await;
}
if options.foreign_workspace {
create_foreign_workspace(&registry).await;
}
if options.foreign_workspace_owner {
seed_foreign_owner(&registry).await;
}
let auth = AuthSettings {
session_secret: SESSION_SECRET.to_owned(),
password_pepper: PASSWORD_PEPPER.to_owned(),
session_ttl_hours: options.session_ttl_hours,
cookie_secure: false,
bootstrap_admin: BootstrapAdminConfig {
email: OWNER_EMAIL.to_owned(),
password: OWNER_PASSWORD.to_owned(),
display_name: "Story 3.6 Guard Owner".to_owned(),
},
};
let storage_root = private_storage_root(name);
let runtime = crank_runtime::community_with_outbound_policy(
crank_runtime::OutboundHttpPolicy::allowing_hosts(["127.0.0.1"]),
)
.build();
let mut builder = AdminServiceBuilder::new(
registry.clone(),
storage_root.clone(),
auth.clone(),
secret_crypto,
runtime,
);
if let Some(limit) = options.resource_limit {
builder = builder.with_resource_limits(
crank_core::resource::ResourceLimits::uniform(limit)
.expect("the configured test limit must stay inside the storage ceiling"),
);
}
let service = builder.build();
let app = build_app(AppState {
service,
api_rate_limiter: crank_runtime::RequestRateLimiter::new(
crank_runtime::RequestRateLimitConfig::new(10_000, 10_000)
.expect("static rate limit config"),
),
trusted_proxy_ips: Vec::new(),
});
let (root_url, base_url, addr, shutdown, handle) = serve(app).await;
Self {
registry,
auth,
root_url,
base_url,
addr,
storage_root,
shutdown: Some(shutdown),
handle: Some(handle),
}
}
/// Session-клиент реального synthetic-аккаунта без CSRF-заголовка.
pub(crate) async fn session_client(&self, email: &str, password: &str) -> reqwest::Client {
login_client(&self.root_url, email, password, LoginOptions::default()).await
}
/// Адрес workspace-сокращённого Resource-маршрута.
pub(crate) fn resources_url(&self) -> String {
format!("{}/resources", self.base_url)
}
pub(crate) fn resource_url(&self, resource_id: &str) -> String {
format!("{}/resources/{resource_id}", self.base_url)
}
pub(crate) fn nested_url(&self, resource_id: &str, suffix: &str) -> String {
format!("{}/resources/{resource_id}/{suffix}", self.base_url)
}
/// URL чужого workspace в том же router: доступ к маршруту есть, прав нет.
pub(crate) fn foreign_resources_url(&self) -> String {
let root = self
.base_url
.split("/api/admin/workspaces/")
.next()
.expect("workspace base url keeps the admin prefix");
format!("{root}/api/admin/workspaces/{FOREIGN_WORKSPACE_ID}/resources")
}
/// Принятые черновики `ws_default` через публичное чтение реестра (composition root).
pub(crate) async fn accepted_drafts(
&self,
) -> Vec<crank_registry::model::resource::ResourceDraftRecord> {
self.registry
.list_resource_drafts(DEFAULT_WORKSPACE_ID, 100)
.await
.expect("accepted drafts must be readable")
}
}
/// Параметры логина: наличие CSRF-заголовка и подменённый `Origin`/`Host`.
#[derive(Clone, Copy, Default)]
pub(crate) struct LoginOptions {
pub csrf: bool,
/// Явное значение заголовка `x-csrf-token` вместо настоящего токена сессии
/// (R-A: недостающий **и чужой** CSRF проверяются отдельно).
pub csrf_token: Option<&'static str>,
pub foreign_origin: bool,
/// `None` — валидный Origin реального адреса стенда (`http://127.0.0.1:<port>`).
pub origin: Option<&'static str>,
/// `Some(value)` — подменённый `Host`, с которым сравнивается `Origin`.
pub host: Option<&'static str>,
}
impl LoginOptions {
pub(crate) fn with_csrf() -> Self {
Self {
csrf: true,
..Self::default()
}
}
/// Тот же аккаунт, но с заведомо чужим значением CSRF-заголовка.
pub(crate) fn with_wrong_csrf() -> Self {
Self {
csrf: true,
csrf_token: Some("story36-not-the-session-token"),
..Self::default()
}
}
/// Cross-origin запрос: чужой `Origin` при настоящем `Host` стенда.
///
/// `Host` намеренно НЕ подменяется: иначе authority совпала бы с `Origin` и запрос
/// перестал бы быть cross-origin (проверка `enforce_browser_security`).
pub(crate) fn cross_origin() -> Self {
Self {
csrf: true,
origin: Some(FOREIGN_ORIGIN),
host: None,
..Self::default()
}
}
}
/// Логин реального аккаунта через `/api/auth/login` и сборка клиента с cookie jar.
pub(crate) async fn login_client(
root_url: &str,
email: &str,
password: &str,
options: LoginOptions,
) -> reqwest::Client {
let cookie_jar = Arc::new(reqwest::cookie::Jar::default());
let login_client = reqwest::Client::builder()
.cookie_provider(Arc::clone(&cookie_jar))
.build()
.expect("login client");
let response = login_client
.post(format!("{root_url}/api/auth/login"))
.json(&json!({ "email": email, "password": password }))
.send()
.await
.expect("login request must complete");
let status = response.status();
let body: Value = response.json().await.unwrap_or(Value::Null);
assert_eq!(
status,
StatusCode::OK,
"synthetic account `{email}` must log in: status={status} body={body}"
);
let mut headers = HeaderMap::new();
if options.csrf {
let token = match options.csrf_token {
Some(token) => token,
None => body["csrf_token"]
.as_str()
.expect("successful login must return csrf_token"),
};
headers.insert(
"x-csrf-token",
HeaderValue::from_str(token).expect("csrf header value"),
);
}
if let Some(origin) = options.origin {
headers.insert(
reqwest::header::ORIGIN,
HeaderValue::from_str(origin).expect("origin header value"),
);
}
if let Some(host) = options.host {
headers.insert(
reqwest::header::HOST,
HeaderValue::from_str(host).expect("host header value"),
);
}
reqwest::Client::builder()
.cookie_provider(cookie_jar)
.default_headers(headers)
.build()
.expect("session client")
}
/// Клиент без сессии (реальный anonymous HTTP-запрос через те же middleware).
pub(crate) fn anonymous_client() -> reqwest::Client {
reqwest::Client::builder()
.build()
.expect("anonymous client")
}
// ---------------------------------------------------------------------------
// Multipart Draft flow (та же форма, что у UI и integration-набора)
// ---------------------------------------------------------------------------
pub(crate) fn draft_metadata(
uri: &str,
name: &str,
kind: &str,
mime: &str,
sensitivity: &str,
) -> Value {
json!({
"uri": uri,
"name": name,
"description": "",
"kind": kind,
"mime_type": mime,
"sensitivity": sensitivity,
})
}
pub(crate) fn draft_form(metadata: &Value, content: &[u8], filename: &str, mime: &str) -> Form {
Form::new()
.part(
"metadata",
Part::bytes(serde_json::to_vec(metadata).expect("metadata must serialize"))
.file_name("metadata.json".to_owned())
.mime_str("application/json")
.expect("json part mime"),
)
.part(
"content",
Part::bytes(content.to_vec())
.file_name(filename.to_owned())
.mime_str(mime)
.expect("content part mime"),
)
}
/// Метаданные обновления Draft: изменяемые поля + precondition, без immutable-ключей (D-16).
pub(crate) fn update_metadata(
description: &str,
mime: &str,
sensitivity: &str,
expected_updated_at: &str,
) -> Value {
json!({
"description": description,
"mime_type": mime,
"sensitivity": sensitivity,
"expected_updated_at": expected_updated_at,
})
}
/// Значение precondition `expected_updated_at` из карточки Draft.
pub(crate) fn draft_updated_at(card: &Value) -> String {
card.pointer("/resource/updated_at")
.or_else(|| card.pointer("/version/updated_at"))
.and_then(Value::as_str)
.expect("a Draft card must expose the precondition timestamp")
.to_owned()
}
/// POST Draft: статус, наличие `x-trace-id`, текст тела, разобранный JSON.
pub(crate) async fn post_draft(
client: &reqwest::Client,
url: &str,
metadata: &Value,
content: &[u8],
mime: &str,
) -> (StatusCode, bool, String, Value) {
let response = client
.post(url)
.multipart(draft_form(metadata, content, "draft.bin", mime))
.send()
.await
.expect("draft POST must complete");
let status = response.status();
let traceable = response.headers().contains_key("x-trace-id");
let text = response.text().await.unwrap_or_default();
let body = serde_json::from_str::<Value>(&text).unwrap_or(Value::Null);
(status, traceable, text, body)
}
/// PUT Draft: статус, заголовки, текст тела, разобранный JSON.
pub(crate) async fn put_draft(
client: &reqwest::Client,
url: &str,
metadata: &Value,
content: &[u8],
mime: &str,
) -> (StatusCode, HeaderMap, String, Value) {
let response = client
.put(url)
.multipart(draft_form(metadata, content, "draft.bin", mime))
.send()
.await
.expect("draft PUT must complete");
let status = response.status();
let headers = response.headers().clone();
let text = response.text().await.unwrap_or_default();
let body = serde_json::from_str::<Value>(&text).unwrap_or(Value::Null);
(status, headers, text, body)
}
/// GET: статус, заголовки, текст тела, разобранный JSON.
pub(crate) async fn get_raw(
client: &reqwest::Client,
url: &str,
) -> (StatusCode, HeaderMap, String, Value) {
let response = client.get(url).send().await.expect("GET must complete");
let status = response.status();
let headers = response.headers().clone();
let text = response.text().await.unwrap_or_default();
let body = serde_json::from_str::<Value>(&text).unwrap_or(Value::Null);
(status, headers, text, body)
}
/// Полная подпись отказа: статус + стабильные `error.code`/`error.context.field`.
pub(crate) fn error_signature(status: StatusCode, body: &Value) -> String {
let code = body["error"]["code"].as_str().unwrap_or("<absent>");
let field = body["error"]["context"]["field"]
.as_str()
.unwrap_or("<absent>");
let message = body["error"]["message"].as_str().unwrap_or("<absent>");
format!("status={status} code={code} field={field} message={message}")
}
/// Идентификатор созданного Draft в ответе 201.
pub(crate) fn created_resource_id(body: &Value) -> String {
body["resource"]["resource_id"]
.as_str()
.or_else(|| body["resource"]["id"].as_str())
.expect("201 response must carry the created Resource identifier")
.to_owned()
}
// ---------------------------------------------------------------------------
// Сев аккаунтов и приватных корней
// ---------------------------------------------------------------------------
async fn seed_owner(registry: &PostgresRegistry) {
let password_hash = hash_password(OWNER_PASSWORD, PASSWORD_PEPPER).expect("owner hash");
let user_id = registry
.upsert_bootstrap_user(OWNER_EMAIL, "Story 3.6 Guard Owner", &password_hash)
.await
.expect("owner account");
registry
.ensure_membership(
&WorkspaceId::new(DEFAULT_WORKSPACE_ID),
&user_id,
MembershipRole::Owner,
)
.await
.expect("owner membership in ws_default");
}
async fn seed_viewer(registry: &PostgresRegistry) {
let password_hash = hash_password(VIEWER_PASSWORD, PASSWORD_PEPPER).expect("viewer hash");
let user_id = registry
.upsert_bootstrap_user(VIEWER_EMAIL, "Story 3.6 Guard Viewer", &password_hash)
.await
.expect("viewer account");
registry
.ensure_membership(
&WorkspaceId::new(DEFAULT_WORKSPACE_ID),
&user_id,
MembershipRole::Viewer,
)
.await
.expect("viewer membership in ws_default");
}
/// Owner чужого WorkspaceB: создаёт и читает существующий ResourceB в своём workspace.
async fn seed_foreign_owner(registry: &PostgresRegistry) {
let password_hash =
hash_password(FOREIGN_OWNER_PASSWORD, PASSWORD_PEPPER).expect("foreign owner hash");
let user_id = registry
.upsert_bootstrap_user(
FOREIGN_OWNER_EMAIL,
"Story 3.6 Guard Foreign Owner",
&password_hash,
)
.await
.expect("foreign owner account");
registry
.ensure_membership(
&WorkspaceId::new(FOREIGN_WORKSPACE_ID),
&user_id,
MembershipRole::Owner,
)
.await
.expect("foreign owner membership in WorkspaceB");
}
async fn create_foreign_workspace(registry: &PostgresRegistry) {
let now = time::OffsetDateTime::now_utc();
registry
.create_workspace(CreateWorkspaceRequest {
workspace: &Workspace {
id: WorkspaceId::new(FOREIGN_WORKSPACE_ID),
slug: "story36-guard-foreign".to_owned(),
display_name: "Story 3.6 Guard Foreign".to_owned(),
status: WorkspaceStatus::Active,
settings: json!({}),
created_at: now,
updated_at: now,
},
})
.await
.expect("foreign workspace must be created");
}
fn private_storage_root(name: &str) -> PathBuf {
let root = std::env::temp_dir().join(format!(
"crank_admin_api_guard_{name}_{}_{}",
std::process::id(),
SystemTime::now()
.duration_since(UNIX_EPOCH)
.expect("clock after epoch")
.as_nanos()
));
std::fs::create_dir_all(&root).expect("guard artifact root must be creatable");
#[cfg(unix)]
std::fs::set_permissions(&root, std::os::unix::fs::PermissionsExt::from_mode(0o700))
.expect("guard artifact root must be private");
root
}
// ---------------------------------------------------------------------------
// Настоящий фрагментированный запрос (chunked, без Content-Length) и наблюдения
// durable-артефакта: обычным `reqwest`-клиентом это не выражается, а SQL и файловые
// наблюдения обязаны жить в composition root, а не в сервисных тестах (R-A/R-D).
// ---------------------------------------------------------------------------
/// Сессия стенда в виде, пригодном для рукописного HTTP-запроса на сокете.
pub(crate) struct RawSession {
pub cookie: String,
pub csrf: String,
}
/// Логин без cookie-jar: cookie и CSRF-токен извлекаются напрямую.
pub(crate) async fn raw_session(root_url: &str, email: &str, password: &str) -> RawSession {
let client = reqwest::Client::builder()
.build()
.expect("raw login client");
let response = client
.post(format!("{root_url}/api/auth/login"))
.json(&json!({ "email": email, "password": password }))
.send()
.await
.expect("raw login must complete");
assert_eq!(
response.status(),
StatusCode::OK,
"the raw session login must succeed"
);
let cookie = response
.headers()
.get_all(reqwest::header::SET_COOKIE)
.iter()
.filter_map(|value| value.to_str().ok())
.filter_map(|value| value.split(';').next())
.collect::<Vec<_>>()
.join("; ");
let body: Value = response.json().await.unwrap_or(Value::Null);
let csrf = body["csrf_token"].as_str().unwrap_or_default().to_owned();
assert!(
!cookie.is_empty() && !csrf.is_empty(),
"a raw session must carry both the cookie and the CSRF token"
);
RawSession { cookie, csrf }
}
/// Ответ рукописного HTTP-запроса: статус-код и тело.
pub(crate) struct RawHttpResponse {
pub status: u16,
/// Голова ответа как её прислал сервер (нужна для диагностики отказов);
/// значения чувствительных заголовков отредактированы.
pub head: String,
pub body: String,
/// Отправленная голова запроса: без неё отказ не отличить от ошибки харнесса.
/// Хранится уже с отредактированными чувствительными заголовками (F5).
pub request_head: String,
/// Ошибка записи фрагмента (сервер мог ответить и закрыть соединение) — наблюдение.
pub write_error: Option<String>,
/// Ошибка дочитывания ответа; пустое тело при `Some` — не «нет ответа», а обрыв.
pub read_error: Option<String>,
}
impl RawHttpResponse {
/// Компактная подпись для сообщений об отказе.
pub(crate) fn signature(&self) -> String {
format!(
"status={} write_error={:?} read_error={:?} response_head={} request_head={} body={}",
self.status,
self.write_error,
self.read_error,
self.head.replace('\r', "").replace('\n', " | "),
self.request_head.replace('\r', "").replace('\n', " | "),
self.body
)
}
}
/// Настоящий chunked-запрос: тело уходит несколькими фрагментами, `Content-Length`
/// отсутствует, `Transfer-Encoding: chunked` объявлен явно.
pub(crate) async fn send_chunked_multipart(
addr: SocketAddr,
path: &str,
session: &RawSession,
boundary: &str,
chunks: &[Vec<u8>],
) -> RawHttpResponse {
use tokio::io::{AsyncReadExt as _, AsyncWriteExt as _};
let mut stream = TcpStream::connect(addr)
.await
.expect("the raw loopback socket must connect");
let head_request = format!(
"POST {path} HTTP/1.1\r\nHost: {addr}\r\nCookie: {}\r\nX-CSRF-Token: {}\r\n\
Content-Type: multipart/form-data; boundary={boundary}\r\n\
Transfer-Encoding: chunked\r\nConnection: close\r\n\r\n",
session.cookie, session.csrf
);
stream
.write_all(head_request.as_bytes())
.await
.expect("the request head must be written");
// Запись фрагментов может прерваться, если сервер уже ответил и закрыл соединение
// (например, ранний отказ guard-а или отказ по лимиту). Это наблюдение, а не ошибка
// теста: ответ всё равно дочитывается ниже и попадает в assertions.
let mut write_error: Option<std::io::Error> = None;
for chunk in chunks {
let size = format!("{:x}\r\n", chunk.len());
let fragment = [
stream.write_all(size.as_bytes()).await,
stream.write_all(chunk).await,
stream.write_all(b"\r\n").await,
];
if let Some(error) = fragment.into_iter().find_map(Result::err) {
write_error = Some(error);
break;
}
stream.flush().await.expect("a fragment must be flushed");
tokio::time::sleep(std::time::Duration::from_millis(5)).await;
}
if write_error.is_none() {
let _ = stream.write_all(b"0\r\n\r\n").await;
}
let _ = stream.flush().await;
let mut raw = Vec::new();
let read_error = stream.read_to_end(&mut raw).await.err();
let text = String::from_utf8_lossy(&raw).into_owned();
let (head, body) = text.clone().split_once("\r\n\r\n").map_or_else(
|| (String::new(), String::new()),
|(head, body)| (head.to_owned(), body.to_owned()),
);
let status = head
.split_whitespace()
.nth(1)
.and_then(|code| code.parse::<u16>().ok())
.unwrap_or(0);
RawHttpResponse {
status,
// Обе головы сохраняются уже отредактированными: ни request-, ни response-голова
// не должны уносить session/CSRF-значения в авторский raw-журнал (F5).
head: redact_sensitive_headers(&head),
body,
request_head: redact_sensitive_headers(&head_request),
write_error: write_error.map(|error| error.to_string()),
read_error: read_error.map(|error| error.to_string()),
}
}
/// Наблюдаемая идентичность durable-артефакта версии Resource (blob + версия + owning ref).
#[derive(Clone, Debug, PartialEq, Eq)]
pub(crate) struct ArtifactIdentity {
pub blob_digest: String,
pub blob_size_bytes: i64,
pub blob_artifact_ref: String,
pub blob_lifecycle: String,
pub version_digest: String,
pub version_size_bytes: i64,
pub version_mime_type: String,
pub version_sensitivity: String,
pub source_id: String,
pub source_mime_type: String,
pub source_sensitivity: String,
pub source_lifecycle: String,
pub source_detached_at: Option<time::OffsetDateTime>,
}
/// Однофакторные мутации metadata, от которых зависит сверка чтения Resource (§6).
///
/// Расхождение `artifact_blobs.artifact_ref` с digest не входит в матрицу: его
/// структурно запрещает CHECK `artifact_blobs_ref_check (artifact_ref = 'sha256:' || digest)`,
/// поэтому такой вектор был бы недостижимым, а не «пропущенным дефектом».
#[derive(Clone, Copy, Debug)]
pub(crate) enum ArtifactMutation {
BlobSize,
BlobStorageLifecycle,
VersionDigest,
VersionSize,
VersionMimeType,
VersionSensitivity,
SourceMimeType,
SourceLifecycle,
}
impl ArtifactMutation {
pub(crate) const ALL: [Self; 8] = [
Self::BlobSize,
Self::BlobStorageLifecycle,
Self::VersionDigest,
Self::VersionSize,
Self::VersionMimeType,
Self::VersionSensitivity,
Self::SourceMimeType,
Self::SourceLifecycle,
];
pub(crate) fn label(self) -> &'static str {
match self {
Self::BlobSize => "blob-size",
Self::BlobStorageLifecycle => "blob-storage-lifecycle",
Self::VersionDigest => "version-digest",
Self::VersionSize => "version-size",
Self::VersionMimeType => "version-mime-type",
Self::VersionSensitivity => "version-sensitivity",
Self::SourceMimeType => "source-mime-type",
Self::SourceLifecycle => "source-lifecycle",
}
}
fn statement(self) -> &'static str {
match self {
Self::BlobSize => "update artifact_blobs set size_bytes = size_bytes + 1",
Self::BlobStorageLifecycle => {
"update artifact_blobs set storage_lifecycle = 'unavailable'"
}
Self::VersionDigest => "update resource_versions set digest = repeat('0', 64)",
Self::VersionSize => "update resource_versions set size_bytes = size_bytes + 1",
Self::VersionMimeType => "update resource_versions set mime_type = 'text/html'",
Self::VersionSensitivity => "update resource_versions set sensitivity = 'public'",
Self::SourceMimeType => "update artifact_sources set mime_type = 'text/html'",
Self::SourceLifecycle => {
"update artifact_sources set lifecycle = 'detached', detached_at = updated_at"
}
}
}
}
/// Текущая идентичность артефакта workspace (ровно одна текущая версия в тестах).
pub(crate) async fn observe_artifact_identity(
pool: &sqlx::PgPool,
workspace_id: &str,
) -> ArtifactIdentity {
let row = sqlx::query(
"select b.digest as blob_digest, b.size_bytes as blob_size_bytes,
b.artifact_ref as blob_artifact_ref, b.storage_lifecycle as blob_lifecycle,
v.digest as version_digest, v.size_bytes as version_size_bytes,
v.mime_type as version_mime_type, v.sensitivity as version_sensitivity,
s.source_id, s.mime_type as source_mime_type,
s.sensitivity as source_sensitivity, s.lifecycle as source_lifecycle,
s.detached_at as source_detached_at
from artifact_blobs b
join artifact_sources s on s.blob_digest = b.digest
join resource_versions v
on v.workspace_id = s.workspace_id and v.artifact_source_id = s.source_id
where s.workspace_id = $1
order by s.source_id
limit 1",
)
.bind(workspace_id)
.fetch_one(pool)
.await
.expect("the durable artifact identity must be observable");
ArtifactIdentity {
blob_digest: row.get("blob_digest"),
blob_size_bytes: row.get("blob_size_bytes"),
blob_artifact_ref: row.get("blob_artifact_ref"),
blob_lifecycle: row.get("blob_lifecycle"),
version_digest: row.get("version_digest"),
version_size_bytes: row.get("version_size_bytes"),
version_mime_type: row.get("version_mime_type"),
version_sensitivity: row.get("version_sensitivity"),
source_id: row.get("source_id"),
source_mime_type: row.get("source_mime_type"),
source_sensitivity: row.get("source_sensitivity"),
source_lifecycle: row.get("source_lifecycle"),
source_detached_at: row.get("source_detached_at"),
}
}
/// Применяет одну однофакторную мутацию metadata (SQL только в composition root).
pub(crate) async fn apply_artifact_mutation(
pool: &sqlx::PgPool,
mutation: ArtifactMutation,
) -> Result<(), sqlx::Error> {
sqlx::raw_sql(sqlx::AssertSqlSafe(mutation.statement().to_owned()))
.execute(pool)
.await
.map(|_| ())
}
/// Возвращает зафиксированные значения байт-в-байт (не «похожие»).
pub(crate) async fn restore_artifact_identity(
pool: &sqlx::PgPool,
workspace_id: &str,
identity: &ArtifactIdentity,
) -> Result<(), sqlx::Error> {
sqlx::query(
"update artifact_blobs
set digest = $1, size_bytes = $2, artifact_ref = $3, storage_lifecycle = $4
where digest = $1",
)
.bind(&identity.blob_digest)
.bind(identity.blob_size_bytes)
.bind(&identity.blob_artifact_ref)
.bind(&identity.blob_lifecycle)
.execute(pool)
.await?;
sqlx::query(
"update resource_versions
set digest = $1, size_bytes = $2, mime_type = $3, sensitivity = $4
where workspace_id = $5 and artifact_source_id = $6",
)
.bind(&identity.version_digest)
.bind(identity.version_size_bytes)
.bind(&identity.version_mime_type)
.bind(&identity.version_sensitivity)
.bind(workspace_id)
.bind(&identity.source_id)
.execute(pool)
.await?;
sqlx::query(
"update artifact_sources
set mime_type = $1, sensitivity = $2, lifecycle = $3, detached_at = $4
where workspace_id = $5 and source_id = $6",
)
.bind(&identity.source_mime_type)
.bind(&identity.source_sensitivity)
.bind(&identity.source_lifecycle)
.bind(identity.source_detached_at)
.bind(workspace_id)
.bind(&identity.source_id)
.execute(pool)
.await?;
Ok(())
}
// ---------------------------------------------------------------------------
// Подмодуль наблюдений: редактирование заголовков (F5), composition-стенд сервисных
// проверок чтения (F3), SQL/файловые наблюдения. Разделён по health-правилу 1000 строк;
// границы и регистрация модуля не меняются.
// ---------------------------------------------------------------------------
mod observations;
pub(crate) use observations::{
ResourceServiceHarness, artifact_files, redact_sensitive_headers, resource_row_counts,
resource_schema,
};
/// Поднимает реальный router на loopback и возвращает URL-ы, адрес и ручки остановки.
async fn serve(
app: Router,
) -> (
String,
String,
SocketAddr,
tokio::sync::oneshot::Sender<()>,
tokio::task::JoinHandle<()>,
) {
let listener = TcpListener::bind("127.0.0.1:0")
.await
.expect("ephemeral loopback port");
let address: SocketAddr = listener.local_addr().expect("listener address");
let (shutdown_tx, shutdown_rx) = tokio::sync::oneshot::channel();
let handle = tokio::spawn(async move {
axum::serve(listener, app)
.with_graceful_shutdown(async move {
let _ = shutdown_rx.await;
})
.await
.expect("guard harness server must serve");
});
(
format!("http://{address}"),
format!("http://{address}/api/admin/workspaces/{DEFAULT_WORKSPACE_ID}"),
address,
shutdown_tx,
handle,
)
}