Files
crank/apps/admin-api/tests/integration/resources/template.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

789 lines
27 KiB
Rust

//! ATDD (RED) Story 3.10 / FR-16 — REST-backed Resource templates.
//!
//! Источник контракта: `_bmad-output/initiative-crank/epic-mcp-capabilities/
//! spec-resource-templates/spec.md` (wire, коды, пределы, AC→test map) +
//! binding TL amendments t_2fb1508b comment 168.
//!
//! Состояние на момент написания: dynamic REST-backed Resource отсутствует.
//! `metadata.source` сейчас игнорируется, а multipart требует часть `content`,
//! поэтому каждый RED ниже — реальное поведенческое расхождение на HTTP-ответе
//! (`400 validation_error` malformed multipart или `201` с проигнорированным
//! source), а не ошибка компиляции/setup. Работоспособность харнесса
//! (auth/session/PG/multipart/публикация операции) доказывает
//! `story310_at00_static_control_create_publish_and_exact_published_source`.
//!
//! Фильтр запуска: `cargo test -p admin-api --test integration story310`.
use super::super::common::{
TestServer, assert_success_json, authorized_client, build_test_app, operation_etag,
spawn_admin_api, spawn_upstream_server, test_registry, test_storage_root,
};
use super::helpers::{
DEFAULT_WORKSPACE_ID, OWNED_WORKSPACE_ID, TEST_AUTH_EMAIL, TEST_AUTH_PASSWORD,
create_owned_workspace, draft_form, draft_metadata, draft_updated_at, error_signature,
get_card, list_resources, login_client, post_draft_raw, read_preview, read_response,
};
use crank_registry::PostgresRegistry;
use reqwest::StatusCode;
use reqwest::multipart::{Form, Part};
use serde_json::{Value, json};
// ---------------------------------------------------------------------------
// Стенд и фикстуры
// ---------------------------------------------------------------------------
pub(super) async fn spawn_stand(
name: &str,
) -> (PostgresRegistry, TestServer, reqwest::Client, String) {
let registry = test_registry().await;
let app = build_test_app(registry.clone(), test_storage_root(name));
let server = spawn_admin_api(app).await;
let client = authorized_client(&server).await;
let upstream = spawn_upstream_server().await;
(registry, server, client, upstream)
}
fn metadata_part(metadata: &Value) -> Part {
Part::bytes(serde_json::to_vec(metadata).expect("metadata must serialize"))
.file_name("metadata.json".to_owned())
.mime_str("application/json")
.expect("json part mime")
}
/// Multipart template Draft: только `metadata` (часть `content` обязана отсутствовать).
pub(super) fn template_form(metadata: &Value) -> Form {
Form::new().part("metadata", metadata_part(metadata))
}
pub(super) async fn post_template_raw(
client: &reqwest::Client,
server: impl AsRef<str> + Copy,
metadata: &Value,
) -> (StatusCode, String, Value) {
read_response(
client
.post(format!("{}/resources", server.as_ref()))
.multipart(template_form(metadata))
.send()
.await
.expect("template create request must complete"),
)
.await
}
pub(super) async fn create_template_draft(
client: &reqwest::Client,
server: impl AsRef<str> + Copy,
metadata: &Value,
) -> Value {
let (status, text, body) = post_template_raw(client, server, metadata).await;
assert_eq!(
status,
StatusCode::CREATED,
"POST /resources with metadata.source must create a template Draft; observed {} body={text}",
error_signature(status, &body)
);
body
}
pub(super) async fn put_template_raw(
client: &reqwest::Client,
server: impl AsRef<str> + Copy,
resource_id: &str,
metadata: &Value,
) -> (StatusCode, String, Value) {
read_response(
client
.put(format!("{}/resources/{resource_id}", server.as_ref()))
.multipart(template_form(metadata))
.send()
.await
.expect("template update request must complete"),
)
.await
}
pub(super) async fn publish_raw(
client: &reqwest::Client,
server: impl AsRef<str> + Copy,
resource_id: &str,
expected_updated_at: Option<&str>,
) -> (StatusCode, String, Value) {
let body = match expected_updated_at {
Some(value) => json!({ "expected_updated_at": value }),
None => json!({}),
};
read_response(
client
.post(format!(
"{}/resources/{resource_id}/publish",
server.as_ref()
))
.json(&body)
.send()
.await
.expect("publish request must complete"),
)
.await
}
pub(super) async fn publish_with_card(
client: &reqwest::Client,
server: impl AsRef<str> + Copy,
resource_id: &str,
) -> (StatusCode, String, Value) {
let card = get_card(client, server, resource_id).await;
let updated_at = draft_updated_at(&card);
publish_raw(client, server, resource_id, Some(&updated_at)).await
}
/// Коды findings из preview-ответа.
pub(super) fn preview_codes(body: &Value) -> Vec<String> {
codes_of(&body["findings"])
}
/// Коды findings из блокирующего 422 (`error.context.findings`).
pub(super) fn blocked_codes(body: &Value) -> Vec<String> {
let context = &body["error"]["context"]["findings"];
if context.is_array() {
codes_of(context)
} else {
codes_of(&body["findings"])
}
}
fn codes_of(items: &Value) -> Vec<String> {
items
.as_array()
.map(|array| {
array
.iter()
.filter_map(|item| item["code"].as_str().map(str::to_owned))
.collect()
})
.unwrap_or_default()
}
pub(super) fn assert_has_code(codes: &[String], expected: &str, context: &str) {
assert!(
codes.iter().any(|code| code == expected),
"{context}: expected blocker finding `{expected}`, observed {codes:?}"
);
}
/// Draft создаётся, preview показывает искомый finding, publish блокируется им же.
pub(super) async fn expect_blocked(
client: &reqwest::Client,
server: &TestServer,
metadata: &Value,
expected_code: &str,
label: &str,
) -> Value {
let created = create_template_draft(client, server, metadata).await;
let resource_id = created["resource"]["resource_id"]
.as_str()
.expect("template Draft id")
.to_owned();
let (status, text, preview) = read_preview(client, server, &resource_id).await;
assert_eq!(
status,
StatusCode::OK,
"preview must answer 200 ({label}): {text}"
);
assert_has_code(
&preview_codes(&preview),
expected_code,
&format!("preview finding ({label})"),
);
let (status, text, published) = publish_with_card(client, server, &resource_id).await;
assert_eq!(
status,
StatusCode::UNPROCESSABLE_ENTITY,
"a blocker finding must stop publication ({label}); observed {} body={text}",
error_signature(status, &published)
);
assert_eq!(published["error"]["code"], json!("resource_source_blocked"));
assert_has_code(
&blocked_codes(&published),
expected_code,
&format!("publication blocker ({label})"),
);
let card = get_card(client, server, &resource_id).await;
assert_eq!(
card["resource"]["latest_published_version"],
Value::Null,
"a blocked template must not be published ({label})"
);
published
}
// ---------------------------------------------------------------------------
// Operation fixtures (существующий accepted contract)
// ---------------------------------------------------------------------------
pub(super) fn object_schema(field: &str, schema: Value) -> Value {
json!({ "type": "object", "required": true, "fields": { field: schema } })
}
pub(super) fn string_field() -> Value {
json!({ "type": "string", "required": true })
}
pub(super) fn path_input_mapping(field: &str) -> Value {
json!({ "rules": [ {
"source": format!("$.mcp.{field}"),
"target": format!("$.request.path.{field}"),
"required": true
} ] })
}
pub(super) fn operation_payload(
name: &str,
upstream: &str,
method: &str,
path_template: &str,
input_schema: Value,
input_mapping: Value,
execution_config: Value,
) -> Value {
json!({
"name": name,
"display_name": name,
"category": "sales",
"protocol": "rest",
"security_level": "standard",
"target": {
"kind": "rest",
"base_url": upstream,
"method": method,
"path_template": path_template
},
"input_schema": input_schema,
"output_schema": object_schema("id", string_field()),
"input_mapping": input_mapping,
"output_mapping": { "rules": [ {
"source": "$.response.body.id",
"target": "$.output.id",
"required": true
} ] },
"execution_config": execution_config,
"tool_description": { "title": name, "description": "Story 3.10 fixture" }
})
}
/// GET-операция, читающая заказ по номеру: путь `/orders/{order_id}` и mapping в
/// `request.path.order_id` — существующий accepted контракт Operation.
pub(super) fn order_operation_payload(
name: &str,
upstream: &str,
method: &str,
safety: Value,
approval: Value,
headers: Value,
) -> Value {
let mut execution = json!({ "timeout_ms": 1_000 });
if !safety.is_null() {
execution["safety"] = safety;
}
if !approval.is_null() {
execution["approval_policy"] = approval;
}
if !headers.is_null() {
execution["headers"] = headers;
}
operation_payload(
name,
upstream,
method,
"/orders/{order_id}",
object_schema(
"order_id",
json!({ "type": "string", "required": true, "format": "uuid" }),
),
path_input_mapping("order_id"),
execution,
)
}
pub(super) fn read_operation_payload(
name: &str,
upstream: &str,
safety: Value,
approval: Value,
headers: Value,
) -> Value {
order_operation_payload(name, upstream, "GET", safety, approval, headers)
}
pub(super) fn read_safety() -> Value {
json!({ "class": "read" })
}
pub(super) fn approval_required() -> Value {
json!({
"required": true,
"risk_level": "dangerous",
"ttl_seconds": 30,
"show_payload_preview": false,
"payload_preview_mode": "summary"
})
}
pub(super) async fn create_operation(
client: &reqwest::Client,
server: impl AsRef<str> + Copy,
payload: &Value,
) -> String {
let created = assert_success_json(
client
.post(format!("{}/operations", server.as_ref()))
.json(payload)
.send()
.await
.expect("operation create must complete"),
)
.await;
created["operation_id"]
.as_str()
.expect("operation create must return an id")
.to_owned()
}
pub(super) async fn publish_operation(
client: &reqwest::Client,
server: impl AsRef<str> + Copy,
operation_id: &str,
) -> Value {
let etag = operation_etag(client, server, operation_id).await;
assert_success_json(
client
.post(format!(
"{}/operations/{operation_id}/publish",
server.as_ref()
))
.header(reqwest::header::IF_MATCH, etag)
.json(&json!({ "version": 1 }))
.send()
.await
.expect("operation publish must complete"),
)
.await
}
pub(super) async fn published_read_operation(
client: &reqwest::Client,
server: impl AsRef<str> + Copy,
upstream: &str,
name: &str,
) -> String {
let payload = read_operation_payload(name, upstream, read_safety(), Value::Null, Value::Null);
let id = create_operation(client, server, &payload).await;
publish_operation(client, server, &id).await;
id
}
pub(super) fn template_source(
operation_id: &str,
operation_version: u32,
uri_template: &str,
parameters: Value,
cache: Value,
failure: Value,
) -> Value {
json!({
"operation_id": operation_id,
"operation_version": operation_version,
"uri_template": uri_template,
"parameters": parameters,
"cache": cache,
"failure": failure
})
}
pub(super) fn order_parameter(name: &str, input_path: &str, schema: Value) -> Value {
json!({ "name": name, "input_path": input_path, "schema": schema })
}
pub(super) fn cache_policy(ttl_ms: Value, vary: Value, max_bytes: Value) -> Value {
json!({ "ttl_ms": ttl_ms, "vary": vary, "max_bytes": max_bytes })
}
pub(super) fn error_outcome() -> Value {
json!({ "outcome": "error" })
}
/// Валидный source для published GET-операции `/orders/{order_id}`.
pub(super) fn valid_source(operation_id: &str) -> Value {
template_source(
operation_id,
1,
"crank://orders/{order_id}",
json!([order_parameter(
"order_id",
"input.order_id",
json!({ "type": "string", "required": true, "format": "uuid" })
)]),
cache_policy(json!(60_000), json!(["order_id"]), json!(65_536)),
error_outcome(),
)
}
pub(super) fn template_metadata(uri: &str, name: &str, source: Value) -> Value {
let mut metadata = draft_metadata(uri, name, "text", "text/plain", "internal");
metadata["source"] = source;
metadata
}
// ---------------------------------------------------------------------------
// AT-3.10-00 — positive controls (должны быть GREEN и сейчас)
// ---------------------------------------------------------------------------
#[tokio::test(flavor = "multi_thread")]
#[serial_test::serial]
async fn story310_at00_static_control_create_publish_and_exact_published_source() {
let (_registry, server, client, upstream) = spawn_stand("story310_control").await;
// 1. Статический Draft по-прежнему создаётся и публикуется (auth/PG/multipart/publish).
let static_metadata = draft_metadata(
"crank://story310/static",
"story310_static",
"text",
"text/plain",
"internal",
);
let (status, _traceable, text, body) = post_draft_raw(
&client,
&server,
&static_metadata,
b"story310 static body\n",
"text/plain",
)
.await;
assert_eq!(
status,
StatusCode::CREATED,
"static create is the harness positive control; observed {} body={text}",
error_signature(status, &body)
);
let static_id = body["resource"]["resource_id"]
.as_str()
.expect("created static draft id")
.to_owned();
let (status, text, body) = publish_with_card(&client, &server, &static_id).await;
assert_eq!(
status,
StatusCode::OK,
"static publish is the harness positive control; observed {} body={text}",
error_signature(status, &body)
);
// 2. Точная Published версия GET-операции доступна через существующий контракт.
let operation_id =
published_read_operation(&client, &server, &upstream, "story310_control_read").await;
let (status, text, version) = read_response(
client
.get(format!(
"{}/operations/{operation_id}/versions/1",
server.as_ref()
))
.send()
.await
.expect("operation version request must complete"),
)
.await;
assert_eq!(
status,
StatusCode::OK,
"the seeded exact Published Operation Version must be readable; observed {} body={text}",
error_signature(status, &version)
);
assert_eq!(version["snapshot"]["target"]["method"], json!("GET"));
assert_eq!(
version["snapshot"]["target"]["path_template"],
json!("/orders/{order_id}")
);
assert_eq!(
version["snapshot"]["input_schema"]["fields"]["order_id"]["type"],
json!("string")
);
assert_eq!(
version["snapshot"]["input_mapping"]["rules"][0]["target"],
json!("$.request.path.order_id")
);
assert_eq!(version["status"], json!("published"));
}
// ---------------------------------------------------------------------------
// AC1 — только exact Published Operation Version того же workspace
// ---------------------------------------------------------------------------
#[tokio::test(flavor = "multi_thread")]
#[serial_test::serial]
async fn story310_at01_draft_accepts_only_exact_published_operation_version() {
let (_registry, server, client, upstream) = spawn_stand("story310_at01_exact").await;
let operation_id =
published_read_operation(&client, &server, &upstream, "story310_at01_read").await;
let metadata = template_metadata(
"crank://story310/orders",
"story310_orders",
valid_source(&operation_id),
);
let created = create_template_draft(&client, &server, &metadata).await;
let resource_id = created["resource"]["resource_id"]
.as_str()
.expect("template Draft id")
.to_owned();
let source = &created["source"];
assert_eq!(source["operation_id"], json!(operation_id));
assert_eq!(source["operation_version"], json!(1));
assert_eq!(source["uri_template"], json!("crank://orders/{order_id}"));
assert_eq!(
source["parameters"][0]["input_path"],
json!("input.order_id"),
"input_path addresses the pinned Operation input_schema, not request.path"
);
assert_eq!(source["cache"]["scope"], json!("workspace_agent_auth"));
assert_eq!(source["read_safety"]["method"], json!("GET"));
assert_eq!(source["read_safety"]["read_safe"], json!(true));
assert_eq!(source["access"]["security_level"], json!("standard"));
let (status, text, preview) = read_preview(&client, &server, &resource_id).await;
assert_eq!(status, StatusCode::OK, "preview must succeed: {text}");
assert!(
preview_codes(&preview).is_empty(),
"a read-safe, fully mapped template Draft has no findings: {preview}"
);
assert_eq!(preview["preview"]["text"], Value::Null);
let (status, text, published) = publish_with_card(&client, &server, &resource_id).await;
assert_eq!(
status,
StatusCode::OK,
"the accepted template Draft must publish; observed {} body={text}",
error_signature(status, &published)
);
assert_eq!(
published["published_version"]["source"]["operation_id"],
json!(operation_id)
);
assert_eq!(
published["published_version"]["source"]["operation_version"],
json!(1)
);
// Negative: версия существует, но не Published → стабильный 422, публикации нет.
let draft_payload = read_operation_payload(
"story310_at01_draft_only",
&upstream,
read_safety(),
Value::Null,
Value::Null,
);
let draft_operation_id = create_operation(&client, &server, &draft_payload).await;
let mut draft_source = valid_source(&draft_operation_id);
draft_source["operation_version"] = json!(1);
let draft_metadata_value = template_metadata(
"crank://story310/orders-draft-op",
"story310_orders_draft_op",
draft_source,
);
let (status, text, body) = post_template_raw(&client, &server, &draft_metadata_value).await;
assert_eq!(
status,
StatusCode::UNPROCESSABLE_ENTITY,
"a Draft Operation Version must not become a source; observed {} body={text}",
error_signature(status, &body)
);
assert_eq!(
body["error"]["code"],
json!("resource_source_not_published")
);
assert_eq!(
body["error"]["context"]["field"],
json!("source.operation_version")
);
let (_, _, listed) = list_resources(&client, &server).await;
assert_eq!(
listed["items"].as_array().map(Vec::len),
Some(1),
"the rejected Draft must not create a second Resource: {listed}"
);
// Positive control: тот же валидный source всё ещё создаётся (не «блокируется всё»).
let accepted_metadata = template_metadata(
"crank://story310/orders-accepted",
"story310_orders_accepted",
valid_source(&operation_id),
);
create_template_draft(&client, &server, &accepted_metadata).await;
}
#[tokio::test(flavor = "multi_thread")]
#[serial_test::serial]
async fn story310_at01_source_rejects_arbitrary_url_and_inline_request_fields() {
let (_registry, server, client, upstream) = spawn_stand("story310_at01_url").await;
let operation_id =
published_read_operation(&client, &server, &upstream, "story310_at01_url_read").await;
// Positive control: валидный source-only request создаётся.
let accepted = template_metadata(
"crank://story310/url-accepted",
"story310_url_accepted",
valid_source(&operation_id),
);
create_template_draft(&client, &server, &accepted).await;
let (_, _, listed_before) = list_resources(&client, &server).await;
let before = listed_before["items"].as_array().map(Vec::len).unwrap_or(0);
// Каждое запрещённое поле — отдельное расширение исходного source.
let forbidden = [
("url", json!("https://evil.example/orders")),
("base_url", json!("https://evil.example")),
("host", json!("evil.example")),
("scheme", json!("https")),
("method", json!("POST")),
("path_template", json!("/orders/{order_id}")),
("headers", json!({ "authorization": "leak" })),
("body", json!({ "order_id": "{order_id}" })),
("request", json!({ "url": "https://evil.example" })),
];
for (index, (field, value)) in forbidden.iter().enumerate() {
let mut source = valid_source(&operation_id);
source[*field] = value.clone();
let metadata = template_metadata(
&format!("crank://story310/url-field-{index}"),
&format!("story310_url_field_{index}"),
source,
);
let (status, text, body) = post_template_raw(&client, &server, &metadata).await;
assert_eq!(
status,
StatusCode::BAD_REQUEST,
"source field `{field}` must be rejected; observed {} body={text}",
error_signature(status, &body)
);
assert_eq!(
body["error"]["code"],
json!("resource_source_invalid"),
"source field `{field}` must use the stable source code: {body}"
);
}
let (_, _, listed_after) = list_resources(&client, &server).await;
assert_eq!(
listed_after["items"].as_array().map(Vec::len),
Some(before),
"rejected source fields must not create Resources: {listed_after}"
);
}
#[tokio::test(flavor = "multi_thread")]
#[serial_test::serial]
async fn story310_at01_source_and_content_are_mutually_exclusive() {
let (_registry, server, client, upstream) = spawn_stand("story310_at01_exclusive").await;
let operation_id =
published_read_operation(&client, &server, &upstream, "story310_at01_exclusive_read").await;
// Control: тот же metadata без source + content — прежний static Draft (201).
let static_metadata = draft_metadata(
"crank://story310/exclusive-static",
"story310_exclusive_static",
"text",
"text/plain",
"internal",
);
let (status, _traceable, text, body) = post_draft_raw(
&client,
&server,
&static_metadata,
b"static body\n",
"text/plain",
)
.await;
assert_eq!(
status,
StatusCode::CREATED,
"the static control must stay 201; observed {} body={text}",
error_signature(status, &body)
);
// Source present ⇒ content part обязана отсутствовать.
let metadata = template_metadata(
"crank://story310/exclusive",
"story310_exclusive",
valid_source(&operation_id),
);
let (status, text, body) = read_response(
client
.post(format!("{}/resources", server.as_ref()))
.multipart(draft_form(
&metadata,
b"content must not travel\n",
"draft.txt",
"text/plain",
))
.send()
.await
.expect("create request must complete"),
)
.await;
assert_eq!(
status,
StatusCode::BAD_REQUEST,
"a template Draft must not carry a content part; observed {} body={text}",
error_signature(status, &body)
);
assert_eq!(body["error"]["code"], json!("resource_source_invalid"));
assert_eq!(body["error"]["context"]["field"], json!("content"));
}
#[tokio::test(flavor = "multi_thread")]
#[serial_test::serial]
async fn story310_at01_foreign_and_missing_operation_are_not_disclosed() {
let (registry, server, client, upstream) = spawn_stand("story310_at01_foreign").await;
create_owned_workspace(&registry).await;
// Права на новый workspace проверяются сессией после membership (как в 3.6 негативах).
let owned_client = login_client(&server, TEST_AUTH_EMAIL, TEST_AUTH_PASSWORD).await;
let owned_base = server
.as_ref()
.replace(DEFAULT_WORKSPACE_ID, OWNED_WORKSPACE_ID);
let foreign_name = "story310_foreign_secret_tool";
let foreign_id =
published_read_operation(&owned_client, &owned_base, &upstream, foreign_name).await;
for (label, operation_id) in [
("foreign", foreign_id.as_str()),
("missing", "op_story310_missing"),
] {
let metadata = template_metadata(
&format!("crank://story310/{label}-op"),
&format!("story310_{label}_op"),
valid_source(operation_id),
);
let (status, text, body) = post_template_raw(&client, &server, &metadata).await;
assert_eq!(
status,
StatusCode::NOT_FOUND,
"an unusable source Operation must be a non-disclosing 404 ({label}); observed {} body={text}",
error_signature(status, &body)
);
assert_eq!(body["error"]["code"], json!("resource_source_not_found"));
assert!(
!text.contains(foreign_name) && !text.contains("crank://orders/"),
"the rejection must not disclose the foreign operation ({label}): {text}"
);
}
}
#[path = "template_boundaries.rs"]
mod boundaries;
#[path = "template_outbound.rs"]
mod outbound;
#[path = "template_parameters.rs"]
mod parameters;
#[path = "template_policy.rs"]
mod policy;
#[path = "template_safety.rs"]
mod safety;