Files
crank/apps/admin-api/tests/integration/resources/archive.rs
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

725 lines
27 KiB
Rust
Raw Permalink 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.
//! ATDD (RED) Story 3.7 — архив Resource: оставшийся серверный lifecycle-контракт AC05/AC06.
//!
//! Источники: live Gitea #14 (`STORY37-SOURCE.md`, AC05/AC06), `docs/acceptance-test-plan.md:1035-1037`
//! (AT-3.7-05/06), QA `.tmp/t_e42cf4cd/QA-REPORT.md` (archive — NOT_RUN) и TL-решение этой карточки:
//! минимальный workspace-scoped `POST .../resources/{resource_id}/archive` с существующим
//! Resource-CAS `expected_updated_at` (JSON body, как publish), без hard-delete, artifact
//! cleanup и изменения Published bytes/Agent snapshots.
//!
//! Состояние на этой стадии: маршрута архива нет (`apps/admin-api/src/app.rs`,
//! `routes/resources.rs`), поэтому позитивные проверки падают на реальном HTTP-ответе
//! fallback-роутера (404 там, где контракт требует 200/428), а не на ошибке компиляции
//! или setup. Отрицательные проверки дополнены положительным контролем владельца, чтобы
//! отказ не мог оказаться «зелёным» из-за отсутствующего маршрута.
//!
//! Семантика доступности archived Published Version: принятое interface decision
//! «Resource published metadata snapshot неизменяем при последующем edit/archive»
//! проверяется чтением точной версии по существующим routes — архив не удаляет и не
//! подменяет immutable snapshot. Решение о том, скрывать ли архивную версию от чтения,
//! относится к checkpoint/build и здесь не изобретается: тест фиксирует неизменность
//! metadata/bytes, а не новый latest-alias.
//!
//! Фильтр запуска: `cargo test -p admin-api --test integration --locked story37_at06_archive -- --test-threads=1`.
use crank_registry::PostgresRegistry;
use reqwest::StatusCode;
use serde_json::{Value, json};
use serial_test::serial;
use super::helpers::{
DEFAULT_WORKSPACE_ID, TEST_AUTH_EMAIL, TEST_AUTH_PASSWORD, create_owned_workspace, draft_form,
draft_metadata, draft_updated_at, ensure_viewer_membership, error_signature, get_card,
login_client, login_client_with_foreign_origin, login_client_without_csrf, read_response,
spawn_authorized, table_row_count,
};
use super::publication::{create_and_publish, create_fixture};
/// Тело архива: тот же CAS, что у PUT/publish — точное `updated_at` карточки.
fn archive_body(expected_updated_at: &str) -> Value {
json!({ "expected_updated_at": expected_updated_at })
}
async fn archive_raw(
client: &reqwest::Client,
server: impl AsRef<str>,
resource_id: &str,
body: &Value,
) -> (StatusCode, String, Value) {
let server = server.as_ref();
read_response(
client
.post(format!("{server}/resources/{resource_id}/archive"))
.json(body)
.send()
.await
.expect("archive request must complete"),
)
.await
}
async fn archive(
client: &reqwest::Client,
server: impl AsRef<str>,
resource_id: &str,
expected_updated_at: &str,
) -> (StatusCode, String, Value) {
archive_raw(
client,
server,
resource_id,
&archive_body(expected_updated_at),
)
.await
}
async fn read_version_bytes(
client: &reqwest::Client,
server: impl AsRef<str>,
resource_id: &str,
version: u32,
) -> (StatusCode, Vec<u8>) {
let server = server.as_ref();
let response = client
.get(format!(
"{server}/resources/{resource_id}/versions/{version}/content"
))
.send()
.await
.expect("version content request must complete");
let status = response.status();
let bytes = response
.bytes()
.await
.expect("version content body")
.to_vec();
(status, bytes)
}
async fn publication_rows(registry: &PostgresRegistry) -> i64 {
table_row_count(registry.pool(), "resource_publications").await
}
// ---------------------------------------------------------------------------
// Позитивный lifecycle: published → archived с точным CAS
// ---------------------------------------------------------------------------
#[tokio::test(flavor = "multi_thread")]
#[serial]
async fn story37_at06_archive_requires_exact_precondition_and_keeps_published_snapshot() {
let (registry, server, client) = spawn_authorized("story37_at06_archive_contract").await;
let bytes = b"story37 archive body".to_vec();
let published = create_and_publish(
&client,
&server,
&draft_metadata(
"crank://story37/archive",
"archive_doc",
"text",
"text/plain",
"internal",
),
&bytes,
"story37-archive.txt",
"text/plain",
)
.await;
let resource_id = published.draft.resource_id.clone();
let before_card = get_card(&client, &server, &resource_id).await;
assert_eq!(
before_card["resource"]["status"],
json!("published"),
"the fixture premise is a published Resource: card={before_card}"
);
let published_version = published.published_version.clone();
let (content_status, published_bytes) =
read_version_bytes(&client, &server, &resource_id, 1).await;
assert_eq!(
content_status,
StatusCode::OK,
"published bytes must be readable"
);
assert_eq!(
published_bytes, bytes,
"the published bytes are the fixture's exact bytes"
);
let rows_before = publication_rows(&registry).await;
let card_cas = draft_updated_at(&before_card);
// POST archive с точным precondition карточки.
let (status, text, body) = archive(&client, &server, &resource_id, &card_cas).await;
assert_eq!(
status,
StatusCode::OK,
"POST .../resources/{{id}}/archive must archive a published Resource (AT-3.7-05/06); \
observed {} body={text}",
error_signature(status, &body)
);
let archived_card = get_card(&client, &server, &resource_id).await;
assert_eq!(
archived_card["resource"]["status"],
json!("archived"),
"the archive action must persist the archived lifecycle: card={archived_card}"
);
assert_ne!(
draft_updated_at(&archived_card),
card_cas,
"an accepted archive must advance the Resource revision so the old CAS is stale"
);
// Immutable history: точная Published Version не изменилась и не удалена.
let version_after = super::publication::read_version(&client, &server, &resource_id, 1).await;
assert_eq!(
version_after.0,
StatusCode::OK,
"archived history must stay readable"
);
assert_eq!(
version_after.2, published_version,
"archive must not modify Published metadata"
);
let (status_after, bytes_after) = read_version_bytes(&client, &server, &resource_id, 1).await;
assert_eq!(status_after, StatusCode::OK);
assert_eq!(
bytes_after, bytes,
"archive must not modify or delete Published bytes"
);
assert_eq!(
publication_rows(&registry).await,
rows_before,
"archive must not create or delete publication rows"
);
// Повтор архива с прежним CAS — stale, без side effects.
let (status, text, body) = archive(&client, &server, &resource_id, &card_cas).await;
assert_eq!(
status,
StatusCode::PRECONDITION_REQUIRED,
"a repeated archive with the previous CAS must be 428; observed {} body={text}",
error_signature(status, &body)
);
assert_eq!(body["error"]["code"], json!("resource_stale"));
assert_eq!(
body["error"]["context"]["recovery"],
json!("reload"),
"the stale archive must keep the accepted reload recovery: body={body}"
);
let unchanged = get_card(&client, &server, &resource_id).await;
assert_eq!(
unchanged, archived_card,
"a stale archive must not change the Resource card"
);
assert_eq!(
publication_rows(&registry).await,
rows_before,
"a stale archive must not create publication rows"
);
}
// ---------------------------------------------------------------------------
// Guards: archive использует ту же session/CSRF/origin/role-защиту, что publish
// ---------------------------------------------------------------------------
#[tokio::test(flavor = "multi_thread")]
#[serial]
async fn story37_at06_archive_guards_mirror_publish_authorization() {
let (registry, server, client) = spawn_authorized("story37_at06_archive_guards").await;
let fixture = create_fixture(
&client,
&server,
&draft_metadata(
"crank://story37/archive-guard",
"archive_guard",
"text",
"text/plain",
"internal",
),
b"archive guard body",
"story37-archive-guard.txt",
"text/plain",
)
.await;
let resource_id = fixture.resource_id.clone();
let cas = fixture.updated_at.clone();
let rows_before = publication_rows(&registry).await;
// (a) без сессии.
let anonymous = reqwest::Client::new();
let (status, text, _) = archive(&anonymous, &server, &resource_id, &cas).await;
assert_eq!(
status,
StatusCode::UNAUTHORIZED,
"an archive without a session must be refused: {text}"
);
// (b) сессия без CSRF.
let without_csrf =
login_client_without_csrf(&server, TEST_AUTH_EMAIL, TEST_AUTH_PASSWORD).await;
let (status, text, _) = archive(&without_csrf, &server, &resource_id, &cas).await;
assert_eq!(
status,
StatusCode::FORBIDDEN,
"an archive 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, _) = archive(&foreign_origin, &server, &resource_id, &cas).await;
assert_eq!(
status,
StatusCode::FORBIDDEN,
"a cross-origin archive must be refused: {text}"
);
// (d) Viewer не мутирует lifecycle.
let (viewer_email, viewer_password) = ensure_viewer_membership(&registry).await;
let viewer = login_client(&server, viewer_email, viewer_password).await;
let (status, text, body) = archive(&viewer, &server, &resource_id, &cas).await;
assert_eq!(
status,
StatusCode::FORBIDDEN,
"a Viewer must not archive a Resource: observed {} body={text}",
error_signature(status, &body)
);
// Ни один негатив не изменил карточку и не создал публикаций.
let unchanged = get_card(&client, &server, &resource_id).await;
assert_eq!(
unchanged, fixture.card,
"refused archives must not change the Resource card"
);
assert_eq!(publication_rows(&registry).await, rows_before);
// Положительный контроль: владелец архивирует тот же Resource.
let (status, text, body) = archive(&client, &server, &resource_id, &cas).await;
assert_eq!(
status,
StatusCode::OK,
"the owner must be able to archive after the refusals; observed {} body={text}",
error_signature(status, &body)
);
let archived = get_card(&client, &server, &resource_id).await;
assert_eq!(archived["resource"]["status"], json!("archived"));
}
// ---------------------------------------------------------------------------
// Негативы precondition/not-found не раскрывают чужие данные
// ---------------------------------------------------------------------------
#[tokio::test(flavor = "multi_thread")]
#[serial]
async fn story37_at06_archive_missing_precondition_and_unknown_resource_are_sanitized() {
let (registry, _server, client) = spawn_authorized("story37_at06_archive_negatives").await;
// spawn_authorized возвращает сервер; используем его явно, чтобы префиксы путей совпали.
let server = _server;
let fixture = create_fixture(
&client,
&server,
&draft_metadata(
"crank://story37/archive-negative",
"archive_negative",
"text",
"text/plain",
"internal",
),
b"archive negative body",
"story37-archive-negative.txt",
"text/plain",
)
.await;
let rows_before = publication_rows(&registry).await;
// Отсутствие precondition — тот же 428 resource_stale/reload, что у publish/PUT.
let (status, text, body) =
archive_raw(&client, &server, &fixture.resource_id, &json!({})).await;
assert_eq!(
status,
StatusCode::PRECONDITION_REQUIRED,
"archive without a precondition must be 428; observed {} body={text}",
error_signature(status, &body)
);
assert_eq!(body["error"]["code"], json!("resource_stale"));
assert_eq!(body["error"]["context"]["recovery"], json!("reload"));
assert_eq!(
get_card(&client, &server, &fixture.resource_id).await,
fixture.card,
"a precondition-less archive must not change the Resource card"
);
// Неизвестный Resource: sanitized 404, без bytes/чужой metadata.
let (status, text, body) = archive(
&client,
&server,
"res_story37_archive_unknown",
&fixture.updated_at,
)
.await;
assert_eq!(
status,
StatusCode::NOT_FOUND,
"an unknown Resource archive must be 404; observed {} body={text}",
error_signature(status, &body)
);
assert_eq!(
body["error"]["code"],
json!("resource_not_found"),
"the 404 must be the accepted sanitized Resource taxonomy: body={body}"
);
assert_eq!(publication_rows(&registry).await, rows_before);
}
// ---------------------------------------------------------------------------
// Чужой workspace: archive не находит Resource и не мутирует его lifecycle
// ---------------------------------------------------------------------------
#[tokio::test(flavor = "multi_thread")]
#[serial]
async fn story37_at06_archive_in_foreign_workspace_is_not_found_without_mutation() {
let (registry, server, _client) = spawn_authorized("story37_at06_archive_foreign").await;
let published = create_and_publish(
&_client,
&server,
&draft_metadata(
"crank://story37/archive-foreign",
"archive_foreign",
"text",
"text/plain",
"internal",
),
b"archive foreign body",
"story37-archive-foreign.txt",
"text/plain",
)
.await;
let resource_id = published.draft.resource_id.clone();
let card = get_card(&_client, &server, &resource_id).await;
let cas = draft_updated_at(&card);
let rows_before = publication_rows(&registry).await;
// WorkspaceB доступен тому же аккаунту (Owner), но Resource принадлежит WorkspaceA:
// archive обязан дать sanitized 404 и не тронуть lifecycle/published history.
let owned_workspace = create_owned_workspace(&registry).await;
let workspace_b = server
.as_ref()
.replace(DEFAULT_WORKSPACE_ID, owned_workspace.as_str());
assert_ne!(
workspace_b,
server.as_ref(),
"the foreign workspace base must really differ from the owning workspace"
);
let client = login_client(&server, TEST_AUTH_EMAIL, TEST_AUTH_PASSWORD).await;
let (status, text, body) = archive(&client, &workspace_b, &resource_id, &cas).await;
assert_eq!(
status,
StatusCode::NOT_FOUND,
"archiving another workspace's Resource must be 404; observed {} body={text}",
error_signature(status, &body)
);
assert_eq!(body["error"]["code"], json!("resource_not_found"));
assert!(
!text.contains("archive_foreign") && !text.contains("crank://story37/archive-foreign"),
"the refusal must not disclose foreign Resource metadata: {text}"
);
// Никакой мутации: карточка и публикация в исходном workspace те же.
assert_eq!(
get_card(&_client, &server, &resource_id).await,
card,
"a foreign-workspace archive must not change the Resource card"
);
assert_eq!(
publication_rows(&registry).await,
rows_before,
"a foreign-workspace archive must not create or delete publications"
);
let version = super::publication::read_version(&_client, &server, &resource_id, 1).await;
assert_eq!(
version.2, published.published_version,
"the exact Published metadata must stay unchanged"
);
}
// ---------------------------------------------------------------------------
// Lifecycle-отказ: актуальный CAS на archived Resource — 409, не 500
// ---------------------------------------------------------------------------
#[tokio::test(flavor = "multi_thread")]
#[serial]
async fn story37_at06_archived_resource_rejects_publish_update_and_repeat_archive() {
let (registry, server, client) = spawn_authorized("story37_at06_archive_lifecycle").await;
let published = create_and_publish(
&client,
&server,
&draft_metadata(
"crank://story37/archive-lifecycle",
"archive_lifecycle",
"text",
"text/plain",
"internal",
),
b"archive lifecycle body",
"story37-archive-lifecycle.txt",
"text/plain",
)
.await;
let resource_id = published.draft.resource_id.clone();
let before_archive = get_card(&client, &server, &resource_id).await;
let (status, text, body) = archive(
&client,
&server,
&resource_id,
&draft_updated_at(&before_archive),
)
.await;
assert_eq!(
status,
StatusCode::OK,
"positive control: a published Resource must be archivable; observed {} body={text}",
error_signature(status, &body)
);
let archived = get_card(&client, &server, &resource_id).await;
assert_eq!(archived["resource"]["status"], json!("archived"));
let archived_cas = draft_updated_at(&archived);
let publication_rows_before = publication_rows(&registry).await;
let version_rows_before = table_row_count(registry.pool(), "resource_versions").await;
// Повтор архива с АКТУАЛЬНЫМ CAS — существующий lifecycle-код 409, без mutation.
let (status, text, body) = archive(&client, &server, &resource_id, &archived_cas).await;
assert_eq!(
status,
StatusCode::CONFLICT,
"a repeated archive with the current CAS must be a sanitized lifecycle refusal; \
observed {} body={text}",
error_signature(status, &body)
);
assert_eq!(body["error"]["code"], json!("resource_lifecycle_invalid"));
assert_eq!(
get_card(&client, &server, &resource_id).await,
archived,
"a refused repeated archive must not change the archived card"
);
// Публикация архивного Resource с АКТУАЛЬНЫМ CAS — тот же lifecycle-код, не 500.
let (status, text, body) =
super::publication::publish(&client, &server, &resource_id, &archived_cas).await;
assert_eq!(
status,
StatusCode::CONFLICT,
"publishing an archived Resource must be a sanitized lifecycle refusal; \
observed {} body={text}",
error_signature(status, &body)
);
assert_eq!(body["error"]["code"], json!("resource_lifecycle_invalid"));
assert!(
!body.to_string().contains("internal server error"),
"a lifecycle refusal must not be reported as an internal error: {body}"
);
// PUT архивного Resource с АКТУАЛЬНЫМ CAS — тот же lifecycle-код, без новой версии.
let (status, text, body) = read_response(
client
.put(format!("{server}/resources/{resource_id}"))
.multipart(draft_form(
&json!({
"description": "archived update attempt",
"mime_type": "text/plain",
"sensitivity": "internal",
"expected_updated_at": archived_cas,
}),
b"archived update attempt body",
"story37-archive-lifecycle-v2.txt",
"text/plain",
))
.send()
.await
.expect("archived update request must complete"),
)
.await;
assert_eq!(
status,
StatusCode::CONFLICT,
"updating an archived Resource must be a sanitized lifecycle refusal; \
observed {} body={text}",
error_signature(status, &body)
);
assert_eq!(body["error"]["code"], json!("resource_lifecycle_invalid"));
// Ни один отказ не изменил карточку, версии, публикации и точную Published Version.
assert_eq!(
get_card(&client, &server, &resource_id).await,
archived,
"lifecycle refusals must not change the archived card"
);
assert_eq!(
publication_rows(&registry).await,
publication_rows_before,
"lifecycle refusals must not create or delete publications"
);
assert_eq!(
table_row_count(registry.pool(), "resource_versions").await,
version_rows_before,
"a refused archived update must not create a Draft version"
);
let version_after = super::publication::read_version(&client, &server, &resource_id, 1).await;
assert_eq!(
version_after.2, published.published_version,
"archive and refused lifecycle actions must not modify the Published metadata"
);
}
// ---------------------------------------------------------------------------
// Архив не меняет существующий immutable Agent snapshot
// ---------------------------------------------------------------------------
#[tokio::test(flavor = "multi_thread")]
#[serial]
async fn story37_at06_archive_keeps_existing_agent_catalog_snapshot() {
let (_registry, server, client) = spawn_authorized("story37_at06_archive_agent").await;
let published = create_and_publish(
&client,
&server,
&draft_metadata(
"crank://story37/archive-agent",
"archive_agent",
"text",
"text/plain",
"internal",
),
b"archive agent body",
"story37-archive-agent.txt",
"text/plain",
)
.await;
let resource_id = published.draft.resource_id.clone();
let created = read_response(
client
.post(format!("{server}/agents"))
.json(&json!({
"slug": "story37_archive_agent",
"display_name": "Story 3.7 archive Agent",
"description": "Agent snapshot must survive Resource archive",
"instructions": {},
"tool_selection_policy": {},
}))
.send()
.await
.expect("agent create request must complete"),
)
.await;
assert!(
created.0.is_success(),
"positive control: the Agent fixture must be created; observed {}",
error_signature(created.0, &created.2)
);
let agent_id = created.2["agent_id"]
.as_str()
.expect("created Agent must expose agent_id")
.to_owned();
let etag = super::super::common::agent_etag(&client, &server, &agent_id).await;
let bound = read_response(
client
.post(format!("{server}/agents/{agent_id}/bindings"))
.header(reqwest::header::IF_MATCH, etag)
.json(&json!({
"bindings": [],
"tool_selection_policy": {},
"resource_bindings": [{ "resource_id": resource_id, "resource_version": 1 }],
}))
.send()
.await
.expect("agent bindings request must complete"),
)
.await;
assert_eq!(
bound.0,
StatusCode::OK,
"positive control: the exact Published Resource Version must bind; observed {} body={}",
error_signature(bound.0, &bound.2),
bound.1
);
let etag = super::super::common::agent_etag(&client, &server, &agent_id).await;
let agent_published = read_response(
client
.post(format!("{server}/agents/{agent_id}/publish"))
.header(reqwest::header::IF_MATCH, etag)
.json(&json!({ "version": 1 }))
.send()
.await
.expect("agent publish request must complete"),
)
.await;
assert_eq!(
agent_published.0,
StatusCode::OK,
"positive control: a Resource-only Agent must publish; observed {} body={}",
error_signature(agent_published.0, &agent_published.2),
agent_published.1
);
let summary_before = get_card(&client, &server, &resource_id).await;
let agent_before = read_response(
client
.get(format!("{server}/agents/{agent_id}"))
.send()
.await
.expect("agent summary request must complete"),
)
.await;
let catalog_before = agent_before.2["catalog_revision"].clone();
let agent_version_before = read_response(
client
.get(format!("{server}/agents/{agent_id}/versions/1"))
.send()
.await
.expect("agent version request must complete"),
)
.await;
assert_eq!(agent_version_before.0, StatusCode::OK);
let (status, text, body) = archive(
&client,
&server,
&resource_id,
&draft_updated_at(&summary_before),
)
.await;
assert_eq!(
status,
StatusCode::OK,
"the published Resource must archive; observed {} body={text}",
error_signature(status, &body)
);
let agent_after = read_response(
client
.get(format!("{server}/agents/{agent_id}"))
.send()
.await
.expect("agent summary request must complete"),
)
.await;
assert_eq!(
agent_after.2["catalog_revision"], catalog_before,
"archiving a Resource must not bump the Agent catalog_revision"
);
let agent_version_after = read_response(
client
.get(format!("{server}/agents/{agent_id}/versions/1"))
.send()
.await
.expect("agent version request must complete"),
)
.await;
assert_eq!(
agent_version_after.2, agent_version_before.2,
"archiving a Resource must not modify the existing immutable Agent snapshot"
);
}