Files
crank/apps/admin-api/tests/integration/resources/publication/contract.rs
T
bsodfather 54ce770682
CI / Rust Checks (pull_request) Failing after 13m41s
CI / UI Checks (pull_request) Skipped
CI / Frontend E2E (pull_request) Skipped
CI / Community Image Smoke (pull_request) Skipped
CI / Deploy (pull_request) Skipped
Community Release / release (push) Failing after 13m33s
feat(epic3): deliver the accepted Epic 3 scope through Story 3.17
Recovery delivery of the accumulated, TL-accepted Epic 3 work that had never been
committed to Git (stories 3.6-3.17, see the crank board). Story 3.18 is not accepted
yet and is deliberately excluded: its logging surface, its capability registration,
its oracle projections and its tests are not part of this tree.

Accepted scope
- 3.6 typed static Resource Drafts; 3.7 publication and exact binding of static
  Resource Versions; 3.8 MCP discovery/read and revocation of static Resources;
- 3.9 Resource import/export in API and UI plus TLS dependency maintenance;
  3.10 REST-backed Resource templates; 3.11 shared REST read runtime and the MCP
  revision/capability foundation;
- 3.12 parameterised Prompt Drafts with preview; 3.13 Prompt publication and exact
  version binding to Agents; 3.14 MCP prompts; 3.15 Prompt import/export;
- 3.16 composite Prompts with published Resources (dependency content scan plus
  dynamic read through the accepted 3.11 runtime, admin preview and MCP prompts/get);
- 3.17 bounded MCP completion suggestions from typed published schemas and the
  resources/list admission fix for bound template publications.

Accepted evidence being reused (unchanged code paths)
- 3.16 candidate: core 7, admin-api 22, registry 4, mcp-server 4, UI 6; one final
  `just verify` run 1651 passed / 0 failed / 2 ignored.
- 3.17 candidate: full run 1672 passed / 0 failed / 2 ignored, QA targeted reruns and
  a real MCP Inspector 2.12.0 client smoke.

Delivery engineering in this commit
- CI: one event per change (feature branches are gated by their pull request, push
  runs only on main), story events run the changed packages, the full workspace suite
  stays the feature/release gate; no cache/sharding without a measured runner check.
- Release: the packaged archives, checksums and SBOM are now uploaded to the Gitea
  release entry of the tag instead of dying with the runner workspace.

Not included on purpose: Story 3.18 work, build caches, runtime databases, local
credentials and scratch evidence.

Refs: crank kanban t_e39d7263; baseline 1b6db09bd1.
2026-10-25 09:08:22 +00:00

