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

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

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

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

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

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

1001 lines
36 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! 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<String> {
let mut keys: Vec<String> = 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<String> = 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("<absent>")
.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<u32>,
) -> (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(&registry, "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}"
);
}