pub(crate) fn serialize_json_with_default<T: serde::Serialize>(value: &T, default: &str) -> String {
serde_json::to_string(value).unwrap_or_else(|e| {
log::warn!("Failed to serialize value to JSON: {e}. Using default: {default}");
default.to_string()
})
}
#[cfg(test)]
mod tests {
use super::*;
use std::collections::HashMap;
fn serialize_json<T: serde::Serialize>(value: &T) -> String {
serde_json::to_string(value).unwrap_or_else(|e| {
log::warn!("Failed to serialize value to JSON: {e}. Using default: {{}}");
"{}".to_string()
})
}
#[test]
fn test_serialize_json_success() {
let mut map = HashMap::new();
map.insert("key1", "value1");
map.insert("key2", "value2");
let json = serialize_json(&map);
assert!(json.contains("key1"));
assert!(json.contains("value1"));
assert!(json.contains("key2"));
assert!(json.contains("value2"));
}
#[test]
fn test_serialize_json_array() {
let vec = vec!["item1", "item2", "item3"];
let json = serialize_json(&vec);
assert_eq!(json, r#"["item1","item2","item3"]"#);
}
#[test]
fn test_serialize_json_with_default_success() {
let vec = vec!["item1", "item2"];
let json = serialize_json_with_default(&vec, "[]");
assert_eq!(json, r#"["item1","item2"]"#);
}
#[test]
fn test_serialize_json_with_default_custom() {
let vec = vec!["item1"];
let json = serialize_json_with_default(&vec, "[]");
assert_eq!(json, r#"["item1"]"#);
}
#[test]
fn test_serialize_json_with_default_empty_array() {
let vec: Vec<String> = vec![];
let json = serialize_json_with_default(&vec, "[]");
assert_eq!(json, "[]");
}
#[test]
fn test_serialize_json_with_default_custom_default() {
let vec: Vec<String> = vec!["test".to_string()];
let json = serialize_json_with_default(&vec, "fallback");
assert!(json.contains("test"));
assert!(!json.contains("fallback"));
}
#[test]
fn test_serialize_json_empty_map() {
let map: HashMap<String, String> = HashMap::new();
let json = serialize_json(&map);
assert_eq!(json, "{}");
}
#[test]
fn test_serialize_json_with_default_nested_structure() {
#[derive(serde::Serialize)]
struct Nested {
inner: Vec<String>,
}
let nested = Nested {
inner: vec!["a".to_string(), "b".to_string()],
};
let json = serialize_json_with_default(&nested, "{}");
assert!(json.contains("inner"));
assert!(json.contains("a"));
assert!(json.contains("b"));
}
#[test]
fn test_serialize_json_with_default_null_values() {
use serde_json::json;
let value = json!({
"key1": "value1",
"key2": null,
"key3": ["item1", null, "item2"]
});
let json = serialize_json_with_default(&value, "{}");
assert!(json.contains("key1"));
assert!(json.contains("key2"));
assert!(json.contains("null")); }
#[test]
fn test_serialize_json_very_large_structure() {
let mut large_map: HashMap<String, String> = HashMap::new();
for i in 0..10000 {
large_map.insert(format!("key_{}", i), format!("value_{}", i));
}
let json = serialize_json(&large_map);
assert!(json.len() > 1000);
assert!(json.contains("key_0"));
assert!(json.contains("value_9999"));
}
#[test]
fn test_serialize_json_with_default_very_large_array() {
let large_vec: Vec<String> = (0..10000).map(|i| format!("item_{}", i)).collect();
let json = serialize_json_with_default(&large_vec, "[]");
assert!(json.len() > 1000);
assert!(json.contains("item_0"));
assert!(json.contains("item_9999"));
}
#[test]
fn test_serialize_json_nested_structures() {
#[derive(serde::Serialize)]
struct Nested {
level1: Level1,
}
#[derive(serde::Serialize)]
struct Level1 {
level2: Level2,
}
#[derive(serde::Serialize)]
struct Level2 {
value: String,
}
let nested = Nested {
level1: Level1 {
level2: Level2 {
value: "deep".to_string(),
},
},
};
let json = serialize_json(&nested);
assert!(json.contains("deep"));
assert!(json.contains("level1"));
assert!(json.contains("level2"));
}
#[test]
fn test_serialize_json_with_default_empty_string() {
let empty: Vec<String> = vec![];
let json = serialize_json_with_default(&empty, "fallback");
assert_eq!(json, "[]");
}
#[test]
fn test_serialize_json_special_characters() {
let mut map = HashMap::new();
map.insert(
"key".to_string(),
"value with \"quotes\" and 'apostrophes'".to_string(),
);
map.insert("unicode".to_string(), "测试 🚀".to_string());
let json = serialize_json(&map);
assert!(json.contains("quotes"));
assert!(json.contains("测试"));
assert!(json.contains("🚀"));
}
#[test]
fn test_serialize_json_with_default_error_path() {
let vec: Vec<String> = vec!["test".to_string()];
let json = serialize_json_with_default(&vec, "fallback");
assert!(json.contains("test"));
assert!(!json.contains("fallback"));
let json2 = serialize_json_with_default(&vec, "[]");
assert!(json2.contains("test"));
assert!(!json2.contains("[]") || json2 == r#"["test"]"#); }
#[test]
fn test_serialize_json_error_returns_empty_object() {
let valid_map: HashMap<String, String> = HashMap::new();
let json = serialize_json(&valid_map);
assert_eq!(json, "{}");
}
#[test]
fn test_serialize_json_error_handling_path() {
use serde::ser::{Error, Serialize, Serializer};
struct FailingSerialize;
impl Serialize for FailingSerialize {
fn serialize<S>(&self, _serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
Err(S::Error::custom(
"Intentional serialization failure for testing",
))
}
}
let failing_value = FailingSerialize;
let json = serialize_json(&failing_value);
assert_eq!(
json, "{}",
"serialize_json should return default '{{}}' on serialization failure"
);
}
#[test]
fn test_serialize_json_with_default_error_handling_path() {
use serde::ser::{Error, Serialize, Serializer};
struct FailingSerialize;
impl Serialize for FailingSerialize {
fn serialize<S>(&self, _serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
Err(S::Error::custom(
"Intentional serialization failure for testing",
))
}
}
let failing_value = FailingSerialize;
let json = serialize_json_with_default(&failing_value, "[]");
assert_eq!(
json, "[]",
"serialize_json_with_default should return the provided default on serialization failure"
);
let json2 = serialize_json_with_default(&failing_value, "fallback");
assert_eq!(
json2, "fallback",
"serialize_json_with_default should return the provided default on serialization failure"
);
}
}