use std::{cell::Cell, rc::Rc};
use super::ranked_keys;
use crate::{
Scored,
retrieve::{EqSeen, HashSeen, Ranked},
};
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
struct SegmentKey {
media: &'static str,
segment: i64,
}
const fn key(media: &'static str, segment: i64) -> SegmentKey {
SegmentKey { media, segment }
}
fn hit(media: &'static str, segment: i64, score: f32) -> Scored<SegmentKey, f32> {
Scored::new(key(media, segment), score)
}
struct Counted<I> {
inner: I,
pulled: Rc<Cell<usize>>,
}
impl<I: Iterator> Iterator for Counted<I> {
type Item = I::Item;
fn next(&mut self) -> Option<I::Item> {
let next = self.inner.next();
if next.is_some() {
self.pulled.set(self.pulled.get() + 1);
}
next
}
}
fn counted<I: IntoIterator>(hits: I) -> (Counted<I::IntoIter>, Rc<Cell<usize>>) {
let pulled = Rc::new(Cell::new(0));
(
Counted {
inner: hits.into_iter(),
pulled: Rc::clone(&pulled),
},
pulled,
)
}
fn shape(ranked: &[Ranked<SegmentKey, f32>]) -> Vec<(&'static str, i64, f32, u64)> {
ranked
.iter()
.map(|hit| {
(
hit.node_ref().media,
hit.node_ref().segment,
hit.score(),
hit.rank(),
)
})
.collect()
}
#[test]
fn the_pipeline_runs_floor_then_dedup_then_rank() {
let hits = vec![
hit("m1", 1, 0.90),
hit("m2", 7, 0.80),
hit("m1", 1, 0.70), hit("m3", 2, 0.60),
hit("m4", 9, 0.20), hit("m5", 4, 0.10),
];
let ranked = ranked_keys::<_, _, HashSeen<_>>(hits, &0.5, usize::MAX);
assert_eq!(
shape(&ranked),
vec![("m1", 1, 0.90, 1), ("m2", 7, 0.80, 2), ("m3", 2, 0.60, 4)]
);
}
#[test]
fn dedup_keeps_the_first_sighting_and_therefore_the_best_score() {
let hits = vec![
hit("m1", 1, 0.90),
hit("m2", 7, 0.80),
hit("m1", 1, 0.50),
hit("m1", 1, 0.30),
];
let ranked = ranked_keys::<_, _, HashSeen<_>>(hits, &0.1, usize::MAX);
assert_eq!(shape(&ranked), vec![("m1", 1, 0.90, 1), ("m2", 7, 0.80, 2)]);
}
#[test]
fn rank_is_the_raw_ordinal_with_the_holes_left_in() {
let hits = vec![
hit("m1", 1, 0.90),
hit("m1", 1, 0.85), hit("m1", 1, 0.84), hit("m2", 7, 0.80), hit("m2", 7, 0.75), hit("m3", 2, 0.60), ];
let ranked = ranked_keys::<_, _, HashSeen<_>>(hits, &0.1, usize::MAX);
assert_eq!(
ranked.iter().map(Ranked::rank).collect::<Vec<_>>(),
vec![1, 4, 6]
);
}
#[test]
fn the_floor_ends_the_walk_rather_than_filtering_the_tail() {
let mut hits = vec![
hit("m1", 1, 0.90),
hit("m2", 2, 0.80),
hit("m3", 3, 0.70),
hit("m4", 4, 0.20), ];
hits.extend((5..13).map(|n| hit("tail", n, 0.19)));
let (stream, pulled) = counted(hits);
let ranked = ranked_keys::<_, _, HashSeen<_>>(stream, &0.5, usize::MAX);
assert_eq!(ranked.len(), 3);
assert_eq!(
pulled.get(),
4,
"the walk must stop AT the first sub-floor hit, not filter past it"
);
}
#[test]
fn the_floor_is_inclusive() {
let hits = vec![hit("m1", 1, 0.5), hit("m2", 2, 0.5), hit("m3", 3, 0.4)];
let ranked = ranked_keys::<_, _, HashSeen<_>>(hits, &0.5, usize::MAX);
assert_eq!(ranked.len(), 2);
}
#[test]
fn an_incomparable_score_ends_the_walk() {
let hits = vec![hit("m1", 1, 0.9), hit("m2", 2, f32::NAN), hit("m3", 3, 0.8)];
let (stream, pulled) = counted(hits);
let ranked = ranked_keys::<_, _, HashSeen<_>>(stream, &0.5, usize::MAX);
assert_eq!(shape(&ranked), vec![("m1", 1, 0.9, 1)]);
assert_eq!(pulled.get(), 2);
}
#[test]
fn the_budget_stops_the_walk_at_the_survivor_it_fills() {
let hits: Vec<_> = (1..=20).map(|n| hit("m", n, 0.9)).collect();
let (stream, pulled) = counted(hits);
let ranked = ranked_keys::<_, _, HashSeen<_>>(stream, &0.5, 3);
assert_eq!(ranked.len(), 3);
assert_eq!(pulled.get(), 3);
}
#[test]
fn a_budget_of_zero_pulls_nothing() {
let hits: Vec<_> = (1..=5).map(|n| hit("m", n, 0.9)).collect();
let (stream, pulled) = counted(hits);
let ranked = ranked_keys::<_, _, HashSeen<_>>(stream, &0.5, 0);
assert!(ranked.is_empty());
assert_eq!(pulled.get(), 0);
}
#[test]
fn the_equality_mechanism_walks_the_same_pipeline() {
let hits = vec![
hit("m1", 1, 0.90),
hit("m2", 7, 0.80),
hit("m1", 1, 0.70),
hit("m3", 2, 0.60),
hit("m4", 9, 0.20),
];
let hashed = ranked_keys::<_, _, HashSeen<_>>(hits.clone(), &0.5, usize::MAX);
let listed = ranked_keys::<_, _, EqSeen<_>>(hits, &0.5, usize::MAX);
assert_eq!(shape(&hashed), shape(&listed));
}
#[test]
fn an_empty_stream_is_an_empty_answer() {
let ranked = ranked_keys::<_, _, HashSeen<SegmentKey>>(Vec::new(), &0.5, usize::MAX);
assert!(ranked.is_empty());
}