use super::*;
use std::sync::Arc;
fn nested(n: u32) -> Value {
let mut v = Value::List(Vec::new().into());
for _ in 1..n {
v = Value::List(vec![v].into());
}
v
}
#[test]
fn depth_within_counts_container_levels() {
assert!(Value::Int(1).depth_within(0));
assert!(nested(1).depth_within(1));
assert!(!nested(2).depth_within(1));
assert!(nested(MAX_VALUE_DEPTH).depth_within(MAX_VALUE_DEPTH));
assert!(!nested(MAX_VALUE_DEPTH + 1).depth_within(MAX_VALUE_DEPTH));
let mut m = BTreeMap::new();
m.insert("a".to_string(), nested(MAX_VALUE_DEPTH));
let map = Value::Map(m.into());
assert!(!map.depth_within(MAX_VALUE_DEPTH));
assert!(map.depth_within(MAX_VALUE_DEPTH + 1));
}
#[test]
fn depth_within_is_iterative_on_a_deep_narrow_value() {
let v = nested(5000);
assert!(v.depth_within(5000));
assert!(!v.depth_within(4999));
assert_eq!(logical_bytes_within([&v], u64::MAX), None);
std::mem::forget(v);
}
#[test]
fn checked_constructors_enforce_the_depth_cap() {
let mut at_cap = Value::List(Vec::new().into());
for _ in 1..MAX_VALUE_DEPTH {
at_cap = Value::checked_list(vec![at_cap]).expect("at-cap construction");
}
assert!(at_cap.depth_within(MAX_VALUE_DEPTH));
let err = Value::checked_list(vec![at_cap.clone()]).expect_err("501 levels must reject");
assert!(
err.to_string().starts_with("ValueDepthExceeded:"),
"typed payload: {err}"
);
let mut m = BTreeMap::new();
m.insert("a".to_string(), at_cap.clone());
let err = Value::checked_map(m).expect_err("501 levels must reject");
assert!(err.to_string().starts_with("ValueDepthExceeded:"));
drop(at_cap);
}
#[test]
fn path_walkers_agree_on_the_depth_boundary() {
fn path_with_property_list(n: u32) -> Value {
let prop = nested(n);
let mut props = BTreeMap::new();
props.insert("p".to_string(), prop);
let node = Node {
id: 1,
labels: Arc::new(vec!["N".to_string()]),
properties: PropertyMap::share(props),
};
Value::from_path(Path {
nodes: vec![node],
rels: Vec::new(),
})
}
fn json_array_depth(v: &serde_json::Value) -> usize {
match v {
serde_json::Value::Array(xs) => 1 + xs.iter().map(json_array_depth).max().unwrap_or(0),
_ => 0,
}
}
fn cypher_list_depth(v: &relate_model::CypherValue) -> usize {
match v {
relate_model::CypherValue::List(xs) => {
1 + xs.iter().map(cypher_list_depth).max().unwrap_or(0)
}
_ => 0,
}
}
let property_levels = MAX_VALUE_DEPTH - 1;
let at_cap = path_with_property_list(property_levels);
assert!(at_cap.depth_within(MAX_VALUE_DEPTH));
assert!(!at_cap.depth_within(MAX_VALUE_DEPTH - 1));
let literal = at_cap.to_cypher_literal();
assert!(
!literal.contains(DEPTH_LIMIT_MARKER),
"at-cap path must render fully, got: {literal}"
);
let json = at_cap.to_json_plain();
assert_eq!(
json_array_depth(&json["nodes"][0]["properties"]["p"]),
property_levels as usize
);
let cypher = crate::convert::value_to_cypher(&at_cap);
let relate_model::CypherValue::Path { nodes, .. } = &cypher else {
panic!("value_to_cypher must keep the path shape");
};
let relate_model::CypherValue::Node { properties, .. } = &nodes[0] else {
panic!("value_to_cypher must keep the node shape");
};
assert_eq!(
cypher_list_depth(&properties["p"]),
property_levels as usize
);
let over = path_with_property_list(MAX_VALUE_DEPTH);
assert!(!over.depth_within(MAX_VALUE_DEPTH));
assert!(over.to_cypher_literal().contains(DEPTH_LIMIT_MARKER));
std::mem::forget(over);
}
#[test]
fn cypher_eq_saturates_past_the_value_depth_cap() {
let at_cap = nested(MAX_VALUE_DEPTH);
assert_eq!(at_cap.cypher_eq(&at_cap), Value::Bool(true));
let over = nested(MAX_VALUE_DEPTH + 1);
assert_eq!(over.cypher_eq(&over), Value::Bool(false));
std::mem::forget(over);
}
#[test]
fn shared_fan_out_depth_is_linear_in_distinct_payloads() {
let mut value = nested(1);
for _ in 0..40 {
value = Value::List(vec![value.clone(), value].into());
}
assert_eq!(value.depth(), 41);
assert!(!value.depth_within(40));
assert!(value.depth_within(41));
let leaf = nested(3);
let shared = Value::List(vec![leaf.clone(), leaf.clone()].into());
assert_eq!(shared.depth(), 4);
}