feat(epic3): deliver the accepted Epic 3 scope through Story 3.17
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

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.
This commit is contained in:
bsodfather committed 2026-10-25 09:08:22 +00:00
1 parent 1b6db09bd1
commit 54ce770682
357 files changed
+117394 -5115

No files matched your search

@@ -0,0 +1,960 @@
//! 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,
)
}
@@ -0,0 +1,136 @@
//! Наблюдения и composition-часть приватного ATDD-стенда Story 3.6.
//!
//! Подмодуль того же приватного `#[cfg(test)]` фикстура
//! `crate::app::resource_test_support` (регистрация в `app.rs` не меняется): физическое
//! разделение выполнено только потому, что health-правило репозитория ограничивает файл
//! 1000 строками (`scripts/check-rust-code-health.sh`), а базовая часть модуля уже
//! содержит HTTP-стенд guard-проверок. Здесь находятся:
//!
//! * редактирование чувствительных заголовков рукописной диагностики (F5, TL run105);
//! * composition-стенд сервисных проверок чтения Resource (F3/F4, TL run105);
//! * SQL-наблюдение итогов строк V16 и файловые наблюдения содержимого.
//!
//! Границы те же, что у корневого файла: `cfg(test)`-only, никакого production API.
use std::{path::PathBuf, sync::Arc};
use crank_artifacts::ArtifactStore;
use crank_core::resource::ResourceLimits;
use crank_registry::PostgresRegistry;
use crate::service::resources::ResourcesService;
// ---------------------------------------------------------------------------
// F5: диагностика не несёт значения чувствительных заголовков
// ---------------------------------------------------------------------------
/// Значения этих заголовков не попадают в диагностику даже синтетического стенда.
const SENSITIVE_HEADERS: [&str; 4] = ["cookie", "set-cookie", "x-csrf-token", "authorization"];
/// Редактирует значения чувствительных заголовков (AGENTS: credentials не в журналах).
///
/// Редактирование выполняется **до** сохранения головы, а не при печати (TL run105 F5);
/// метод, путь, структура заголовков и статус сохраняются, иначе отказ не отличить от
/// ошибки харнесса.
pub(crate) fn redact_sensitive_headers(head: &str) -> String {
head.split("\r\n")
.map(|line| match line.split_once(':') {
Some((name, _value))
if SENSITIVE_HEADERS.contains(&name.trim().to_ascii_lowercase().as_str()) =>
{
format!("{name}: <redacted-sensitive-header>")
}
_ => line.to_owned(),
})
.collect::<Vec<_>>()
.join("\r\n")
}
// ---------------------------------------------------------------------------
// F3/F4: composition-стенд сервисных проверок чтения Resource
// ---------------------------------------------------------------------------
/// Изолированная PG-схема вместе с соединением к ней.
///
/// Конкретный драйвер допускается только в composition root (`cfg(test)`-фикстура
/// вне `service/**`): сервисные тест-модули получают готовые registry/service и
/// не называют адаптер хранилища сами (TL run105 F3, FINAL-DISPOSITION run99:47).
pub(crate) async fn resource_schema(prefix: &str) -> (String, sqlx::PgPool) {
let url = crank_test_support::postgres_schema_url(prefix).await;
let pool = sqlx::postgres::PgPoolOptions::new()
.max_connections(2)
.connect(&url)
.await
.expect("the isolated test schema must accept connections");
(url, pool)
}
/// Приватный стенд сервисных проверок чтения Resource: изолированная PG-схема V16,
/// приватный artifact root и **готовый** `ResourcesService`.
///
/// Драйвер, миграция и сборка store/service живут в composition root, а не в сервисном
/// тест-модуле (TL run105 F3; FINAL-DISPOSITION run99:47).
pub(crate) struct ResourceServiceHarness {
pub service: ResourcesService,
pub registry: PostgresRegistry,
/// Приватный root содержимого: по нему наблюдаются физические отказы чтения.
pub root: PathBuf,
}
impl ResourceServiceHarness {
pub(crate) async fn spawn(name: &str, limit: usize) -> Self {
let (database_url, pool) = resource_schema(&format!("story36_integrity_{name}")).await;
crank_registry::MigrationAuthority::apply(&pool)
.await
.expect("V16 must be applicable");
drop(pool);
let registry = PostgresRegistry::connect(&database_url)
.await
.expect("fixture registry must connect");
let root = super::private_storage_root(&format!("integrity_{name}"));
let store = ArtifactStore::open(&root).expect("private artifact store must open");
let limits = ResourceLimits::uniform(limit)
.expect("the configured test limit must stay inside the storage ceiling");
Self {
service: ResourcesService::new(registry.clone(), Arc::new(store), limits),
registry,
root,
}
}
}
// ---------------------------------------------------------------------------
// SQL/файловые наблюдения состояния (только composition root)
// ---------------------------------------------------------------------------
/// Итоги строк V16 `(resources, resource_versions, artifact_sources, artifact_blobs)` —
/// наблюдение «отказ без побочных эффектов» (SQL только в composition root).
pub(crate) async fn resource_row_counts(pool: &sqlx::PgPool) -> (i64, i64, i64, i64) {
sqlx::query_as(
"select (select count(*) from resources), (select count(*) from resource_versions),
(select count(*) from artifact_sources), (select count(*) from artifact_blobs)",
)
.fetch_one(pool)
.await
.expect("V16 relations must be countable")
}
/// Физические файлы содержимого под приватным artifact root.
pub(crate) fn artifact_files(root: &std::path::Path) -> Vec<PathBuf> {
let mut files = Vec::new();
let mut pending = vec![root.to_path_buf()];
while let Some(dir) = pending.pop() {
let entries = std::fs::read_dir(&dir).expect("the private artifact root must be readable");
for entry in entries {
let entry = entry.expect("an artifact entry must be readable");
let path = entry.path();
if path.is_dir() {
pending.push(path);
} else {
files.push(path);
}
}
}
files.sort();
files
}