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.
1001 lines
36 KiB
Rust
1001 lines
36 KiB
Rust
//! 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(®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}"
|
||
);
|
||
}
|