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.
725 lines
27 KiB
Rust
725 lines
27 KiB
Rust
//! 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(®istry).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(®istry).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(®istry).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(®istry).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(®istry).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(®istry).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(®istry).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(®istry).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(®istry).await;
|
||
|
||
// WorkspaceB доступен тому же аккаунту (Owner), но Resource принадлежит WorkspaceA:
|
||
// archive обязан дать sanitized 404 и не тронуть lifecycle/published history.
|
||
let owned_workspace = create_owned_workspace(®istry).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(®istry).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(®istry).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(®istry).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"
|
||
);
|
||
}
|