use super::{
IndexModel,
tests::{document, embedding_index},
};
use crate::{model::NodeKind, prefix::EmissionPrefix};
fn emitted(model: &IndexModel) -> String {
model.emit().to_string()
}
#[test]
fn the_retrieve_face_is_written_once_per_half() {
let emission = emitted(&document());
assert!(emission.contains("if_tracing"), "{emission}");
assert!(emission.contains("if_no_tracing"), "{emission}");
for door in ["async fn retrieve_keys <", "async fn retrieve <"] {
assert_eq!(
emission.matches(door).count(),
2,
"`{door}` is not written once per half: {emission}"
);
}
}
#[test]
fn the_instrumented_half_opens_a_named_span_per_door() {
let emission = emitted(&embedding_index());
assert!(emission.contains("\"ingraph.query\""), "{emission}");
assert!(emission.contains("tracing :: Level :: INFO"), "{emission}");
for field in ["record", "entry", "engine"] {
assert!(
emission.contains(&format!("{field} =")),
"the span carries no `{field}`: {emission}"
);
}
assert!(
emission.contains("record = \"SegmentEmbedding\""),
"{emission}"
);
for entry in [
"retrieve_keys_by_image_embedding",
"retrieve_by_image_embedding",
"get_image_embedding",
"retrieve_similar_by_image_embedding",
] {
assert!(
emission.contains(&format!("entry = \"{entry}\"")),
"no door named `{entry}`: {emission}"
);
}
}
#[test]
fn each_kind_names_the_engine_it_crossed() {
for (model, engine) in [(document(), "fulltext"), (embedding_index(), "vector")] {
let emission = emitted(&model);
assert!(
emission.contains(&format!("engine = \"{engine}\"")),
"{:?} names no engine: {emission}",
model.kind
);
assert!(
!emission.contains("db ="),
"a derived index has no database to name: {emission}"
);
}
}
#[test]
fn the_gate_shut_build_names_no_tracing() {
let shut = shut_halves(embedding_index().emit());
assert!(!shut.is_empty(), "there is no shut half to check");
assert!(
!shut.contains("tracing"),
"a build with observation off still names tracing: {shut}"
);
assert!(
!shut.contains("async move"),
"the uninstrumented half carries the wrapper the span needed: {shut}"
);
for door in [
"retrieve_keys_by_image_embedding",
"retrieve_by_image_embedding",
"get_image_embedding",
"retrieve_similar_by_image_embedding",
] {
assert!(
shut.contains(&format!("async fn {door}")),
"the shut half lost the door it exists to keep: {shut}"
);
}
}
#[test]
fn the_artifact_family_rides_no_gate() {
let emission = emitted(&IndexModel {
prefix: EmissionPrefix::default(),
kind: NodeKind::Blob,
..document()
});
assert!(
!emission.contains("if_tracing"),
"a node with no retrieve carries the gate: {emission}"
);
assert!(
!emission.contains("if_no_tracing"),
"a node with no retrieve carries the complement: {emission}"
);
}
fn shut_halves(tokens: proc_macro2::TokenStream) -> String {
let mut kept = String::new();
let mut named = false;
for tree in tokens {
match tree {
proc_macro2::TokenTree::Ident(ident) => named = ident == "if_no_tracing",
proc_macro2::TokenTree::Group(group) if named => {
kept.push_str(&group.stream().to_string());
named = false;
}
proc_macro2::TokenTree::Group(group) => kept.push_str(&shut_halves(group.stream())),
_ => {}
}
}
kept
}