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.
961 lines
38 KiB
Rust
961 lines
38 KiB
Rust
//! 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(®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<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,
|
||
)
|
||
}
|