#![cfg(test)]
use std::process::Command;
use crate::opaque::{Envelope, Payload};
use crate::transcript::item::{Item, ModelVisibility, User};
use super::content::{
KnownPartKind, Metadata, MetadataValue, MetadataValueRef, Part, PartFields, PartKind, Segment,
SegmentExtensions, is_valid_system_instruction,
};
use super::tool_call::{self, Id, ToolCall};
use crate::redact_tests::{SECRET, assert_redacted, assert_states};
fn complete_fields(text: &str) -> PartFields {
PartFields::new(
text.into(),
"application/example".into(),
Some(vec![1, 2].into_boxed_slice()),
"reef://part".into(),
Some(Metadata::from_iter([(
"flag".to_owned(),
MetadataValue::Bool(true),
)])),
Some(Payload::copy_from_slice(b"raw")),
)
}
fn envelope(value: u8) -> Envelope {
Envelope::try_new(
"provider".into(),
"segment".into(),
Payload::from_vec(vec![b'{', b'"', b'v', b'"', b':', value, b'}']),
)
.expect("fixture is valid JSON")
}
const DEEP_METADATA_DEPTH: usize = 50_000;
const DEEP_METADATA_CHILD: &str = "REEF_DEEP_METADATA_CHILD";
fn deep_metadata_value() -> MetadataValue {
let mut value = MetadataValue::String("leaf".into());
for level in 0..DEEP_METADATA_DEPTH {
value = if level % 2 == 0 {
MetadataValue::Array(vec![
MetadataValue::Signed(level as i64),
value,
MetadataValue::Unsigned(level as u64),
])
} else {
MetadataValue::Object(Metadata::from_iter([
("a-level".to_owned(), MetadataValue::Signed(level as i64)),
("m-next".to_owned(), value),
("z-level".to_owned(), MetadataValue::Unsigned(level as u64)),
]))
};
}
value
}
fn metadata_with_deep_value() -> Metadata {
Metadata::from_iter([
("a-presence".to_owned(), MetadataValue::Null),
("m-root".to_owned(), deep_metadata_value()),
("z-presence".to_owned(), MetadataValue::Array(Vec::new())),
])
}
fn assert_deep_metadata_value(mut value: &MetadataValue) {
for level in (0..DEEP_METADATA_DEPTH).rev() {
if level % 2 == 0 {
let MetadataValueRef::Array(values) = value.as_borrowed() else {
panic!("expected array at level {level}");
};
assert_eq!(values.len(), 3);
assert!(
matches!(values[0].as_borrowed(), MetadataValueRef::Signed(actual) if actual == level as i64)
);
assert!(
matches!(values[2].as_borrowed(), MetadataValueRef::Unsigned(actual) if actual == level as u64)
);
value = &values[1];
} else {
let MetadataValueRef::Object(metadata) = value.as_borrowed() else {
panic!("expected object at level {level}");
};
let keys: Vec<_> = metadata.iter().map(|(key, _)| key).collect();
assert_eq!(keys, ["a-level", "m-next", "z-level"]);
assert!(
matches!(metadata.get("a-level").map(MetadataValue::as_borrowed), Some(MetadataValueRef::Signed(actual)) if actual == level as i64)
);
assert!(
matches!(metadata.get("z-level").map(MetadataValue::as_borrowed), Some(MetadataValueRef::Unsigned(actual)) if actual == level as u64)
);
value = metadata
.get("m-next")
.expect("deep object retains its child");
}
}
assert!(matches!(
value.as_borrowed(),
MetadataValueRef::String("leaf")
));
}
fn assert_deep_metadata(metadata: &Metadata) {
let keys: Vec<_> = metadata.iter().map(|(key, _)| key).collect();
assert_eq!(keys, ["a-presence", "m-root", "z-presence"]);
assert!(matches!(
metadata.get("a-presence"),
Some(MetadataValue::Null)
));
assert!(
matches!(metadata.get("z-presence"), Some(MetadataValue::Array(values)) if values.is_empty())
);
assert_deep_metadata_value(metadata.get("m-root").expect("deep root remains present"));
}
fn run_deep_metadata_child(test_name: &str) {
let status = Command::new(std::env::current_exe().expect("test executable is available"))
.arg("--exact")
.arg(test_name)
.env(DEEP_METADATA_CHILD, "1")
.status()
.expect("deep metadata child process starts");
assert!(status.success(), "deep metadata child failed: {test_name}");
}
#[test]
fn part_kind_is_canonical_and_open() {
let known = [
KnownPartKind::Text,
KnownPartKind::Image,
KnownPartKind::File,
KnownPartKind::ToolResult,
KnownPartKind::Thinking,
];
for (value, expected) in (0_i64..=4).zip(known) {
let kind = PartKind::from_i64(value);
assert_eq!(kind.as_i64(), value);
assert_eq!(kind.known(), Some(expected));
assert_eq!(expected.as_part_kind(), kind);
assert_eq!(expected.as_part_kind().as_i64(), value);
assert_eq!(expected.as_part_kind().known(), Some(expected));
}
for value in [i64::MIN, -1, 5, 77, i64::MAX] {
let kind = PartKind::from_i64(value);
assert_eq!(kind.as_i64(), value);
assert_eq!(kind.known(), None);
}
}
#[test]
fn part_all_fields_survive_known_and_unknown_kinds() {
for value in [0, 1, 2, 3, 4, 99] {
let part = Part::new(PartKind::from_i64(value), complete_fields("cross-kind"));
assert_eq!(part.kind().as_i64(), value);
let fields = part.fields();
assert_eq!(fields.text(), "cross-kind");
assert_eq!(fields.mime(), "application/example");
assert_eq!(fields.data(), Some([1, 2].as_slice()));
assert_eq!(fields.reference(), "reef://part");
assert!(matches!(
fields.metadata().and_then(|metadata| metadata.get("flag")),
Some(MetadataValue::Bool(true))
));
assert_eq!(
fields.raw_payload().map(Payload::as_bytes),
Some(b"raw".as_slice())
);
let (kind, fields) = part.into_parts();
assert_eq!(kind.as_i64(), value);
assert_eq!(fields.text(), "cross-kind");
}
}
#[test]
fn text_convenience_has_only_text_present() {
let part = Part::text("hello".into());
assert_eq!(part.kind().known(), Some(KnownPartKind::Text));
assert_eq!(part.fields().text(), "hello");
assert_eq!(part.fields().mime(), "");
assert_eq!(part.fields().data(), None);
assert_eq!(part.fields().reference(), "");
assert!(part.fields().metadata().is_none());
assert!(part.fields().raw_payload().is_none());
}
#[test]
fn part_presence_distinguishes_absent_empty_and_nonempty() {
let absent = PartFields::new("".into(), "".into(), None, "".into(), None, None);
assert_eq!(absent.data(), None);
assert!(absent.metadata().is_none());
assert!(absent.raw_payload().is_none());
let empty = PartFields::new(
"".into(),
"".into(),
Some(Vec::new().into_boxed_slice()),
"".into(),
Some(Metadata::new()),
Some(Payload::from_vec(Vec::new())),
);
assert_eq!(empty.data(), Some([].as_slice()));
assert_eq!(empty.metadata().map(|value| value.iter().count()), Some(0));
assert_eq!(
empty.raw_payload().map(Payload::as_bytes),
Some([].as_slice())
);
let nonempty = complete_fields("value");
assert_eq!(nonempty.data(), Some([1, 2].as_slice()));
assert_eq!(
nonempty.metadata().map(|value| value.iter().count()),
Some(1)
);
assert_eq!(
nonempty.raw_payload().map(Payload::as_bytes),
Some(b"raw".as_slice())
);
}
#[test]
fn metadata_closed_domain_is_recursive_ordered_and_owned() {
let mut nested = Metadata::new();
assert!(
nested
.insert("nested".to_owned(), MetadataValue::Null)
.is_none()
);
let values = [
MetadataValue::Null,
MetadataValue::Bool(true),
MetadataValue::Signed(-2),
MetadataValue::Unsigned(3),
MetadataValue::Float(f64::NAN),
MetadataValue::String("text".into()),
MetadataValue::Bytes(vec![4].into_boxed_slice()),
MetadataValue::Array(vec![MetadataValue::Bool(false)]),
MetadataValue::Object(nested),
];
let metadata = values
.into_iter()
.enumerate()
.map(|(index, value)| (format!("k{index}"), value))
.collect::<Metadata>();
assert!(metadata.get("missing").is_none());
assert_eq!(metadata.iter().next().map(|(key, _)| key), Some("k0"));
assert_eq!(metadata.iter().len(), 9);
assert!(matches!(metadata.get("k0"), Some(MetadataValue::Null)));
assert!(matches!(
metadata.get("k1"),
Some(MetadataValue::Bool(true))
));
assert!(matches!(
metadata.get("k2"),
Some(MetadataValue::Signed(-2))
));
assert!(matches!(
metadata.get("k3"),
Some(MetadataValue::Unsigned(3))
));
assert!(matches!(metadata.get("k4"), Some(MetadataValue::Float(value)) if value.is_nan()));
assert!(matches!(metadata.get("k5"), Some(MetadataValue::String(value)) if value == "text"));
assert!(
matches!(metadata.get("k6"), Some(MetadataValue::Bytes(value)) if value.as_ref() == [4])
);
assert!(
matches!(metadata.get("k7"), Some(MetadataValue::Array(value)) if matches!(value.as_slice(), [MetadataValue::Bool(false)]))
);
assert!(
matches!(metadata.get("k8"), Some(MetadataValue::Object(value)) if matches!(value.get("nested"), Some(MetadataValue::Null)))
);
let clone = metadata.clone();
let mut consumed = Metadata::from_iter(metadata);
assert!(
consumed
.insert("changed".to_owned(), MetadataValue::Null)
.is_none()
);
assert!(clone.get("changed").is_none());
let mut owned = clone.into_iter();
assert_eq!(owned.len(), 9);
assert_eq!(owned.size_hint(), (9, Some(9)));
assert_eq!(owned.next().map(|(key, _)| key), Some("k0".to_owned()));
assert_eq!(
owned.map(|(key, _)| key).collect::<Vec<_>>(),
["k1", "k2", "k3", "k4", "k5", "k6", "k7", "k8"]
);
let mut borrowed = consumed.iter();
assert_eq!(borrowed.len(), 10);
assert_eq!(borrowed.size_hint(), (10, Some(10)));
assert_eq!(borrowed.next().map(|(key, _)| key), Some("changed"));
assert_eq!(borrowed.len(), 9);
assert_eq!(
(&consumed).into_iter().map(|(key, _)| key).next(),
Some("changed")
);
}
#[test]
fn metadata_value_borrowed_view_observes_every_closed_variant() {
let values = [
MetadataValue::Null,
MetadataValue::Bool(true),
MetadataValue::Signed(-7),
MetadataValue::Unsigned(8),
MetadataValue::Float(f64::from_bits(0x7ff8_0000_0000_0001)),
MetadataValue::String("text".into()),
MetadataValue::Bytes(vec![1, 2].into_boxed_slice()),
MetadataValue::Array(vec![MetadataValue::Null]),
MetadataValue::Object(Metadata::from_iter([(
"key".to_owned(),
MetadataValue::Bool(false),
)])),
];
assert!(matches!(values[0].as_borrowed(), MetadataValueRef::Null));
assert!(matches!(
values[1].as_borrowed(),
MetadataValueRef::Bool(true)
));
assert!(matches!(
values[2].as_borrowed(),
MetadataValueRef::Signed(-7)
));
assert!(matches!(
values[3].as_borrowed(),
MetadataValueRef::Unsigned(8)
));
assert!(
matches!(values[4].as_borrowed(), MetadataValueRef::Float(value) if value.to_bits() == 0x7ff8_0000_0000_0001)
);
assert!(matches!(
values[5].as_borrowed(),
MetadataValueRef::String("text")
));
assert!(matches!(
values[6].as_borrowed(),
MetadataValueRef::Bytes([1, 2])
));
assert!(matches!(
values[7].as_borrowed(),
MetadataValueRef::Array([MetadataValue::Null])
));
assert!(
matches!(values[8].as_borrowed(), MetadataValueRef::Object(value) if matches!(value.get("key"), Some(MetadataValue::Bool(false))))
);
}
#[test]
fn standalone_deep_metadata_value_clone_and_drop_is_stack_safe_subprocess() {
run_deep_metadata_child(
"value::content_tests::standalone_deep_metadata_value_clone_and_drop_child",
);
}
#[test]
fn standalone_deep_metadata_value_clone_and_drop_child() {
if std::env::var_os(DEEP_METADATA_CHILD).is_none() {
return;
}
let value = deep_metadata_value();
let cloned = value.clone();
assert_deep_metadata_value(&value);
assert_deep_metadata_value(&cloned);
drop(cloned);
drop(value);
}
#[test]
fn standalone_deep_metadata_clone_and_drop_is_stack_safe_subprocess() {
run_deep_metadata_child("value::content_tests::standalone_deep_metadata_clone_and_drop_child");
}
#[test]
fn standalone_deep_metadata_clone_and_drop_child() {
if std::env::var_os(DEEP_METADATA_CHILD).is_none() {
return;
}
let metadata = metadata_with_deep_value();
let cloned = metadata.clone();
assert_deep_metadata(&metadata);
assert_deep_metadata(&cloned);
drop(cloned);
drop(metadata);
}
#[test]
fn part_with_deep_metadata_clone_and_drop_is_stack_safe_subprocess() {
run_deep_metadata_child("value::content_tests::part_with_deep_metadata_clone_and_drop_child");
}
#[test]
fn part_with_deep_metadata_clone_and_drop_child() {
if std::env::var_os(DEEP_METADATA_CHILD).is_none() {
return;
}
let part = Part::new(
PartKind::from_i64(77),
PartFields::new(
"deep".into(),
"application/deep".into(),
Some(Vec::new().into_boxed_slice()),
"reef://deep".into(),
Some(metadata_with_deep_value()),
None,
),
);
let cloned = part.clone();
assert_eq!(cloned.kind().as_i64(), 77);
assert_eq!(cloned.fields().text(), "deep");
assert_eq!(cloned.fields().data(), Some([].as_slice()));
assert_deep_metadata(
cloned
.fields()
.metadata()
.expect("metadata remains present"),
);
drop(cloned);
drop(part);
}
#[test]
fn transcript_item_with_deep_metadata_clone_and_drop_is_stack_safe_subprocess() {
run_deep_metadata_child(
"value::content_tests::transcript_item_with_deep_metadata_clone_and_drop_child",
);
}
#[test]
fn transcript_item_with_deep_metadata_clone_and_drop_child() {
if std::env::var_os(DEEP_METADATA_CHILD).is_none() {
return;
}
let part = Part::new(
PartKind::from_i64(2),
PartFields::new(
"item".into(),
String::new(),
None,
String::new(),
Some(metadata_with_deep_value()),
None,
),
);
let item = Item::User(User::new(vec![part], ModelVisibility::Hidden));
let cloned = item.clone();
let Item::User(user) = &cloned else {
panic!("item variant remains user");
};
assert_eq!(user.visibility(), ModelVisibility::Hidden);
assert_deep_metadata(
user.parts()[0]
.fields()
.metadata()
.expect("item part metadata remains present"),
);
drop(cloned);
drop(item);
}
#[test]
fn system_instruction_boundary_requires_nonempty_text_without_rebuilding() {
assert!(is_valid_system_instruction(&[]));
let accepted = vec![
Part::new(PartKind::from_i64(0), complete_fields("policy")),
Part::text("task".into()),
];
assert!(is_valid_system_instruction(&accepted));
assert_eq!(accepted[0].fields().mime(), "application/example");
assert_eq!(accepted[0].fields().data(), Some([1, 2].as_slice()));
assert!(!is_valid_system_instruction(&[Part::text(String::new())]));
for kind in [1, 2, 3, 4, 5, -1] {
assert!(!is_valid_system_instruction(&[Part::new(
PartKind::from_i64(kind),
complete_fields("not-system-text"),
)]));
}
}
#[test]
fn segment_extensions_preserve_presence_and_transfer_ownership() {
let absent = SegmentExtensions::new("".into(), None, None);
assert_eq!(absent.signature(), "");
assert!(absent.raw_payload().is_none());
assert!(absent.provider_data().is_none());
let present_empty = SegmentExtensions::new(
"signature".into(),
Some(Payload::from_vec(Vec::new())),
Some(Vec::new()),
);
assert_eq!(
present_empty.raw_payload().map(Payload::as_bytes),
Some([].as_slice())
);
assert_eq!(
present_empty.provider_data().map(<[Envelope]>::len),
Some(0)
);
let bare = SegmentExtensions::new(String::new(), None, None);
assert_eq!(bare.item_id(), None);
let identified = bare.clone().with_item_id("answer".into());
assert_eq!(identified.item_id(), Some("answer"));
assert_eq!(
identified.with_item_id("replaced".into()).item_id(),
Some("replaced"),
"the last identity written wins, because there is only one"
);
let extensions = SegmentExtensions::new(
"sig".into(),
Some(Payload::copy_from_slice(b"raw")),
Some(vec![envelope(b'1')]),
)
.with_item_id("answer".into());
let cloned = extensions.clone();
assert_eq!(cloned.provider_data().map(<[Envelope]>::len), Some(1));
assert_eq!(cloned.item_id(), Some("answer"));
let (signature, raw, provider_data, item_id) = extensions.into_parts();
assert_eq!(signature, "sig");
assert_eq!(raw.as_ref().map(Payload::as_bytes), Some(b"raw".as_slice()));
assert_eq!(provider_data.as_deref().map(<[Envelope]>::len), Some(1));
assert_eq!(item_id.as_deref(), Some("answer"));
}
#[test]
fn segment_variants_preserve_mixed_order() {
let extensions = || SegmentExtensions::new(String::new(), None, None);
let segments = [
Segment::Text {
text: "before".into(),
extensions: extensions(),
},
Segment::Thinking {
text: "reason".into(),
extensions: extensions(),
},
Segment::ToolCall {
call: ToolCall::new(
Id::new("call".into()),
tool_call::Name::new("tool".into()),
Payload::copy_from_slice(b"{}"),
),
extensions: extensions(),
},
Segment::Text {
text: "after".into(),
extensions: extensions(),
},
];
assert!(matches!(&segments[0], Segment::Text { text, .. } if text == "before"));
assert!(matches!(&segments[1], Segment::Thinking { text, .. } if text == "reason"));
assert!(matches!(&segments[2], Segment::ToolCall { call, .. } if call.id().as_str() == "call"));
assert!(matches!(&segments[3], Segment::Text { text, .. } if text == "after"));
}
fn secret_metadata() -> Metadata {
Metadata::from_iter([
("secret".to_owned(), MetadataValue::String(SECRET.into())),
(
"nested".to_owned(),
MetadataValue::Object(Metadata::from_iter([(
"deeper".to_owned(),
MetadataValue::Bytes(SECRET.as_bytes().into()),
)])),
),
])
}
#[test]
fn metadata_debug_counts_entries_without_naming_one() {
let metadata = secret_metadata();
assert_redacted(&metadata);
assert_eq!(format!("{metadata:?}"), "Metadata { entries: 2 }");
assert_eq!(format!("{:?}", Metadata::new()), "Metadata { entries: 0 }");
}
#[test]
fn metadata_iterator_debug_counts_what_is_left() {
let metadata = secret_metadata();
let mut borrowing = metadata.iter();
assert_redacted(&borrowing);
assert_eq!(format!("{borrowing:?}"), "MetadataIter { remaining: 2 }");
let _consumed = borrowing.next();
assert_eq!(format!("{borrowing:?}"), "MetadataIter { remaining: 1 }");
let mut owning = secret_metadata().into_iter();
assert_redacted(&owning);
assert_eq!(format!("{owning:?}"), "MetadataIntoIter { remaining: 2 }");
let _consumed = owning.next();
assert_eq!(format!("{owning:?}"), "MetadataIntoIter { remaining: 1 }");
}
#[test]
fn metadata_value_debug_keeps_the_discriminant_and_drops_the_payload() {
let cases: [(MetadataValue, &str); 9] = [
(MetadataValue::Null, "Null"),
(MetadataValue::Bool(true), "Bool(..)"),
(MetadataValue::Signed(-7), "Signed(..)"),
(MetadataValue::Unsigned(8), "Unsigned(..)"),
(MetadataValue::Float(1.5), "Float(..)"),
(MetadataValue::String(SECRET.into()), "String(<21 bytes>)"),
(
MetadataValue::Bytes(SECRET.as_bytes().into()),
"Bytes(<21 bytes>)",
),
(
MetadataValue::Array(vec![MetadataValue::String(SECRET.into())]),
"Array(<1 items>)",
),
(
MetadataValue::Object(secret_metadata()),
"Object(Metadata { entries: 2 })",
),
];
for (value, expected) in cases {
assert_redacted(&value);
assert_eq!(format!("{value:?}"), expected);
let borrowed = value.as_borrowed();
assert_redacted(&borrowed);
assert_eq!(format!("{borrowed:?}"), expected);
}
}
#[test]
fn metadata_value_debug_never_emits_a_scalar_it_was_given() {
for (value, leaked) in [
(MetadataValue::Signed(4321), "4321"),
(MetadataValue::Unsigned(99), "99"),
(MetadataValue::Bool(true), "true"),
(MetadataValue::Float(0.5), "0.5"),
] {
assert!(
!format!("{value:?}").contains(leaked),
"a metadata scalar reached the log: {value:?}"
);
}
}
#[test]
fn part_fields_debug_sizes_content_and_keeps_all_three_presences_apart() {
let present = PartFields::new(
SECRET.into(),
"application/example".into(),
Some(Vec::new().into_boxed_slice()),
"reef://part".into(),
Some(secret_metadata()),
Some(Payload::copy_from_slice(SECRET.as_bytes())),
);
assert_redacted(&present);
assert_states(
&present,
&[
"text: <21 bytes>",
"mime: <19 bytes>",
"data: Some(<0 bytes>)",
"reference: <11 bytes>",
"metadata: Some(Metadata { entries: 2 })",
"raw: Some(<21 bytes>)",
],
);
let absent = PartFields::new(
String::new(),
String::new(),
None,
String::new(),
None,
None,
);
assert_redacted(&absent);
assert_states(
&absent,
&[
"text: <0 bytes>",
"data: None",
"metadata: None",
"raw: None",
],
);
let seven = PartFields::new(
String::new(),
String::new(),
Some(vec![0; 7].into_boxed_slice()),
String::new(),
None,
None,
);
assert_states(&seven, &["data: Some(<7 bytes>)"]);
}
#[test]
fn part_debug_inherits_redaction_and_keeps_the_kind() {
let part = Part::new(PartKind::from_i64(77), complete_fields(SECRET));
assert_redacted(&part);
assert_states(&part, &["Part", "PartKind(77)", "text: <21 bytes>"]);
}
#[test]
fn segment_extensions_debug_reports_signature_presence_and_never_its_size() {
let present = SegmentExtensions::new(
SECRET.into(),
Some(Payload::copy_from_slice(SECRET.as_bytes())),
Some(vec![envelope(b'1')]),
);
assert_redacted(&present);
assert_states(&present, &["signature: <present>", "raw: Some(<21 bytes>)"]);
assert!(!format!("{present:?}").contains("signature: <21 bytes>"));
let absent = SegmentExtensions::new(String::new(), None, None);
assert_redacted(&absent);
assert_states(
&absent,
&["signature: <absent>", "raw: None", "provider_data: None"],
);
}
#[test]
fn segment_debug_treats_thinking_exactly_like_answer_text() {
let extensions = || SegmentExtensions::new(SECRET.into(), None, None);
let text = Segment::Text {
text: SECRET.into(),
extensions: extensions(),
};
let thinking = Segment::Thinking {
text: SECRET.into(),
extensions: extensions(),
};
assert_redacted(&text);
assert_redacted(&thinking);
assert_states(&text, &["Text", "text: <21 bytes>"]);
assert_states(&thinking, &["Thinking", "text: <21 bytes>"]);
assert_eq!(
format!("{text:?}").replace("Text", "Thinking"),
format!("{thinking:?}")
);
}
#[test]
fn segment_tool_call_debug_keeps_identifiers_and_sizes_the_arguments() {
let call = Segment::ToolCall {
call: ToolCall::new(
Id::new("call-1".into()),
tool_call::Name::new("search".into()),
Payload::copy_from_slice(SECRET.as_bytes()),
),
extensions: SegmentExtensions::new(SECRET.into(), None, None),
};
assert_redacted(&call);
assert_states(
&call,
&[
"ToolCall",
"Id(\"call-1\")",
"Name(\"search\")",
"arguments: <21 bytes>",
],
);
}
#[test]
fn deep_metadata_debug_is_stack_safe_subprocess() {
run_deep_metadata_child("value::content_tests::deep_metadata_debug_child");
}
#[test]
fn deep_metadata_debug_child() {
if std::env::var_os(DEEP_METADATA_CHILD).is_none() {
return;
}
let value = deep_metadata_value();
assert_eq!(format!("{value:?}"), "Object(Metadata { entries: 3 })");
let metadata = metadata_with_deep_value();
assert_eq!(format!("{metadata:?}"), "Metadata { entries: 3 }");
let part = Part::new(
PartKind::from_i64(0),
PartFields::new(
String::new(),
String::new(),
None,
String::new(),
Some(metadata_with_deep_value()),
None,
),
);
assert!(format!("{part:?}").contains("Metadata { entries: 3 }"));
drop(value);
drop(metadata);
drop(part);
}
#[cfg(feature = "serde")]
mod serde_format {
use serde_core::de::Deserialize;
use super::super::content::{
Metadata, MetadataValue, MetadataValueRef, Part, PartFields, PartKind, Segment,
SegmentExtensions,
};
use super::{complete_fields, deep_metadata_value};
use crate::opaque::Payload;
use crate::value::tool_call::{Id, Name, ToolCall};
use crate::wire::wire_tests::{assert_expecting, assert_refusal, encode, round_trip};
const MAX_DEPTH: usize = 128;
fn extensions() -> SegmentExtensions {
SegmentExtensions::new(
"signature".into(),
Some(Payload::copy_from_slice(b"1")),
Some(Vec::new()),
)
}
fn nest(levels: usize) -> MetadataValue {
let mut value = MetadataValue::Null;
for _ in 1..levels {
value = MetadataValue::Array(vec![value]);
}
value
}
fn nested_document(levels: usize) -> String {
let mut document = String::new();
for _ in 1..levels {
document.push_str(r#"{"array":["#);
}
document.push_str(r#""null""#);
for _ in 1..levels {
document.push_str("]}");
}
document
}
fn read_deeply(document: &str) -> Result<MetadataValue, serde_json::Error> {
let mut deserializer = serde_json::Deserializer::from_str(document);
deserializer.disable_recursion_limit();
MetadataValue::deserialize(&mut deserializer)
}
#[test]
fn a_part_kind_travels_as_the_number_it_is() {
for kind in [i64::MIN, -1, 0, 4, 77, i64::MAX] {
let original = PartKind::from_i64(kind);
assert_eq!(round_trip(&original).as_i64(), kind);
}
assert_eq!(encode(&PartKind::from_i64(-3)), "-3");
}
#[test]
fn every_metadata_variant_survives_a_round_trip() {
let values = vec![
MetadataValue::Null,
MetadataValue::Bool(true),
MetadataValue::Signed(-7),
MetadataValue::Unsigned(8),
MetadataValue::Float(1.5),
MetadataValue::String("text".into()),
MetadataValue::Bytes(vec![1, 2].into_boxed_slice()),
MetadataValue::Array(vec![MetadataValue::Null]),
MetadataValue::Object(Metadata::from_iter([(
"key".to_owned(),
MetadataValue::Bool(false),
)])),
];
let original = MetadataValue::Array(values);
assert_eq!(encode(&round_trip(&original)), encode(&original));
}
#[test]
fn a_non_finite_float_is_the_formats_limitation_and_is_documented_as_one() {
let original = MetadataValue::Float(f64::NAN);
assert_eq!(encode(&original), r#"{"float":null}"#);
assert_refusal(
serde_json::from_str::<MetadataValue>(r#"{"float":null}"#),
"invalid type",
);
}
#[test]
fn metadata_is_a_map_that_keeps_ascending_key_order_and_last_writer_wins() {
let metadata = Metadata::from_iter([
("zeta".to_owned(), MetadataValue::Null),
("alpha".to_owned(), MetadataValue::Bool(true)),
]);
assert_eq!(
encode(&metadata),
r#"{"alpha":{"bool":true},"zeta":"null"}"#
);
let repeated: Metadata =
serde_json::from_str(r#"{"k":{"signed":1},"k":{"signed":2}}"#).expect("a map reads");
assert!(
matches!(
repeated.get("k").map(MetadataValue::as_borrowed),
Some(MetadataValueRef::Signed(2))
),
"a repeated key keeps the last value, exactly as `Metadata::from_iter` documents"
);
}
#[test]
fn a_null_metadata_value_reads_from_both_spellings_of_a_unit_variant() {
assert!(matches!(
serde_json::from_str::<MetadataValue>(r#""null""#).expect("the bare tag reads"),
MetadataValue::Null
));
assert!(matches!(
serde_json::from_str::<MetadataValue>(r#"{"null":null}"#)
.expect("the tag-to-unit mapping reads"),
MetadataValue::Null
));
}
#[test]
fn metadata_refuses_an_unknown_tag_and_a_document_that_is_not_a_value() {
assert_refusal(
serde_json::from_str::<MetadataValue>(r#"{"decimal":1}"#),
"unknown variant `decimal`",
);
assert_expecting::<MetadataValue>("a metadata value");
assert_refusal(
serde_json::from_str::<MetadataValue>(r#"{"array":1}"#),
"an array of metadata values",
);
assert_refusal(
serde_json::from_str::<MetadataValue>(r#"{"object":1}"#),
"a metadata object",
);
assert_expecting::<Metadata>("a metadata object");
}
#[test]
fn a_metadata_value_is_bounded_at_the_documented_depth_in_both_directions() {
let deepest = nest(MAX_DEPTH);
let encoded = serde_json::to_string(&deepest).expect("the last accepted depth serializes");
assert_eq!(encoded, nested_document(MAX_DEPTH));
assert_eq!(
encode(&read_deeply(&encoded).expect("the last accepted depth deserializes")),
encoded
);
let over = serde_json::to_string(&nest(MAX_DEPTH + 1))
.expect_err("one level past the bound is refused rather than truncated")
.to_string();
assert!(over.contains("128-level serialization limit"), "{over}");
let read_back = read_deeply(&nested_document(MAX_DEPTH + 1))
.expect_err("one level past the bound is refused on the way in too")
.to_string();
assert!(
read_back.contains("128-level serialization limit"),
"{read_back}"
);
}
#[test]
fn the_deepest_fixture_reports_a_typed_error_instead_of_overflowing() {
let reported = serde_json::to_string(&deep_metadata_value())
.expect_err("50 000 levels is past the bound")
.to_string();
assert!(
reported.contains("128-level serialization limit"),
"{reported}"
);
}
#[test]
fn part_fields_keep_every_presence_state_and_read_from_both_forms() {
let complete = complete_fields("body");
assert_eq!(encode(&round_trip(&complete)), encode(&complete));
let absent = PartFields::new(
String::new(),
String::new(),
None,
String::new(),
None,
None,
);
let present_empty = PartFields::new(
String::new(),
String::new(),
Some(Vec::new().into_boxed_slice()),
String::new(),
Some(Metadata::new()),
Some(Payload::from_vec(Vec::new())),
);
assert_ne!(encode(&absent), encode(&present_empty));
assert_eq!(encode(&round_trip(&absent)), encode(&absent));
assert_eq!(encode(&round_trip(&present_empty)), encode(&present_empty));
let from_sequence: PartFields = serde_json::from_str(r#"["","",null,"",null,null]"#)
.expect("a compact format writes a struct as its fields in order");
assert_eq!(encode(&from_sequence), encode(&absent));
}
#[test]
fn part_fields_refuse_an_unknown_repeated_missing_or_mistyped_document() {
assert_refusal(
serde_json::from_str::<PartFields>(
r#"{"text":"","mime":"","data":null,"ref":"","metadata":null,"raw":null}"#,
),
"unknown field `ref`",
);
assert_refusal(
serde_json::from_str::<PartFields>(r#"{"text":"","text":""}"#),
"duplicate field `text`",
);
assert_refusal(
serde_json::from_str::<PartFields>(r#"{"text":"","mime":""}"#),
"missing field `data`",
);
assert_refusal(
serde_json::from_str::<PartFields>(r#"[""]"#),
"every struct field",
);
assert_expecting::<PartFields>("a complete part field set");
}
#[test]
fn a_part_reads_from_both_forms_and_refuses_the_rest() {
let part = Part::new(PartKind::from_i64(77), complete_fields("body"));
assert_eq!(encode(&round_trip(&part)), encode(&part));
let from_sequence: Part = serde_json::from_str(r#"[0,["ok","",null,"",null,null]]"#)
.expect("a compact format writes a struct as its fields in order");
assert_eq!(encode(&from_sequence), encode(&Part::text("ok".into())));
assert_refusal(
serde_json::from_str::<Part>(r#"{"kind":0,"extra":1}"#),
"unknown field `extra`",
);
assert_refusal(
serde_json::from_str::<Part>(r#"{"kind":0,"kind":0}"#),
"duplicate field `kind`",
);
assert_refusal(
serde_json::from_str::<Part>(r#"{"kind":0}"#),
"missing field `fields`",
);
assert_refusal(serde_json::from_str::<Part>("[0]"), "every struct field");
assert_expecting::<Part>("a message part");
}
#[test]
fn segment_extensions_read_from_both_forms_and_refuse_the_rest() {
let complete = extensions();
assert_eq!(encode(&round_trip(&complete)), encode(&complete));
let bare = SegmentExtensions::new(String::new(), None, None);
let from_sequence: SegmentExtensions = serde_json::from_str(r#"["",null,null,null]"#)
.expect("a compact format writes a struct as its fields in order");
assert_eq!(encode(&from_sequence), encode(&bare));
assert_refusal(
serde_json::from_str::<SegmentExtensions>(r#"{"signature":"","sig":""}"#),
"unknown field `sig`",
);
assert_refusal(
serde_json::from_str::<SegmentExtensions>(r#"{"signature":"","signature":""}"#),
"duplicate field `signature`",
);
assert_refusal(
serde_json::from_str::<SegmentExtensions>(
r#"{"signature":"","raw":null,"provider_data":null}"#,
),
"missing field `item_id`",
);
assert_refusal(
serde_json::from_str::<SegmentExtensions>(r#"[""]"#),
"every struct field",
);
assert_expecting::<SegmentExtensions>("segment extensions");
}
#[test]
fn every_segment_variant_survives_a_round_trip_in_both_forms() {
let segments = [
Segment::Text {
text: "answer".into(),
extensions: extensions(),
},
Segment::Thinking {
text: "reason".into(),
extensions: SegmentExtensions::new(String::new(), None, None),
},
Segment::ToolCall {
call: ToolCall::new(
Id::new("call-1".into()),
Name::new("search".into()),
Payload::copy_from_slice(b"{}"),
),
extensions: SegmentExtensions::new(String::new(), None, None),
},
];
for segment in &segments {
assert_eq!(encode(&round_trip(segment)), encode(segment));
}
let text_from_sequence: Segment =
serde_json::from_str(r#"{"text":["answer",["",null,null,null]]}"#)
.expect("a struct variant also reads from the sequence form");
assert!(matches!(text_from_sequence, Segment::Text { .. }));
let thinking_from_sequence: Segment =
serde_json::from_str(r#"{"thinking":["reason",["",null,null,null]]}"#)
.expect("a struct variant also reads from the sequence form");
assert!(matches!(thinking_from_sequence, Segment::Thinking { .. }));
let call_from_sequence: Segment =
serde_json::from_str(r#"{"tool_call":[["c","t",[]],["",null,null,null]]}"#)
.expect("a struct variant also reads from the sequence form");
assert!(matches!(call_from_sequence, Segment::ToolCall { .. }));
}
#[test]
fn a_segment_refuses_an_unknown_repeated_missing_or_mistyped_document() {
assert_refusal(
serde_json::from_str::<Segment>(r#"{"reasoning":{}}"#),
"unknown variant `reasoning`",
);
assert_expecting::<Segment>("an assistant content segment");
assert_refusal(
serde_json::from_str::<Segment>(r#"{"text":{"text":"","body":""}}"#),
"unknown field `body`",
);
assert_refusal(
serde_json::from_str::<Segment>(r#"{"text":{"text":"","text":""}}"#),
"duplicate field `text`",
);
assert_refusal(
serde_json::from_str::<Segment>(r#"{"text":{"text":""}}"#),
"missing field `extensions`",
);
assert_refusal(
serde_json::from_str::<Segment>(r#"{"text":[""]}"#),
"every struct field",
);
assert_refusal(
serde_json::from_str::<Segment>(r#"{"text":1}"#),
"a text-bearing segment",
);
assert_refusal(
serde_json::from_str::<Segment>(r#"{"tool_call":{"invocation":null}}"#),
"unknown field `invocation`",
);
assert_refusal(
serde_json::from_str::<Segment>(
r#"{"tool_call":{"call":["c","t",[]],"call":["c","t",[]]}}"#,
),
"duplicate field `call`",
);
assert_refusal(
serde_json::from_str::<Segment>(r#"{"tool_call":{"extensions":["",null,null,null]}}"#),
"missing field `call`",
);
assert_refusal(
serde_json::from_str::<Segment>(r#"{"tool_call":[["c","t",[]]]}"#),
"every struct field",
);
assert_refusal(
serde_json::from_str::<Segment>(r#"{"tool_call":1}"#),
"a tool-call segment",
);
}
}