feat(import): preserve supported HTTP contracts

This commit is contained in:
bsodfather committed 2026-09-13 03:30:31 +03:00
1 parent 083974c27f
commit f8ee7c9bfe
87 files changed
+7496 -534

No files matched your search

+6
View File
@@ -134,9 +134,13 @@ mod tests {
method: HttpMethod::Delete,
path_template: "/items/{id}".to_owned(),
static_headers: BTreeMap::new(),
request_contract: None,
response_contract: Vec::new(),
multipart_field_mime_types: BTreeMap::new(),
}),
input_schema: Schema {
kind: SchemaKind::Object,
format: None,
description: None,
required: true,
nullable: false,
@@ -148,6 +152,7 @@ mod tests {
},
output_schema: Schema {
kind: SchemaKind::Object,
format: None,
description: None,
required: false,
nullable: false,
@@ -198,6 +203,7 @@ mod tests {
fn string_schema() -> Schema {
Schema {
kind: SchemaKind::String,
format: None,
description: None,
required: true,
nullable: false,
+3
View File
@@ -421,6 +421,9 @@ fn demo_rest_operation_payload() -> OperationPayload {
method: crank_core::HttpMethod::Get,
path_template: "/v1/latest".to_owned(),
static_headers: BTreeMap::from([("Accept".to_owned(), "application/json".to_owned())]),
request_contract: None,
response_contract: Vec::new(),
multipart_field_mime_types: BTreeMap::new(),
}),
input_schema: Schema::from_json_sample(&input),
output_schema: Schema::from_json_sample(&output),
+6 -1
View File
@@ -639,7 +639,12 @@ fn import_replay_contract(
if normalizer == NORMALIZER_VERSION && projection == PROJECTION_VERSION {
return Ok(ImportReplayContract::Current);
}
if normalizer != "normalized-ir-v2" || projection != "preview-v2" {
// Historical preview payloads are replayed as their persisted projection.
// They must never be parsed again with the current v4 semantics.
if !matches!(
(normalizer, projection),
("normalized-ir-v2", "preview-v2") | ("normalized-ir-v3", "preview-v3")
) {
return Err(ApiError::openapi_upload(locale, "source_integrity"));
}
@@ -93,7 +93,14 @@ pub(super) fn validate_idempotency_policy(
}
match target {
Target::Rest(rest_target) if rest_target.method != crank_core::HttpMethod::Get => {}
Target::Rest(rest_target)
if matches!(
rest_target.method,
crank_core::HttpMethod::Post
| crank_core::HttpMethod::Put
| crank_core::HttpMethod::Patch
| crank_core::HttpMethod::Delete
) => {}
_ => {
return Err(ApiError::validation_with_context(
"idempotency is supported only for mutating REST operations".to_owned(),
@@ -206,6 +213,9 @@ mod tests {
method: HttpMethod::Get,
path_template: "/catalog".to_owned(),
static_headers: BTreeMap::new(),
request_contract: None,
response_contract: Vec::new(),
multipart_field_mime_types: BTreeMap::new(),
});
let result = validate_response_cache_policy(&target, &cacheable_execution_config());
@@ -233,6 +243,9 @@ mod tests {
method: HttpMethod::Post,
path_template: "/catalog".to_owned(),
static_headers: BTreeMap::new(),
request_contract: None,
response_contract: Vec::new(),
multipart_field_mime_types: BTreeMap::new(),
});
let error =
@@ -252,6 +265,9 @@ mod tests {
method: HttpMethod::Post,
path_template: "/orders".to_owned(),
static_headers: BTreeMap::new(),
request_contract: None,
response_contract: Vec::new(),
multipart_field_mime_types: BTreeMap::new(),
});
let result = validate_idempotency_policy(
@@ -269,6 +285,9 @@ mod tests {
method: HttpMethod::Get,
path_template: "/orders".to_owned(),
static_headers: BTreeMap::new(),
request_contract: None,
response_contract: Vec::new(),
multipart_field_mime_types: BTreeMap::new(),
});
let error = validate_idempotency_policy(
@@ -291,6 +310,9 @@ mod tests {
method: HttpMethod::Post,
path_template: "/orders".to_owned(),
static_headers: BTreeMap::new(),
request_contract: None,
response_contract: Vec::new(),
multipart_field_mime_types: BTreeMap::new(),
});
let mut config = idempotent_execution_config(IdempotencyMode::Required);
let policy = config.idempotency.as_mut().unwrap();
@@ -435,6 +435,9 @@ pub(super) fn test_operation_payload(base_url: &str, name: &str) -> OperationPay
method: HttpMethod::Post,
path_template: "/crm/leads".to_owned(),
static_headers: BTreeMap::new(),
request_contract: None,
response_contract: Vec::new(),
multipart_field_mime_types: BTreeMap::new(),
}),
input_schema: object_schema("email"),
output_schema: object_schema("id"),
@@ -483,6 +486,7 @@ pub(super) fn test_operation_payload(base_url: &str, name: &str) -> OperationPay
pub(super) fn object_schema(field_name: &str) -> Schema {
Schema {
kind: SchemaKind::Object,
format: None,
description: None,
required: true,
nullable: false,
@@ -491,6 +495,7 @@ pub(super) fn object_schema(field_name: &str) -> Schema {
field_name.to_owned(),
Schema {
kind: SchemaKind::String,
format: None,
description: None,
required: true,
nullable: false,
@@ -323,6 +323,9 @@ async fn rejects_response_cache_for_operation_with_auth_profile() {
method: HttpMethod::Get,
path_template: "/crm/leads".to_owned(),
static_headers: BTreeMap::new(),
request_contract: None,
response_contract: Vec::new(),
multipart_field_mime_types: BTreeMap::new(),
});
payload.execution_config.response_cache = Some(ResponseCachePolicy { ttl_ms: 5_000 });
payload.execution_config.auth_profile_ref = Some("auth_profile_01".into());
@@ -10,6 +10,7 @@ use super::common::{
};
mod external_references;
mod http_contract;
const OPENAPI3: &str = r#"
openapi: 3.0.3
@@ -77,11 +78,11 @@ async fn previews_openapi_and_creates_draft_operations() {
assert_eq!(preview_job.status, ImportJobStatus::Pending);
assert_eq!(
preview_job.preview_payload["normalization"]["normalizer_version"],
"normalized-ir-v3"
"normalized-ir-v4"
);
assert_eq!(
preview_job.preview_payload["normalization"]["projection_version"],
"preview-v3"
"preview-v4"
);
assert!(preview_job.preview_payload["normalization"]["ir_fingerprint"].is_string());
@@ -451,6 +452,8 @@ async fn apply_fails_closed_for_each_normalization_contract_field_and_digest_sha
#[tokio::test]
#[serial]
async fn legacy_job_without_normalization_contract_replays_until_expiry() {
use sha2::{Digest, Sha256};
let registry = test_registry().await;
let service = test_service(
registry.clone(),
@@ -464,10 +467,22 @@ async fn legacy_job_without_normalization_contract_replays_until_expiry() {
.await
.unwrap();
let job_id: crank_registry::ImportJobId = preview.job_id.as_str().into();
// A legacy job stores the legacy projection and its matching fingerprint,
// not a current projection with only the version metadata removed.
let legacy_preview =
serde_json::to_value(crank_import::rest::preview_document_legacy_v1(OPENAPI3).unwrap())
.unwrap();
let legacy_digest = format!(
"{:x}",
Sha256::digest(serde_json::to_vec(&legacy_preview).unwrap())
);
sqlx::query(
"update import_jobs set preview_payload = preview_payload - 'normalization' where id = $1",
"update import_jobs set preview_payload = (preview_payload - 'normalization') || \
jsonb_build_object('preview', $2::jsonb, 'preview_digest', $3::text) where id = $1",
)
.bind(job_id.as_str())
.bind(legacy_preview)
.bind(legacy_digest)
.execute(registry.pool())
.await
.unwrap();
@@ -536,3 +536,73 @@ async fn exact_v2_contract_replays_persisted_preview_without_v3_or_dependency_re
.unwrap();
assert_eq!(completed.status, ImportJobStatus::Completed);
}
#[tokio::test]
#[serial]
async fn exact_v3_contract_replays_persisted_preview_without_v4_or_dependency_reads() {
let registry = test_registry().await;
let service = test_service(
registry.clone(),
test_storage_root("openapi_import_v3_compatibility"),
test_auth_settings(),
test_secret_crypto(),
);
let workspace_id = WorkspaceId::new("ws_default");
let preview = service
.preview_openapi_import(&workspace_id, openapi_upload())
.await
.unwrap();
let job_id: crank_registry::ImportJobId = preview.job_id.as_str().into();
let missing_dependency = serde_json::json!([{
"source_id": "src_openapi_dep_v3_must_not_be_read",
"digest": format!("sha256:{}", "0".repeat(64)),
"canonical_uri": "https://schemas.example.test/v3.yaml"
}]);
sqlx::query(
"update import_jobs
set preview_payload = jsonb_set(
jsonb_set(
jsonb_set(
jsonb_set(
preview_payload,
'{normalization,normalizer_version}',
to_jsonb('normalized-ir-v3'::text)
),
'{normalization,projection_version}',
to_jsonb('preview-v3'::text)
),
'{normalization,ir_fingerprint}',
to_jsonb($1::text)
),
'{dependency_snapshots}',
$2::jsonb
)
where id = $3",
)
.bind("a".repeat(64))
.bind(missing_dependency)
.bind(job_id.as_str())
.execute(registry.pool())
.await
.unwrap();
let result = service
.create_openapi_import(
&workspace_id,
&job_id,
OpenApiImportCreatePayload {
selected_operation_keys: vec!["GET /v2/latest".to_owned()],
server_url: Some("https://api.frankfurter.dev".to_owned()),
conflict_mode: "skip".to_owned(),
},
)
.await
.unwrap();
assert_eq!(result.created.len(), 1);
let completed = registry
.get_import_job(&workspace_id, &job_id)
.await
.unwrap()
.unwrap();
assert_eq!(completed.status, ImportJobStatus::Completed);
}
@@ -0,0 +1,296 @@
use super::*;
use crank_core::Target;
use serde_json::json;
#[tokio::test]
#[serial]
async fn http_contract_preview_apply_and_replay_preserve_json_multipart_schemas_mapping_and_mime() {
let registry = test_registry().await;
let service = test_service(
registry.clone(),
test_storage_root("openapi_import_http_contract_replay"),
test_auth_settings(),
test_secret_crypto(),
);
let workspace_id = WorkspaceId::new("ws_default");
let preview = service
.preview_openapi_import(&workspace_id, rich_http_contract_upload())
.await
.unwrap();
let job_id: crank_registry::ImportJobId = preview.job_id.as_str().into();
let persisted_preview_before_apply = registry
.get_import_job(&workspace_id, &job_id)
.await
.unwrap()
.unwrap()
.preview_payload["preview"]
.clone();
assert_eq!(
persisted_preview_before_apply,
serde_json::to_value(&preview.preview).unwrap()
);
let operations = preview
.preview
.groups
.iter()
.flat_map(|group| group.operations.iter())
.collect::<Vec<_>>();
assert_eq!(operations.len(), 1, "media variants must not split a Tool");
let candidate = operations[0];
assert_eq!(candidate.key, "POST /documents");
assert!(
candidate.findings.iter().all(|finding| {
finding.severity != crank_import::rest::ImportFindingSeverity::Error
})
);
let json_arguments = json!({
"content_type": "application/json",
"body": {"title": "Quarterly report"}
});
let multipart_arguments = json!({
"content_type": "multipart/form-data",
"body": {
"file": {
"data_base64": "AA==",
"filename": "report.png",
"content_type": "image/png"
},
"caption": "Quarterly report"
}
});
candidate
.draft
.input_schema
.validate_shape(&json_arguments)
.unwrap();
candidate
.draft
.input_schema
.validate_shape(&multipart_arguments)
.unwrap();
assert!(
candidate
.draft
.input_schema
.validate_shape(&json!({
"content_type": "multipart/form-data",
"body": {"title": "wrong branch"}
}))
.is_err()
);
let mapped = candidate
.draft
.input_mapping
.apply(&json!({"mcp": multipart_arguments}))
.unwrap();
assert_eq!(
mapped["request"]["body_content_type"],
"multipart/form-data"
);
assert_eq!(mapped["request"]["body"]["file"]["data_base64"], "AA==");
let preview_target = &candidate.draft.target;
let preview_contract = preview_target.request_contract.as_ref().unwrap();
assert_eq!(preview_contract.body_field, "body");
assert_eq!(
preview_contract.selector_field.as_deref(),
Some("content_type")
);
assert_eq!(preview_contract.variants.len(), 2);
assert_eq!(
preview_target.multipart_field_mime_types["multipart/form-data"]["file"],
["image/png", "image/jpeg"]
);
let payload = OpenApiImportCreatePayload {
selected_operation_keys: vec![candidate.key.clone()],
server_url: None,
conflict_mode: "skip".to_owned(),
};
let created = service
.create_openapi_import(&workspace_id, &job_id, payload.clone())
.await
.unwrap();
assert_eq!(created.created.len(), 1);
let replayed = service
.create_openapi_import(&workspace_id, &job_id, payload)
.await
.unwrap();
assert_eq!(replayed.created, created.created);
let persisted_preview_after_replay = registry
.get_import_job(&workspace_id, &job_id)
.await
.unwrap()
.unwrap()
.preview_payload["preview"]
.clone();
assert_eq!(
persisted_preview_after_replay,
persisted_preview_before_apply
);
let version = service
.get_operation_version(
&workspace_id,
&created.created[0].operation_id.as_str().into(),
created.created[0].version,
)
.await
.unwrap();
assert_eq!(version.snapshot.input_schema, candidate.draft.input_schema);
assert_eq!(
version.snapshot.output_schema,
candidate.draft.output_schema
);
assert_eq!(
version.snapshot.input_mapping,
candidate.draft.input_mapping
);
assert_eq!(
version.snapshot.output_mapping,
candidate.draft.output_mapping
);
assert_eq!(
version.snapshot.target,
Target::Rest(candidate.draft.target.clone())
);
}
#[tokio::test]
#[serial]
async fn xml_and_unsupported_media_block_apply_without_registry_mutation() {
let registry = test_registry().await;
let service = test_service(
registry.clone(),
test_storage_root("openapi_import_http_contract_blockers"),
test_auth_settings(),
test_secret_crypto(),
);
let workspace_id = WorkspaceId::new("ws_default");
let preview = service
.preview_openapi_import(&workspace_id, unsupported_media_upload())
.await
.unwrap();
let candidate = preview
.preview
.groups
.iter()
.flat_map(|group| group.operations.iter())
.find(|operation| operation.key == "POST /blocked")
.unwrap();
assert!(candidate.findings.iter().any(|finding| {
finding.code == "unsupported_xml_request_media_type"
&& finding.severity == crank_import::rest::ImportFindingSeverity::Error
}));
assert!(candidate.findings.iter().any(|finding| {
finding.code == "unsupported_request_media_type"
&& finding.severity == crank_import::rest::ImportFindingSeverity::Error
}));
assert!(
service
.create_openapi_import(
&workspace_id,
&preview.job_id.as_str().into(),
OpenApiImportCreatePayload {
selected_operation_keys: vec![candidate.key.clone()],
server_url: None,
conflict_mode: "skip".to_owned(),
},
)
.await
.is_err()
);
assert!(
service
.list_operations(&workspace_id)
.await
.unwrap()
.is_empty()
);
let job = registry
.get_import_job(&workspace_id, &preview.job_id.as_str().into())
.await
.unwrap()
.unwrap();
assert_eq!(job.status, ImportJobStatus::Failed);
assert_eq!(
job.error_text.as_deref(),
Some("reference_resolution_blocked")
);
}
fn rich_http_contract_upload() -> OpenApiUpload {
OpenApiUpload {
bytes: br#"
openapi: 3.0.3
info: { title: Document import }
servers: [{ url: https://api.example.test/v1 }]
paths:
/documents:
post:
operationId: importDocument
requestBody:
required: true
content:
application/json:
schema:
type: object
required: [title]
properties:
title: { type: string }
multipart/form-data:
schema:
type: object
required: [file]
properties:
file: { type: string, format: binary }
caption: { type: string }
encoding:
file: { contentType: 'image/png, image/jpeg' }
responses:
'201':
description: Created
content:
application/json:
schema: { type: object, properties: { id: { type: string } } }
"#
.to_vec(),
mime_type: "application/yaml".to_owned(),
locale: OpenApiUploadLocale::En,
}
}
fn unsupported_media_upload() -> OpenApiUpload {
OpenApiUpload {
bytes: br#"
openapi: 3.0.3
info: { title: Unsupported request media }
servers: [{ url: https://api.example.test/v1 }]
paths:
/blocked:
post:
operationId: blockedMedia
requestBody:
required: true
content:
application/json:
schema: { type: object, properties: { name: { type: string } } }
application/xml:
schema: { type: string }
application/pdf:
schema: { type: string, format: binary }
responses:
'200': { description: OK }
"#
.to_vec(),
mime_type: "application/yaml".to_owned(),
locale: OpenApiUploadLocale::En,
}
}
@@ -489,6 +489,9 @@ pub(super) fn test_operation(base_url: &str, name: &str) -> Operation<Schema, Ma
method: HttpMethod::Post,
path_template: "/crm/leads".to_owned(),
static_headers: BTreeMap::new(),
request_contract: None,
response_contract: Vec::new(),
multipart_field_mime_types: BTreeMap::new(),
}),
input_schema: object_schema("email"),
output_schema: object_schema("id"),
@@ -543,6 +546,7 @@ pub(super) fn test_operation(base_url: &str, name: &str) -> Operation<Schema, Ma
pub(super) fn object_schema(field_name: &str) -> Schema {
Schema {
kind: SchemaKind::Object,
format: None,
description: None,
required: true,
nullable: false,
@@ -551,6 +555,7 @@ pub(super) fn object_schema(field_name: &str) -> Schema {
field_name.to_owned(),
Schema {
kind: SchemaKind::String,
format: None,
description: None,
required: true,
nullable: false,