394 lines
14 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! API/registry часть AC06 / AT-3.7-06 для первого среза публикации.
//!
//! Проверяется: недоступная (отсутствующая/чужая) сущность — 404 без раскрытия; ответы
//! публикации и точной версии не раскрывают storage/path/raw filename; новые мутирующие
//! маршруты публикации подчиняются существующим guard-ам (сессия, CSRF, origin, роль), а
//! владелец тем же путём публикует успешно.
//!
//! Остаток AC06 (archive, stale Agent revision, Playwright/browser) остаётся обязательным
//! остатком Story 3.7 и здесь не проверяется.
use super::super::helpers::{
DEFAULT_WORKSPACE_ID, TEST_AUTH_EMAIL, TEST_AUTH_PASSWORD, assert_download_policy,
create_draft, create_owned_workspace, created_resource_id, draft_metadata, draft_updated_at,
ensure_viewer_membership, error_signature, get_card, header_value, login_client,
login_client_with_foreign_origin, login_client_without_csrf, spawn_authorized,
};
use super::{
assert_immutable_metadata, assert_nothing_published, assert_version_not_published,
create_and_publish, create_fixture, publish, published_metadata, read_version,
read_version_content, version_metadata,
};
use reqwest::StatusCode;
use serde_json::json;
use serial_test::serial;
#[tokio::test(flavor = "multi_thread")]
#[serial]
async fn story37_at06_missing_and_foreign_resources_are_not_found_without_disclosure() {
let (registry, server, _client) = spawn_authorized("story37_at06_not_found").await;
// (a) несуществующая сущность: разрешение (C) важнее precondition (F), как в существующем
// PUT-контракте.
let (status, text, body) = publish(
&_client,
&server,
"res_story37_missing",
"2026-01-01T00:00:00Z",
)
.await;
assert_eq!(
status,
StatusCode::NOT_FOUND,
"publishing an unavailable Resource must be 404 (TL decision 2); observed {} body={text}",
error_signature(status, &body)
);
assert_eq!(
body["error"]["code"],
json!("resource_not_found"),
"a publish of an unavailable Resource must keep the existing sanitized Resource envelope \
(`error.code`=resource_not_found); observed status={status} body={text}"
);
assert_eq!(
body["error"]["context"]["field"],
json!("resource_id"),
"the refusal must name the offending field; observed body={text}"
);
assert!(
!text.contains("uri") && !text.contains("digest") && !text.contains("mime"),
"a missing Resource refusal must not disclose artifact metadata: {text}"
);
assert_version_not_published(
&_client,
&server,
"res_story37_missing",
1,
"AT-3.7-06 missing resource",
)
.await;
// (b) чужая сущность: Resource существует в другом workspace того же аккаунта
// (Owner membership выдан), поэтому проверяется entity-level scoping, а не workspace-guard.
let owned_workspace = create_owned_workspace(&registry).await;
let workspace_b = server
.as_ref()
.replace(DEFAULT_WORKSPACE_ID, owned_workspace.as_str());
// Сессия логинится уже после выдачи membership.
let client = login_client(&server, TEST_AUTH_EMAIL, TEST_AUTH_PASSWORD).await;
let foreign_meta = draft_metadata(
"crank://story37/foreign",
"foreign_doc",
"text",
"text/plain",
"secret",
);
let foreign = create_draft(
&client,
&workspace_b,
&foreign_meta,
b"foreign secret body",
"story37-foreign-raw.txt",
"text/plain",
)
.await;
let foreign_id = created_resource_id(&foreign);
let (status, text, body) = publish(&client, &server, &foreign_id, "2026-01-01T00:00:00Z").await;
assert_eq!(
status,
StatusCode::NOT_FOUND,
"a Resource of another workspace must be 404 without disclosure; observed {} body={text}",
error_signature(status, &body)
);
assert_eq!(body["error"]["code"], json!("resource_not_found"));
assert!(
!text.contains("foreign_doc")
&& !text.contains("crank://story37/foreign")
&& !text.contains("text/plain"),
"the refusal must not disclose the foreign Resource metadata: {text}"
);
assert_version_not_published(&client, &server, &foreign_id, 1, "AT-3.7-06 foreign").await;
// Positive control: в своём workspace тот же Resource публикуется тем же маршрутом.
let foreign_card = get_card(&client, &workspace_b, &foreign_id).await;
let (status, text, body) = publish(
&client,
&workspace_b,
&foreign_id,
&draft_updated_at(&foreign_card),
)
.await;
assert_eq!(
status,
StatusCode::OK,
"the same Resource must publish inside its own workspace; observed {} body={text}",
error_signature(status, &body)
);
assert_eq!(published_metadata(&body)["version"], json!(1));
}
#[tokio::test(flavor = "multi_thread")]
#[serial]
async fn story37_at06_published_reads_do_not_disclose_storage_reference() {
let (_registry, server, client) = spawn_authorized("story37_at06_no_disclosure").await;
let bytes = "опубликованный документ\n".as_bytes();
let raw_upload_filename = "story37-raw-upload-secret-name.bin";
let mut meta = draft_metadata(
"crank://story37/disclosure",
"public_doc",
"text",
"text/plain",
"internal",
);
meta["description"] = json!("описание опубликованного документа");
let published = create_and_publish(
&client,
&server,
&meta,
bytes,
raw_upload_filename,
"text/plain",
)
.await;
let id = published.draft.resource_id.clone();
assert!(
!published.body.to_string().contains(raw_upload_filename),
"the publish response must not echo the raw upload filename: {}",
published.body
);
let (status, text, body) = read_version(&client, &server, &id, 1).await;
assert_eq!(
status,
StatusCode::OK,
"the exact Version metadata must be readable; observed {} body={text}",
error_signature(status, &body)
);
assert_immutable_metadata(&version_metadata(&body), raw_upload_filename);
assert!(
!text.contains(raw_upload_filename) && !text.contains("src_") && !text.contains("/sha256/"),
"the Version metadata response must not disclose a storage reference: {text}"
);
let response = read_version_content(&client, &server, &id, 1).await;
assert_eq!(response.status(), StatusCode::OK);
assert_download_policy(response.headers());
let disposition = header_value(response.headers(), "content-disposition");
assert!(
disposition.contains("public_doc.txt"),
"the published download must keep the filename derived from `name`: {disposition}"
);
assert!(
!disposition.contains(raw_upload_filename),
"the published download must not leak the raw upload filename: {disposition}"
);
assert_eq!(
response
.bytes()
.await
.expect("published content must be readable")
.to_vec(),
bytes.to_vec()
);
}
#[tokio::test(flavor = "multi_thread")]
#[serial]
async fn story37_at06_guard_negatives_protect_publish_route() {
let (_registry, server, client) = spawn_authorized("story37_at06_guards").await;
let fixture = create_fixture(
&client,
&server,
&draft_metadata(
"crank://story37/guard",
"guard_doc",
"text",
"text/plain",
"internal",
),
b"guard body",
"story37-guard.txt",
"text/plain",
)
.await;
// (a) без сессии guard обязан отказать до маршрутизации и до чтения тела.
let anonymous = reqwest::Client::new();
let (status, text, _) = publish(
&anonymous,
&server,
&fixture.resource_id,
&fixture.updated_at,
)
.await;
assert_eq!(
status,
StatusCode::UNAUTHORIZED,
"a publish without a session must be refused: {text}"
);
// (b) сессия без CSRF (browser mutation).
let without_csrf =
login_client_without_csrf(&server, TEST_AUTH_EMAIL, TEST_AUTH_PASSWORD).await;
let (status, text, _) = publish(
&without_csrf,
&server,
&fixture.resource_id,
&fixture.updated_at,
)
.await;
assert_eq!(
status,
StatusCode::FORBIDDEN,
"a publish without the CSRF token must be refused: {text}"
);
// (c) cross-origin запрос.
let foreign_origin =
login_client_with_foreign_origin(&server, TEST_AUTH_EMAIL, TEST_AUTH_PASSWORD).await;
let (status, text, _) = publish(
&foreign_origin,
&server,
&fixture.resource_id,
&fixture.updated_at,
)
.await;
assert_eq!(
status,
StatusCode::FORBIDDEN,
"a cross-origin publish must be refused: {text}"
);
// Ни один негатив не создал Published Version и не сдвинул карточку Draft.
assert_nothing_published(
&client,
&server,
&fixture.resource_id,
1,
"AT-3.7-06 guards",
)
.await;
}
#[tokio::test(flavor = "multi_thread")]
#[serial]
async fn story37_at06_viewer_cannot_publish_but_owner_can() {
let (registry, server, client) = spawn_authorized("story37_at06_roles").await;
let fixture = create_fixture(
&client,
&server,
&draft_metadata(
"crank://story37/roles",
"roles_doc",
"text",
"text/plain",
"internal",
),
b"roles body",
"story37-roles.txt",
"text/plain",
)
.await;
let (viewer_email, viewer_password) = ensure_viewer_membership(&registry).await;
let viewer = login_client(&server, viewer_email, viewer_password).await;
let (status, text, body) =
publish(&viewer, &server, &fixture.resource_id, &fixture.updated_at).await;
assert_eq!(
status,
StatusCode::FORBIDDEN,
"a Viewer must not publish a Resource — the existing mutation guard covers the new route; \
observed {} body={text}",
error_signature(status, &body)
);
assert_nothing_published(
&client,
&server,
&fixture.resource_id,
1,
"AT-3.7-06 viewer",
)
.await;
// Positive control: владелец публикует тот же Draft (отказ Viewer не оставил side effects).
let (status, text, body) =
publish(&client, &server, &fixture.resource_id, &fixture.updated_at).await;
assert_eq!(
status,
StatusCode::OK,
"the owner must publish the same Draft; observed {} body={text}",
error_signature(status, &body)
);
assert_eq!(published_metadata(&body)["version"], json!(1));
}
/// F4 (TL CODE-REVIEW): `version` — публичный `u32`-path, но версия вне представимого
/// БД диапазона не может существовать. Оба exact-read маршрута авторизованного
/// workspace обязаны дать sanitized 404, а не storage-500.
#[tokio::test(flavor = "multi_thread")]
#[serial]
async fn story37_at06_unrepresentable_version_is_not_found() {
let (_registry, server, client) = spawn_authorized("story37_at06_version_bounds").await;
// Положительный контроль: реальная Published Version 1 доступна обоими маршрутами.
let published = create_and_publish(
&client,
&server,
&draft_metadata(
"crank://story37/version-bounds",
"version_bounds",
"text",
"text/plain",
"internal",
),
b"version bounds body\n",
"story37-version-bounds.txt",
"text/plain",
)
.await;
let resource_id = published.draft.resource_id.clone();
let (status, text, body) = read_version(&client, &server, &resource_id, 1).await;
assert_eq!(
status,
StatusCode::OK,
"the existing version must stay readable; observed {} body={text}",
error_signature(status, &body)
);
// Версия вне i32-диапазона: metadata и content — sanitized 404.
let impossible: u32 = 2_147_483_648;
let (status, text, body) = read_version(&client, &server, &resource_id, impossible).await;
assert_eq!(
status,
StatusCode::NOT_FOUND,
"an unrepresentable version must be a sanitized 404, not a storage failure; observed {} \
body={text}",
error_signature(status, &body)
);
assert_eq!(body["error"]["code"], json!("resource_not_found"));
assert!(
!text.to_ascii_lowercase().contains("storage")
&& !text.contains("internal server error")
&& !text.contains(&impossible.to_string()),
"the refusal must stay sanitized: {text}"
);
let response = read_version_content(&client, &server, &resource_id, impossible).await;
let content_status = response.status();
let content_text = response.text().await.unwrap_or_default();
assert_eq!(
content_status,
StatusCode::NOT_FOUND,
"the content route must mirror the sanitized 404; observed body={content_text}"
);
assert!(
!content_text.to_ascii_lowercase().contains("storage")
&& !content_text.contains("internal server error"),
"the content refusal must stay sanitized: {content_text}"
);
}