pub fn sanitize_error_message(message: &str) -> String {
message
.chars()
.filter(|c| {
let code = *c as u32;
code >= 0x20 || code == 0x09 || code == 0x0A || code == 0x0D || code > 0x7F })
.collect()
}
fn truncate_at_char_boundary(value: &str, max_len: usize) -> &str {
if value.len() <= max_len {
return value;
}
let mut end = max_len;
while end > 0 && !value.is_char_boundary(end) {
end -= 1;
}
&value[..end]
}
pub fn truncate_utf8(value: &str, max_len: usize) -> String {
truncate_at_char_boundary(value, max_len).to_string()
}
pub fn truncate_utf8_with_suffix(value: &str, max_len: usize, suffix: &str) -> String {
if value.len() <= max_len {
return value.to_string();
}
if max_len == 0 {
return String::new();
}
if suffix.len() >= max_len {
return truncate_utf8(suffix, max_len);
}
let prefix = truncate_at_char_boundary(value, max_len.saturating_sub(suffix.len()));
format!("{prefix}{suffix}")
}
pub fn sanitize_and_truncate_error_message(message: &str) -> String {
let sanitized = sanitize_error_message(message);
if sanitized.len() > crate::config::MAX_ERROR_MESSAGE_LENGTH {
let suffix = format!(
"... (truncated, original length: {} chars)",
sanitized.chars().count()
);
truncate_utf8_with_suffix(&sanitized, crate::config::MAX_ERROR_MESSAGE_LENGTH, &suffix)
} else {
sanitized
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_sanitize_error_message_removes_control_chars() {
let input = "Error\x00message\x01with\x02control\x03chars";
let output = sanitize_error_message(input);
assert_eq!(output, "Errormessagewithcontrolchars");
}
#[test]
fn test_sanitize_error_message_preserves_newlines() {
let input = "Error\nmessage\nwith\nnewlines";
let output = sanitize_error_message(input);
assert_eq!(output, "Error\nmessage\nwith\nnewlines");
}
#[test]
fn test_sanitize_error_message_preserves_tabs() {
let input = "Error\tmessage\twith\ttabs";
let output = sanitize_error_message(input);
assert_eq!(output, "Error\tmessage\twith\ttabs");
}
#[test]
fn test_sanitize_error_message_preserves_unicode() {
let input = "Error message with unicode: 测试 🚀";
let output = sanitize_error_message(input);
assert_eq!(output, "Error message with unicode: 测试 🚀");
}
#[test]
fn test_sanitize_error_message_empty_string() {
let input = "";
let output = sanitize_error_message(input);
assert_eq!(output, "");
}
#[test]
fn test_sanitize_error_message_normal_text() {
let input = "Normal error message without control characters";
let output = sanitize_error_message(input);
assert_eq!(output, input);
}
#[test]
fn test_sanitize_error_message_preserves_carriage_return() {
let input = "Error\rmessage\rwith\rcarriage\rreturns";
let output = sanitize_error_message(input);
assert_eq!(output, "Error\rmessage\rwith\rcarriage\rreturns");
}
#[test]
fn test_sanitize_error_message_mixed_control_chars() {
let input = "Error\x00\nmessage\x01\twith\x02mixed\x03chars";
let output = sanitize_error_message(input);
assert_eq!(output, "Error\nmessage\twithmixedchars");
}
#[test]
fn test_sanitize_error_message_all_control_chars() {
let mut input = String::new();
for i in 0..=0x1F {
if i != 0x09 && i != 0x0A && i != 0x0D {
input.push(char::from_u32(i).unwrap());
}
}
let output = sanitize_error_message(&input);
assert_eq!(
output, "",
"All control chars except \\t, \\n, \\r should be removed"
);
}
#[test]
fn test_sanitize_error_message_unicode_control_chars() {
let input = "Error with unicode: 测试 🚀 \u{200B}"; let output = sanitize_error_message(input);
assert!(output.contains("测试"));
assert!(output.contains("🚀"));
}
#[test]
fn test_sanitize_and_truncate_error_message_short() {
let input = "Short error message";
let output = sanitize_and_truncate_error_message(input);
assert_eq!(output, input);
}
#[test]
fn test_sanitize_and_truncate_error_message_long() {
let long_message = "A".repeat(crate::config::MAX_ERROR_MESSAGE_LENGTH + 100);
let output = sanitize_and_truncate_error_message(&long_message);
assert!(output.len() < long_message.len());
assert!(output.contains("... (truncated"));
assert!(output.contains("original length:"));
}
#[test]
fn test_sanitize_and_truncate_error_message_exact_length() {
let exact_message = "A".repeat(crate::config::MAX_ERROR_MESSAGE_LENGTH);
let output = sanitize_and_truncate_error_message(&exact_message);
assert_eq!(output, exact_message);
}
#[test]
fn test_sanitize_and_truncate_error_message_one_over_limit() {
let over_limit = "A".repeat(crate::config::MAX_ERROR_MESSAGE_LENGTH + 1);
let output = sanitize_and_truncate_error_message(&over_limit);
assert!(output.len() < over_limit.len());
assert!(output.contains("... (truncated"));
}
#[test]
fn test_sanitize_and_truncate_error_message_with_control_chars() {
let input = format!(
"{}\x00\x01\x02",
"A".repeat(crate::config::MAX_ERROR_MESSAGE_LENGTH + 50)
);
let output = sanitize_and_truncate_error_message(&input);
assert!(!output.contains('\x00'));
assert!(!output.contains('\x01'));
assert!(!output.contains('\x02'));
assert!(output.contains("... (truncated"));
}
#[test]
fn test_sanitize_error_message_boundary_chars() {
let input = "Before\x1FAfter\x20Space";
let output = sanitize_error_message(input);
assert_eq!(output, "BeforeAfter Space");
}
#[test]
fn test_sanitize_error_message_very_long_unicode() {
let input = "测试".repeat(1000);
let output = sanitize_error_message(&input);
assert_eq!(output, input);
}
#[test]
fn test_sanitize_and_truncate_error_message_unicode_boundary() {
let unicode_text = "测试🚀";
let long_message = format!(
"{}{}",
unicode_text.repeat(1000),
"A".repeat(crate::config::MAX_ERROR_MESSAGE_LENGTH)
);
let output = sanitize_and_truncate_error_message(&long_message);
assert!(output.len() < long_message.len());
assert!(output.contains("... (truncated"));
assert!(std::str::from_utf8(output.as_bytes()).is_ok());
}
#[test]
fn test_sanitize_and_truncate_error_message_very_small_limit() {
let message = "A".repeat(100);
let output = sanitize_and_truncate_error_message(&message);
assert!(output.len() <= message.len() + 50); }
#[test]
fn test_sanitize_and_truncate_error_message_control_chars_affect_length() {
let base_message = "A".repeat(crate::config::MAX_ERROR_MESSAGE_LENGTH - 10);
let message_with_control = format!("{}\x00\x01\x02\x03\x04\x05", base_message);
let output = sanitize_and_truncate_error_message(&message_with_control);
assert!(!output.contains('\x00'));
if base_message.len() <= crate::config::MAX_ERROR_MESSAGE_LENGTH {
assert!(!output.contains("... (truncated"));
}
}
#[test]
fn test_truncate_utf8_preserves_code_point_boundaries() {
let value = "prefix-测试🚀-suffix";
let truncated = truncate_utf8(value, 10);
assert!(std::str::from_utf8(truncated.as_bytes()).is_ok());
assert!(value.starts_with(&truncated));
}
#[test]
fn test_truncate_utf8_with_suffix_preserves_code_point_boundaries() {
let value = "测试🚀测试🚀测试🚀";
let truncated = truncate_utf8_with_suffix(value, 18, "...(cut)");
assert!(std::str::from_utf8(truncated.as_bytes()).is_ok());
assert!(truncated.ends_with("...(cut)"));
}
}