#[derive(Debug, Clone, Copy)]
pub struct ParserConfig {
pub max_depth: Option<usize>,
pub max_string_length: Option<usize>,
pub max_array_size: Option<usize>,
pub max_object_size: Option<usize>,
}
impl ParserConfig {
pub fn new() -> Self {
Self {
max_depth: Some(32),
max_string_length: Some(4096),
max_array_size: Some(1024),
max_object_size: Some(256),
}
}
pub fn unlimited() -> Self {
Self {
max_depth: None,
max_string_length: None,
max_array_size: None,
max_object_size: None,
}
}
pub fn strict() -> Self {
Self {
max_depth: Some(16),
max_string_length: Some(256),
max_array_size: Some(64),
max_object_size: Some(32),
}
}
pub fn with_max_depth(mut self, max_depth: Option<usize>) -> Self {
self.max_depth = max_depth;
self
}
pub fn with_max_string_length(mut self, max_string_length: Option<usize>) -> Self {
self.max_string_length = max_string_length;
self
}
pub fn with_max_array_size(mut self, max_array_size: Option<usize>) -> Self {
self.max_array_size = max_array_size;
self
}
pub fn with_max_object_size(mut self, max_object_size: Option<usize>) -> Self {
self.max_object_size = max_object_size;
self
}
}
impl Default for ParserConfig {
fn default() -> Self {
Self::new()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_default_config() {
let config = ParserConfig::default();
assert_eq!(config.max_depth, Some(32));
assert_eq!(config.max_string_length, Some(4096));
assert_eq!(config.max_array_size, Some(1024));
assert_eq!(config.max_object_size, Some(256));
}
#[test]
fn test_unlimited_config() {
let config = ParserConfig::unlimited();
assert_eq!(config.max_depth, None);
assert_eq!(config.max_string_length, None);
assert_eq!(config.max_array_size, None);
assert_eq!(config.max_object_size, None);
}
#[test]
fn test_strict_config() {
let config = ParserConfig::strict();
assert_eq!(config.max_depth, Some(16));
assert_eq!(config.max_string_length, Some(256));
assert_eq!(config.max_array_size, Some(64));
assert_eq!(config.max_object_size, Some(32));
}
#[test]
fn test_builder_pattern() {
let config = ParserConfig::new()
.with_max_depth(Some(10))
.with_max_string_length(Some(100))
.with_max_array_size(Some(50))
.with_max_object_size(Some(25));
assert_eq!(config.max_depth, Some(10));
assert_eq!(config.max_string_length, Some(100));
assert_eq!(config.max_array_size, Some(50));
assert_eq!(config.max_object_size, Some(25));
}
#[test]
fn test_new_equals_default() {
let a = ParserConfig::new();
let b = ParserConfig::default();
assert_eq!(a.max_depth, b.max_depth);
assert_eq!(a.max_string_length, b.max_string_length);
assert_eq!(a.max_array_size, b.max_array_size);
assert_eq!(a.max_object_size, b.max_object_size);
}
#[test]
fn test_clone_preserves_values() {
let original = ParserConfig::new()
.with_max_depth(Some(8))
.with_max_string_length(Some(512));
let cloned = original; assert_eq!(cloned.max_depth, Some(8));
assert_eq!(cloned.max_string_length, Some(512));
assert_eq!(cloned.max_array_size, original.max_array_size);
assert_eq!(cloned.max_object_size, original.max_object_size);
}
#[test]
fn test_with_max_depth_only() {
let config = ParserConfig::new().with_max_depth(Some(5));
assert_eq!(config.max_depth, Some(5));
assert_eq!(config.max_string_length, Some(4096));
assert_eq!(config.max_array_size, Some(1024));
assert_eq!(config.max_object_size, Some(256));
}
#[test]
fn test_with_max_string_length_only() {
let config = ParserConfig::new().with_max_string_length(Some(128));
assert_eq!(config.max_string_length, Some(128));
assert_eq!(config.max_depth, Some(32));
assert_eq!(config.max_array_size, Some(1024));
assert_eq!(config.max_object_size, Some(256));
}
#[test]
fn test_with_max_array_size_only() {
let config = ParserConfig::new().with_max_array_size(Some(8));
assert_eq!(config.max_array_size, Some(8));
assert_eq!(config.max_depth, Some(32));
assert_eq!(config.max_string_length, Some(4096));
assert_eq!(config.max_object_size, Some(256));
}
#[test]
fn test_with_max_object_size_only() {
let config = ParserConfig::new().with_max_object_size(Some(10));
assert_eq!(config.max_object_size, Some(10));
assert_eq!(config.max_depth, Some(32));
assert_eq!(config.max_string_length, Some(4096));
assert_eq!(config.max_array_size, Some(1024));
}
#[test]
fn test_with_max_depth_none_removes_limit() {
let config = ParserConfig::new().with_max_depth(None);
assert_eq!(config.max_depth, None);
}
#[test]
fn test_with_max_string_length_none_removes_limit() {
let config = ParserConfig::new().with_max_string_length(None);
assert_eq!(config.max_string_length, None);
}
#[test]
fn test_with_max_array_size_none_removes_limit() {
let config = ParserConfig::new().with_max_array_size(None);
assert_eq!(config.max_array_size, None);
}
#[test]
fn test_with_max_object_size_none_removes_limit() {
let config = ParserConfig::new().with_max_object_size(None);
assert_eq!(config.max_object_size, None);
}
#[test]
fn test_builder_from_unlimited_adds_limits() {
let config = ParserConfig::unlimited()
.with_max_depth(Some(64))
.with_max_array_size(Some(512));
assert_eq!(config.max_depth, Some(64));
assert_eq!(config.max_array_size, Some(512));
assert_eq!(config.max_string_length, None); assert_eq!(config.max_object_size, None); }
#[test]
fn test_builder_from_strict_overrides_limit() {
let config = ParserConfig::strict().with_max_depth(Some(100));
assert_eq!(config.max_depth, Some(100));
assert_eq!(config.max_string_length, Some(256));
assert_eq!(config.max_array_size, Some(64));
assert_eq!(config.max_object_size, Some(32));
}
#[test]
fn test_builder_all_none_equals_unlimited() {
let built = ParserConfig::new()
.with_max_depth(None)
.with_max_string_length(None)
.with_max_array_size(None)
.with_max_object_size(None);
let unlimited = ParserConfig::unlimited();
assert_eq!(built.max_depth, unlimited.max_depth);
assert_eq!(built.max_string_length, unlimited.max_string_length);
assert_eq!(built.max_array_size, unlimited.max_array_size);
assert_eq!(built.max_object_size, unlimited.max_object_size);
}
#[test]
fn test_builder_zero_limits() {
let config = ParserConfig::new()
.with_max_depth(Some(0))
.with_max_string_length(Some(0))
.with_max_array_size(Some(0))
.with_max_object_size(Some(0));
assert_eq!(config.max_depth, Some(0));
assert_eq!(config.max_string_length, Some(0));
assert_eq!(config.max_array_size, Some(0));
assert_eq!(config.max_object_size, Some(0));
}
#[test]
fn test_builder_large_limits() {
let config = ParserConfig::unlimited()
.with_max_depth(Some(usize::MAX))
.with_max_string_length(Some(usize::MAX));
assert_eq!(config.max_depth, Some(usize::MAX));
assert_eq!(config.max_string_length, Some(usize::MAX));
}
#[test]
fn test_debug_output_contains_field_names() {
let config = ParserConfig::new();
let s = format!("{:?}", config);
assert!(s.contains("max_depth"));
assert!(s.contains("max_string_length"));
assert!(s.contains("max_array_size"));
assert!(s.contains("max_object_size"));
}
#[test]
fn test_debug_unlimited_shows_none() {
let config = ParserConfig::unlimited();
let s = format!("{:?}", config);
assert!(s.contains("None"));
}
#[test]
fn test_strict_tighter_than_default() {
let strict = ParserConfig::strict();
let default = ParserConfig::new();
assert!(strict.max_depth.unwrap() < default.max_depth.unwrap());
assert!(strict.max_string_length.unwrap() < default.max_string_length.unwrap());
assert!(strict.max_array_size.unwrap() < default.max_array_size.unwrap());
assert!(strict.max_object_size.unwrap() < default.max_object_size.unwrap());
}
#[test]
fn test_builder_does_not_mutate_original() {
let original = ParserConfig::new();
let _modified = original.with_max_depth(Some(1));
assert_eq!(original.max_depth, Some(32));
}
}