//! ATDD (RED) Story 3.15 — перенос шаблонов сообщений (Prompts) через API: bounded //! envelope, экспорт Draft и точной Published Version, импорт как **нового** Draft. //! //! Источники: `epics.md`:2887–2918 (полный AC Story 3.15/FR-17), Gitea #22, принятый //! контракт `_bmad-output/initiative-crank/epic-mcp-capabilities/spec-prompt-portability/spec.md`, //! `test-design-epic-3.md`:117 (3.15-E2E-A/B, E3-R2/E3-R3) и принятый аналог Story 3.9. //! //! Состояние на этой стадии: маршрутов `.../prompts/{id}/export`, `.../versions/{n}/export` //! и `POST .../prompts/import` ещё нет. Каждый RED ниже — расхождение на **реальном** //! HTTP-ответе (404/400 вместо 200/201), а не ошибка компиляции, setup или skip. Позитивный //! контроль `story315_at01_positive_control_*` использует уже принятые Story 3.12/3.13 //! контракты на том же сервере/сессии и обязан быть зелёным до реализации. //! //! Запуск: `cargo test -p admin-api --test integration prompt_portability -- --test-threads=1` use reqwest::StatusCode; use serde_json::{Value, json}; use serial_test::serial; use time::OffsetDateTime; use crank_core::{MembershipRole, Workspace, WorkspaceId, WorkspaceStatus}; use crank_registry::{CreateWorkspaceRequest, PostgresRegistry}; use super::common::{ authorized_client, build_test_app, spawn_admin_api, test_auth_settings, test_registry, test_storage_root, }; const DEFAULT_WORKSPACE_ID: &str = "ws_default"; const TEST_AUTH_EMAIL: &str = "owner@crank.local"; const TEST_AUTH_PASSWORD: &str = "test-password"; const ENVELOPE_FORMAT: &str = "crank-prompt-portability"; const ENVELOPE_VERSION: u64 = 1; /// Ключи, которых не должно быть ни в экспортируемом envelope, ни в телах отказов: /// внутренние owning/lifecycle-ссылки и хранилищные детали. const FORBIDDEN_KEYS: &[&str] = &[ "prompt_id", "owner", "owner_user_id", "workspace", "workspace_id", "status", "published_at", "created_at", "updated_at", "storage", "storage_root", "storage_path", "artifact", "artifact_id", "path", "credential", "credentials", "secret", ]; /// Значения, доказывающие утечку внутреннего состояния (пути/БД/ключи). const FORBIDDEN_VALUE_MARKERS: &[&str] = &[ "/home/", "/tmp/", ".tmp/", "postgres://", "test-master-key", "artifact_blobs", "artifact_sources", ]; /// Точный definition шаблона: три роли сообщений, integer/enum-аргументы, default. fn prompt_body(name: &str, description: &str, count_message: &str) -> Value { json!({ "name": name, "description": description, "sensitivity": "internal", "arguments": [ {"name": "count", "schema": {"type": "integer"}, "required": true}, {"name": "tone", "schema": {"type": "string", "enum": ["warm", "plain"]}, "required": false, "default": "warm"} ], "messages": [ {"role": "system", "content": "Be {{tone}}."}, {"role": "user", "content": count_message}, {"role": "assistant", "content": "Done."} ] }) } /// Независимый оракул теста: ровно те поля, которые обязана сохранить wire-форма. fn prompt_block(body: &Value) -> Value { json!({ "name": body["name"], "description": body["description"], "sensitivity": body["sensitivity"], "arguments": body["arguments"], "messages": body["messages"], }) } /// Принятый item view хранит `sensitivity` на уровне Prompt, а не внутри /// `definition`: oracle сравнивает ровно четыре поля определения. fn definition_block(body: &Value) -> Value { json!({ "name": body["name"], "description": body["description"], "arguments": body["arguments"], "messages": body["messages"], }) } fn sorted_keys(value: &Value, context: &str) -> Vec { let mut keys: Vec = value .as_object() .unwrap_or_else(|| panic!("{context}: expected a JSON object, got {value}")) .keys() .cloned() .collect(); keys.sort(); keys } fn assert_keys(value: &Value, expected: &[&str], context: &str) { let mut expected: Vec = expected.iter().map(|key| (*key).to_owned()).collect(); expected.sort(); assert_eq!( sorted_keys(value, context), expected, "{context}: the allowlist of keys must stay exact: {value}" ); } fn assert_no_internal_leak(text: &str, context: &str) { let value: Value = serde_json::from_str(text) .unwrap_or_else(|_| panic!("{context}: expected a JSON document, got: {text}")); assert_no_forbidden_keys(&value, context); for marker in FORBIDDEN_VALUE_MARKERS { assert!( !text.contains(marker), "{context}: internal value marker `{marker}` must not be exported/leaked: {text}" ); } } /// Запрет внутренних полей проверяется по **ключам** JSON, а не по подстрокам: /// значение `sensitivity: "secret"` — принятая классификация, а не утечка /// секрета (defect oracle, QA F3). fn assert_no_forbidden_keys(value: &Value, context: &str) { match value { Value::Object(object) => { for (key, child) in object { assert!( !FORBIDDEN_KEYS.contains(&key.as_str()), "{context}: internal key `{key}` must not be exported/leaked: {value}" ); assert_no_forbidden_keys(child, context); } } Value::Array(items) => { for item in items { assert_no_forbidden_keys(item, context); } } _ => {} } } fn header(headers: &reqwest::header::HeaderMap, name: &str) -> String { headers .get(name) .unwrap_or_else(|| panic!("missing `{name}` header")) .to_str() .unwrap_or_default() .to_owned() } fn error_code(body: &Value) -> String { body["error"]["code"] .as_str() .unwrap_or("") .to_owned() } async fn read(response: reqwest::Response) -> (StatusCode, Value) { let status = response.status(); let text = response.text().await.unwrap_or_default(); (status, serde_json::from_str(&text).unwrap_or(Value::Null)) } async fn create_prompt(client: &reqwest::Client, base: &str, body: &Value) -> Value { let (status, created) = read( client .post(format!("{base}/prompts")) .json(body) .send() .await .expect("create request completes"), ) .await; assert_eq!( status, StatusCode::CREATED, "the accepted Prompt create contract must stay green: {created}" ); created } async fn publish_prompt( client: &reqwest::Client, base: &str, prompt_id: &str, expected_updated_at: &str, ) -> Value { let (status, published) = read( client .post(format!("{base}/prompts/{prompt_id}")) .json(&json!({"action": "publish", "expected_updated_at": expected_updated_at})) .send() .await .expect("publish request completes"), ) .await; assert_eq!( status, StatusCode::OK, "the accepted publish contract must stay green: {published}" ); published } async fn update_prompt( client: &reqwest::Client, base: &str, prompt_id: &str, body: &Value, expected_updated_at: &str, ) -> Value { let mut payload = body.clone(); payload["expected_updated_at"] = json!(expected_updated_at); let (status, updated) = read( client .put(format!("{base}/prompts/{prompt_id}")) .json(&payload) .send() .await .expect("update request completes"), ) .await; assert_eq!( status, StatusCode::OK, "the accepted Draft update contract must stay green: {updated}" ); updated } async fn get_prompt( client: &reqwest::Client, base: &str, prompt_id: &str, version: Option, ) -> (StatusCode, Value) { let url = match version { Some(version) => format!("{base}/prompts/{prompt_id}?version={version}"), None => format!("{base}/prompts/{prompt_id}"), }; read(client.get(url).send().await.expect("read completes")).await } async fn prompt_count(client: &reqwest::Client, base: &str) -> usize { let (status, listed) = read( client .get(format!("{base}/prompts")) .send() .await .expect("list completes"), ) .await; assert_eq!(status, StatusCode::OK, "list must stay green: {listed}"); listed["items"] .as_array() .expect("list exposes items") .len() } struct Export { status: StatusCode, headers: reqwest::header::HeaderMap, raw: String, envelope: Value, } async fn export(client: &reqwest::Client, url: String) -> Export { let response = client.get(url).send().await.expect("export completes"); let status = response.status(); let headers = response.headers().clone(); let raw = response.text().await.unwrap_or_default(); let envelope = serde_json::from_str(&raw).unwrap_or(Value::Null); Export { status, headers, raw, envelope, } } async fn import(client: &reqwest::Client, base: &str, body: &Value) -> (StatusCode, Value) { read( client .post(format!("{base}/prompts/import")) .json(body) .send() .await .expect("import request completes"), ) .await } fn assert_export_headers(export: &Export, name: &str) { assert_eq!( export.status, StatusCode::OK, "export must succeed with the exact envelope: {}", export.raw ); assert_eq!( header(&export.headers, "content-type"), "application/json", "the portability document is JSON, never a rendered template" ); assert_eq!( header(&export.headers, "x-content-type-options"), "nosniff", "export must not be sniffed as another content type" ); assert_eq!( header(&export.headers, "content-disposition"), format!("attachment; filename=\"{name}.crank-prompt.json\""), "the download must be an attachment with a sanitized filename" ); } /// Импорт создаёт новый Draft: точная форма принятого item view. fn assert_imported_draft(imported: &Value, envelope: &Value, source_prompt_id: &str) { let prompt_id = imported["prompt_id"] .as_str() .unwrap_or_else(|| panic!("the import must return the accepted item view: {imported}")); assert!( prompt_id.starts_with("prm_"), "the imported Draft must receive a server-side prompt id: {prompt_id}" ); assert_ne!( prompt_id, source_prompt_id, "import must never reuse the source Prompt identity" ); assert_eq!(imported["version"], 1, "a new Draft starts at version 1"); assert_eq!(imported["current_draft_version"], 1); assert!( imported["latest_published_version"].is_null(), "an imported Prompt is never published: {imported}" ); assert_eq!(imported["status"], "draft"); assert_eq!(imported["sensitivity"], envelope["prompt"]["sensitivity"]); assert_eq!(imported["name"], envelope["prompt"]["name"]); assert_eq!(imported["description"], envelope["prompt"]["description"]); assert_eq!( imported["definition"]["arguments"], envelope["prompt"]["arguments"], "arguments (schema/enum/required/default) must survive the transfer" ); assert_eq!( imported["definition"]["messages"], envelope["prompt"]["messages"], "messages and their roles must survive the transfer" ); } async fn create_workspace(registry: &PostgresRegistry, suffix: &str) -> WorkspaceId { let now = OffsetDateTime::now_utc(); let workspace_id = WorkspaceId::new(format!("ws_story315_{suffix}")); registry .create_workspace(CreateWorkspaceRequest { workspace: &Workspace { id: workspace_id.clone(), slug: format!("story315-{suffix}"), display_name: format!("Story 3.15 {suffix}"), status: WorkspaceStatus::Active, settings: json!({}), created_at: now, updated_at: now, }, }) .await .expect("synthetic workspace creates"); let password_hash = admin_api::auth::hash_password(TEST_AUTH_PASSWORD, &test_auth_settings().password_pepper) .expect("owner password hash"); let owner_id = registry .upsert_bootstrap_user(TEST_AUTH_EMAIL, "Test Owner", &password_hash) .await .expect("owner account"); registry .ensure_membership(&workspace_id, &owner_id, MembershipRole::Owner) .await .expect("owner membership"); workspace_id } fn workspace_base(server: &str, workspace: &WorkspaceId) -> String { server.replace(DEFAULT_WORKSPACE_ID, workspace.as_str()) } /// Позитивный контроль: принятые Story 3.12/3.13 контракты на том же сервере/сессии /// зелёные до появления portability. Доказывает, что RED ниже — отсутствие нового /// поведения, а не сломанный setup. #[tokio::test(flavor = "multi_thread")] #[serial] async fn story315_at01_positive_control_prompt_draft_publish_and_list_stay_green() { let registry = test_registry().await; let server = spawn_admin_api(build_test_app( registry, test_storage_root("story315_positive_control"), )) .await; let client = authorized_client(&server).await; let base = server.as_ref(); let name = "story315 positive control"; let body = prompt_body(name, "accepted contracts stay green", "Count {{count}}."); let created = create_prompt(&client, base, &body).await; let prompt_id = created["prompt_id"].as_str().expect("prompt id returned"); let (status, draft) = get_prompt(&client, base, prompt_id, None).await; assert_eq!(status, StatusCode::OK); assert_eq!(draft["name"], name); assert_eq!(draft["definition"]["messages"].as_array().unwrap().len(), 3); let preview = client .post(format!("{base}/prompts/{prompt_id}/preview")) .json(&json!({"arguments": {"count": 7}})) .send() .await .expect("preview completes"); let (status, preview) = read(preview).await; assert_eq!(status, StatusCode::OK, "preview must stay green: {preview}"); assert_eq!(preview["messages"][1]["content"], "Count 7."); let published = publish_prompt( &client, base, prompt_id, created["updated_at"].as_str().expect("updated_at"), ) .await; assert_eq!(published["status"], "published"); assert_eq!(published["version"], 1); let (status, exact) = get_prompt(&client, base, prompt_id, Some(1)).await; assert_eq!(status, StatusCode::OK); assert_eq!(exact["version"], 1); assert!(prompt_count(&client, base).await >= 1); } /// AC1/AC3 (wire contract): экспорт Draft сохраняет arguments/messages/exact metadata, /// не содержит identities, lifecycle и внутренних путей. #[tokio::test(flavor = "multi_thread")] #[serial] async fn story315_at01_export_draft_envelope_roundtrip_preserves_definition() { let registry = test_registry().await; let server = spawn_admin_api(build_test_app( registry, test_storage_root("story315_export_draft"), )) .await; let client = authorized_client(&server).await; let base = server.as_ref(); let name = "story315_export_draft"; let body = prompt_body(name, "wire contract fixture", "Count {{count}}."); let created = create_prompt(&client, base, &body).await; let prompt_id = created["prompt_id"].as_str().expect("prompt id returned"); let draft_export = export(&client, format!("{base}/prompts/{prompt_id}/export")).await; assert_export_headers(&draft_export, name); assert_no_internal_leak(&draft_export.raw, "draft export"); assert!( !draft_export.envelope.is_null(), "the export must be a JSON envelope: {}", draft_export.raw ); assert_keys( &draft_export.envelope, &["format", "version", "prompt", "source"], "envelope", ); assert_eq!(draft_export.envelope["format"], ENVELOPE_FORMAT); assert_eq!(draft_export.envelope["version"], ENVELOPE_VERSION); assert_keys( &draft_export.envelope["prompt"], &[ "name", "description", "sensitivity", "arguments", "messages", ], "envelope.prompt", ); assert_eq!( draft_export.envelope["prompt"], prompt_block(&body), "the wire contract must preserve arguments/messages/exact metadata unchanged" ); assert_keys( &draft_export.envelope["source"], &["kind", "version"], "envelope.source", ); assert_eq!( draft_export.envelope["source"], json!({"kind": "draft", "version": 1}) ); // Экспорт ничего не публикует и не меняет lifecycle источника. let (status, after) = get_prompt(&client, base, prompt_id, None).await; assert_eq!(status, StatusCode::OK); assert_eq!(after["version"], 1); assert!(after["latest_published_version"].is_null()); let (status, _) = get_prompt(&client, base, prompt_id, Some(1)).await; assert_eq!( status, StatusCode::NOT_FOUND, "exporting a Draft must never publish it" ); // F3: `public`/`secret` — допустимая metadata; утечка проверяется по ключам. for sensitivity in ["public", "secret"] { let mut body = prompt_body(name, "wire contract fixture", "Count {{count}}."); body["sensitivity"] = json!(sensitivity); let id = create_prompt(&client, base, &body).await["prompt_id"] .as_str() .expect("prompt id returned") .to_owned(); let exported = export(&client, format!("{base}/prompts/{id}/export")).await; assert_export_headers(&exported, name); assert_no_internal_leak(&exported.raw, sensitivity); assert_eq!(exported.envelope["prompt"], prompt_block(&body)); let (status, imported) = import(&client, base, &exported.envelope).await; assert_eq!(status, StatusCode::CREATED, "{sensitivity}: {imported}"); assert_imported_draft(&imported, &exported.envelope, &id); } } /// AC1 (Draft-only upsert): импорт создаёт новый Draft; исходный Prompt не меняется; /// повторный перенос того же файла создаёт ещё один независимый Draft. #[tokio::test(flavor = "multi_thread")] #[serial] async fn story315_at01_import_creates_new_draft_and_reimport_stays_independent() { let registry = test_registry().await; let server = spawn_admin_api(build_test_app( registry, test_storage_root("story315_import"), )) .await; let client = authorized_client(&server).await; let base = server.as_ref(); let name = "story315_import_source"; let body = prompt_body(name, "import fixture", "Count {{count}}."); let created = create_prompt(&client, base, &body).await; let source_id = created["prompt_id"] .as_str() .expect("prompt id returned") .to_owned(); let draft_export = export(&client, format!("{base}/prompts/{source_id}/export")).await; assert_export_headers(&draft_export, name); let envelope = draft_export.envelope; let before = prompt_count(&client, base).await; let (status, imported) = import(&client, base, &envelope).await; assert_eq!( status, StatusCode::CREATED, "a valid envelope must create a Draft through POST /prompts/import: {imported}" ); assert_imported_draft(&imported, &envelope, &source_id); assert_eq!( prompt_count(&client, base).await, before + 1, "the import must add exactly one Draft" ); let imported_id = imported["prompt_id"].as_str().unwrap().to_owned(); let (status, fetched) = get_prompt(&client, base, &imported_id, None).await; assert_eq!(status, StatusCode::OK); assert_eq!( fetched["definition"]["messages"], envelope["prompt"]["messages"] ); let (status, _) = get_prompt(&client, base, &imported_id, Some(1)).await; assert_eq!( status, StatusCode::NOT_FOUND, "an imported Draft must have no Published Version" ); // AC3 (повторный перенос): ещё один независимый Draft, оба прежних не изменены. let (status, reimported) = import(&client, base, &envelope).await; assert_eq!( status, StatusCode::CREATED, "re-importing the same file must stay allowed: {reimported}" ); let reimported_id = reimported["prompt_id"].as_str().unwrap().to_owned(); assert_ne!(reimported_id, imported_id); assert_ne!(reimported_id, source_id); assert_imported_draft(&reimported, &envelope, &source_id); assert_eq!( prompt_count(&client, base).await, before + 2, "each import creates its own Draft" ); // Ни источник, ни первый импорт не перезаписаны. let (status, source_after) = get_prompt(&client, base, &source_id, None).await; assert_eq!(status, StatusCode::OK); assert_eq!(source_after["version"], 1); assert_eq!(source_after["definition"], created["definition"]); let (status, first_after) = get_prompt(&client, base, &imported_id, None).await; assert_eq!(status, StatusCode::OK); assert_eq!(first_after["version"], 1); } /// AC1/AC3 (immutable versions): экспорт точной Published Version и импорт этой версии /// как нового Draft не меняют опубликованный снимок источника. #[tokio::test(flavor = "multi_thread")] #[serial] async fn story315_at01_published_export_imports_as_draft_without_changing_published_version() { let registry = test_registry().await; let server = spawn_admin_api(build_test_app( registry, test_storage_root("story315_published"), )) .await; let client = authorized_client(&server).await; let base = server.as_ref(); let name = "story315_published_source"; let v1_body = prompt_body(name, "published fixture", "Count {{count}}."); let created = create_prompt(&client, base, &v1_body).await; let source_id = created["prompt_id"] .as_str() .expect("prompt id returned") .to_owned(); let published = publish_prompt( &client, base, &source_id, created["updated_at"].as_str().expect("updated_at"), ) .await; assert_eq!(published["version"], 1); // Правка после публикации открывает новый Draft v2 (Story 3.13). let v2_body = prompt_body(name, "draft after publication", "Changed {{count}}."); let edited = update_prompt( &client, base, &source_id, &v2_body, published["updated_at"].as_str().expect("updated_at"), ) .await; assert_eq!(edited["version"], 2); let draft_export = export(&client, format!("{base}/prompts/{source_id}/export")).await; assert_export_headers(&draft_export, name); assert_eq!( draft_export.envelope["source"], json!({"kind": "draft", "version": 2}), "the Draft export must describe its own revision" ); assert_eq!( draft_export.envelope["prompt"], prompt_block(&v2_body), "the Draft export must carry the current Draft definition" ); let published_export = export( &client, format!("{base}/prompts/{source_id}/versions/1/export"), ) .await; assert_export_headers(&published_export, name); assert_no_internal_leak(&published_export.raw, "published export"); assert_eq!( published_export.envelope["source"], json!({"kind": "published", "version": 1}) ); assert_eq!( published_export.envelope["prompt"], prompt_block(&v1_body), "the Published Version export must carry the immutable v1 definition" ); // Импорт точной версии — новый Draft с содержимым v1, без публикации. let (status, imported) = import(&client, base, &published_export.envelope).await; assert_eq!( status, StatusCode::CREATED, "a published envelope must import as a new Draft: {imported}" ); assert_imported_draft(&imported, &published_export.envelope, &source_id); assert_eq!( imported["definition"]["messages"], prompt_block(&v1_body)["messages"] ); // Источник: Published Version v1 остаётся точной и неизменной. let (status, source_after) = get_prompt(&client, base, &source_id, None).await; assert_eq!(status, StatusCode::OK); assert_eq!(source_after["version"], 2); assert_eq!(source_after["latest_published_version"], 1); let (status, exact_v1) = get_prompt(&client, base, &source_id, Some(1)).await; assert_eq!(status, StatusCode::OK); assert_eq!(exact_v1["status"], "published"); assert_eq!(exact_v1["version"], 1); assert_eq!(exact_v1["definition"], definition_block(&v1_body)); } /// AC3 (отказы): malformed/неверные envelopes отклоняются до любых изменений и без /// раскрытия содержимого; definition-ошибки используют принятый код. #[tokio::test(flavor = "multi_thread")] #[serial] async fn story315_at03_malformed_envelopes_are_rejected_without_state_change() { let registry = test_registry().await; let server = spawn_admin_api(build_test_app( registry, test_storage_root("story315_malformed"), )) .await; let client = authorized_client(&server).await; let base = server.as_ref(); let name = "story315_malformed_source"; let body = prompt_body(name, "malformed fixture", "Count {{count}}."); let created = create_prompt(&client, base, &body).await; let prompt_id = created["prompt_id"].as_str().expect("prompt id returned"); let envelope = export(&client, format!("{base}/prompts/{prompt_id}/export")) .await .envelope; assert_eq!(envelope["format"], ENVELOPE_FORMAT); let before = prompt_count(&client, base).await; let with_root = |key: &str, value: Value| { let mut candidate = envelope.clone(); candidate[key] = value; candidate }; let with_prompt = |key: &str, value: Value| { let mut candidate = envelope.clone(); candidate["prompt"][key] = value; candidate }; let envelope_failures = [ ("missing prompt block", with_root("prompt", Value::Null)), ( "unknown root key", with_root("storage_path", json!("/home/leak")), ), ( "unsupported format", with_root("format", json!("crank-prompt-portability-v2")), ), ("unsupported version", with_root("version", json!(2))), ( "source kind not supported", with_root("source", json!({"kind": "agent", "version": 1})), ), ( "source version zero", with_root("source", json!({"kind": "draft", "version": 0})), ), ( "unknown prompt metadata", with_prompt("status", json!("draft")), ), ( "unknown sensitivity", with_prompt("sensitivity", json!("top-secret")), ), ( "prompt id injected", with_prompt("prompt_id", json!("prm_injected")), ), ]; for (label, candidate) in envelope_failures { let (status, rejected) = import(&client, base, &candidate).await; assert_eq!( status, StatusCode::BAD_REQUEST, "{label}: the envelope must be rejected as invalid: {rejected}" ); assert_eq!( error_code(&rejected), "prompt_portability_envelope_invalid", "{label}: a stable envelope code is required: {rejected}" ); assert!( !rejected.to_string().contains(name), "{label}: the refusal must not echo the transferred definition: {rejected}" ); assert_no_internal_leak(&rejected.to_string(), label); } // Не JSON тело: тот же стабильный код, а не framework-ошибка. let raw = client .post(format!("{base}/prompts/import")) .header("content-type", "application/json") .body("{") .send() .await .expect("raw import completes"); let (status, rejected) = read(raw).await; assert_eq!(status, StatusCode::BAD_REQUEST, "{rejected}"); assert_eq!(error_code(&rejected), "prompt_portability_envelope_invalid"); // Валидная оболочка, невалидный definition: принятый код, без создания Draft. let mut unrenderable = envelope.clone(); unrenderable["prompt"]["messages"] = json!([{"role": "tool", "content": "x"}]); let (status, rejected) = import(&client, base, &unrenderable).await; assert_eq!(status, StatusCode::BAD_REQUEST, "{rejected}"); assert_eq!( error_code(&rejected), "prompt_invalid_definition", "definition failures reuse the accepted Story 3.12 code: {rejected}" ); let mut unknown_placeholder = envelope.clone(); unknown_placeholder["prompt"]["messages"] = json!([{"role": "user", "content": "{{missing}}"}]); let (status, rejected) = import(&client, base, &unknown_placeholder).await; assert_eq!(status, StatusCode::BAD_REQUEST, "{rejected}"); assert_eq!(error_code(&rejected), "prompt_invalid_definition"); let mut empty_messages = envelope.clone(); empty_messages["prompt"]["messages"] = json!([]); let (status, rejected) = import(&client, base, &empty_messages).await; assert_eq!(status, StatusCode::BAD_REQUEST, "{rejected}"); assert_eq!(error_code(&rejected), "prompt_invalid_definition"); assert_eq!( prompt_count(&client, base).await, before, "no rejected envelope may create a Prompt" ); } /// AC3 (scope isolation): экспорт чужого Prompt через workspace-URL → 404 без раскрытия; /// импорт в целевой workspace создаёт owned Draft только там. #[tokio::test(flavor = "multi_thread")] #[serial] async fn story315_at03_cross_workspace_export_is_denied_and_import_is_owned_by_target() { let registry = test_registry().await; let server = spawn_admin_api(build_test_app( registry.clone(), test_storage_root("story315_scope"), )) .await; let client = authorized_client(&server).await; let base = server.as_ref(); let foreign_workspace = create_workspace(®istry, "foreign").await; let foreign_base = workspace_base(base, &foreign_workspace); let foreign_name = "story315_foreign_secret_prompt"; let foreign_body = prompt_body(foreign_name, "foreign fixture", "Secret {{count}}."); let foreign_created = create_prompt(&client, &foreign_base, &foreign_body).await; let foreign_id = foreign_created["prompt_id"] .as_str() .expect("prompt id returned") .to_owned(); // Свой workspace: экспорт разрешён (положительный контроль перед проверкой изоляции). let allowed = export( &client, format!("{foreign_base}/prompts/{foreign_id}/export"), ) .await; assert_export_headers(&allowed, foreign_name); assert_eq!(allowed.envelope["prompt"], prompt_block(&foreign_body)); // Чужой workspace: 404 без definition. let denied = export(&client, format!("{base}/prompts/{foreign_id}/export")).await; assert_eq!( denied.status, StatusCode::NOT_FOUND, "a Prompt of another workspace must not be exportable: {}", denied.raw ); assert_eq!(error_code(&denied.envelope), "prompt_not_found"); assert!( !denied.raw.contains(foreign_name) && !denied.raw.contains("Secret {{count}}."), "the refusal must not leak the foreign definition: {}", denied.raw ); // Импорт в целевой workspace: Draft принадлежит ему и может публиковаться здесь. let target_before = prompt_count(&client, base).await; let (status, imported) = import(&client, base, &allowed.envelope).await; assert_eq!( status, StatusCode::CREATED, "the envelope must import into the target workspace: {imported}" ); assert_imported_draft(&imported, &allowed.envelope, &foreign_id); assert_eq!(prompt_count(&client, base).await, target_before + 1); let imported_id = imported["prompt_id"] .as_str() .expect("imported prompt id") .to_owned(); let published = publish_prompt( &client, base, &imported_id, imported["updated_at"].as_str().expect("updated_at"), ) .await; assert_eq!( published["status"], "published", "the imported Draft is owned by the target workspace" ); // Исходный workspace не получил копию и не изменился. let (status, listed_foreign) = read( client .get(format!("{foreign_base}/prompts")) .send() .await .expect("foreign list completes"), ) .await; assert_eq!(status, StatusCode::OK); let foreign_items = listed_foreign["items"].as_array().expect("items"); assert_eq!( foreign_items.len(), 1, "the source workspace must not receive an imported copy" ); assert_eq!(foreign_items[0]["prompt_id"], foreign_id.as_str()); assert!(foreign_items[0]["latest_published_version"].is_null()); // Несуществующий Prompt/версия: 404 без содержимого. let missing = export(&client, format!("{base}/prompts/prm_missing_315/export")).await; assert_eq!(missing.status, StatusCode::NOT_FOUND); assert_eq!(error_code(&missing.envelope), "prompt_not_found"); let missing_version = export( &client, format!("{base}/prompts/{imported_id}/versions/9/export"), ) .await; assert_eq!(missing_version.status, StatusCode::NOT_FOUND); assert_eq!( error_code(&missing_version.envelope), "prompt_publication_not_found" ); } /// AC3 (guards): экспорт шаблона не доступен без аутентифицированной сессии. #[tokio::test(flavor = "multi_thread")] #[serial] async fn story315_at03_export_requires_an_authenticated_session() { let registry = test_registry().await; let server = spawn_admin_api(build_test_app( registry, test_storage_root("story315_guards"), )) .await; let client = authorized_client(&server).await; let base = server.as_ref(); let body = prompt_body("story315_guards", "guard fixture", "Count {{count}}."); let created = create_prompt(&client, base, &body).await; let prompt_id = created["prompt_id"].as_str().expect("prompt id returned"); let anonymous = reqwest::Client::builder() .build() .expect("anonymous client builds"); let response = anonymous .get(format!("{base}/prompts/{prompt_id}/export")) .send() .await .expect("anonymous export completes"); assert_eq!( response.status(), StatusCode::UNAUTHORIZED, "an export must require a session" ); let text = response.text().await.unwrap_or_default(); assert!( !text.contains("Be {{tone}}."), "the refusal must not leak the definition: {text}" ); }