use core::num::NonZeroUsize;
use uuid::Uuid;
use super::{
ColumnReader, ColumnWriter, Connected, Field, FulltextEngine, FulltextRead, FulltextStore,
FulltextSubset, FulltextWrite, TantivyDoc, TantivyFulltext, TantivyStore,
};
const SLOT: &str = "captions";
const SOURCE: &str = "captions";
const ROOMY: NonZeroUsize = NonZeroUsize::new(10).expect("10 is not zero");
#[derive(Debug, Clone, PartialEq, Eq)]
struct CaptionKey {
media: String,
frame: i64,
run: Uuid,
}
impl Field for CaptionKey {
fn write(&self, w: &mut impl ColumnWriter) {
self.media.write(w);
self.frame.write(w);
self.run.write(w);
}
fn read<R: ColumnReader>(r: &mut R) -> Result<Self, R::Error> {
Ok(Self {
media: String::read(r)?,
frame: i64::read(r)?,
run: Uuid::read(r)?,
})
}
}
fn key(media: &str, frame: i64) -> CaptionKey {
CaptionKey {
media: media.to_owned(),
frame,
run: Uuid::from_u128(0x9f1c_2d3e_4a5b_6c7d_8e9f_a0b1_c2d3_e4f5),
}
}
fn sealed(key: &CaptionKey) -> <TantivyFulltext as FulltextEngine>::Address {
let mut buf = TantivyFulltext::buffer();
key.write(&mut buf);
TantivyFulltext::finalize(buf)
}
fn taken(
address: <TantivyFulltext as FulltextEngine>::Address,
) -> Result<CaptionKey, super::TantivyFulltextError> {
let mut phase = TantivyFulltext::open(address);
let key = CaptionKey::read(&mut phase)?;
phase.finish()?;
Ok(key)
}
fn entry(key: &CaptionKey, body: &str) -> TantivyDoc {
TantivyDoc::new(SOURCE)
.with_identity(&key.frame)
.with_address(key)
.with_body(body)
}
fn indexed(corpus: &[(CaptionKey, &str)]) -> (tempfile::TempDir, TantivyStore, TantivyFulltext) {
let dir = tempfile::tempdir().expect("a temporary directory");
let store = TantivyStore::open(dir.path()).expect("the store opens");
let face = FulltextStore::fulltext(&store, SLOT);
{
let mut writer = store
.writer(SLOT, TantivyStore::MIN_WRITER_HEAP_BYTES)
.expect("the slot's writer opens");
for (key, body) in corpus {
FulltextWrite::upsert(&face, Connected::new(&store, &mut writer), entry(key, body))
.expect("the entry queues");
}
writer.commit().expect("the batch commits");
}
store.reload(SLOT).expect("the slot's reader reloads");
(dir, store, face)
}
#[test]
fn a_key_reported_in_columns_comes_back_off_a_live_search() {
let fox = key("m1", 1);
let heron = key("m2", 2);
let (_dir, store, face) = indexed(&[
(fox.clone(), "the quick brown fox"),
(heron.clone(), "a heron over still water"),
]);
let hits = FulltextRead::search(
&face,
Connected::new(&store, ()),
FulltextSubset::All,
"fox",
ROOMY,
None,
)
.expect("the search runs");
assert_eq!(hits.len(), 1, "{hits:?}");
assert_eq!(
hits[0].data_ref(),
&sealed(&fox),
"the stored address is not the one the write walk sealed",
);
assert_eq!(
taken(hits[0].data_ref().clone()).expect("the address reads back"),
fox
);
assert!(hits[0].score() > 0.0, "{hits:?}");
let hits = FulltextRead::search(
&face,
Connected::new(&store, ()),
FulltextSubset::All,
"heron",
ROOMY,
None,
)
.expect("the search runs");
assert_eq!(hits.len(), 1, "{hits:?}");
assert_eq!(
taken(hits[0].data_ref().clone()).expect("the address reads back"),
heron
);
}
#[test]
fn the_builder_seals_the_same_address_the_walk_does() {
let key = key("m1", 7);
assert_eq!(
entry(&key, "a red car").address().as_slice(),
sealed(&key).as_slice()
);
}
#[test]
fn a_stored_address_the_key_does_not_finish_is_refused() {
#[derive(Debug, PartialEq, Eq)]
struct Shorter {
media: String,
frame: i64,
}
impl Field for Shorter {
fn write(&self, w: &mut impl ColumnWriter) {
self.media.write(w);
self.frame.write(w);
}
fn read<R: ColumnReader>(r: &mut R) -> Result<Self, R::Error> {
Ok(Self {
media: String::read(r)?,
frame: i64::read(r)?,
})
}
}
let (_dir, store, face) = indexed(&[(key("m1", 1), "the quick brown fox")]);
let hits = FulltextRead::search(
&face,
Connected::new(&store, ()),
FulltextSubset::All,
"fox",
ROOMY,
None,
)
.expect("the search runs");
let mut phase = TantivyFulltext::open(hits[0].data_ref().clone());
assert_eq!(
Shorter::read(&mut phase).expect("the two columns it does read are there"),
Shorter {
media: "m1".to_owned(),
frame: 1,
}
);
assert!(
matches!(
phase.finish(),
Err(super::TantivyFulltextError::Key(
super::KeyDecodeError::Trailing
))
),
"a key that read short must be refused rather than served",
);
}