Files
crank/crates/crank-import/tests/decode_limits.rs
T
bsodfather e93de7015a
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
feat(import): complete OpenAPI onboarding and verify delivery
2026-10-09 17:50:38 +03:00

373 lines
12 KiB
Rust

//! Regression coverage for the bounded YAML/JSON materialization guard
//! (Gitea #87).
//!
//! Alias expansions are charged against an aggregate expanded string/key
//! budget *before* `serde_yaml` materializes an owned `Value`. The public
//! entry points must return the controlled `ImportParseError::LimitExceeded`
//! instead of materializing an oversized tree. Small, ordinary alias usage,
//! duplicate keys, non-finite numbers and legacy behaviour are unchanged.
//!
//! The fixtures here are deliberately modest (a 16 KiB scalar with eight
//! doubling levels expands to a few MiB, well under the risky 256 MiB
//! reproduction) so the suite is safe to run in-process. Exact boundary
//! arithmetic is covered by unit tests inside `decode_budget`.
use crank_import::rest::{
ExternalDocumentSnapshot, ImportParseError, NormalizationConfig, SourceDigest,
external_reference_uris, normalize_verified_bundle, normalize_verified_document,
preview_document_legacy_v1, reference_uris, validate_document_bundle_source_safe,
validate_document_source_safe, validate_resolved_bundle_source_safe,
};
fn digest(byte: char) -> SourceDigest {
SourceDigest::parse(byte.to_string().repeat(64)).expect("64-char digest is valid")
}
/// Minimal valid OpenAPI 3.1 document with one GET operation. `extra` is
/// inserted at the root, ahead of `servers`, for extension fields.
fn valid_openapi(extra: &str) -> String {
format!(
"openapi: 3.1.0\n\
info: {{ title: Alias budget, version: '1' }}\n\
{extra}\
servers: [{{ url: https://api.example.test }}]\n\
paths:\n\
\x20 /items:\n\
\x20 get:\n\
\x20 operationId: listItems\n\
\x20 responses:\n\
\x20 '200': {{ description: ok }}\n"
)
}
/// Root extension whose value doubles the previous alias `levels` times,
/// starting from a 16 KiB scalar. Every per-item default limit is respected;
/// only the aggregate materialized size grows.
fn doubling_alias_document(levels: usize) -> String {
let scalar = "a".repeat(16 * 1024);
let mut extra = format!("x-expansion-0: &expansion0 \"{scalar}\"\n");
for level in 1..levels {
let previous = level - 1;
extra.push_str(&format!(
"x-expansion-{level}: &expansion{level} [*expansion{previous}, *expansion{previous}]\n"
));
}
let previous = levels - 1;
extra.push_str(&format!(
"x-expansion: &expansion{levels} [*expansion{previous}, *expansion{previous}]\n"
));
valid_openapi(&extra)
}
/// A compact alias chain for configurable boundary tests. The top-level value
/// repeats the scalar `2^levels` times through aliases.
fn alias_chain(scalar_len: usize, levels: usize) -> String {
let scalar = "b".repeat(scalar_len);
let mut document = format!("k0: &a0 \"{scalar}\"\n");
for level in 1..=levels {
let previous = level - 1;
document.push_str(&format!(
"k{level}: &a{level} [*a{previous}, *a{previous}]\n"
));
}
document
}
/// Ordinary, small alias usage that must remain accepted.
fn small_alias_document() -> String {
valid_openapi(
"x-anchor: &anchor { type: string }\n\
x-aliases: [*anchor, *anchor, *anchor]\n",
)
}
const LEVELS: usize = 8;
#[test]
fn primary_source_safety_rejects_doubling_aliases_over_aggregate_budget() {
let document = doubling_alias_document(LEVELS);
assert_eq!(
validate_document_source_safe(&document, &NormalizationConfig::default()),
Err(ImportParseError::LimitExceeded)
);
}
#[test]
fn bundle_source_safety_rejects_doubling_aliases_over_aggregate_budget() {
let document = doubling_alias_document(LEVELS);
assert_eq!(
validate_document_bundle_source_safe(&[document.as_str()], &NormalizationConfig::default()),
Err(ImportParseError::LimitExceeded)
);
}
#[test]
fn resolved_source_safety_rejects_doubling_aliases_over_aggregate_budget() {
let document = doubling_alias_document(LEVELS);
assert_eq!(
validate_resolved_bundle_source_safe(
&document,
digest('a'),
&[],
&NormalizationConfig::default()
),
Err(ImportParseError::LimitExceeded)
);
}
#[test]
fn normalization_rejects_doubling_aliases_over_aggregate_budget() {
let document = doubling_alias_document(LEVELS);
assert!(matches!(
normalize_verified_document(&document, digest('a'), &NormalizationConfig::default()),
Err(ImportParseError::LimitExceeded)
));
}
#[test]
fn primary_reference_uri_scan_rejects_doubling_aliases_over_aggregate_budget() {
let document = doubling_alias_document(LEVELS);
assert_eq!(
reference_uris(&document, &NormalizationConfig::default()),
Err(ImportParseError::LimitExceeded)
);
}
#[test]
fn external_reference_uri_scan_rejects_doubling_aliases_over_aggregate_budget() {
let document = doubling_alias_document(LEVELS);
assert_eq!(
external_reference_uris(&document, &NormalizationConfig::default()),
Err(ImportParseError::LimitExceeded)
);
}
#[test]
fn supplied_external_snapshot_rejects_doubling_aliases_over_aggregate_budget() {
let primary = valid_openapi("");
let snapshot = ExternalDocumentSnapshot {
canonical_uri: "https://schemas.example.test/root.yaml".to_owned(),
digest: digest('b'),
document: doubling_alias_document(LEVELS),
};
assert!(matches!(
normalize_verified_bundle(
&primary,
digest('a'),
&[snapshot],
&NormalizationConfig::default()
),
Err(ImportParseError::LimitExceeded)
));
}
#[test]
fn resolved_source_safety_rejects_doubling_aliases_in_supplied_snapshot() {
let primary = valid_openapi("");
let snapshot = ExternalDocumentSnapshot {
canonical_uri: "https://schemas.example.test/root.yaml".to_owned(),
digest: digest('b'),
document: doubling_alias_document(LEVELS),
};
assert_eq!(
validate_resolved_bundle_source_safe(
&primary,
digest('a'),
&[snapshot],
&NormalizationConfig::default()
),
Err(ImportParseError::LimitExceeded)
);
}
#[test]
fn small_aliases_remain_accepted_across_public_entry_points() {
let document = small_alias_document();
let config = NormalizationConfig::default();
assert_eq!(validate_document_source_safe(&document, &config), Ok(()));
assert_eq!(
validate_document_bundle_source_safe(&[document.as_str()], &config),
Ok(())
);
assert_eq!(
validate_resolved_bundle_source_safe(&document, digest('a'), &[], &config),
Ok(())
);
assert!(normalize_verified_document(&document, digest('a'), &config).is_ok());
assert_eq!(reference_uris(&document, &config), Ok(Vec::new()));
assert_eq!(external_reference_uris(&document, &config), Ok(Vec::new()));
}
#[test]
fn duplicate_keys_are_still_rejected_as_invalid_document() {
let document = valid_openapi("x-dup: 1\nx-dup: 2\n");
assert_eq!(
validate_document_source_safe(&document, &NormalizationConfig::default()),
Err(ImportParseError::InvalidDocument)
);
}
#[test]
fn non_finite_yaml_scalars_are_still_rejected_as_invalid_document() {
let document = valid_openapi("x-nonfinite: .inf\n");
assert_eq!(
validate_document_source_safe(&document, &NormalizationConfig::default()),
Err(ImportParseError::InvalidDocument)
);
}
#[test]
fn alias_expansion_below_boundary_is_accepted_and_above_is_rejected() {
// allowance = 16 * max(max_bytes, max_scalar_bytes) = 16 * 4096 = 65536.
let config = NormalizationConfig {
max_bytes: 4096,
max_scalar_bytes: 64,
..NormalizationConfig::default()
};
let below = alias_chain(60, 9); // ~61_400 expanded string bytes
let above = alias_chain(60, 10); // ~122_800 expanded string bytes
assert!(
below.len() <= config.max_bytes,
"fixture must fit raw limit"
);
assert!(
above.len() <= config.max_bytes,
"fixture must fit raw limit"
);
assert_eq!(reference_uris(&below, &config), Ok(Vec::new()));
assert_eq!(
reference_uris(&above, &config),
Err(ImportParseError::LimitExceeded)
);
}
#[test]
fn ordinary_alias_output_matches_expanded_equivalent() {
let aliased = valid_openapi("x-shared: &shared { type: string }\nx-copy: *shared\n");
let expanded = valid_openapi("x-shared: { type: string }\nx-copy: { type: string }\n");
let config = NormalizationConfig::default();
let aliased = normalize_verified_document(&aliased, digest('a'), &config)
.expect("aliased fixture parses");
let expanded = normalize_verified_document(&expanded, digest('a'), &config)
.expect("expanded fixture parses");
assert_eq!(aliased, expanded);
}
#[test]
fn legacy_duplicate_keys_keep_historical_invalid_document() {
// The legacy `serde_yaml::Value` mapping rejects duplicate keys, the same
// as the strict decoder; the preflight must not change that.
let document = "openapi: 3.0.3\n\
info: { title: Legacy, version: '1' }\n\
info: { title: Second, version: '1' }\n\
paths:\n\
\x20 /x:\n\
\x20 get:\n\
\x20 responses:\n\
\x20 '200': { description: ok }\n";
assert_eq!(
preview_document_legacy_v1(document),
Err(ImportParseError::InvalidDocument)
);
}
#[test]
fn legacy_tagged_extension_keeps_historical_mapping_conversion() {
let document = "openapi: 3.0.3\n\
info: { title: Legacy tag, version: '1' }\n\
x-tagged: !Thing value\n\
paths:\n\
\x20 /x:\n\
\x20 get:\n\
\x20 responses:\n\
\x20 '200': { description: ok }\n";
assert!(preview_document_legacy_v1(document).is_ok());
}
#[test]
fn legacy_non_finite_numbers_keep_historical_null_conversion() {
// The legacy path converts through `serde_yaml::Value` and then JSON, so a
// non-finite number becomes `null` and stays accepted; the strict decoder
// rejects it (covered above). The permissive preflight must preserve this.
let document = "openapi: 3.0.3\n\
info: { title: Legacy non-finite, version: '1' }\n\
x-nonfinite: .inf\n\
paths:\n\
\x20 /x:\n\
\x20 get:\n\
\x20 responses:\n\
\x20 '200': { description: ok }\n";
assert!(preview_document_legacy_v1(document).is_ok());
}
fn snapshot(document: &str) -> ExternalDocumentSnapshot {
ExternalDocumentSnapshot {
canonical_uri: "https://schemas.example.test/root.yaml".to_owned(),
digest: digest('b'),
document: document.to_owned(),
}
}
#[test]
fn raw_bundle_document_count_is_capped_before_preflight() {
// Without the early count guard the empty documents would fail later as
// InvalidDocument; the explicit cap must win with LimitExceeded.
let config = NormalizationConfig {
max_reference_documents: 1,
..NormalizationConfig::default()
};
let documents = ["", "", ""];
assert_eq!(
validate_document_bundle_source_safe(&documents, &config),
Err(ImportParseError::LimitExceeded)
);
}
#[test]
fn resolved_bundle_snapshot_count_is_capped_before_preflight() {
let config = NormalizationConfig {
max_reference_documents: 0,
..NormalizationConfig::default()
};
let primary = valid_openapi("");
assert_eq!(
validate_resolved_bundle_source_safe(&primary, digest('a'), &[snapshot("{}")], &config),
Err(ImportParseError::LimitExceeded)
);
}
#[test]
fn bundle_snapshot_raw_bytes_and_aliases_are_guarded_before_preflight() {
let primary = valid_openapi("");
let bytes_config = NormalizationConfig {
max_external_document_bytes: 4,
..NormalizationConfig::default()
};
assert!(matches!(
normalize_verified_bundle(
&primary,
digest('a'),
&[snapshot("{\"a\":1}")],
&bytes_config
),
Err(ImportParseError::LimitExceeded)
));
let alias_config = NormalizationConfig {
max_aliases: 8,
..NormalizationConfig::default()
};
let aliased = "a: &x 1\nb: [*x, *x, *x, *x, *x, *x, *x, *x, *x]\n";
assert_eq!(
validate_resolved_bundle_source_safe(
&primary,
digest('a'),
&[snapshot(aliased)],
&alias_config
),
Err(ImportParseError::LimitExceeded)
);
}