//! ATDD (RED) Story 3.7 — AC04 и stale-Agent часть AC06: exact Resource binding. //! //! Источники: live Gitea #14 (`STORY37-SOURCE.md`, AC04/AC06), canonical `tickets.toml` //! entry 7 (lines 174–232), `docs/acceptance-test-plan.md` AT-3.7-04/06, //! `_bmad-output/test-artifacts/test-design-epic-3.md` rows 3.7-INT-A/B (risk E3-R3) и //! TL interface decisions (`.tmp/t_8c38b75f/STORY37-NEXT.md`, пункты 1–4). //! //! Контракт реализован в Story 3.7 build: `resource_bindings` в Config-форме //! `POST .../agents/{agent_id}/bindings`, отдельный `resource_bindings` в ответе //! `AgentVersionRecord`, typed binding table `agent_resource_bindings` (V18) и //! атомарный `catalog_revision`. Эти тесты остаются behavioural ATDD: они //! проверяют реальный HTTP-ответ и PostgreSQL-инварианты, а не строки исходников. //! Позитивный контроль `story37_at04_...` держит уже принятое поведение публикации //! Resource (`story37_at03_*`) и публикации Agent. //! //! Фильтр запуска: //! `cargo test -p admin-api --test integration --locked story37_at04_ -- --test-threads=1` //! (stale-Agent тесты: `story37_at06_`). use reqwest::StatusCode; use serde_json::json; use serial_test::serial; use super::common::*; mod fixtures; use fixtures::*; #[tokio::test(flavor = "multi_thread", worker_threads = 2)] #[serial] async fn story37_at04_resource_binding_pins_exact_published_version() { let (_registry, server, client) = spawn_workspace("story37_at04_pin").await; let server_url = server.as_ref().to_owned(); let upstream = spawn_upstream_server().await; let (resource_id, _) = create_published_resource( &client, &server_url, "crank://story37/pin", "pin_doc", b"v1\n", ) .await; let operation_id = create_published_operation(&client, &server_url, &upstream, "story37_pin_tool").await; let agent_id = create_agent(&client, &server_url, "story37-at04-pin-agent").await; // Config-форма: существующие Operation bindings + additive exact Resource binding. let saved = save_bindings_expect_success( &client, &server_url, &agent_id, &catalog_config( json!([operation_binding(&operation_id, "story37_pin_tool")]), json!([resource_binding(&resource_id, 1)]), ), "AC04 exact binding v1", ) .await; assert_eq!( saved["resource_bindings"], expected_resource_bindings(&resource_id, 1), "save response must expose the exact typed Resource binding next to Operation bindings: \ {saved}" ); assert_eq!( saved["bindings"].as_array().map(|items| items.len()), Some(1), "existing Operation bindings must keep their meaning in Config form: {saved}" ); let draft = get_agent_version(&client, &server_url, &agent_id, 1).await; assert_eq!( draft["resource_bindings"], expected_resource_bindings(&resource_id, 1), "GET versions/1 must return the same exact typed Resource binding: {draft}" ); let before_publish = get_agent(&client, &server_url, &agent_id).await; let catalog_before = before_publish["catalog_revision"] .as_i64() .unwrap_or_else(|| panic!("agent summary must expose catalog_revision: {before_publish}")); publish_agent_expect_success(&client, &server_url, &agent_id, 1, "AC04 publication").await; let after_publish = get_agent(&client, &server_url, &agent_id).await; assert_eq!( after_publish["catalog_revision"].as_i64(), Some(catalog_before + 1), "Agent publication must raise catalog_revision by exactly one: {before_publish} -> {after_publish}" ); let published = get_agent_version(&client, &server_url, &agent_id, 1).await; assert_eq!( published["resource_bindings"], expected_resource_bindings(&resource_id, 1), "the published immutable Agent snapshot must carry the exact Resource Version: {published}" ); // Resource v2 не меняет уже зафиксированный v1 snapshot и catalog_revision. edit_and_publish_second_version(&client, &server_url, &resource_id, b"v2\n", "resource v2") .await; let still_pinned = get_agent_version(&client, &server_url, &agent_id, 1).await; assert_eq!( still_pinned["resource_bindings"], expected_resource_bindings(&resource_id, 1), "a newer Published Resource Version must not replace the pinned v1 in the Agent snapshot: \ {still_pinned}" ); let after_resource_v2 = get_agent(&client, &server_url, &agent_id).await; assert_eq!( after_resource_v2["catalog_revision"].as_i64(), Some(catalog_before + 1), "a Resource publication must not bump the Agent catalog_revision: {after_resource_v2}" ); } #[tokio::test(flavor = "multi_thread", worker_threads = 2)] #[serial] async fn story37_at04_republish_agent_changes_resource_snapshot_only_explicitly() { let (_registry, server, client) = spawn_workspace("story37_at04_republish").await; let server_url = server.as_ref().to_owned(); let upstream = spawn_upstream_server().await; let (resource_id, _) = create_published_resource( &client, &server_url, "crank://story37/republish", "republish_doc", b"pinned v1\n", ) .await; let operation_id = create_published_operation(&client, &server_url, &upstream, "story37_republish_tool").await; let agent_id = create_agent(&client, &server_url, "story37-at04-republish-agent").await; save_bindings_expect_success( &client, &server_url, &agent_id, &catalog_config( json!([operation_binding(&operation_id, "story37_republish_tool")]), json!([resource_binding(&resource_id, 1)]), ), "republish: initial v1 binding", ) .await; publish_agent_expect_success(&client, &server_url, &agent_id, 1, "republish: publish v1").await; let published_v1 = get_agent_version(&client, &server_url, &agent_id, 1).await; assert_eq!( published_v1["resource_bindings"], expected_resource_bindings(&resource_id, 1), "published v1 snapshot must carry Resource v1: {published_v1}" ); edit_and_publish_second_version(&client, &server_url, &resource_id, b"pinned v2\n", "v2").await; // Явное изменение binding на v2 форкает новый Draft и только он несёт v2. let draft_v2 = save_bindings_expect_success( &client, &server_url, &agent_id, &catalog_config( json!([operation_binding(&operation_id, "story37_republish_tool")]), json!([resource_binding(&resource_id, 2)]), ), "republish: explicit v2 binding", ) .await; assert_eq!( draft_v2["version"], json!(2), "editing a published Agent must fork exactly one new Draft version: {draft_v2}" ); assert_eq!( draft_v2["resource_bindings"], expected_resource_bindings(&resource_id, 2), "the new Draft must carry the explicitly requested v2: {draft_v2}" ); // Старый published snapshot остаётся exact v1. let published_v1_after = get_agent_version(&client, &server_url, &agent_id, 1).await; assert_eq!( published_v1_after["resource_bindings"], expected_resource_bindings(&resource_id, 1), "the earlier published snapshot must not change when the Draft pins v2: {published_v1_after}" ); let before_republish = get_agent(&client, &server_url, &agent_id).await; let catalog_before = before_republish["catalog_revision"].as_i64().unwrap(); publish_agent_expect_success(&client, &server_url, &agent_id, 2, "republish: publish v2").await; let published_v2 = get_agent_version(&client, &server_url, &agent_id, 2).await; assert_eq!( published_v2["resource_bindings"], expected_resource_bindings(&resource_id, 2), "the explicitly republished snapshot must carry v2: {published_v2}" ); let after_republish = get_agent(&client, &server_url, &agent_id).await; assert_eq!( after_republish["catalog_revision"].as_i64(), Some(catalog_before + 1), "the second Agent publication must raise catalog_revision by exactly one: {after_republish}" ); } #[tokio::test(flavor = "multi_thread", worker_threads = 2)] #[serial] async fn story37_at04_foreign_and_unpublished_versions_are_sanitized_404() { let (registry, server, client) = spawn_workspace("story37_at04_scope").await; let server_url = server.as_ref().to_owned(); let upstream = spawn_upstream_server().await; // Draft, который никогда не публиковался: точная версия недоступна для binding. let unpublished_metadata = draft_metadata( "crank://story37/unpublished", "unpublished_doc", "text", "text/plain", "internal", ); let (unpublished_id, _) = create_draft( &client, &server_url, &unpublished_metadata, b"never published\n", "story37-unpublished.txt", "text/plain", ) .await; // Чужой опубликованный Resource Version в WorkspaceB. let foreign_workspace = create_owned_workspace(®istry, "ws_story37_at04_foreign", "story37-at04-foreign").await; let foreign_url = workspace_url(&server, foreign_workspace.as_str()); let foreign_client = authorized_client(&foreign_url).await; let (foreign_id, _) = create_published_resource( &foreign_client, &foreign_url, "crank://story37/foreign", "foreign_doc", b"foreign v1\n", ) .await; let operation_id = create_published_operation(&client, &server_url, &upstream, "story37_scope_tool").await; let agent_id = create_agent(&client, &server_url, "story37-at04-scope-agent").await; save_bindings_expect_success( &client, &server_url, &agent_id, &catalog_config( json!([operation_binding(&operation_id, "story37_scope_tool")]), json!([]), ), "scope: base Agent config", ) .await; let before = get_agent(&client, &server_url, &agent_id).await; let before_version = get_agent_version(&client, &server_url, &agent_id, 1).await; let before_catalog = before["catalog_revision"].as_i64().unwrap(); let before_versions = agent_version_count(®istry, &agent_id).await; let etag = agent_etag(&client, &server_url, &agent_id).await; let (foreign_status, foreign_text, foreign_body) = save_bindings_raw( &client, &server_url, &agent_id, &etag, &catalog_config( json!([operation_binding(&operation_id, "story37_scope_tool")]), json!([resource_binding(&foreign_id, 1)]), ), ) .await; assert_eq!( foreign_status, StatusCode::NOT_FOUND, "a foreign workspace Resource Version must be refused as sanitized 404; \ observed {foreign_status} body={foreign_text}" ); assert!( foreign_body["error"]["code"].is_string(), "refusal must keep the sanitized error envelope: {foreign_text}" ); let etag = agent_etag(&client, &server_url, &agent_id).await; let (unpublished_status, unpublished_text, unpublished_body) = save_bindings_raw( &client, &server_url, &agent_id, &etag, &catalog_config( json!([operation_binding(&operation_id, "story37_scope_tool")]), json!([resource_binding(&unpublished_id, 1)]), ), ) .await; assert_eq!( unpublished_status, StatusCode::NOT_FOUND, "an unpublished Resource Version must be refused as sanitized 404; \ observed {unpublished_status} body={unpublished_text}" ); assert_eq!( unpublished_body["error"]["code"], foreign_body["error"]["code"], "foreign and unpublished/missing versions must be indistinguishable: \ foreign={foreign_text} unpublished={unpublished_text}" ); // Несуществующая Resource Version даёт тот же sanitized 404 (нет утечки существования). let etag = agent_etag(&client, &server_url, &agent_id).await; let (missing_status, missing_text, missing_body) = save_bindings_raw( &client, &server_url, &agent_id, &etag, &catalog_config( json!([operation_binding(&operation_id, "story37_scope_tool")]), json!([resource_binding("res_story37_missing", 1)]), ), ) .await; assert_eq!( missing_status, StatusCode::NOT_FOUND, "a missing Resource Version must be refused as sanitized 404; \ observed {missing_status} body={missing_text}" ); assert_eq!( missing_body["error"]["code"], foreign_body["error"]["code"], "missing, foreign and unpublished versions must share one taxonomy: \ foreign={foreign_text} missing={missing_text}" ); // Отказ не меняет Draft/snapshot/catalog_revision и не пишет новую версию. assert_eq!( get_agent_version(&client, &server_url, &agent_id, 1).await, before_version, "a refused Resource binding must not mutate the Agent version" ); let after = get_agent(&client, &server_url, &agent_id).await; assert_eq!( after["catalog_revision"].as_i64(), Some(before_catalog), "a refused Resource binding must not change catalog_revision: {after}" ); assert_eq!( after["current_draft_version"], before["current_draft_version"], "a refused Resource binding must not fork a Draft version: {after}" ); assert_eq!( agent_version_count(®istry, &agent_id).await, before_versions, "a refused Resource binding must not write an Agent version row" ); } #[tokio::test(flavor = "multi_thread", worker_threads = 2)] #[serial] async fn story37_at04_duplicate_and_invalid_resource_bindings_refused_without_writes() { let (registry, server, client) = spawn_workspace("story37_at04_invalid").await; let server_url = server.as_ref().to_owned(); let upstream = spawn_upstream_server().await; let (resource_id, _) = create_published_resource( &client, &server_url, "crank://story37/invalid", "invalid_doc", b"valid v1\n", ) .await; let operation_id = create_published_operation(&client, &server_url, &upstream, "story37_invalid_tool").await; let agent_id = create_agent(&client, &server_url, "story37-at04-invalid-agent").await; let saved = save_bindings_expect_success( &client, &server_url, &agent_id, &catalog_config( json!([operation_binding(&operation_id, "story37_invalid_tool")]), json!([resource_binding(&resource_id, 1)]), ), "invalid: base config", ) .await; assert_eq!( saved["resource_bindings"], expected_resource_bindings(&resource_id, 1), "base config must be saved before the refusal checks: {saved}" ); let before = get_agent(&client, &server_url, &agent_id).await; let before_version = get_agent_version(&client, &server_url, &agent_id, 1).await; let before_catalog = before["catalog_revision"].as_i64().unwrap(); let before_versions = agent_version_count(®istry, &agent_id).await; // Повтор пары в одном запросе — validation refusal без partial writes. let duplicate = json!([ resource_binding(&resource_id, 1), resource_binding(&resource_id, 1) ]); let etag = agent_etag(&client, &server_url, &agent_id).await; let (status, text, body) = save_bindings_raw( &client, &server_url, &agent_id, &etag, &catalog_config( json!([operation_binding(&operation_id, "story37_invalid_tool")]), duplicate, ), ) .await; assert_eq!( status, StatusCode::BAD_REQUEST, "a duplicated (resource_id, resource_version) pair must be a validation refusal; \ observed {status} body={text}" ); assert!( body["error"]["code"].is_string(), "validation refusal must keep the sanitized error envelope: {text}" ); // Невалидный exact version (не positive integer) также отклоняется до записи. let etag = agent_etag(&client, &server_url, &agent_id).await; let (status, text, _) = save_bindings_raw( &client, &server_url, &agent_id, &etag, &catalog_config( json!([operation_binding(&operation_id, "story37_invalid_tool")]), json!([resource_binding(&resource_id, 0)]), ), ) .await; assert_eq!( status, StatusCode::BAD_REQUEST, "resource_version must be a positive exact integer; observed {status} body={text}" ); assert_eq!( get_agent_version(&client, &server_url, &agent_id, 1).await, before_version, "invalid Resource bindings must not mutate the Agent version" ); let after = get_agent(&client, &server_url, &agent_id).await; assert_eq!( after["catalog_revision"].as_i64(), Some(before_catalog), "invalid Resource bindings must not change catalog_revision: {after}" ); assert_eq!( after["current_draft_version"], before["current_draft_version"], "invalid Resource bindings must not fork a Draft version: {after}" ); assert_eq!( agent_version_count(®istry, &agent_id).await, before_versions, "invalid Resource bindings must not write an Agent version row" ); } #[tokio::test(flavor = "multi_thread", worker_threads = 2)] #[serial] async fn story37_at04_resource_only_agent_publishes_exact_snapshot() { let (_registry, server, client) = spawn_workspace("story37_at04_resource_only").await; let server_url = server.as_ref().to_owned(); let (resource_id, _) = create_published_resource( &client, &server_url, "crank://story37/resource-only", "resource_only_doc", b"resource only\n", ) .await; let agent_id = create_agent(&client, &server_url, "story37-at04-resource-only").await; let saved = save_bindings_expect_success( &client, &server_url, &agent_id, &catalog_config(json!([]), json!([resource_binding(&resource_id, 1)])), "resource-only Agent: save", ) .await; assert_eq!( saved["resource_bindings"], expected_resource_bindings(&resource_id, 1), "a Resource-only Agent must still expose its exact typed binding: {saved}" ); assert_eq!( saved["bindings"].as_array().map(|items| items.len()), Some(0), "empty Operation bindings must stay valid: {saved}" ); let before = get_agent(&client, &server_url, &agent_id).await; let catalog_before = before["catalog_revision"].as_i64().unwrap(); publish_agent_expect_success( &client, &server_url, &agent_id, 1, "resource-only Agent publication", ) .await; let published = get_agent_version(&client, &server_url, &agent_id, 1).await; assert_eq!( published["resource_bindings"], expected_resource_bindings(&resource_id, 1), "the published snapshot must atomically include the Resource: {published}" ); let after = get_agent(&client, &server_url, &agent_id).await; assert_eq!( after["catalog_revision"].as_i64(), Some(catalog_before + 1), "resource-only publication must raise catalog_revision by exactly one: {after}" ); } #[tokio::test(flavor = "multi_thread", worker_threads = 2)] #[serial] async fn story37_at04_absent_or_legacy_config_preserves_and_explicit_empty_clears() { let (_registry, server, client) = spawn_workspace("story37_at04_tristate").await; let server_url = server.as_ref().to_owned(); let upstream = spawn_upstream_server().await; let (resource_id, _) = create_published_resource( &client, &server_url, "crank://story37/tristate", "tristate_doc", b"tristate v1\n", ) .await; let operation_id = create_published_operation(&client, &server_url, &upstream, "story37_tristate_tool").await; let agent_id = create_agent(&client, &server_url, "story37-at04-tristate-agent").await; let saved = save_bindings_expect_success( &client, &server_url, &agent_id, &catalog_config( json!([operation_binding(&operation_id, "story37_tristate_tool")]), json!([resource_binding(&resource_id, 1)]), ), "tristate: base v1 binding", ) .await; assert_eq!( saved["resource_bindings"], expected_resource_bindings(&resource_id, 1), "the base config must pin v1: {saved}" ); // Config без поля `resource_bindings` сохраняет прежние Resource bindings. let preserved = save_bindings_expect_success( &client, &server_url, &agent_id, &json!({ "bindings": [operation_binding(&operation_id, "story37_tristate_tool")], "tool_selection_policy": {}, }), "tristate: absent field preserves", ) .await; assert_eq!( preserved["resource_bindings"], expected_resource_bindings(&resource_id, 1), "an absent additive field must preserve the exact binding: {preserved}" ); // Legacy array-форма тоже сохраняет прежние Resource bindings. let legacy = save_bindings_expect_success( &client, &server_url, &agent_id, &json!([operation_binding(&operation_id, "story37_tristate_tool")]), "tristate: legacy array preserves", ) .await; assert_eq!( legacy["resource_bindings"], expected_resource_bindings(&resource_id, 1), "the legacy Operation-bindings array must keep Resource bindings: {legacy}" ); // Явный `[]` очищает Resource bindings в Draft. let cleared = save_bindings_expect_success( &client, &server_url, &agent_id, &catalog_config( json!([operation_binding(&operation_id, "story37_tristate_tool")]), json!([]), ), "tristate: explicit empty clears", ) .await; assert_eq!( cleared["resource_bindings"], json!([]), "an explicit empty list must clear Resource bindings: {cleared}" ); let reread = get_agent_version(&client, &server_url, &agent_id, 1).await; assert_eq!( reread["resource_bindings"], json!([]), "the cleared state must be durable on version 1: {reread}" ); } // --------------------------------------------------------------------------- // AC06: stale Agent revision (Resource binding часть) // --------------------------------------------------------------------------- #[tokio::test(flavor = "multi_thread", worker_threads = 2)] #[serial] async fn story37_at06_stale_agent_save_and_publish_leave_resource_bindings_untouched() { let (registry, server, client) = spawn_workspace("story37_at06_stale").await; let server_url = server.as_ref().to_owned(); let upstream = spawn_upstream_server().await; let (resource_id, _) = create_published_resource( &client, &server_url, "crank://story37/stale", "stale_doc", b"stale v1\n", ) .await; edit_and_publish_second_version(&client, &server_url, &resource_id, b"stale v2\n", "v2").await; let operation_id = create_published_operation(&client, &server_url, &upstream, "story37_stale_tool").await; let agent_id = create_agent(&client, &server_url, "story37-at06-stale-agent").await; save_bindings_expect_success( &client, &server_url, &agent_id, &catalog_config( json!([operation_binding(&operation_id, "story37_stale_tool")]), json!([resource_binding(&resource_id, 1)]), ), "stale: base v1 binding", ) .await; // Устаревший If-Match: параллельная правка summary тем же клиентом. let stale_etag = agent_etag(&client, &server_url, &agent_id).await; let summary_update = read_response( client .patch(format!("{server_url}/agents/{agent_id}")) .header(reqwest::header::IF_MATCH, stale_etag.clone()) .json(&json!({ "slug": "story37-at06-stale-agent", "display_name": "Story 3.7 stale agent (renamed)", "description": "concurrent summary edit makes the prior ETag stale" })) .send() .await .expect("summary update must complete"), ) .await; assert_eq!( summary_update.0, StatusCode::OK, "positive control: the summary edit must be accepted first; observed {} body={}", summary_update.0, summary_update.1 ); let before = get_agent(&client, &server_url, &agent_id).await; let before_version = get_agent_version(&client, &server_url, &agent_id, 1).await; assert_eq!( before_version["resource_bindings"], expected_resource_bindings(&resource_id, 1), "the draft must keep Resource v1 before the stale attempts: {before_version}" ); let catalog_before = before["catalog_revision"].as_i64().unwrap(); let versions_before = agent_version_count(®istry, &agent_id).await; // Stale save с явно запрошенным v2 не должен ничего записать. let (status, text, body) = save_bindings_raw( &client, &server_url, &agent_id, &stale_etag, &catalog_config( json!([operation_binding(&operation_id, "story37_stale_tool")]), json!([resource_binding(&resource_id, 2)]), ), ) .await; assert_eq!( status, StatusCode::CONFLICT, "a stale save must be refused with 409; observed {status} body={text}" ); assert_eq!( body["error"]["code"], json!("agent_stale_revision"), "stale save must keep the Agent taxonomy error code: {text}" ); assert_eq!( body["error"]["context"]["recovery"], json!("reload"), "stale save must keep recovery=reload: {text}" ); // Stale publish не должен ни публиковать, ни повышать catalog_revision. let (status, text, body) = publish_agent_raw(&client, &server_url, &agent_id, &stale_etag, 1).await; assert_eq!( status, StatusCode::CONFLICT, "a stale publish must be refused with 409; observed {status} body={text}" ); assert_eq!( body["error"]["code"], json!("agent_stale_revision"), "stale publish must keep the Agent taxonomy error code: {text}" ); assert_eq!( body["error"]["context"]["recovery"], json!("reload"), "stale publish must keep recovery=reload: {text}" ); assert_eq!( get_agent_version(&client, &server_url, &agent_id, 1).await, before_version, "stale save/publish must not mutate the exact Resource binding snapshot" ); let after = get_agent(&client, &server_url, &agent_id).await; assert_eq!( after["catalog_revision"].as_i64(), Some(catalog_before), "stale save/publish must not bump catalog_revision: {after}" ); assert_eq!( agent_version_count(®istry, &agent_id).await, versions_before, "stale save/publish must not write an Agent version row" ); }