//! Regressions for the `$ref` expansion aggregate string/key byte budget //! (Gitea #88). //! //! `reference::resolve` clones the referenced target subtree per `$ref` //! occurrence. Many individually small (but not tiny) targets therefore //! multiply into a large materialized tree while staying under //! `max_references`, `max_expanded_nodes`, `max_nodes`, `max_collection_items` //! and `max_scalar_bytes`; a bounded probe reproduced a child address-space //! abort for such an input. The aggregate copy budget must reject these with //! `ImportParseError::LimitExceeded` before the copies allocate, for both local //! and supplied external references, while small ordinary usage keeps working. //! //! The fixture is deliberately modest (16 KiB payload, 400 references → ≈6.4 //! MiB expanded, far below the risky 256 MiB reproduction and below 20 MiB). use crank_import::rest::{ ExternalDocumentSnapshot, ImportParseError, NormalizationConfig, SourceDigest, normalize_verified_document, validate_resolved_bundle_source_safe, }; use serde_json::{Map, Value, json}; const DESCRIPTION_BYTES: usize = 16 * 1024; const EXPANDING_REFS: usize = 400; const EXTERNAL_URI: &str = "https://schemas.example.test/root.yaml"; // The fixture must stay comfortably below the unsafe reproduction size. const _: () = assert!(DESCRIPTION_BYTES * EXPANDING_REFS < 20 * 1024 * 1024); fn digest(byte: char) -> SourceDigest { SourceDigest::parse(byte.to_string().repeat(64)).expect("64-char digest is valid") } fn big_schema() -> Value { json!({ "type": "object", "description": "x".repeat(DESCRIPTION_BYTES), "properties": { "id": { "type": "string" } } }) } fn big_schema_with_large_property_key() -> Value { let mut properties = Map::new(); properties.insert("k".repeat(DESCRIPTION_BYTES), json!({ "type": "string" })); json!({ "type": "object", "properties": Value::Object(properties) }) } fn document_with_refs(ref_uri: &str, ref_count: usize) -> String { let all_of: Vec = (0..ref_count).map(|_| json!({ "$ref": ref_uri })).collect(); let document = json!({ "openapi": "3.1.0", "info": { "title": "Ref budget", "version": "1" }, "servers": [{ "url": "https://api.example.test" }], "paths": { "/items": { "get": { "operationId": "listItems", "responses": { "200": { "description": "ok", "content": { "application/json": { "schema": { "allOf": all_of } } } } } } } } }); serde_json::to_string(&document).expect("document serializes") } fn local_ref_document(ref_count: usize) -> String { local_ref_document_with(big_schema(), ref_count) } fn local_ref_document_with(schema: Value, ref_count: usize) -> String { let mut document: Value = serde_json::from_str(&document_with_refs("#/components/schemas/Big", ref_count)) .expect("valid JSON"); document["components"] = json!({ "schemas": { "Big": schema } }); serde_json::to_string(&document).expect("document serializes") } fn external_ref_document(ref_count: usize) -> String { let uri = format!("{EXTERNAL_URI}#/Big"); document_with_refs(&uri, ref_count) } fn external_snapshot() -> ExternalDocumentSnapshot { let document = serde_json::to_string(&json!({ "Big": big_schema() })).expect("snapshot serializes"); ExternalDocumentSnapshot { canonical_uri: EXTERNAL_URI.to_owned(), digest: digest('b'), document, } } fn assert_fits_raw_limit(document: &str) { assert!( document.len() < NormalizationConfig::default().max_bytes, "fixture must stay under the raw byte limit, got {} bytes", document.len() ); } #[test] fn local_ref_expansion_over_aggregate_budget_is_rejected() { let document = local_ref_document(EXPANDING_REFS); assert_fits_raw_limit(&document); assert!(matches!( normalize_verified_document(&document, digest('a'), &NormalizationConfig::default()), Err(ImportParseError::LimitExceeded) )); } #[test] fn local_ref_expansion_counts_large_object_keys() { let document = local_ref_document_with(big_schema_with_large_property_key(), EXPANDING_REFS); assert_fits_raw_limit(&document); assert!(matches!( normalize_verified_document(&document, digest('a'), &NormalizationConfig::default()), Err(ImportParseError::LimitExceeded) )); } #[test] fn supplied_external_ref_expansion_over_aggregate_budget_is_rejected() { let primary = external_ref_document(EXPANDING_REFS); assert_fits_raw_limit(&primary); assert_eq!( validate_resolved_bundle_source_safe( &primary, digest('a'), &[external_snapshot()], &NormalizationConfig::default() ), Err(ImportParseError::LimitExceeded) ); } #[test] fn a_single_local_ref_stays_within_budget() { let document = local_ref_document(1); let ir = normalize_verified_document(&document, digest('a'), &NormalizationConfig::default()) .expect("a single reference must stay within the expanded budget"); assert_eq!(ir.operations.len(), 1); assert_eq!(ir.reference_graph.edges.len(), 1); } #[test] fn several_local_refs_stay_within_budget() { let document = local_ref_document(4); assert!( normalize_verified_document(&document, digest('a'), &NormalizationConfig::default()) .is_ok() ); } #[test] fn a_single_supplied_external_ref_stays_within_budget() { let primary = external_ref_document(1); assert_eq!( validate_resolved_bundle_source_safe( &primary, digest('a'), &[external_snapshot()], &NormalizationConfig::default() ), Ok(()) ); }