feat(import): complete OpenAPI onboarding and verify delivery
CI / Rust Checks (pull_request) Failing after 1s
CI / UI Checks (pull_request) Skipped
CI / Frontend E2E (pull_request) Skipped
CI / Community Image Smoke (pull_request) Skipped
CI / Deploy (pull_request) Skipped

This commit is contained in:
bsodfather committed 2026-10-09 17:50:38 +03:00
1 parent bb3e376767
commit e93de7015a
244 files changed
+57020 -5139

No files matched your search

@@ -0,0 +1,413 @@
use super::*;
// --- Referenced security credentials RED regressions ---
// These tests prove that credential literals hidden behind local/external $ref
// security scheme + parameter splits are rejected before artifact persistence.
#[tokio::test]
#[serial]
async fn referenced_security_credentials_local_scheme_ref_with_parameter_default_canary_rejected() {
let canary = b"local-ref-canary-001-Zx9qK";
let registry = test_registry().await;
let storage_root = test_storage_root("openapi_import_local_scheme_ref_canary");
let service = test_service(
registry.clone(),
storage_root.clone(),
test_auth_settings(),
test_secret_crypto(),
);
let workspace_id = WorkspaceId::new("ws_default");
let upload = OpenApiUpload {
bytes: r##"{
"openapi":"3.1.0",
"info":{"title":"Local ref scheme","version":"1"},
"servers":[{"url":"https://api.example.test"}],
"x-scheme":{"type":"apiKey","in":"header","name":"X-Custom"},
"x-key":{"type":"string","default":"local-ref-canary-001-Zx9qK"},
"components":{
"securitySchemes":{"custom":{"$ref":"#/x-scheme"}}
},
"security":[{"custom":[]}],
"paths":{
"/test":{"get":{
"operationId":"test", "security":[{"custom":[]}],
"parameters":[{"name":"X-Custom","in":"header","schema":{"$ref":"#/x-key"}}],
"responses":{"200":{"description":"ok"}}
}}
}
}"##
.as_bytes()
.to_vec(),
mime_type: "application/json".to_owned(),
locale: OpenApiUploadLocale::En,
};
let result = service.preview_openapi_import(&workspace_id, upload).await;
// Canary must NOT appear in the API response (error or preview).
let response_repr = match &result {
Ok(preview) => serde_json::to_string(preview).unwrap(),
Err(err) => format!("{err:?}"),
};
assert!(
response_repr.contains("invalid_document"),
"unsafe local ref bundle was not rejected: {response_repr}"
);
assert!(
!response_repr.contains(std::str::from_utf8(canary).unwrap()),
"credential canary leaked into API response"
);
// Canary must NOT be persisted to artifact storage.
assert!(
!storage_contains_literal(&storage_root, canary),
"raw credential literal from referenced local scheme ref persisted to storage"
);
assert_rejected_bundle_unpersisted(&registry, &workspace_id, &storage_root).await;
}
#[tokio::test]
#[serial]
async fn encoded_access_token_fragment_is_rejected_before_persistence() {
let canary = b"fragment-ingress-canary-004-Qm7vN";
let registry = test_registry().await;
let storage_root = test_storage_root("openapi_import_encoded_fragment_canary");
let service = test_service(
registry.clone(),
storage_root.clone(),
test_auth_settings(),
test_secret_crypto(),
);
let workspace_id = WorkspaceId::new("ws_default");
let upload = OpenApiUpload {
bytes: br##"{
"openapi":"3.1.0",
"info":{"title":"Encoded fragment credential","version":"1"},
"servers":[{"url":"https://api.example.test/v1#%61%63%63%65%73%73%5F%74%6F%6B%65%6E=fragment-ingress-canary-004-Qm7vN"}],
"paths":{"/health":{"get":{"responses":{"200":{"description":"ok"}}}}}
}"##
.to_vec(),
mime_type: "application/json".to_owned(),
locale: OpenApiUploadLocale::En,
};
let error = service
.preview_openapi_import(&workspace_id, upload)
.await
.expect_err("encoded access_token fragment must be rejected at ingress");
let rendered_error = format!("{error:?}");
assert!(rendered_error.contains("invalid_document"));
assert!(rendered_error.len() <= 512, "error must remain bounded");
assert!(!rendered_error.contains("fragment-ingress-canary-004-Qm7vN"));
assert!(!rendered_error.contains("%61%63%63%65%73%73%5F%74%6F%6B%65%6E"));
assert_rejected_bundle_unpersisted(&registry, &workspace_id, &storage_root).await;
assert!(!storage_contains_literal(&storage_root, canary));
}
#[tokio::test]
#[serial]
async fn referenced_security_credentials_external_scheme_ref_local_parameter_default_canary_rejected()
{
let canary = b"split-ext-canary-002-Yw8pJ";
// External document defines the apiKey security scheme with header X-Custom.
let external_doc = r#"{"x-scheme":{"type":"apiKey","in":"header","name":"X-Custom"}}"#;
let fetched = Arc::new(AtomicUsize::new(0));
let fetch_count = Arc::clone(&fetched);
let app = Router::new().route(
"/scheme.yaml",
get(move || {
let fc = Arc::clone(&fetch_count);
async move {
fc.fetch_add(1, Ordering::SeqCst);
external_doc.to_owned()
}
}),
);
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let address = listener.local_addr().unwrap();
let server = tokio::spawn(async move { axum::serve(listener, app).await.unwrap() });
let origin = format!("http://{address}");
let registry = test_registry().await;
let storage_root = test_storage_root("openapi_import_ext_scheme_ref_canary");
let service = test_service_with_external_references(
registry.clone(),
storage_root.clone(),
vec![format!("{origin}/")],
);
let workspace_id = WorkspaceId::new("ws_default");
// Primary references the external scheme; contains a local parameter
// with name X-Custom and schema.default = canary.
let upload = OpenApiUpload {
bytes: format!(
r#"{{
"openapi":"3.1.0",
"info":{{"title":"Ext scheme ref","version":"1"}},
"servers":[{{"url":"https://api.example.test"}}],
"components":{{
"securitySchemes":{{"custom":{{"$ref":"{origin}/scheme.yaml#/x-scheme"}}}}
}},
"security":[{{"custom":[]}}],
"paths":{{
"/test":{{"get":{{
"operationId":"test", "security":[{{"custom":[]}}],
"parameters":[{{"name":"X-Custom","in":"header","schema":{{"type":"string","default":"{canary}"}}}}],
"responses":{{"200":{{"description":"ok"}}}}
}}}}
}}
}}"#,
origin = origin,
canary = std::str::from_utf8(canary).unwrap(),
)
.into_bytes(),
mime_type: "application/json".to_owned(),
locale: OpenApiUploadLocale::En,
};
let result = service.preview_openapi_import(&workspace_id, upload).await;
server.abort();
assert_eq!(
fetched.load(Ordering::SeqCst),
1,
"external scheme must be fetched before the split is checked"
);
let response_repr = match &result {
Ok(preview) => serde_json::to_string(preview).unwrap(),
Err(err) => format!("{err:?}"),
};
assert!(
response_repr.contains("invalid_document"),
"unsafe external scheme bundle was not rejected: {response_repr}"
);
assert!(
!response_repr.contains(std::str::from_utf8(canary).unwrap()),
"credential canary leaked into API response"
);
assert!(
!storage_contains_literal(&storage_root, canary),
"raw credential literal from split external scheme ref persisted to storage"
);
assert_rejected_bundle_unpersisted(&registry, &workspace_id, &storage_root).await;
}
#[tokio::test]
#[serial]
async fn referenced_security_credentials_local_scheme_external_parameter_default_canary_rejected() {
let canary = b"split-local-canary-003-Xv7oI";
// External document defines a parameter schema whose default is the canary.
let external_doc = format!(
r#"{{"x-key":{{"type":"string","default":"{canary}"}}}}"#,
canary = std::str::from_utf8(canary).unwrap(),
);
let fetched = Arc::new(AtomicUsize::new(0));
let fetch_count = Arc::clone(&fetched);
let app = Router::new().route(
"/key.yaml",
get(move || {
let fc = Arc::clone(&fetch_count);
async move {
fc.fetch_add(1, Ordering::SeqCst);
external_doc.clone()
}
}),
);
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let address = listener.local_addr().unwrap();
let server = tokio::spawn(async move { axum::serve(listener, app).await.unwrap() });
let origin = format!("http://{address}");
let registry = test_registry().await;
let storage_root = test_storage_root("openapi_import_local_scheme_ext_param_canary");
let service = test_service_with_external_references(
registry.clone(),
storage_root.clone(),
vec![format!("{origin}/")],
);
let workspace_id = WorkspaceId::new("ws_default");
// Primary declares the scheme directly (no $ref); parameter schema is
// an external $ref whose resolved default would be the canary.
let upload = OpenApiUpload {
bytes: format!(
r#"{{
"openapi":"3.1.0",
"info":{{"title":"Local scheme ext param","version":"1"}},
"servers":[{{"url":"https://api.example.test"}}],
"components":{{
"securitySchemes":{{"custom":{{"type":"apiKey","in":"header","name":"X-Custom"}}}}
}},
"security":[{{"custom":[]}}],
"paths":{{
"/test":{{"get":{{
"operationId":"test", "security":[{{"custom":[]}}],
"parameters":[{{"name":"X-Custom","in":"header","schema":{{"$ref":"{origin}/key.yaml#/x-key"}}}}],
"responses":{{"200":{{"description":"ok"}}}}
}}}}
}}
}}"#,
origin = origin,
)
.into_bytes(),
mime_type: "application/json".to_owned(),
locale: OpenApiUploadLocale::En,
};
let result = service.preview_openapi_import(&workspace_id, upload).await;
server.abort();
assert_eq!(
fetched.load(Ordering::SeqCst),
1,
"external parameter must be fetched before the split is checked"
);
let response_repr = match &result {
Ok(preview) => serde_json::to_string(preview).unwrap(),
Err(err) => format!("{err:?}"),
};
assert!(
response_repr.contains("invalid_document"),
"unsafe external parameter bundle was not rejected: {response_repr}"
);
assert!(
!response_repr.contains(std::str::from_utf8(canary).unwrap()),
"credential canary leaked into API response"
);
assert!(
!storage_contains_literal(&storage_root, canary),
"raw credential literal from external referenced parameter persisted to storage"
);
assert_rejected_bundle_unpersisted(&registry, &workspace_id, &storage_root).await;
}
#[tokio::test]
#[serial]
async fn safe_external_security_scheme_and_parameter_are_preserved() {
let external_doc = r#"{"x-scheme":{"type":"apiKey","in":"header","name":"X-Custom"}}"#;
let fetched = Arc::new(AtomicUsize::new(0));
let fetch_count = Arc::clone(&fetched);
let app = Router::new().route(
"/scheme.yaml",
get(move || {
let count = Arc::clone(&fetch_count);
async move {
count.fetch_add(1, Ordering::SeqCst);
external_doc
}
}),
);
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let address = listener.local_addr().unwrap();
let server = tokio::spawn(async move { axum::serve(listener, app).await.unwrap() });
let origin = format!("http://{address}");
let registry = test_registry().await;
let storage_root = test_storage_root("openapi_import_safe_external_security_ref");
let service = test_service_with_external_references(
registry.clone(),
storage_root,
vec![format!("{origin}/")],
);
let workspace_id = WorkspaceId::new("ws_default");
let preview = service
.preview_openapi_import(
&workspace_id,
OpenApiUpload {
bytes: format!(
r#"openapi: 3.1.0
info: {{ title: Safe external scheme, version: '1' }}
servers: [{{ url: https://api.example.test }}]
components:
securitySchemes:
custom: {{ $ref: '{origin}/scheme.yaml#/x-scheme' }}
security: [{{ custom: [] }}]
paths:
/test:
get:
operationId: safeExternalSecurity
security: [{{ custom: [] }}]
parameters:
- name: X-Custom
in: header
schema: {{ type: string }}
- name: locale
in: query
schema: {{ type: string, default: en }}
responses:
'200': {{ description: ok }}
"#
)
.into_bytes(),
mime_type: "application/yaml".to_owned(),
locale: OpenApiUploadLocale::En,
},
)
.await
.expect("safe referenced schemes and parameters remain importable");
server.abort();
assert_eq!(fetched.load(Ordering::SeqCst), 1);
let operation = preview
.preview
.groups
.iter()
.flat_map(|group| &group.operations)
.find(|operation| operation.key == "GET /test")
.expect("operation preview is preserved");
assert!(matches!(
&operation.security_schemes["custom"].kind,
crank_import::rest::NormalizedSecuritySchemeKind::ApiKey {
parameter_name,
location: crank_import::rest::SecurityParameterLocation::Header,
..
} if parameter_name == "X-Custom"
));
let input_schema = serde_json::to_value(&operation.draft.input_schema).unwrap();
assert_eq!(
input_schema.pointer("/fields/locale/default_value"),
Some(&serde_json::json!("en")),
"benign locale default must remain visible in the preview"
);
let job = registry
.get_import_job(&workspace_id, &preview.job_id.as_str().into())
.await
.unwrap()
.unwrap();
assert_eq!(
job.preview_payload["dependency_snapshots"]
.as_array()
.unwrap()
.len(),
1
);
}
async fn assert_rejected_bundle_unpersisted(
registry: &crank_registry::PostgresRegistry,
workspace_id: &WorkspaceId,
storage_root: &std::path::Path,
) {
let sources: i64 =
sqlx::query_scalar("select count(*) from artifact_sources where workspace_id = $1")
.bind(workspace_id.as_str())
.fetch_one(registry.pool())
.await
.unwrap();
let jobs: i64 = sqlx::query_scalar("select count(*) from import_jobs where workspace_id = $1")
.bind(workspace_id.as_str())
.fetch_one(registry.pool())
.await
.unwrap();
assert_eq!(sources, 0, "rejected bundle registered a source");
assert_eq!(jobs, 0, "rejected bundle created an import job");
assert!(
!storage_has_files(storage_root),
"rejected bundle stored artifact bytes"
);
}
fn storage_has_files(path: &std::path::Path) -> bool {
std::fs::read_dir(path).unwrap().any(|entry| {
let path = entry.unwrap().path();
if path.is_dir() {
storage_has_files(&path)
} else {
true
}
})
}