use super::common::{ authorized_client, build_test_app, spawn_admin_api, test_auth_settings, test_registry, test_storage_root, }; use crank_core::{MembershipRole, Workspace, WorkspaceId, WorkspaceStatus}; use crank_registry::{CreateWorkspaceRequest, PostgresRegistry}; use reqwest::StatusCode; use serde_json::{Value, json}; use serial_test::serial; use time::OffsetDateTime; const DEFAULT_WORKSPACE_ID: &str = "ws_default"; const TEST_AUTH_EMAIL: &str = "owner@crank.local"; const TEST_AUTH_PASSWORD: &str = "test-password"; fn payload(name: &str) -> Value { json!({ "name": name, "description": "typed prompt", "sensitivity": "internal", "arguments": [{"name":"count","schema":{"type":"integer"},"required":true}], "messages": [{"role":"system","content":"Safe"},{"role":"user","content":"Count={{count}}"}] }) } async fn create_prompt(client: &reqwest::Client, base: &str, body: &Value) -> Value { let response = client .post(format!("{base}/prompts")) .json(body) .send() .await .expect("create request completes"); let status = response.status(); let text = response.text().await.unwrap_or_default(); assert_eq!(status, StatusCode::CREATED, "create must succeed: {text}"); serde_json::from_str(&text).expect("created prompt is JSON") } async fn create_workspace( registry: &PostgresRegistry, suffix: &str, with_membership: bool, ) -> WorkspaceId { let now = OffsetDateTime::now_utc(); let workspace_id = WorkspaceId::new(format!("ws_story312_{suffix}")); registry .create_workspace(CreateWorkspaceRequest { workspace: &Workspace { id: workspace_id.clone(), slug: format!("story312-{suffix}"), display_name: format!("Story 3.12 {suffix}"), status: WorkspaceStatus::Active, settings: json!({}), created_at: now, updated_at: now, }, }) .await .expect("synthetic workspace creates"); if with_membership { 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()) } #[tokio::test(flavor = "multi_thread")] #[serial] async fn story312_http_draft_preview_and_invalid_arguments_return_no_partial_messages() { let registry = test_registry().await; let server = spawn_admin_api(build_test_app( registry, test_storage_root("story312_prompts"), )) .await; let client = authorized_client(&server).await; let base = server.as_ref(); let prompt = create_prompt( &client, base, &json!({ "name":"HTTP preview fixture", "description":"typed prompt", "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":"Safe"},{"role":"user","content":"Count={{count}}, tone {{tone}}"}] }), ) .await; let prompt_id = prompt["prompt_id"].as_str().expect("prompt id returned"); let preview = client .post(format!("{base}/prompts/{prompt_id}/preview")) .json(&json!({"arguments":{"count":7}})) .send() .await .expect("preview request completes"); assert_eq!(preview.status(), StatusCode::OK); let preview: Value = preview.json().await.expect("preview is JSON"); assert_eq!(preview["status"], "draft"); assert_eq!(preview["messages"][1]["content"], "Count=7, tone warm"); for (label, arguments, expected_field, expected_code) in [ ( "invalid value", json!({"count":"seven"}), "count", "prompt_invalid_argument", ), ( "unsupported enum value", json!({"count":7,"tone":"loud"}), "tone", "prompt_invalid_argument", ), ( "missing required value", json!({"tone":"plain"}), "count", "prompt_missing_argument", ), ( "unknown value", json!({"count":7,"extra":true}), "extra", "prompt_unknown_argument", ), ] { let rejected = client .post(format!("{base}/prompts/{prompt_id}/preview")) .json(&json!({"arguments": arguments})) .send() .await .unwrap_or_else(|error| panic!("{label} preview completes: {error}")); let status = rejected.status(); let body: Value = rejected.json().await.expect("structured error response"); assert_eq!(status, StatusCode::BAD_REQUEST, "{label}: {body}"); assert_eq!(body["error"]["code"], expected_code, "{label}: {body}"); assert_eq!( body["error"]["context"]["field"], expected_field, "{label}: {body}" ); assert!( body.get("messages").is_none(), "{label}: invalid values must not return partial messages" ); } let stored = client .get(format!("{base}/prompts/{prompt_id}")) .send() .await .expect("read request completes"); let stored: Value = stored.json().await.expect("stored prompt is JSON"); assert_eq!( stored["version"], 1, "rejected previews must not change the Draft" ); } #[tokio::test(flavor = "multi_thread")] #[serial] async fn story312_http_update_roundtrip_and_stale_conflict_keep_the_last_version() { let registry = test_registry().await; let server = spawn_admin_api(build_test_app( registry, test_storage_root("story312_prompts_update"), )) .await; let client = authorized_client(&server).await; let base = server.as_ref(); let created = create_prompt( &client, base, &json!({ "name":"Before update", "description":"first description", "sensitivity":"internal", "arguments":[{"name":"tone","schema":{"type":"string","enum":["warm","plain"]},"required":false,"default":"warm"}], "messages":[{"role":"user","content":"Tone {{tone}}"}] }), ) .await; let prompt_id = created["prompt_id"].as_str().expect("prompt id returned"); let updated = client .put(format!("{base}/prompts/{prompt_id}")) .json(&json!({ "name":"After update", "description":"second description", "sensitivity":"secret", "expected_updated_at": created["updated_at"], "arguments":[{"name":"tone","schema":{"type":"string","enum":["warm","plain","formal"]},"required":false,"default":"formal"}], "messages":[{"role":"system","content":"Be {{tone}}."},{"role":"user","content":"Hello"}] })) .send() .await .expect("update request completes"); let status = updated.status(); let body: Value = updated.json().await.expect("updated prompt is JSON"); assert_eq!(status, StatusCode::OK, "update must succeed: {body}"); assert_eq!(body["version"], 2); assert_eq!(body["name"], "After update"); assert_eq!(body["description"], "second description"); assert_eq!(body["sensitivity"], "secret"); assert_eq!(body["definition"]["arguments"][0]["default"], "formal"); assert_eq!( body["definition"]["arguments"][0]["schema"]["enum"], json!(["warm", "plain", "formal"]) ); assert_eq!(body["definition"]["messages"][0]["content"], "Be {{tone}}."); assert_eq!(body["definition"]["messages"][1]["role"], "user"); let fetched = client .get(format!("{base}/prompts/{prompt_id}")) .send() .await .expect("read request completes"); let fetched: Value = fetched.json().await.expect("stored prompt is JSON"); assert_eq!(fetched["version"], 2); assert_eq!(fetched["name"], "After update"); assert_eq!(fetched["description"], "second description"); assert_eq!(fetched["sensitivity"], "secret"); assert_eq!(fetched["definition"], body["definition"]); let stale = client .put(format!("{base}/prompts/{prompt_id}")) .json(&json!({ "name":"Stale edit", "description":"stale", "sensitivity":"public", "expected_updated_at": created["updated_at"], "arguments":[{"name":"tone","schema":{"type":"string"},"required":false,"default":"warm"}], "messages":[{"role":"user","content":"Stale"}] })) .send() .await .expect("stale update request completes"); let status = stale.status(); let body: Value = stale.json().await.expect("stale error is JSON"); assert_eq!( status, StatusCode::CONFLICT, "stale update must conflict: {body}" ); assert_eq!(body["error"]["code"], "prompt_stale_revision"); let preserved = client .get(format!("{base}/prompts/{prompt_id}")) .send() .await .expect("read request completes"); let preserved: Value = preserved.json().await.expect("stored prompt is JSON"); assert_eq!( preserved["version"], 2, "a conflicting update must not create a revision" ); assert_eq!(preserved["name"], "After update"); assert_eq!( preserved["definition"]["messages"][0]["content"], "Be {{tone}}." ); } #[tokio::test(flavor = "multi_thread")] #[serial] async fn story312_http_default_value_boundary_is_rejected_before_storage() { let registry = test_registry().await; let server = spawn_admin_api(build_test_app( registry, test_storage_root("story312_prompts_bounds"), )) .await; let client = authorized_client(&server).await; let base = server.as_ref(); let at_limit = "a".repeat(16_382); let prompt = create_prompt( &client, base, &json!({ "name":"Boundary fixture", "description":"default boundary", "sensitivity":"internal", "arguments":[{"name":"text","schema":{"type":"string"},"required":false,"default": at_limit}], "messages":[{"role":"user","content":"{{text}}"}] }), ) .await; let prompt_id = prompt["prompt_id"].as_str().expect("prompt id returned"); assert_eq!(prompt["definition"]["arguments"][0]["default"], at_limit); let rendered = client .post(format!("{base}/prompts/{prompt_id}/preview")) .json(&json!({"arguments":{}})) .send() .await .expect("preview request completes"); assert_eq!(rendered.status(), StatusCode::OK); let rendered: Value = rendered.json().await.expect("preview is JSON"); assert_eq!(rendered["messages"][0]["content"], at_limit); let too_large = "a".repeat(16_383); let rejected = client .post(format!("{base}/prompts")) .json(&json!({ "name":"Over boundary fixture", "description":"default boundary", "sensitivity":"internal", "arguments":[{"name":"text","schema":{"type":"string"},"required":false,"default": too_large}], "messages":[{"role":"user","content":"{{text}}"}] })) .send() .await .expect("over-boundary create completes"); let status = rejected.status(); let body: Value = rejected.json().await.expect("rejection is JSON"); assert_eq!( status, StatusCode::BAD_REQUEST, "an oversized default needs a structured 4xx: {body}" ); assert_eq!(body["error"]["code"], "prompt_invalid_definition"); let listed = client .get(format!("{base}/prompts")) .send() .await .expect("list request completes"); let listed: Value = listed.json().await.expect("list is JSON"); assert_eq!( listed["items"].as_array().map(Vec::len), Some(1), "a rejected default must not create a partial Draft" ); } #[tokio::test(flavor = "multi_thread")] #[serial] async fn story312_http_scope_isolates_two_existing_workspaces() { let registry = test_registry().await; let owned = create_workspace(®istry, "scope_owned", true).await; let foreign = create_workspace(®istry, "scope_foreign", false).await; let server = spawn_admin_api(build_test_app( registry, test_storage_root("story312_prompts_scope"), )) .await; // Memberships belong to the authenticated session, so log in after granting them. let client = authorized_client(&server).await; let base = server.as_ref(); let owned_base = workspace_base(base, &owned); let foreign_base = workspace_base(base, &foreign); let local = create_prompt(&client, base, &payload("Local prompt")).await; let remote = create_prompt(&client, &owned_base, &payload("Owned workspace prompt")).await; let local_id = local["prompt_id"].as_str().expect("local prompt id"); let remote_id = remote["prompt_id"].as_str().expect("remote prompt id"); for (label, request) in [ ("read", client.get(format!("{base}/prompts/{remote_id}"))), ( "preview", client .post(format!("{base}/prompts/{remote_id}/preview")) .json(&json!({"arguments":{"count":1}})), ), ( "update", client .put(format!("{base}/prompts/{remote_id}")) .json(&json!({ "name":"Hijacked", "description":"hijacked", "sensitivity":"public", "expected_updated_at": remote["updated_at"], "arguments":[{"name":"count","schema":{"type":"integer"},"required":true}], "messages":[{"role":"user","content":"Hijacked"}] })), ), ] { let response = request.send().await.expect("foreign request completes"); let status = response.status(); let body: Value = response.json().await.unwrap_or(Value::Null); assert_eq!( status, StatusCode::NOT_FOUND, "{label} of another workspace's prompt must stay hidden: {body}" ); } let mirrored = client .get(format!("{owned_base}/prompts/{local_id}")) .send() .await .expect("cross read completes"); assert_eq!( mirrored.status(), StatusCode::NOT_FOUND, "the other workspace must not read the local prompt" ); let unchanged = client .get(format!("{owned_base}/prompts/{remote_id}")) .send() .await .expect("owned read completes"); let unchanged: Value = unchanged.json().await.expect("owned prompt is JSON"); assert_eq!(unchanged["version"], 1); assert_eq!(unchanged["name"], "Owned workspace prompt"); let denied_list = client .get(format!("{foreign_base}/prompts")) .send() .await .expect("foreign list completes"); assert_eq!( denied_list.status(), StatusCode::FORBIDDEN, "a workspace without membership must be refused" ); let denied_create = client .post(format!("{foreign_base}/prompts")) .json(&payload("Foreign prompt")) .send() .await .expect("foreign create completes"); assert_eq!( denied_create.status(), StatusCode::FORBIDDEN, "a workspace without membership must not accept writes" ); let listed = client .get(format!("{base}/prompts")) .send() .await .expect("own list completes"); assert_eq!(listed.status(), StatusCode::OK); let listed: Value = listed.json().await.expect("list is JSON"); assert_eq!(listed["items"].as_array().map(Vec::len), Some(1)); assert_eq!(listed["items"][0]["prompt_id"], local_id); } #[tokio::test(flavor = "multi_thread")] #[serial] async fn story312_http_stores_multiline_defaults_and_rejects_nul_before_storage() { let registry = test_registry().await; let server = spawn_admin_api(build_test_app( registry, test_storage_root("story312_prompts_escapes"), )) .await; let client = authorized_client(&server).await; let base = server.as_ref(); let lines = "\n".repeat(3_000); let tabs = "\t".repeat(3_000); // PostgreSQL stores LF/TAB as two-byte escapes, so these defaults fit the guard. let prompt = create_prompt( &client, base, &json!({ "name":"Multiline fixture", "description":"multiline defaults", "sensitivity":"internal", "arguments":[ {"name":"lines","schema":{"type":"string"},"required":false,"default": lines}, {"name":"tabs","schema":{"type":"string"},"required":false,"default": tabs} ], "messages":[{"role":"user","content":"{{lines}}|{{tabs}}"}] }), ) .await; let prompt_id = prompt["prompt_id"] .as_str() .expect("prompt id returned") .to_owned(); assert_eq!(prompt["definition"]["arguments"][0]["default"], lines); assert_eq!(prompt["definition"]["arguments"][1]["default"], tabs); let read = client .get(format!("{base}/prompts/{prompt_id}")) .send() .await .expect("read request completes"); assert_eq!(read.status(), StatusCode::OK); let read: Value = read.json().await.expect("read prompt is JSON"); assert_eq!(read["definition"]["arguments"][0]["default"], lines); assert_eq!(read["definition"]["arguments"][1]["default"], tabs); let previewed = client .post(format!("{base}/prompts/{prompt_id}/preview")) .json(&json!({"arguments":{}})) .send() .await .expect("preview request completes"); assert_eq!(previewed.status(), StatusCode::OK); let previewed: Value = previewed.json().await.expect("preview is JSON"); assert_eq!( previewed["messages"][0]["content"], format!("{lines}|{tabs}"), "the preview must return the stored multiline text unchanged" ); // PostgreSQL refuses U+0000 in jsonb and text, so it must stop at the API boundary. for (label, body) in [ ( "default", json!({ "name":"NUL default", "description":"nul default", "sensitivity":"internal", "arguments":[{"name":"text","schema":{"type":"string"},"required":false,"default":"a\u{0}b"}], "messages":[{"role":"user","content":"{{text}}"}] }), ), ( "enum", json!({ "name":"NUL enum", "description":"nul enum", "sensitivity":"internal", "arguments":[{"name":"text","schema":{"type":"string","enum":["ok","a\u{0}b"]},"required":false,"default":"ok"}], "messages":[{"role":"user","content":"{{text}}"}] }), ), ( "name", json!({ "name":"NUL \u{0} name", "description":"nul name", "sensitivity":"internal", "arguments":[{"name":"text","schema":{"type":"string"},"required":true}], "messages":[{"role":"user","content":"{{text}}"}] }), ), ( "message", json!({ "name":"NUL message", "description":"nul message", "sensitivity":"internal", "arguments":[{"name":"text","schema":{"type":"string"},"required":true}], "messages":[{"role":"user","content":"before\u{0}after {{text}}"}] }), ), ] { let rejected = client .post(format!("{base}/prompts")) .json(&body) .send() .await .expect("NUL create request completes"); let status = rejected.status(); let body: Value = rejected.json().await.expect("NUL rejection is JSON"); assert_eq!( status, StatusCode::BAD_REQUEST, "U+0000 in {label} needs a structured 4xx, not a storage failure: {body}" ); assert_eq!(body["error"]["code"], "prompt_invalid_definition"); assert_eq!(body["error"]["context"]["field"], "definition"); } // A rejected update must not create a new version or change the stored text. let rejected_update = client .put(format!("{base}/prompts/{prompt_id}")) .json(&json!({ "name":"Multiline fixture", "description":"multiline defaults", "sensitivity":"internal", "expected_updated_at": prompt["updated_at"], "arguments":[ {"name":"lines","schema":{"type":"string"},"required":false,"default":"a\u{0}b"}, {"name":"tabs","schema":{"type":"string"},"required":false,"default": tabs} ], "messages":[{"role":"user","content":"{{lines}}|{{tabs}}"}] })) .send() .await .expect("NUL update request completes"); let status = rejected_update.status(); let body: Value = rejected_update .json() .await .expect("NUL update rejection is JSON"); assert_eq!(status, StatusCode::BAD_REQUEST, "{body}"); assert_eq!(body["error"]["code"], "prompt_invalid_definition"); let unchanged = client .get(format!("{base}/prompts/{prompt_id}")) .send() .await .expect("read after rejected update completes"); let unchanged: Value = unchanged.json().await.expect("prompt is JSON"); assert_eq!( unchanged["version"], 1, "a rejected update must not version" ); assert_eq!(unchanged["definition"]["arguments"][0]["default"], lines); let listed = client .get(format!("{base}/prompts")) .send() .await .expect("list request completes"); let listed: Value = listed.json().await.expect("list is JSON"); assert_eq!( listed["items"].as_array().map(Vec::len), Some(1), "rejected NUL drafts must not be persisted" ); assert_eq!(listed["items"][0]["prompt_id"], prompt_id); }