use super::corpus::SegmentKey;
use crate::{FulltextQuery, Fused, Fusion, HashJoin, HashSeen, Ranked, Rooted, retrieve::fuse};
#[derive(Debug, Clone, PartialEq)]
enum Sighting {
Transcript(Ranked<SegmentKey, f32>),
Voiceprint(Ranked<SegmentKey, f32>),
}
impl Sighting {
fn ranked(&self) -> &Ranked<SegmentKey, f32> {
match self {
Self::Transcript(hit) | Self::Voiceprint(hit) => hit,
}
}
fn member(&self) -> &'static str {
match self {
Self::Transcript(_) => "transcript",
Self::Voiceprint(_) => "voiceprint",
}
}
fn segment(&self) -> i64 {
self.ranked().node_ref().id
}
}
fn rooted(
hits: Vec<Ranked<SegmentKey, f32>>,
variant: fn(Ranked<SegmentKey, f32>) -> Sighting,
) -> Vec<Rooted<String, Sighting>> {
hits
.into_iter()
.map(|hit| {
let root = hit.node_ref().media.clone();
let rank = hit.rank();
Rooted::new(root, rank, variant(hit))
})
.collect()
}
const MEDIA: [&str; 3] = ["m1", "m2", "m3"];
fn term(rank: u64) -> f64 {
1.0 / (60.0 + rank as f64)
}
fn roots(fused: &[Fused<String, Sighting>]) -> Vec<&str> {
fused.iter().map(|row| row.root_ref().as_str()).collect()
}
async fn transcripts() -> Vec<Ranked<SegmentKey, f32>> {
let (_dir, index, mut engine) = super::fulltext::index(&[]).await;
super::fulltext::retrieve_keys::<HashSeen<_>>(
&mut engine,
&index,
&FulltextQuery::new("sunset", 0.0_f32),
usize::MAX,
)
.await
}
async fn voiceprints() -> Vec<Ranked<SegmentKey, f32>> {
let mut engine = super::vector::index([super::vector::Voiceprint::of(
"m1",
1,
[1.0, 0.10, 0.0, 0.0],
)]);
super::vector::retrieve_keys::<HashSeen<_>>(&mut engine, &super::vector::query(0.0), usize::MAX)
.await
}
#[tokio::test]
async fn both_flavours_fuse_into_one_ranking() {
let lexical = transcripts().await;
let similar = voiceprints().await;
assert_ne!(
lexical
.iter()
.map(|hit| hit.node_ref().id)
.collect::<Vec<_>>(),
similar
.iter()
.map(|hit| hit.node_ref().id)
.collect::<Vec<_>>(),
);
assert_eq!(
similar.iter().map(Ranked::rank).collect::<Vec<_>>(),
vec![1, 3, 4, 5, 6, 7],
"the deduped duplicate left its ordinal behind",
);
let best = |hits: &[Ranked<SegmentKey, f32>], medium: &str| -> Option<u64> {
hits
.iter()
.find(|hit| hit.node_ref().media == medium)
.map(Ranked::rank)
};
let expected: Vec<(&str, f64)> = MEDIA
.iter()
.map(|medium| {
let lexically = best(&lexical, medium).map(term).unwrap_or_default();
let similarly = best(&similar, medium).map(term).unwrap_or_default();
(*medium, lexically + similarly)
})
.collect();
let fused = fuse::<_, _, HashJoin<_>>(
vec![
rooted(lexical, Sighting::Transcript),
rooted(similar, Sighting::Voiceprint),
],
Fusion::rrf(),
);
assert_eq!(fused.len(), 3, "three media, three rows");
for (medium, score) in expected {
let row = fused
.iter()
.find(|row| row.root_ref() == medium)
.unwrap_or_else(|| panic!("{medium} is in the answer"));
assert!(
(row.score().get() - score).abs() < 1e-12,
"{medium}: {} is not {score}",
row.score().get()
);
let mut members: Vec<&str> = row
.evidence()
.iter()
.map(|held| Sighting::member(held.seen()))
.collect();
members.sort_unstable();
assert_eq!(
members,
vec!["transcript", "voiceprint"],
"{medium} carries BOTH members' reasons"
);
}
assert!(
fused
.windows(2)
.all(|pair| pair[0].score() >= pair[1].score()),
"{:?}",
fused.iter().map(Fused::score).collect::<Vec<_>>()
);
}
#[tokio::test]
async fn each_row_carries_the_best_segment_of_its_medium() {
let similar = voiceprints().await;
assert_eq!(
similar
.iter()
.map(|hit| hit.node_ref().id)
.collect::<Vec<_>>(),
vec![1, 2, 3, 4, 5, 6],
"the fixture's stream, which the expectation below reads",
);
assert_eq!(
similar.iter().map(Ranked::rank).collect::<Vec<_>>(),
vec![1, 3, 4, 5, 6, 7],
"with the dedup's hole in it",
);
let fused = fuse::<_, _, HashJoin<_>>(vec![rooted(similar, Sighting::Voiceprint)], Fusion::rrf());
assert_eq!(roots(&fused), MEDIA);
assert_eq!(
fused
.iter()
.map(|row| {
assert_eq!(row.evidence().len(), 1, "one member, counted once");
row.evidence()[0].seen().segment()
})
.collect::<Vec<_>>(),
vec![1, 3, 5],
"the second sighting of each medium is dropped, not added",
);
}
#[tokio::test]
async fn a_member_the_floor_silenced_leaves_the_answer_to_the_rest() {
let (_dir, index, mut engine) = super::fulltext::index(&[]).await;
let unfloored = super::fulltext::retrieve_keys::<HashSeen<_>>(
&mut engine,
&index,
&FulltextQuery::new("sunset", 0.0_f32),
usize::MAX,
)
.await;
let above_everything = unfloored[0].score() + 1.0;
let silenced = super::fulltext::retrieve_keys::<HashSeen<_>>(
&mut engine,
&index,
&FulltextQuery::new("sunset", above_everything),
usize::MAX,
)
.await;
assert!(silenced.is_empty(), "the floor took the whole stream");
let fused = fuse::<_, _, HashJoin<_>>(
vec![
rooted(silenced, Sighting::Transcript),
rooted(voiceprints().await, Sighting::Voiceprint),
],
Fusion::rrf(),
);
assert_eq!(roots(&fused), MEDIA);
let scores: Vec<f64> = fused.iter().map(|row| row.score().get()).collect();
for (got, hand_computed) in scores.iter().zip([
0.016_393_442_622_950_82,
0.015_625,
0.015_151_515_151_515_152,
]) {
assert!(
(got - hand_computed).abs() < 1e-15,
"{got} is not {hand_computed}"
);
}
assert!(
fused.iter().all(|row| row
.evidence()
.iter()
.all(|saw| saw.seen().member() == "voiceprint")),
"a silenced member offers no evidence",
);
}