//! 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, } 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>, handle: Option>, } 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(®istry).await; if options.viewer_membership { seed_viewer(®istry).await; } if options.foreign_workspace { create_foreign_workspace(®istry).await; } if options.foreign_workspace_owner { seed_foreign_owner(®istry).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 { 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:`). 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::(&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::(&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::(&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(""); let field = body["error"]["context"]["field"] .as_str() .unwrap_or(""); let message = body["error"]["message"].as_str().unwrap_or(""); 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::>() .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, /// Ошибка дочитывания ответа; пустое тело при `Some` — не «нет ответа», а обрыв. pub read_error: Option, } 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], ) -> 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 = 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::().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, } /// Однофакторные мутации 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, ) }