use crate::store::*;
use std::time::Duration;
#[test]
#[should_panic(expected = "corrupt frame in the store")]
fn a_corrupt_frame_panics_saying_which() {
let dir = tempfile::TempDir::new().unwrap().keep();
let store = Store::open(dir, StoreOptions::default()).unwrap();
let frame = store.append(Frame::builder("test").build()).unwrap();
store
.stream
.insert(frame.id.to_bytes(), b"not json")
.unwrap();
let _ = store.get(&frame.id);
}
#[test]
fn a_panic_on_a_corrupt_frame_does_not_jam_later_writes() {
let dir = tempfile::TempDir::new().unwrap().keep();
let store = Store::open(dir, StoreOptions::default()).unwrap();
let frame = store.append(Frame::builder("damaged").build()).unwrap();
store
.stream
.insert(frame.id.to_bytes(), b"not json")
.unwrap();
let remover = store.clone();
let id = frame.id;
let removed = std::thread::spawn(move || remover.remove(&id)).join();
assert!(removed.is_err(), "removing a corrupt frame did not panic");
store
.append(Frame::builder("elsewhere").build())
.expect("an unrelated write failed after the panic");
}
mod tests_ensure {
use super::*;
use static_assertions::assert_impl_all;
#[test]
fn test_store_is_send_sync() {
assert_impl_all!(Store: Send, Sync);
}
}
mod tests_read_options {
use super::*;
#[derive(Debug)]
struct TestCase<'a> {
input: Option<&'a str>,
expected: ReadOptions,
reencoded: Option<&'a str>,
}
#[tokio::test]
async fn test_topic_index_order() {
let folder = tempfile::tempdir().unwrap();
let store = Store::new(folder.path().to_path_buf()).unwrap();
let frame1 = Frame {
id: scru128::new(),
topic: "ab".to_owned(),
..Default::default()
};
let frame1 = store.append(frame1).unwrap();
let frame2 = Frame {
id: scru128::new(),
topic: "abc".to_owned(),
..Default::default()
};
let frame2 = store.append(frame2).unwrap();
let keys = store
.idx_topic
.iter()
.filter_map(|guard| guard.key().ok())
.collect::<Vec<_>>();
assert_eq!(
&[
fjall::Slice::from(idx_topic_key_from_frame(&frame1).unwrap()),
fjall::Slice::from(idx_topic_key_from_frame(&frame2).unwrap()),
],
&*keys,
);
}
#[test]
fn test_read_options_from_query() {
let test_cases = [
TestCase {
input: None,
expected: ReadOptions::default(),
reencoded: None,
},
TestCase {
input: Some("foo=bar"),
expected: ReadOptions::default(),
reencoded: Some(""),
},
TestCase {
input: Some("follow"),
expected: ReadOptions::builder().follow(FollowOption::On).build(),
reencoded: Some("follow=true"),
},
TestCase {
input: Some("follow=1"),
expected: ReadOptions::builder()
.follow(FollowOption::WithHeartbeat(Duration::from_millis(1)))
.build(),
reencoded: None,
},
TestCase {
input: Some("follow=yes"),
expected: ReadOptions::builder().follow(FollowOption::On).build(),
reencoded: Some("follow=true"),
},
TestCase {
input: Some("follow=true"),
expected: ReadOptions::builder().follow(FollowOption::On).build(),
reencoded: None,
},
TestCase {
input: Some("after=03bidzvknotgjpvuew3k23g45"),
expected: ReadOptions::builder()
.after("03bidzvknotgjpvuew3k23g45".parse().unwrap())
.build(),
reencoded: None,
},
TestCase {
input: Some("follow&after=03bidzvknotgjpvuew3k23g45"),
expected: ReadOptions::builder()
.follow(FollowOption::On)
.after("03bidzvknotgjpvuew3k23g45".parse().unwrap())
.build(),
reencoded: Some("follow=true&after=03bidzvknotgjpvuew3k23g45"),
},
TestCase {
input: Some("topic=foo"),
expected: ReadOptions::builder().topic("foo".to_string()).build(),
reencoded: None,
},
TestCase {
input: Some("follow&topic=foo"),
expected: ReadOptions::builder()
.follow(FollowOption::On)
.topic("foo".to_string())
.build(),
reencoded: Some("follow=true&topic=foo"),
},
];
for case in &test_cases {
let options = ReadOptions::from_query(case.input);
assert_eq!(
options.as_ref().ok(),
Some(&case.expected),
"case {:?}",
case.input
);
let query = options.unwrap().to_query_string();
assert_eq!(
query,
case.reencoded
.unwrap_or_else(|| case.input.unwrap_or_default()),
"case {:?}",
case.input,
);
}
assert!(ReadOptions::from_query(Some("after=123")).is_err());
}
}
mod tests_store {
use super::*;
use tempfile::TempDir;
use tokio::time::timeout;
#[tokio::test]
async fn test_get() {
let temp_dir = TempDir::new().unwrap();
let store = Store::new(temp_dir.keep()).unwrap();
let meta = serde_json::json!({"key": "value"});
let frame = store
.append(Frame::builder("stream").meta(meta).build())
.unwrap();
let got = store.get(&frame.id);
assert_eq!(Some(frame.clone()), got);
}
#[tokio::test]
async fn test_follow() {
let temp_dir = TempDir::new().unwrap();
let store = Store::new(temp_dir.keep()).unwrap();
let f1 = store.append(Frame::builder("stream").build()).unwrap();
let f2 = store.append(Frame::builder("stream").build()).unwrap();
let follow_options = ReadOptions::builder()
.follow(FollowOption::WithHeartbeat(Duration::from_millis(5)))
.build();
let mut recver = store.read(follow_options);
async fn next_frame(
recver: &mut tokio::sync::mpsc::Receiver<crate::store::ReadItem>,
) -> Frame {
loop {
let frame = recver.recv().await.unwrap().unwrap();
if frame.topic != "xs.pulse" {
return frame;
}
}
}
assert_eq!(f1, next_frame(&mut recver).await);
assert_eq!(f2, next_frame(&mut recver).await);
assert_eq!(
"xs.threshold".to_string(),
next_frame(&mut recver).await.topic
);
let f3 = store.append(Frame::builder("stream").build()).unwrap();
let f4 = store.append(Frame::builder("stream").build()).unwrap();
assert_eq!(f3, next_frame(&mut recver).await);
assert_eq!(f4, next_frame(&mut recver).await);
assert_eq!(
"xs.pulse".to_string(),
recver.recv().await.unwrap().unwrap().topic
);
assert_eq!(
"xs.pulse".to_string(),
recver.recv().await.unwrap().unwrap().topic
);
assert_eq!(
"xs.pulse".to_string(),
recver.recv().await.unwrap().unwrap().topic
);
assert_eq!(
"xs.pulse".to_string(),
recver.recv().await.unwrap().unwrap().topic
);
}
#[tokio::test]
async fn test_follow_new_ends_with_lagged_when_outrun_before_its_first_poll() {
let temp_dir = TempDir::new().unwrap();
let store = Store::new(temp_dir.keep()).unwrap();
let options = ReadOptions::builder()
.new(true)
.follow(FollowOption::On)
.build();
let mut rx = store.read(options);
for _ in 0..(FOLLOW_BUFFER + 500) {
store.append(Frame::builder("filler").build()).unwrap();
}
let marker = store.append(Frame::builder("marker").build()).unwrap();
let mut received = Vec::new();
let mut ended = None;
loop {
match timeout(Duration::from_secs(5), rx.recv()).await {
Ok(Some(Ok(frame))) => received.push(frame),
Ok(Some(Err(err))) => ended = Some(err),
Ok(None) => break,
Err(_) => panic!("the read neither ended nor delivered"),
}
}
assert_eq!(ended, Some(ReadError::Lagged { skipped: 501 }));
assert_eq!(
ended.unwrap().to_string(),
"fell behind the live stream: 501 frames skipped"
);
assert!(received.iter().all(|frame| frame.id != marker.id));
}
#[tokio::test]
async fn test_read_limit_nofollow() {
let temp_dir = tempfile::tempdir().unwrap();
let store = Store::new(temp_dir.path().to_path_buf()).unwrap();
let frame1 = store.append(Frame::builder("test").build()).unwrap();
let frame2 = store.append(Frame::builder("test").build()).unwrap();
let frame3 = store.append(Frame::builder("test").build()).unwrap();
let options = ReadOptions::builder().limit(2).build();
let mut rx = store.read(options);
assert_eq!(Some(Ok(frame1.clone())), rx.recv().await);
assert_eq!(Some(Ok(frame2.clone())), rx.recv().await);
assert_eq!(None, rx.recv().await);
let options = ReadOptions::builder().after(frame1.id).build();
let mut rx = store.read(options);
assert_eq!(Some(Ok(frame2)), rx.recv().await);
assert_eq!(Some(Ok(frame3)), rx.recv().await);
assert_eq!(None, rx.recv().await);
}
#[tokio::test]
async fn test_read_last_nofollow() {
let temp_dir = tempfile::tempdir().unwrap();
let store = Store::new(temp_dir.path().to_path_buf()).unwrap();
let _frame1 = store.append(Frame::builder("test").build()).unwrap();
let _frame2 = store.append(Frame::builder("test").build()).unwrap();
let _frame3 = store.append(Frame::builder("test").build()).unwrap();
let frame4 = store.append(Frame::builder("test").build()).unwrap();
let frame5 = store.append(Frame::builder("test").build()).unwrap();
let options = ReadOptions::builder().last(2).build();
let mut rx = store.read(options);
assert_eq!(Some(Ok(frame4)), rx.recv().await);
assert_eq!(Some(Ok(frame5)), rx.recv().await);
assert_eq!(None, rx.recv().await);
}
#[tokio::test]
async fn test_read_last_with_topic() {
let temp_dir = tempfile::tempdir().unwrap();
let store = Store::new(temp_dir.path().to_path_buf()).unwrap();
let _a1 = store.append(Frame::builder("topic.a").build()).unwrap();
let _b1 = store.append(Frame::builder("topic.b").build()).unwrap();
let a2 = store.append(Frame::builder("topic.a").build()).unwrap();
let _b2 = store.append(Frame::builder("topic.b").build()).unwrap();
let a3 = store.append(Frame::builder("topic.a").build()).unwrap();
let options = ReadOptions::builder()
.last(2)
.topic("topic.a".to_string())
.build();
let mut rx = store.read(options);
assert_eq!(Some(Ok(a2)), rx.recv().await);
assert_eq!(Some(Ok(a3)), rx.recv().await);
assert_eq!(None, rx.recv().await);
}
#[tokio::test]
async fn test_read_follow_last_emits_threshold() {
let temp_dir = tempfile::tempdir().unwrap();
let store = Store::new(temp_dir.path().to_path_buf()).unwrap();
let frame1 = store.append(Frame::builder("test").build()).unwrap();
let options = ReadOptions::builder()
.last(2)
.follow(FollowOption::On)
.build();
let mut rx = store.read(options);
assert_eq!(Some(Ok(frame1)), rx.recv().await);
assert_eq!(rx.recv().await.unwrap().unwrap().topic, "xs.threshold");
}
#[tokio::test]
async fn test_read_follow_limit_emits_threshold() {
let temp_dir = tempfile::tempdir().unwrap();
let store = Store::new(temp_dir.path().to_path_buf()).unwrap();
let frame1 = store.append(Frame::builder("test").build()).unwrap();
let options = ReadOptions::builder()
.limit(2)
.follow(FollowOption::On)
.build();
let mut rx = store.read(options);
assert_eq!(Some(Ok(frame1)), rx.recv().await);
assert_eq!(rx.recv().await.unwrap().unwrap().topic, "xs.threshold");
}
#[tokio::test]
async fn test_follow_ends_with_lagged_when_the_reader_falls_behind() {
let temp_dir = tempfile::tempdir().unwrap();
let store = Store::new(temp_dir.path().to_path_buf()).unwrap();
let options = ReadOptions::builder().follow(FollowOption::On).build();
let mut rx = store.read(options);
assert_eq!(rx.recv().await.unwrap().unwrap().topic, "xs.threshold");
for _ in 0..(FOLLOW_BUFFER * 2) {
store.append(Frame::builder("test").build()).unwrap();
}
let mut received = Vec::new();
let mut ended = None;
loop {
match timeout(Duration::from_secs(5), rx.recv()).await {
Ok(Some(Ok(frame))) => received.push(frame),
Ok(Some(Err(err))) => ended = Some(err),
Ok(None) => break,
Err(_) => panic!(
"the read neither ended nor delivered after {} frames",
received.len()
),
}
}
let Some(ReadError::Lagged { skipped }) = ended else {
panic!("the read ended without an error");
};
let skipped = skipped as usize;
assert!(skipped > 0);
assert!(received.iter().all(|frame| frame.topic == "test"));
assert!(received.len() + skipped <= FOLLOW_BUFFER * 2);
}
#[tokio::test]
async fn test_follow_reads_frames_appended_during_replay_from_the_store() {
let temp_dir = tempfile::tempdir().unwrap();
let store = Store::new(temp_dir.path().to_path_buf()).unwrap();
let mut expected: Vec<Scru128Id> = (0..300)
.map(|_| store.append(Frame::builder("stored").build()).unwrap().id)
.collect();
let options = ReadOptions::builder().follow(FollowOption::On).build();
let mut rx = store.read(options);
let first = rx.recv().await.unwrap().unwrap();
assert_eq!(first.id, expected[0]);
for _ in 0..(FOLLOW_BUFFER + 500) {
expected.push(store.append(Frame::builder("during").build()).unwrap().id);
}
let mut got = vec![first.id];
loop {
let frame = timeout(Duration::from_secs(5), rx.recv())
.await
.expect("the replay stalled")
.expect("the read ended during the replay")
.unwrap();
if frame.topic == "xs.threshold" {
break;
}
got.push(frame.id);
}
assert_eq!(got, expected);
let live = store.append(Frame::builder("live").build()).unwrap();
let frame = timeout(Duration::from_secs(5), rx.recv())
.await
.expect("the live frame never arrived")
.unwrap()
.unwrap();
assert_eq!(frame.id, live.id);
}
#[tokio::test(flavor = "multi_thread")]
async fn test_follow_delivers_concurrent_appends_once_in_order() {
let temp_dir = tempfile::tempdir().unwrap();
let store = Store::new(temp_dir.path().to_path_buf()).unwrap();
for _ in 0..1000 {
store.append(Frame::builder("stored").build()).unwrap();
}
let options = ReadOptions::builder().follow(FollowOption::On).build();
let mut rx = store.read(options);
let appender = {
let store = store.clone();
std::thread::spawn(move || {
for _ in 0..3000 {
store.append(Frame::builder("during").build()).unwrap();
}
})
};
let mut got = Vec::new();
let mut thresholds = 0;
while got.len() < 4000 {
let frame = timeout(Duration::from_secs(10), rx.recv())
.await
.expect("the read stalled")
.expect("the read ended")
.unwrap();
if frame.topic == "xs.threshold" {
thresholds += 1;
continue;
}
got.push(frame.id);
}
appender.join().unwrap();
if thresholds == 0 {
assert_eq!(rx.recv().await.unwrap().unwrap().topic, "xs.threshold");
thresholds += 1;
}
assert!(
timeout(Duration::from_millis(100), rx.recv())
.await
.is_err(),
"a frame was delivered twice"
);
let stored: Vec<Scru128Id> = store
.read_sync(ReadOptions::default())
.map(|frame| frame.id)
.collect();
assert_eq!(got, stored);
assert_eq!(thresholds, 1);
}
#[tokio::test]
async fn test_read_follow_limit_after_subscribe() {
let temp_dir = tempfile::tempdir().unwrap();
let store = Store::new(temp_dir.path().to_path_buf()).unwrap();
let frame1 = store.append(Frame::builder("test").build()).unwrap();
let options = ReadOptions::builder()
.limit(2)
.follow(FollowOption::On)
.build();
let mut rx = store.read(options);
assert_eq!(Some(Ok(frame1)), rx.recv().await);
assert_eq!(rx.recv().await.unwrap().unwrap().topic, "xs.threshold");
assert!(timeout(Duration::from_millis(100), rx.recv())
.await
.is_err());
let frame2 = store.append(Frame::builder("test").build()).unwrap();
let _frame3 = store.append(Frame::builder("test").build()).unwrap();
assert_eq!(Some(Ok(frame2)), rx.recv().await);
assert_eq!(None, rx.recv().await);
}
#[tokio::test]
async fn test_read_follow_limit_processing_history() {
let temp_dir = tempfile::tempdir().unwrap();
let store = Store::new(temp_dir.path().to_path_buf()).unwrap();
let frame1 = store.append(Frame::builder("test").build()).unwrap();
let frame2 = store.append(Frame::builder("test").build()).unwrap();
let frame3 = store.append(Frame::builder("test").build()).unwrap();
let _frame4 = store.append(Frame::builder("test").build()).unwrap();
let _frame5 = store.append(Frame::builder("test").build()).unwrap();
let options = ReadOptions::builder()
.limit(3)
.follow(FollowOption::On)
.build();
let mut rx = store.read(options);
assert_eq!(Some(Ok(frame1)), rx.recv().await);
assert_eq!(Some(Ok(frame2)), rx.recv().await);
assert_eq!(Some(Ok(frame3)), rx.recv().await);
assert_eq!(
Ok(None),
timeout(Duration::from_millis(100), rx.recv()).await,
"Channel should be closed after limit"
);
}
#[test]
fn test_read_sync() {
let temp_dir = TempDir::new().unwrap();
let store = Store::new(temp_dir.keep()).unwrap();
let frame1 = store.append(Frame::builder("test").build()).unwrap();
let frame2 = store.append(Frame::builder("test").build()).unwrap();
let frame3 = store.append(Frame::builder("test").build()).unwrap();
let options = ReadOptions::builder().build();
let frames: Vec<Frame> = store.read_sync(options).collect();
assert_eq!(vec![frame1.clone(), frame2.clone(), frame3.clone()], frames);
let options = ReadOptions::builder().after(frame1.id).build();
let frames: Vec<Frame> = store.read_sync(options).collect();
assert_eq!(vec![frame2.clone(), frame3.clone()], frames);
let options = ReadOptions::builder().limit(2).build();
let frames: Vec<Frame> = store.read_sync(options).collect();
assert_eq!(vec![frame1, frame2], frames);
}
}
mod tests_ttl {
use super::*;
#[test]
fn test_serialize() {
let ttl: TTL = Default::default();
let serialized = serde_json::to_string(&ttl).unwrap();
assert_eq!(serialized, r#""forever""#);
let ttl = TTL::Time(Duration::from_secs(1));
let serialized = serde_json::to_string(&ttl).unwrap();
assert_eq!(serialized, r#""time:1000""#);
}
#[test]
fn test_to_query() {
assert_eq!(TTL::Forever.to_query(), "ttl=forever");
assert_eq!(TTL::Ephemeral.to_query(), "ttl=ephemeral");
assert_eq!(
TTL::Time(Duration::from_secs(3600)).to_query(),
"ttl=time:3600000"
);
assert_eq!(TTL::Last(2).to_query(), "ttl=last:2");
}
#[test]
fn test_parse_ttl() {
assert_eq!(parse_ttl("forever"), Ok(TTL::Forever));
assert_eq!(parse_ttl("ephemeral"), Ok(TTL::Ephemeral));
assert_eq!(
parse_ttl("time:3600000"),
Ok(TTL::Time(Duration::from_secs(3600)))
);
assert_eq!(parse_ttl("last:3"), Ok(TTL::Last(3)));
assert!(parse_ttl("time:abc").is_err());
assert!(parse_ttl("last:0").is_err());
assert!(parse_ttl("unknown").is_err());
}
#[test]
fn test_from_query() {
assert_eq!(TTL::from_query(None), Ok(TTL::Forever));
assert_eq!(TTL::from_query(Some("ttl=forever")), Ok(TTL::Forever));
assert_eq!(TTL::from_query(Some("ttl=ephemeral")), Ok(TTL::Ephemeral));
assert_eq!(TTL::from_query(Some("foo=bar")), Ok(TTL::Forever));
assert!(TTL::from_query(Some("ttl=time")).is_err()); assert!(TTL::from_query(Some("ttl=head")).is_err()); assert!(TTL::from_query(Some("ttl=head&n=0")).is_err()); assert!(TTL::from_query(Some("ttl=invalid")).is_err()); }
#[test]
fn test_ttl_round_trip() {
let ttls = vec![
TTL::Forever,
TTL::Ephemeral,
TTL::Time(Duration::from_secs(3600)),
TTL::Last(2),
];
for ttl in ttls {
let query = ttl.to_query();
let parsed = TTL::from_query(Some(&query)).expect("Failed to parse query");
assert_eq!(parsed, ttl, "Round trip failed for TTL: {:?}", ttl);
}
}
#[test]
fn test_ttl_json_round_trip() {
let ttls = vec![
(TTL::Forever, r#""forever""#),
(TTL::Ephemeral, r#""ephemeral""#),
(TTL::Time(Duration::from_secs(3600)), r#""time:3600000""#),
(TTL::Last(2), r#""last:2""#),
];
for (ttl, expect) in ttls {
let json = serde_json::to_string(&ttl).expect("Failed to serialize TTL to JSON");
assert_eq!(json, expect);
let deserialized: TTL =
serde_json::from_str(&json).expect("Failed to deserialize JSON back to TTL");
assert_eq!(
deserialized, ttl,
"JSON round-trip failed for TTL: {:?}",
ttl
);
}
}
}
mod tests_topic {
use super::*;
use tempfile::TempDir;
#[test]
fn test_topic_validation() {
assert!(validate_topic("foo").is_ok());
assert!(validate_topic("foo.bar").is_ok());
assert!(validate_topic("foo.bar.baz").is_ok());
assert!(validate_topic("user-123").is_ok());
assert!(validate_topic("user_123").is_ok());
assert!(validate_topic("_private").is_ok());
assert!(validate_topic("123").is_err());
assert!(validate_topic("a").is_ok());
assert!(validate_topic("").is_err());
assert!(validate_topic("foo.").is_err());
assert!(validate_topic("foo.bar.").is_err());
assert!(validate_topic(".foo").is_err());
assert!(validate_topic("-foo").is_err());
assert!(validate_topic("foo*bar").is_err());
assert!(validate_topic("foo bar").is_err());
assert!(validate_topic("foo\0bar").is_err());
assert!(validate_topic("foo..bar").is_err());
assert!(validate_topic("user..double").is_err());
let long_topic = "a".repeat(256);
assert!(validate_topic(&long_topic).is_err());
let max_topic = "a".repeat(255);
assert!(validate_topic(&max_topic).is_ok());
}
#[tokio::test]
async fn test_reject_trailing_dot_in_topic() {
let temp_dir = tempfile::tempdir().unwrap();
let store = Store::new(temp_dir.path().to_path_buf()).unwrap();
let result = store.append(Frame::builder("user.").build());
assert!(result.is_err());
assert!(result.unwrap_err().to_string().contains("end with '.'"));
}
#[tokio::test]
async fn test_wildcard_query_historical() {
let temp_dir = tempfile::tempdir().unwrap();
let store = Store::new(temp_dir.path().to_path_buf()).unwrap();
let user = store.append(Frame::builder("user").build()).unwrap();
let user_profile = store
.append(Frame::builder("user.profile").build())
.unwrap();
let user_settings = store
.append(Frame::builder("user.settings").build())
.unwrap();
let order = store.append(Frame::builder("order").build()).unwrap();
let options = ReadOptions::builder().topic("user.*".to_string()).build();
let rx = store.read(options);
let frames: Vec<_> = tokio_stream::StreamExt::collect(tokio_stream::StreamExt::map(
tokio_stream::wrappers::ReceiverStream::new(rx),
Result::unwrap,
))
.await;
assert_eq!(frames, vec![user_profile, user_settings]);
let options = ReadOptions::builder().topic("user".to_string()).build();
let rx = store.read(options);
let frames: Vec<_> = tokio_stream::StreamExt::collect(tokio_stream::StreamExt::map(
tokio_stream::wrappers::ReceiverStream::new(rx),
Result::unwrap,
))
.await;
assert_eq!(frames, vec![user]);
let options = ReadOptions::builder().topic("*".to_string()).build();
let rx = store.read(options);
let frames: Vec<_> = tokio_stream::StreamExt::collect(tokio_stream::StreamExt::map(
tokio_stream::wrappers::ReceiverStream::new(rx),
Result::unwrap,
))
.await;
assert_eq!(frames.len(), 4);
assert_eq!(frames[3], order);
}
#[tokio::test]
async fn test_wildcard_query_multilevel() {
let temp_dir = tempfile::tempdir().unwrap();
let store = Store::new(temp_dir.path().to_path_buf()).unwrap();
let user_a_msg = store
.append(Frame::builder("user.a.messages").build())
.unwrap();
let user_a_notes = store
.append(Frame::builder("user.a.notes").build())
.unwrap();
let user_b_msg = store
.append(Frame::builder("user.b.messages").build())
.unwrap();
let options = ReadOptions::builder().topic("user.*".to_string()).build();
let rx = store.read(options);
let frames: Vec<_> = tokio_stream::StreamExt::collect(tokio_stream::StreamExt::map(
tokio_stream::wrappers::ReceiverStream::new(rx),
Result::unwrap,
))
.await;
assert_eq!(
frames,
vec![user_a_msg.clone(), user_a_notes.clone(), user_b_msg]
);
let options = ReadOptions::builder().topic("user.a.*".to_string()).build();
let rx = store.read(options);
let frames: Vec<_> = tokio_stream::StreamExt::collect(tokio_stream::StreamExt::map(
tokio_stream::wrappers::ReceiverStream::new(rx),
Result::unwrap,
))
.await;
assert_eq!(frames, vec![user_a_msg, user_a_notes]);
}
#[tokio::test]
async fn test_wildcard_query_live() {
let temp_dir = tempfile::tempdir().unwrap();
let store = Store::new(temp_dir.path().to_path_buf()).unwrap();
let options = ReadOptions::builder()
.topic("user.*".to_string())
.follow(FollowOption::On)
.build();
let mut rx = store.read(options);
assert_eq!(rx.recv().await.unwrap().unwrap().topic, "xs.threshold");
let user_profile = store
.append(Frame::builder("user.profile").build())
.unwrap();
let _order = store.append(Frame::builder("order").build()).unwrap();
let user_settings = store
.append(Frame::builder("user.settings").build())
.unwrap();
assert_eq!(rx.recv().await, Some(Ok(user_profile)));
assert_eq!(rx.recv().await, Some(Ok(user_settings)));
}
#[test]
fn test_iter_frames_with_start_bound() {
let temp_dir = TempDir::new().unwrap();
let store = Store::new(temp_dir.keep()).unwrap();
let _frame1 = store.append(Frame::builder("test").build()).unwrap();
let frame2 = store.append(Frame::builder("test").build()).unwrap();
let frame3 = store.append(Frame::builder("test").build()).unwrap();
let frames: Vec<_> = store.iter_frames(Some((frame2.id, false))).collect();
assert_eq!(frames, vec![frame3.clone()], "exclusive bound failed");
let frames: Vec<_> = store.iter_frames(Some((frame2.id, true))).collect();
assert_eq!(
frames,
vec![frame2.clone(), frame3.clone()],
"inclusive bound failed"
);
}
#[tokio::test]
async fn test_topic_filter_historical() {
let temp_dir = TempDir::new().unwrap();
let store = Store::new(temp_dir.keep()).unwrap();
let foo1 = store.append(Frame::builder("foo").build()).unwrap();
let _bar1 = store.append(Frame::builder("bar").build()).unwrap();
let foo2 = store.append(Frame::builder("foo").build()).unwrap();
let options = ReadOptions::builder().topic("foo".to_string()).build();
let rx = store.read(options);
let frames: Vec<_> = tokio_stream::StreamExt::collect(tokio_stream::StreamExt::map(
tokio_stream::wrappers::ReceiverStream::new(rx),
Result::unwrap,
))
.await;
assert_eq!(frames, vec![foo1, foo2]);
}
#[tokio::test]
async fn test_topic_filter_live() {
let temp_dir = TempDir::new().unwrap();
let store = Store::new(temp_dir.keep()).unwrap();
let foo1 = store.append(Frame::builder("foo").build()).unwrap();
let _bar1 = store.append(Frame::builder("bar").build()).unwrap();
let options = ReadOptions::builder()
.topic("foo".to_string())
.follow(FollowOption::On)
.build();
let mut rx = store.read(options);
assert_eq!(rx.recv().await, Some(Ok(foo1)));
assert_eq!(
rx.recv().await.unwrap().unwrap().topic,
"xs.threshold".to_string()
);
let foo2 = store.append(Frame::builder("foo").build()).unwrap();
let _bar2 = store.append(Frame::builder("bar").build()).unwrap();
assert_eq!(rx.recv().await, Some(Ok(foo2)));
}
}
mod tests_ttl_expire {
use super::*;
use tempfile::TempDir;
use tokio::time::sleep;
use tokio_stream::StreamExt;
fn store_without_tick() -> Store {
let temp_dir = TempDir::new().unwrap();
let options = StoreOptions::builder()
.ttl_sweep(Duration::from_secs(600))
.build();
Store::open(temp_dir.keep(), options).unwrap()
}
#[tokio::test]
async fn test_time_based_ttl_expiry() {
let store = store_without_tick();
let permanent_frame = store.append(Frame::builder("test").build()).unwrap();
let expiring_frame = store
.append(
Frame::builder("test")
.ttl(TTL::Time(Duration::from_millis(100)))
.build(),
)
.unwrap();
let recver = store.read(ReadOptions::default());
assert_eq!(
tokio_stream::wrappers::ReceiverStream::new(recver)
.map(Result::unwrap)
.collect::<Vec<Frame>>()
.await,
vec![permanent_frame.clone(), expiring_frame.clone()]
);
sleep(Duration::from_millis(200)).await;
let recver = store.read(ReadOptions::default());
assert_eq!(
tokio_stream::wrappers::ReceiverStream::new(recver)
.map(Result::unwrap)
.collect::<Vec<Frame>>()
.await,
vec![permanent_frame]
);
store.wait_for_gc().await;
assert_eq!(store.get(&expiring_frame.id), Some(expiring_frame.clone()));
assert_eq!(store.idx_expiry_len(), 1);
store.sweep();
store.wait_for_gc().await;
assert_eq!(store.get(&expiring_frame.id), None);
assert_eq!(store.idx_expiry_len(), 0);
}
#[tokio::test]
async fn test_sweep_tick_removes_untouched_expired_frame() {
let temp_dir = TempDir::new().unwrap();
let options = StoreOptions::builder()
.ttl_sweep(Duration::from_millis(20))
.build();
let store = Store::open(temp_dir.keep(), options).unwrap();
let permanent = store.append(Frame::builder("test").build()).unwrap();
let expiring = store
.append(
Frame::builder("test")
.ttl(TTL::Time(Duration::from_millis(50)))
.build(),
)
.unwrap();
let deadline = std::time::Instant::now() + Duration::from_secs(5);
while store.get(&expiring.id).is_some() {
assert!(std::time::Instant::now() < deadline, "never swept");
sleep(Duration::from_millis(10)).await;
}
assert_eq!(store.idx_expiry_len(), 0);
assert_eq!(store.get(&permanent.id), Some(permanent));
}
#[tokio::test]
async fn test_sweep_keeps_unexpired_frame() {
let store = store_without_tick();
let living = store
.append(
Frame::builder("test")
.ttl(TTL::Time(Duration::from_secs(600)))
.build(),
)
.unwrap();
let expiring = store
.append(
Frame::builder("test")
.ttl(TTL::Time(Duration::from_millis(50)))
.build(),
)
.unwrap();
assert_eq!(store.idx_expiry_len(), 2);
sleep(Duration::from_millis(200)).await;
store.sweep();
store.wait_for_gc().await;
assert_eq!(store.get(&living.id), Some(living));
assert_eq!(store.get(&expiring.id), None);
assert_eq!(store.idx_expiry_len(), 1);
}
#[tokio::test]
async fn test_removing_time_frame_drops_expiry_entry() {
let store = store_without_tick();
let frame = store
.append(
Frame::builder("test")
.ttl(TTL::Time(Duration::from_secs(600)))
.build(),
)
.unwrap();
assert_eq!(store.idx_expiry_len(), 1);
store.remove(&frame.id).unwrap();
assert_eq!(store.get(&frame.id), None);
assert_eq!(store.idx_expiry_len(), 0);
for _ in 0..3 {
store
.append(
Frame::builder("test")
.ttl(TTL::Time(Duration::from_secs(600)))
.build(),
)
.unwrap();
}
assert_eq!(store.idx_expiry_len(), 3);
store
.append(Frame::builder("test").ttl(TTL::Last(1)).build())
.unwrap();
store.wait_for_gc().await;
assert_eq!(store.read_sync(ReadOptions::default()).count(), 1);
assert_eq!(store.idx_expiry_len(), 0);
}
#[tokio::test]
async fn test_sweep_over_cap_runs_again() {
let store = store_without_tick();
let total = 4096 + 5;
for _ in 0..total {
store
.append(
Frame::builder("test")
.ttl(TTL::Time(Duration::from_millis(50)))
.build(),
)
.unwrap();
}
assert_eq!(store.idx_expiry_len(), total);
sleep(Duration::from_millis(200)).await;
store.sweep();
let deadline = std::time::Instant::now() + Duration::from_secs(30);
while store.idx_expiry_len() > 0 {
assert!(std::time::Instant::now() < deadline, "sweep never finished");
sleep(Duration::from_millis(10)).await;
}
store.wait_for_gc().await;
assert_eq!(store.read_sync(ReadOptions::default()).count(), 0);
assert_eq!(store.stats.remove_commits.load(Ordering::Relaxed), 2);
}
#[tokio::test]
async fn test_last_based_ttl_retention() {
let temp_dir = TempDir::new().unwrap();
let store = Store::new(temp_dir.keep()).unwrap();
let _frame1 = store
.append(
Frame::builder("test")
.ttl(TTL::Last(2))
.meta(serde_json::json!({"order": 1}))
.build(),
)
.unwrap();
let _frame2 = store
.append(
Frame::builder("test")
.ttl(TTL::Last(2))
.meta(serde_json::json!({"order": 2}))
.build(),
)
.unwrap();
let frame3 = store
.append(
Frame::builder("test")
.ttl(TTL::Last(2))
.meta(serde_json::json!({"order": 3}))
.build(),
)
.unwrap();
let frame4 = store
.append(
Frame::builder("test")
.ttl(TTL::Last(2))
.meta(serde_json::json!({"order": 4}))
.build(),
)
.unwrap();
let other_frame = store
.append(
Frame::builder("other")
.ttl(TTL::Last(2))
.meta(serde_json::json!({"order": 1}))
.build(),
)
.unwrap();
store.wait_for_gc().await;
let options = ReadOptions::builder().build();
let frames: Vec<_> = store.read_sync(options).collect();
assert_eq!(frames, vec![frame3, frame4, other_frame]);
}
#[tokio::test]
async fn test_many_expired_frames_removed_in_one_drain() {
let store = store_without_tick();
let permanent = store.append(Frame::builder("test").build()).unwrap();
let expiring: Vec<Frame> = (0..50)
.map(|_| {
store
.append(
Frame::builder("test")
.ttl(TTL::Time(Duration::from_millis(50)))
.build(),
)
.unwrap()
})
.collect();
sleep(Duration::from_millis(200)).await;
let frames: Vec<Frame> = store.read_sync(ReadOptions::default()).collect();
assert_eq!(frames, vec![permanent.clone()]);
store.sweep();
store.wait_for_gc().await;
for frame in &expiring {
assert_eq!(store.get(&frame.id), None, "{} still present", frame.id);
}
assert_eq!(store.get(&permanent.id), Some(permanent));
assert_eq!(store.stats.remove_commits.load(Ordering::Relaxed), 1);
}
#[tokio::test]
async fn test_last_ttl_trims_several_frames_in_one_commit() {
let temp_dir = TempDir::new().unwrap();
let store = Store::new(temp_dir.keep()).unwrap();
for _ in 0..5 {
store
.append(Frame::builder("test").ttl(TTL::Last(10)).build())
.unwrap();
}
store.wait_for_gc().await;
assert_eq!(store.stats.remove_commits.load(Ordering::Relaxed), 0);
let last = store
.append(Frame::builder("test").ttl(TTL::Last(2)).build())
.unwrap();
store.wait_for_gc().await;
let frames: Vec<Frame> = store.read_sync(ReadOptions::default()).collect();
assert_eq!(frames.len(), 2);
assert_eq!(frames[1], last);
assert_eq!(store.stats.remove_commits.load(Ordering::Relaxed), 1);
}
#[tokio::test]
async fn test_gc_drain_interleaves_expiry_and_last_ttl() {
let store = store_without_tick();
let f1 = store
.append(Frame::builder("test").ttl(TTL::Last(10)).build())
.unwrap();
let f2 = store
.append(Frame::builder("test").ttl(TTL::Last(10)).build())
.unwrap();
let f3 = store
.append(
Frame::builder("test")
.ttl(TTL::Time(Duration::from_millis(50)))
.build(),
)
.unwrap();
let other: Vec<Frame> = (0..3)
.map(|_| {
store
.append(
Frame::builder("other")
.ttl(TTL::Time(Duration::from_millis(50)))
.build(),
)
.unwrap()
})
.collect();
sleep(Duration::from_millis(200)).await;
let frames: Vec<Frame> = store.read_sync(ReadOptions::default()).collect();
assert_eq!(frames, vec![f1.clone(), f2.clone()]);
store.sweep();
let f4 = store
.append(Frame::builder("test").ttl(TTL::Last(2)).build())
.unwrap();
store.wait_for_gc().await;
let frames: Vec<Frame> = store.read_sync(ReadOptions::default()).collect();
assert_eq!(frames, vec![f2, f4]);
assert_eq!(store.get(&f1.id), None);
assert_eq!(store.get(&f3.id), None);
for frame in &other {
assert_eq!(store.get(&frame.id), None);
}
}
#[tokio::test]
async fn test_pruning_ttl_on_module_hides_version_from_earlier_create() {
let temp_dir = TempDir::new().unwrap();
let store = Store::new(temp_dir.keep()).unwrap();
let hash_v1 = store.cas_insert("export def v [] { 1 }").await.unwrap();
let mod_v1 = store
.append(
Frame::builder("xs.module.foo")
.ttl(TTL::Last(1))
.hash(hash_v1)
.build(),
)
.unwrap();
let create = store
.append(Frame::builder("xs.service.bar.create").build())
.unwrap();
assert!(
store.nu_modules_at(&create.id).contains_key("foo"),
"module is visible as of a create that came after v1"
);
let hash_v2 = store.cas_insert("export def v [] { 2 }").await.unwrap();
let _mod_v2 = store
.append(
Frame::builder("xs.module.foo")
.ttl(TTL::Last(1))
.hash(hash_v2)
.build(),
)
.unwrap();
store.wait_for_gc().await;
assert_eq!(store.get(&mod_v1.id), None, "v1 was pruned by last:1");
assert!(
!store.nu_modules_at(&create.id).contains_key("foo"),
"the version the earlier create resolved against is gone, and v2 is in its future"
);
let create_after = store
.append(Frame::builder("xs.service.baz.create").build())
.unwrap();
assert!(
store.nu_modules_at(&create_after.id).contains_key("foo"),
"a create after v2 resolves the surviving version"
);
}
}
mod tests_append_race {
use super::*;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::{Arc, Barrier};
use tempfile::TempDir;
#[tokio::test(flavor = "multi_thread", worker_threads = 8)]
async fn test_concurrent_append_broadcast_order() {
let temp_dir = TempDir::new().unwrap();
let store = Arc::new(Store::new(temp_dir.keep()).unwrap());
let mut rx = store.read(ReadOptions::builder().follow(FollowOption::On).build());
let threshold = rx.recv().await.unwrap().unwrap();
assert_eq!(threshold.topic, "xs.threshold");
let num_threads = 8;
let appends_per_thread = 50;
let barrier = Arc::new(Barrier::new(num_threads));
let completed = Arc::new(AtomicUsize::new(0));
let mut handles = Vec::new();
for thread_id in 0..num_threads {
let store = Arc::clone(&store);
let barrier = Arc::clone(&barrier);
let completed = Arc::clone(&completed);
handles.push(std::thread::spawn(move || {
barrier.wait();
for i in 0..appends_per_thread {
let _ = store.append(
Frame::builder("race-test")
.meta(serde_json::json!({"thread": thread_id, "seq": i}))
.build(),
);
}
completed.fetch_add(1, Ordering::SeqCst);
}));
}
for handle in handles {
handle.join().unwrap();
}
let expected_count = num_threads * appends_per_thread;
let mut received = Vec::with_capacity(expected_count);
loop {
if received.len() >= expected_count {
break;
}
match tokio::time::timeout(Duration::from_secs(5), rx.recv()).await {
Ok(Some(Ok(frame))) if frame.topic == "race-test" => {
received.push(frame);
}
Ok(Some(_)) => {
continue;
}
Ok(None) => panic!("Channel closed unexpectedly"),
Err(_) => panic!(
"Timeout waiting for frames, got {} of {}",
received.len(),
expected_count
),
}
}
let mut out_of_order = Vec::new();
for i in 1..received.len() {
if received[i].id < received[i - 1].id {
out_of_order.push((i - 1, i, received[i - 1].id, received[i].id));
}
}
assert!(
out_of_order.is_empty(),
"Frames received out of scru128 order! Found {} violations:\n{:?}",
out_of_order.len(),
out_of_order.iter().take(10).collect::<Vec<_>>()
);
}
}
#[test]
fn test_read_sync_last() {
let temp_dir = tempfile::tempdir().unwrap();
let store = Store::new(temp_dir.path().to_path_buf()).unwrap();
let _frame1 = store.append(Frame::builder("test").build()).unwrap();
let _frame2 = store.append(Frame::builder("test").build()).unwrap();
let _frame3 = store.append(Frame::builder("test").build()).unwrap();
let frame4 = store.append(Frame::builder("test").build()).unwrap();
let frame5 = store.append(Frame::builder("test").build()).unwrap();
let options = ReadOptions::builder().last(2).build();
let frames: Vec<_> = store.read_sync(options).collect();
assert_eq!(vec![frame4, frame5], frames);
}
#[test]
fn test_read_sync_from() {
let temp_dir = tempfile::tempdir().unwrap();
let store = Store::new(temp_dir.path().to_path_buf()).unwrap();
let _frame1 = store.append(Frame::builder("test").build()).unwrap();
let frame2 = store.append(Frame::builder("test").build()).unwrap();
let frame3 = store.append(Frame::builder("test").build()).unwrap();
let options = ReadOptions::builder().from(frame2.id).build();
let frames: Vec<_> = store.read_sync(options).collect();
assert_eq!(vec![frame2.clone(), frame3.clone()], frames);
let options = ReadOptions::builder().after(frame2.id).build();
let frames: Vec<_> = store.read_sync(options).collect();
assert_eq!(vec![frame3], frames);
}
#[test]
fn test_read_sync_last_with_topic() {
let temp_dir = tempfile::tempdir().unwrap();
let store = Store::new(temp_dir.path().to_path_buf()).unwrap();
let _a1 = store.append(Frame::builder("topic.a").build()).unwrap();
let _b1 = store.append(Frame::builder("topic.b").build()).unwrap();
let a2 = store.append(Frame::builder("topic.a").build()).unwrap();
let _b2 = store.append(Frame::builder("topic.b").build()).unwrap();
let a3 = store.append(Frame::builder("topic.a").build()).unwrap();
let options = ReadOptions::builder()
.last(2)
.topic("topic.a".to_string())
.build();
let frames: Vec<_> = store.read_sync(options).collect();
assert_eq!(vec![a2, a3], frames);
}
#[test]
fn test_read_sync_limit_with_topic() {
let temp_dir = tempfile::tempdir().unwrap();
let store = Store::new(temp_dir.path().to_path_buf()).unwrap();
let a1 = store.append(Frame::builder("topic.a").build()).unwrap();
let _b1 = store.append(Frame::builder("topic.b").build()).unwrap();
let a2 = store.append(Frame::builder("topic.a").build()).unwrap();
let _a3 = store.append(Frame::builder("topic.a").build()).unwrap();
let options = ReadOptions::builder()
.limit(2)
.topic("topic.a".to_string())
.build();
let frames: Vec<_> = store.read_sync(options).collect();
assert_eq!(vec![a1, a2], frames);
}
#[test]
fn test_read_sync_is_lazy() {
const FRAMES: usize = 500;
let temp_dir = tempfile::tempdir().unwrap();
let store = Store::new(temp_dir.path().to_path_buf()).unwrap();
for _ in 0..FRAMES {
store.append(Frame::builder("topic.a").build()).unwrap();
}
let before = store.stats.frames_scanned.load(Ordering::Relaxed);
let mut iter = store.read_sync(ReadOptions::default());
let first = iter.next().unwrap();
let scanned = store.stats.frames_scanned.load(Ordering::Relaxed) - before;
assert_eq!(first.topic, "topic.a");
assert!(
scanned <= 2,
"read_sync scanned {scanned} of {FRAMES} frames to yield its first"
);
let before = store.stats.frames_scanned.load(Ordering::Relaxed);
let options = ReadOptions::builder().topic("topic.*".to_string()).build();
let mut iter = store.read_sync(options);
let _ = iter.next().unwrap();
let scanned = store.stats.frames_scanned.load(Ordering::Relaxed) - before;
assert!(
scanned <= 2,
"read_sync scanned {scanned} of {FRAMES} frames to yield its first"
);
let all: Vec<_> = store.read_sync(ReadOptions::default()).collect();
assert_eq!(FRAMES, all.len());
}
mod tests_topic_seek {
use super::*;
fn seed(store: &Store, each: usize) -> (Vec<Scru128Id>, Vec<Scru128Id>) {
let mut a = Vec::with_capacity(each);
let mut b = Vec::with_capacity(each);
for _ in 0..each {
a.push(store.append(Frame::builder("topic.a").build()).unwrap().id);
b.push(store.append(Frame::builder("topic.b").build()).unwrap().id);
}
(a, b)
}
fn read(store: &Store, options: ReadOptions) -> (Vec<Scru128Id>, usize) {
let before = store.stats.frames_scanned.load(Ordering::Relaxed);
let ids: Vec<_> = store.read_sync(options).map(|f| f.id).collect();
(
ids,
store.stats.frames_scanned.load(Ordering::Relaxed) - before,
)
}
fn topic_after(topic: &str, after: Scru128Id) -> ReadOptions {
ReadOptions::builder()
.topic(topic.to_string())
.after(after)
.build()
}
fn topic_from(topic: &str, from: Scru128Id) -> ReadOptions {
ReadOptions::builder()
.topic(topic.to_string())
.from(from)
.build()
}
#[test]
fn test_topic_read_seeks_to_the_start_bound() {
const EACH: usize = 400;
let temp_dir = tempfile::tempdir().unwrap();
let store = Store::new(temp_dir.path().to_path_buf()).unwrap();
let (a, b) = seed(&store, EACH);
let (ids, scanned) = read(&store, topic_after("topic.a", a[EACH - 5]));
assert_eq!(ids, a[EACH - 4..]);
assert_eq!(
scanned, 4,
"scanned {scanned} of {EACH} index entries to return the last 4"
);
let (ids, scanned) = read(&store, topic_after("topic.*", a[EACH - 5]));
let mut expected: Vec<_> = a[EACH - 4..]
.iter()
.chain(b[EACH - 5..].iter())
.copied()
.collect();
expected.sort();
assert_eq!(ids, expected);
assert_eq!(
scanned,
9,
"scanned {scanned} of {} index entries to return the last 9",
EACH * 2
);
}
#[test]
fn test_start_bound_semantics_are_unchanged() {
let temp_dir = tempfile::tempdir().unwrap();
let store = Store::new(temp_dir.path().to_path_buf()).unwrap();
let (a, b) = seed(&store, 3);
assert_eq!(read(&store, topic_from("topic.a", a[1])).0, a[1..]);
assert_eq!(read(&store, topic_after("topic.a", a[1])).0, a[2..]);
assert_eq!(read(&store, topic_from("topic.a", b[0])).0, a[1..]);
assert_eq!(read(&store, topic_after("topic.a", b[0])).0, a[1..]);
let low = Scru128Id::from_bytes([0x00; 16]);
let high = Scru128Id::from_bytes([0xff; 16]);
assert_eq!(read(&store, topic_from("topic.a", low)).0, a);
assert!(read(&store, topic_from("topic.a", high)).0.is_empty());
let (ids, _) = read(&store, topic_after("topic.*", a[1]));
assert_eq!(ids, vec![b[1], a[2], b[2]]);
}
#[test]
fn test_bounded_scan_stops_at_the_topic() {
let temp_dir = tempfile::tempdir().unwrap();
let store = Store::new(temp_dir.path().to_path_buf()).unwrap();
let a = store.append(Frame::builder("topic.a").build()).unwrap();
store.append(Frame::builder("topic.ab").build()).unwrap();
store.append(Frame::builder("topic.a.c").build()).unwrap();
let low = Scru128Id::from_bytes([0x00; 16]);
assert_eq!(read(&store, topic_from("topic.a", low)).0, vec![a.id]);
}
}
mod tests_topic_filter {
use super::*;
use tempfile::TempDir;
#[test]
fn test_topic_filter_parse() {
assert_eq!(TopicFilter::from_option(None), TopicFilter::All);
assert_eq!(TopicFilter::parse("*"), TopicFilter::All);
assert_eq!(TopicFilter::parse("a,*"), TopicFilter::All);
assert_eq!(
TopicFilter::parse("game.move.*,game.create"),
TopicFilter::Patterns(vec![
Pattern::Prefix("game.move.".to_string()),
Pattern::Exact("game.create".to_string()),
])
);
assert_eq!(
TopicFilter::parse("a,,b"),
TopicFilter::Patterns(vec![
Pattern::Exact("a".to_string()),
Pattern::Exact("b".to_string()),
])
);
assert_eq!(TopicFilter::parse(""), TopicFilter::All);
let filter = TopicFilter::parse("game.move.*,game.create");
assert!(filter.matches("game.move.up"));
assert!(filter.matches("game.create"));
assert!(!filter.matches("game.move"));
assert!(!filter.matches("game.created"));
assert!(!filter.matches("other"));
}
#[test]
fn test_validate_topic_rejects_comma() {
assert!(validate_topic("a,b").is_err());
assert!(validate_topic("game.move").is_ok());
}
#[test]
fn test_validate_topic_query_comma_list() {
assert!(validate_topic_query("game.move.*,game.create").is_ok());
assert!(validate_topic_query("*").is_ok());
assert!(validate_topic_query("a,").is_ok());
assert!(validate_topic_query("").is_err());
assert!(validate_topic_query(",").is_err());
assert!(validate_topic_query("a,1bad").is_err());
}
fn seed_store() -> (Store, TempDir, Vec<Frame>) {
let temp_dir = tempfile::tempdir().unwrap();
let store = Store::new(temp_dir.path().to_path_buf()).unwrap();
let frames = vec![
store.append(Frame::builder("game.create").build()).unwrap(),
store.append(Frame::builder("noise").build()).unwrap(),
store
.append(Frame::builder("game.move.up").build())
.unwrap(),
store.append(Frame::builder("other.thing").build()).unwrap(),
store
.append(Frame::builder("game.move.down").build())
.unwrap(),
store.append(Frame::builder("game.create").build()).unwrap(),
];
(store, temp_dir, frames)
}
#[test]
fn test_read_sync_multi_pattern_forward() {
let (store, _temp_dir, frames) = seed_store();
let options = ReadOptions::builder()
.topic("game.move.*,game.create".to_string())
.build();
let got: Vec<_> = store.read_sync(options).collect();
assert_eq!(
vec![
frames[0].clone(),
frames[2].clone(),
frames[4].clone(),
frames[5].clone()
],
got
);
}
#[test]
fn test_read_sync_multi_pattern_last_n() {
let (store, _temp_dir, frames) = seed_store();
let options = ReadOptions::builder()
.last(3)
.topic("game.move.*,game.create".to_string())
.build();
let got: Vec<_> = store.read_sync(options).collect();
assert_eq!(
vec![frames[2].clone(), frames[4].clone(), frames[5].clone()],
got
);
}
#[test]
fn test_read_sync_overlapping_patterns_dedupe() {
let (store, _temp_dir, frames) = seed_store();
let options = ReadOptions::builder()
.topic("game.*,game.move.up".to_string())
.build();
let got: Vec<_> = store.read_sync(options).collect();
assert_eq!(
vec![
frames[0].clone(),
frames[2].clone(),
frames[4].clone(),
frames[5].clone()
],
got
);
let options = ReadOptions::builder()
.last(4)
.topic("game.*,game.move.up".to_string())
.build();
let got: Vec<_> = store.read_sync(options).collect();
assert_eq!(
vec![
frames[0].clone(),
frames[2].clone(),
frames[4].clone(),
frames[5].clone()
],
got
);
}
#[test]
fn test_read_sync_multi_pattern_after_and_limit() {
let (store, _temp_dir, frames) = seed_store();
let options = ReadOptions::builder()
.topic("game.move.*,game.create".to_string())
.after(frames[0].id)
.limit(2)
.build();
let got: Vec<_> = store.read_sync(options).collect();
assert_eq!(vec![frames[2].clone(), frames[4].clone()], got);
}
#[tokio::test]
async fn test_read_multi_pattern_historical_and_follow() {
let (store, _temp_dir, frames) = seed_store();
let options = ReadOptions::builder()
.topic("game.move.*,game.create".to_string())
.follow(FollowOption::On)
.build();
let mut recver = store.read(options);
for want in [&frames[0], &frames[2], &frames[4], &frames[5]] {
assert_eq!(recver.recv().await.unwrap().unwrap().id, want.id);
}
assert_eq!(recver.recv().await.unwrap().unwrap().topic, "xs.threshold");
store.append(Frame::builder("noise").build()).unwrap();
let live = store
.append(Frame::builder("game.move.left").build())
.unwrap();
assert_eq!(recver.recv().await.unwrap().unwrap().id, live.id);
}
#[tokio::test]
async fn test_read_multi_pattern_rev_last_n() {
let (store, _temp_dir, frames) = seed_store();
let options = ReadOptions::builder()
.last(2)
.topic("noise,game.create".to_string())
.build();
let mut recver = store.read(options);
assert_eq!(recver.recv().await.unwrap().unwrap().id, frames[1].id);
assert_eq!(recver.recv().await.unwrap().unwrap().id, frames[5].id);
assert!(recver.recv().await.is_none());
}
}
mod tests_fsync {
use super::*;
#[test]
fn test_parse_fsync() {
assert_eq!("always".parse::<Fsync>(), Ok(Fsync::Always));
assert_eq!("never".parse::<Fsync>(), Ok(Fsync::Never));
assert_eq!(
"interval:250".parse::<Fsync>(),
Ok(Fsync::Interval(Duration::from_millis(250)))
);
assert_eq!(Fsync::default(), Fsync::Interval(Duration::from_secs(1)));
for policy in [
Fsync::Always,
Fsync::Never,
Fsync::Interval(Duration::from_millis(1000)),
] {
assert_eq!(policy.to_string().parse::<Fsync>(), Ok(policy));
}
assert_eq!(Fsync::default().to_string(), "interval:1000");
assert!("interval:0".parse::<Fsync>().is_err());
assert!("interval:abc".parse::<Fsync>().is_err());
assert!("interval:".parse::<Fsync>().is_err());
assert!("interval".parse::<Fsync>().is_err());
assert!("Always".parse::<Fsync>().is_err());
assert!("".parse::<Fsync>().is_err());
}
fn append_and_read_back(policy: Fsync) {
let folder = tempfile::tempdir().unwrap();
let store = Store::with_fsync(folder.path().to_path_buf(), policy).unwrap();
assert_eq!(store.fsync(), policy);
let a = store.append(Frame::builder("a").build()).unwrap();
let b = store.append(Frame::builder("b").build()).unwrap();
assert_eq!(store.get(&a.id), Some(a.clone()));
let ids: Vec<_> = store
.read_sync(ReadOptions::default())
.map(|f| f.id)
.collect();
assert_eq!(ids, vec![a.id, b.id]);
store.flush().unwrap();
}
#[test]
fn test_append_under_interval() {
append_and_read_back(Fsync::Interval(Duration::from_millis(50)));
}
#[test]
fn test_append_under_never() {
append_and_read_back(Fsync::Never);
}
#[test]
fn test_append_under_always() {
append_and_read_back(Fsync::Always);
}
#[test]
fn test_interval_tick_clears_dirty() {
let folder = tempfile::tempdir().unwrap();
let store = Store::with_fsync(
folder.path().to_path_buf(),
Fsync::Interval(Duration::from_millis(20)),
)
.unwrap();
store.append(Frame::builder("a").build()).unwrap();
assert!(store.fsync.dirty.load(Ordering::Acquire));
let deadline = std::time::Instant::now() + Duration::from_secs(5);
while store.fsync.dirty.load(Ordering::Acquire) {
assert!(std::time::Instant::now() < deadline, "tick never fired");
std::thread::sleep(Duration::from_millis(5));
}
}
#[test]
fn test_reopen_sees_frames_appended_under_interval() {
let folder = tempfile::tempdir().unwrap();
let path = folder.path().to_path_buf();
let store =
Store::with_fsync(path.clone(), Fsync::Interval(Duration::from_secs(60))).unwrap();
let frames: Vec<Frame> = (0..3)
.map(|_| store.append(Frame::builder("a").build()).unwrap())
.collect();
let started = std::time::Instant::now();
drop(store);
assert!(started.elapsed() < Duration::from_secs(5));
let store = Store::with_fsync(path, Fsync::Never).unwrap();
let ids: Vec<_> = store
.read_sync(ReadOptions::default())
.map(|f| f.id)
.collect();
assert_eq!(ids, frames.iter().map(|f| f.id).collect::<Vec<_>>());
}
}
mod tests_idx_topic_expiry {
use super::*;
use tempfile::TempDir;
fn store_without_tick() -> Store {
let options = StoreOptions::builder()
.ttl_sweep(Duration::from_secs(600))
.build();
Store::open(TempDir::new().unwrap().keep(), options).unwrap()
}
fn ids(store: &Store, options: ReadOptions) -> Vec<Scru128Id> {
store.read_sync(options).map(|f| f.id).collect()
}
fn assert_visible(store: &Store, expected: &[Scru128Id]) {
let shapes = [
ReadOptions::builder().topic("a.b".to_string()).build(),
ReadOptions::builder().topic("a.*".to_string()).build(),
ReadOptions::builder()
.topic("a.b".to_string())
.last(16usize)
.build(),
ReadOptions::builder()
.topic("a.*".to_string())
.last(16usize)
.build(),
ReadOptions::default(),
];
for options in shapes {
assert_eq!(ids(store, options.clone()), expected, "{options:?}");
}
}
fn append_live(store: &Store) -> Frame {
store.append(Frame::builder("a.b").build()).unwrap()
}
fn append_expiring(store: &Store) -> Frame {
store
.append(
Frame::builder("a.b")
.ttl(TTL::Time(Duration::from_millis(1)))
.build(),
)
.unwrap()
}
fn seed(store: &Store) -> Scru128Id {
let live = append_live(store);
append_expiring(store);
std::thread::sleep(Duration::from_millis(20));
live.id
}
fn strip_expiry_values(store: &Store, frame: &Frame) {
let mut batch = store.db.batch();
batch.insert(
&store.idx_topic,
idx_topic_key_from_frame(frame).unwrap(),
b"",
);
for key in idx_topic_prefix_keys(&frame.topic, &frame.id) {
batch.insert(&store.idx_topic, key, b"");
}
batch.commit().unwrap();
}
#[test]
fn test_expired_frames_stay_hidden() {
let store = store_without_tick();
let live = seed(&store);
assert_visible(&store, &[live]);
}
#[test]
fn test_reads_an_index_written_without_an_expiry() {
let store = store_without_tick();
let live = append_live(&store);
let expiring = append_expiring(&store);
strip_expiry_values(&store, &live);
strip_expiry_values(&store, &expiring);
std::thread::sleep(Duration::from_millis(20));
assert_visible(&store, &[live.id]);
let live2 = append_live(&store);
append_expiring(&store);
std::thread::sleep(Duration::from_millis(20));
assert_visible(&store, &[live.id, live2.id]);
}
#[test]
fn test_remove_clears_entries_carrying_an_expiry() {
let store = store_without_tick();
let frame = store
.append(
Frame::builder("a.b")
.ttl(TTL::Time(Duration::from_secs(600)))
.build(),
)
.unwrap();
assert_visible(&store, &[frame.id]);
store.remove(&frame.id).unwrap();
assert_visible(&store, &[]);
}
#[test]
fn test_expired_entries_skip_the_point_read() {
const EXPIRED: usize = 200;
let store = store_without_tick();
let expiring: Vec<_> = (0..EXPIRED).map(|_| append_expiring(&store)).collect();
let live = append_live(&store);
std::thread::sleep(Duration::from_millis(20));
for topic in ["a.b", "a.*"] {
let scanned = store.stats.frames_scanned.load(Ordering::Relaxed);
let reads = store.stats.stream_reads.load(Ordering::Relaxed);
let options = ReadOptions::builder().topic(topic.to_string()).build();
assert_eq!(ids(&store, options), vec![live.id]);
let scanned = store.stats.frames_scanned.load(Ordering::Relaxed) - scanned;
let reads = store.stats.stream_reads.load(Ordering::Relaxed) - reads;
assert_eq!(scanned, EXPIRED + 1, "{topic}");
assert_eq!(reads, 1, "{topic} read {reads} frames to return 1");
}
for frame in expiring.iter().chain(std::iter::once(&live)) {
strip_expiry_values(&store, frame);
}
let reads = store.stats.stream_reads.load(Ordering::Relaxed);
let options = ReadOptions::builder().topic("a.b".to_string()).build();
assert_eq!(ids(&store, options), vec![live.id]);
assert_eq!(
store.stats.stream_reads.load(Ordering::Relaxed) - reads,
EXPIRED + 1
);
}
#[test]
fn test_trim_removes_without_a_point_read() {
let store = store_without_tick();
let mut appended = Vec::new();
for _ in 0..3 {
appended.push(
store
.append(Frame::builder("a.b").ttl(TTL::Last(1000)).build())
.unwrap(),
);
appended.push(
store
.append(
Frame::builder("a.b")
.ttl(TTL::Time(Duration::from_secs(600)))
.build(),
)
.unwrap(),
);
}
assert_eq!(store.idx_expiry_len(), 3);
let overflow = store.last_overflow("a.b", 2, &HashSet::new(), 0, 100);
let trimmed: Vec<_> = overflow.iter().map(|frame| frame.id).collect();
assert_eq!(
trimmed,
appended[..4].iter().map(|f| f.id).collect::<Vec<_>>()
);
let reads = store.stats.stream_reads.load(Ordering::Relaxed);
store
.remove_many(overflow.into_iter().map(|frame| Removal::Indexed {
id: frame.id,
topic: "a.b".to_string(),
expires_at: frame.expires_at,
}))
.unwrap();
assert_eq!(
store.stats.stream_reads.load(Ordering::Relaxed) - reads,
0,
"the trim read frames it had already been handed"
);
assert_eq!(
ids(&store, ReadOptions::default()),
appended[4..].iter().map(|f| f.id).collect::<Vec<_>>()
);
assert_eq!(store.idx_expiry_len(), 1);
for frame in &appended[..4] {
assert!(store.get(&frame.id).is_none());
}
}
#[test]
fn test_trim_of_a_legacy_entry_still_removes_the_frame() {
let store = store_without_tick();
let old = store
.append(
Frame::builder("a.b")
.ttl(TTL::Time(Duration::from_secs(600)))
.build(),
)
.unwrap();
strip_expiry_values(&store, &old);
let keep = store
.append(Frame::builder("a.b").ttl(TTL::Last(1000)).build())
.unwrap();
let overflow = store.last_overflow("a.b", 1, &HashSet::new(), 0, 100);
assert_eq!(overflow.len(), 1);
assert_eq!(overflow[0].expires_at, None);
store
.remove_many(overflow.into_iter().map(|frame| Removal::Indexed {
id: frame.id,
topic: "a.b".to_string(),
expires_at: frame.expires_at,
}))
.unwrap();
assert!(store.get(&old.id).is_none());
assert_eq!(ids(&store, ReadOptions::default()), vec![keep.id]);
assert_eq!(store.idx_expiry_len(), 1);
let swept = store.expired_at(now_ms() + 1_000_000, 100);
store.remove_many(swept).unwrap();
assert_eq!(store.idx_expiry_len(), 0);
}
#[test]
fn test_seek_and_expiry_skip_compose() {
const BELOW: usize = 200;
let store = store_without_tick();
for _ in 0..BELOW {
append_live(&store);
}
let bound = append_live(&store);
let expired = append_expiring(&store);
let live = append_live(&store);
std::thread::sleep(Duration::from_millis(20));
for topic in ["a.b", "a.*"] {
let scanned = store.stats.frames_scanned.load(Ordering::Relaxed);
let reads = store.stats.stream_reads.load(Ordering::Relaxed);
let options = ReadOptions::builder()
.topic(topic.to_string())
.after(bound.id)
.build();
assert_eq!(ids(&store, options), vec![live.id]);
let scanned = store.stats.frames_scanned.load(Ordering::Relaxed) - scanned;
let reads = store.stats.stream_reads.load(Ordering::Relaxed) - reads;
assert_eq!(scanned, 2, "{topic}");
assert_eq!(reads, 1, "{topic}");
}
assert!(store.get(&expired.id).is_some());
}
}
mod tests_gc_resume {
use super::*;
use tempfile::TempDir;
use tokio::time::sleep;
fn store_at(path: std::path::PathBuf) -> Store {
let options = StoreOptions::builder()
.ttl_sweep(Duration::from_secs(600))
.build();
Store::open(path, options).unwrap()
}
fn store_without_tick() -> Store {
store_at(TempDir::new().unwrap().keep())
}
fn frame_from_the_past(topic: &str, ago: Duration) -> Frame {
let ts = now_ms() - ago.as_millis() as u64;
Frame {
id: Scru128Id::try_from_fields(ts, 0, 0, 0).unwrap(),
topic: topic.to_string(),
ttl: Some(TTL::Time(Duration::ZERO)),
..Default::default()
}
}
fn expiring(store: &Store, topic: &str) -> Frame {
store
.append(Frame::builder(topic).ttl(TTL::Time(Duration::ZERO)).build())
.unwrap()
}
fn overflow_ids(overflow: &[Overflow]) -> Vec<Scru128Id> {
overflow.iter().map(|frame| frame.id).collect()
}
fn trim_removals(topic: &str, overflow: Vec<Overflow>) -> Vec<Removal> {
overflow
.into_iter()
.map(|frame| Removal::Indexed {
id: frame.id,
topic: topic.to_string(),
expires_at: frame.expires_at,
})
.collect()
}
fn topic_ids(store: &Store, topic: &str) -> Vec<Scru128Id> {
let options = ReadOptions::builder().topic(topic.to_string()).build();
store.read_sync(options).map(|f| f.id).collect()
}
#[tokio::test]
async fn test_sweep_resumes_across_capped_batches() {
let store = store_without_tick();
let ids: Vec<Scru128Id> = (0..10).map(|_| expiring(&store, "test").id).collect();
let mut swept = Vec::new();
let mut batches = 0;
loop {
let batch = store.expired_at(now_ms(), 3);
if batch.is_empty() {
break;
}
batches += 1;
swept.extend(batch.iter().map(Removal::id));
store.remove_many(batch).unwrap();
}
assert_eq!(swept, ids, "every due frame, once, oldest first");
assert_eq!(batches, 4, "3 + 3 + 3 + 1");
assert_eq!(store.idx_expiry_len(), 0);
}
#[tokio::test]
async fn test_sweep_does_not_skip_a_frame_that_is_not_yet_due() {
let store = store_without_tick();
let later = store
.append(
Frame::builder("test")
.ttl(TTL::Time(Duration::from_millis(300)))
.build(),
)
.unwrap();
let due = expiring(&store, "test");
store.sweep();
store.wait_for_gc().await;
assert_eq!(store.get(&due.id), None);
assert_eq!(store.get(&later.id), Some(later.clone()));
sleep(Duration::from_millis(400)).await;
store.sweep();
store.wait_for_gc().await;
assert_eq!(store.get(&later.id), None, "swept once it came due");
assert_eq!(store.idx_expiry_len(), 0);
}
#[tokio::test]
async fn test_sweep_takes_a_frame_indexed_below_the_resume_point() {
let store = store_without_tick();
let first = expiring(&store, "test");
store.sweep();
store.wait_for_gc().await;
assert_eq!(store.get(&first.id), None);
let old = frame_from_the_past("test", Duration::from_secs(60));
store.insert_frame(&old).unwrap();
store.sweep();
store.wait_for_gc().await;
assert_eq!(store.get(&old.id), None, "swept from behind the sweeper");
assert_eq!(store.idx_expiry_len(), 0);
}
#[tokio::test]
async fn test_reopened_store_drains_the_rest_of_a_backlog() {
let path = TempDir::new().unwrap().keep();
let store = store_at(path.clone());
let ids: Vec<Scru128Id> = (0..10).map(|_| expiring(&store, "test").id).collect();
let batch = store.expired_at(now_ms(), 4);
assert_eq!(batch.len(), 4);
store.remove_many(batch).unwrap();
drop(store);
let store = store_at(path);
store.sweep();
store.wait_for_gc().await;
for id in &ids {
assert_eq!(store.get(id), None, "{id} outlived the reopen");
}
assert_eq!(store.idx_expiry_len(), 0);
}
#[tokio::test]
async fn test_trim_resumes_across_capped_batches() {
let store = store_without_tick();
let ids: Vec<Scru128Id> = (0..10)
.map(|_| {
store
.append(Frame::builder("test").ttl(TTL::Last(1000)).build())
.unwrap()
.id
})
.collect();
let mut trimmed = Vec::new();
let mut batches = 0;
loop {
let batch = store.last_overflow("test", 2, &HashSet::new(), 0, 3);
if batch.is_empty() {
break;
}
batches += 1;
trimmed.extend(overflow_ids(&batch));
store.remove_many(trim_removals("test", batch)).unwrap();
}
assert_eq!(trimmed, ids[..8], "everything but the newest two, once");
assert_eq!(batches, 3, "3 + 3 + 2");
assert_eq!(topic_ids(&store, "test"), ids[8..]);
}
#[tokio::test]
async fn test_trim_below_keep_does_not_scan_the_topic() {
let store = store_without_tick();
let ids: Vec<Scru128Id> = (0..3)
.map(|_| {
store
.append(Frame::builder("test").ttl(TTL::Last(1000)).build())
.unwrap()
.id
})
.collect();
store.remove(&ids[0]).unwrap();
assert!(store
.last_overflow("test", 10, &HashSet::new(), 0, 16)
.is_empty());
assert_eq!(
store.trim_floor.lock().unwrap().get("test").copied(),
None,
"a topic under its cap is never scanned, so there is no floor to set",
);
let last = store
.append(Frame::builder("test").ttl(TTL::Last(1000)).build())
.unwrap()
.id;
let overflow = store.last_overflow("test", 2, &HashSet::new(), 0, 16);
assert_eq!(overflow_ids(&overflow), vec![ids[1]]);
store.remove_many(trim_removals("test", overflow)).unwrap();
assert_eq!(topic_ids(&store, "test"), vec![ids[2], last]);
}
#[tokio::test]
async fn test_trim_over_cap_runs_again() {
let store = store_without_tick();
let total = 4096 + 5;
for _ in 0..total {
store.append(Frame::builder("test").build()).unwrap();
}
let last = store
.append(Frame::builder("test").ttl(TTL::Last(1)).build())
.unwrap();
let deadline = std::time::Instant::now() + Duration::from_secs(60);
while store.read_sync(ReadOptions::default()).count() > 1 {
assert!(std::time::Instant::now() < deadline, "trim never finished");
sleep(Duration::from_millis(10)).await;
}
store.wait_for_gc().await;
assert_eq!(topic_ids(&store, "test"), vec![last.id]);
assert_eq!(store.stats.remove_commits.load(Ordering::Relaxed), 2);
}
#[tokio::test]
async fn test_trim_takes_a_frame_indexed_below_the_floor() {
let store = store_without_tick();
for _ in 0..3 {
store
.append(Frame::builder("test").ttl(TTL::Last(1)).build())
.unwrap();
}
store.wait_for_gc().await;
assert_eq!(topic_ids(&store, "test").len(), 1);
let old = frame_from_the_past("test", Duration::from_secs(60));
store.insert_frame(&old).unwrap();
let last = store
.append(Frame::builder("test").ttl(TTL::Last(1)).build())
.unwrap();
store.wait_for_gc().await;
assert_eq!(store.get(&old.id), None, "trimmed from behind the trim");
assert_eq!(topic_ids(&store, "test"), vec![last.id]);
}
#[tokio::test]
async fn test_trim_after_a_manual_remove_inside_the_kept_window() {
let store = store_without_tick();
let ids: Vec<Scru128Id> = (0..5)
.map(|_| {
store
.append(Frame::builder("test").ttl(TTL::Last(1000)).build())
.unwrap()
.id
})
.collect();
assert_eq!(
overflow_ids(&store.last_overflow("test", 2, &HashSet::new(), 0, 16)),
ids[..3]
);
store
.remove_many(ids[..3].iter().copied().map(Removal::Id))
.unwrap();
store.remove(&ids[3]).unwrap();
assert_eq!(
overflow_ids(&store.last_overflow("test", 2, &HashSet::new(), 0, 16)),
Vec::<Scru128Id>::new(),
"one frame left on the topic, nothing to trim"
);
let more: Vec<Scru128Id> = (0..2)
.map(|_| {
store
.append(Frame::builder("test").ttl(TTL::Last(1000)).build())
.unwrap()
.id
})
.collect();
let overflow = store.last_overflow("test", 2, &HashSet::new(), 0, 16);
assert_eq!(overflow_ids(&overflow), vec![ids[4]]);
store.remove_many(trim_removals("test", overflow)).unwrap();
assert_eq!(topic_ids(&store, "test"), more);
}
#[tokio::test]
async fn test_sweeps_and_trims_interleave_over_several_drains() {
let store = store_without_tick();
let mut kept = Vec::new();
for round in 0..5 {
expiring(&store, "test");
expiring(&store, "test");
let live = store
.append(
Frame::builder("test")
.ttl(TTL::Time(Duration::from_secs(600)))
.build(),
)
.unwrap();
let trimmed = store
.append(Frame::builder("test").ttl(TTL::Last(2)).build())
.unwrap();
kept.push(live.id);
kept.push(trimmed.id);
store.sweep();
store.wait_for_gc().await;
assert_eq!(
topic_ids(&store, "test"),
kept[kept.len() - 2..],
"round {round}"
);
kept = kept[kept.len() - 2..].to_vec();
assert_eq!(store.idx_expiry_len(), 1, "round {round}: the live frame");
}
}
}
mod tests_gc_scale {
use super::*;
use std::path::PathBuf;
use std::sync::atomic::Ordering;
use std::time::Instant;
use tokio::time::sleep;
fn bench_n(var: &str, default: usize) -> usize {
std::env::var(var)
.ok()
.and_then(|v| v.parse().ok())
.unwrap_or(default)
}
fn bench_dir(name: &str) -> PathBuf {
let dir = std::env::temp_dir().join(format!("xs-bench-{name}-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
dir
}
fn bench_store(path: PathBuf) -> Store {
let options = StoreOptions::builder()
.fsync(Fsync::Never)
.ttl_sweep(Duration::from_secs(3600))
.build();
Store::open(path, options).unwrap()
}
async fn await_removals(store: &Store, want: usize, budget: Duration) -> (usize, Duration) {
let start = Instant::now();
let mut next_report = Duration::from_secs(10);
loop {
let removed = store.stats.removed_frames.load(Ordering::Relaxed);
let elapsed = start.elapsed();
if removed >= want {
return (removed, elapsed);
}
if elapsed > budget {
println!(" gave up after {:.1}s", elapsed.as_secs_f64());
return (removed, elapsed);
}
if elapsed > next_report {
println!(
" {removed}/{want} removed in {:.1}s",
elapsed.as_secs_f64()
);
next_report = elapsed + Duration::from_secs(10);
}
sleep(Duration::from_millis(20)).await;
}
}
#[tokio::test]
#[ignore = "benchmark"]
async fn bench_sweep_backlog() {
let n = bench_n("XS_BENCH_SWEEP_N", 200_000);
let path = bench_dir("sweep");
let store = bench_store(path.clone());
let start = Instant::now();
for _ in 0..n {
store
.append(
Frame::builder("bench")
.ttl(TTL::Time(Duration::ZERO))
.build(),
)
.unwrap();
}
let append = start.elapsed();
store.sweep();
let (removed, elapsed) = await_removals(&store, n, Duration::from_secs(900)).await;
println!(
"sweep-backlog frames={n} append_ms={:.0} sweep_ms={:.0} removed={removed} \
frames_per_s={:.0}",
append.as_secs_f64() * 1e3,
elapsed.as_secs_f64() * 1e3,
removed as f64 / elapsed.as_secs_f64(),
);
std::mem::forget(store);
let _ = std::fs::remove_dir_all(&path);
}
#[tokio::test]
#[ignore = "benchmark"]
async fn bench_last_trim() {
let n = bench_n("XS_BENCH_TRIM_N", 20_000);
let path = bench_dir("trim");
let store = bench_store(path.clone());
let start = Instant::now();
let mut report = Duration::from_secs(10);
for i in 0..n {
store
.append(Frame::builder("bench").ttl(TTL::Last(1)).build())
.unwrap();
store.wait_for_gc().await;
if start.elapsed() > report {
println!(
" {i}/{n} appended in {:.1}s",
start.elapsed().as_secs_f64()
);
report = start.elapsed() + Duration::from_secs(10);
}
}
let elapsed = start.elapsed();
let removed = store.stats.removed_frames.load(Ordering::Relaxed);
println!(
"last-trim frames={n} ms={:.0} removed={removed} frames_per_s={:.0} \
us_per_frame={:.1}",
elapsed.as_secs_f64() * 1e3,
removed as f64 / elapsed.as_secs_f64(),
elapsed.as_secs_f64() * 1e6 / n as f64,
);
assert_eq!(
removed,
n - 1,
"every append but the last should be trimmed"
);
std::mem::forget(store);
let _ = std::fs::remove_dir_all(&path);
}
}
#[cfg(test)]
mod tests_gc_drain_contract {
use super::*;
use tempfile::TempDir;
#[tokio::test]
async fn test_wait_for_gc_can_return_with_a_trim_still_outstanding() {
let temp_dir = TempDir::new().unwrap();
let store = Store::open(
temp_dir.path().to_path_buf(),
StoreOptions::builder().fsync(Fsync::Never).build(),
)
.unwrap();
let keep = 10u32;
let over = 6_000;
for _ in 0..(keep as usize + over) {
store
.append(
Frame::builder("drain.contract")
.ttl(TTL::Last(keep))
.build(),
)
.unwrap();
}
store.wait_for_gc().await;
let after_first = store
.read_sync(
ReadOptions::builder()
.topic("drain.contract".to_string())
.build(),
)
.count();
let mut settled = after_first;
for _ in 0..20 {
store.wait_for_gc().await;
let n = store
.read_sync(
ReadOptions::builder()
.topic("drain.contract".to_string())
.build(),
)
.count();
if n == settled && n == keep as usize {
break;
}
settled = n;
}
assert_eq!(
settled, keep as usize,
"the trim must finish across repeated drains"
);
assert!(
after_first >= settled,
"the first reply cannot have removed more than the settled state"
);
}
}
#[cfg(test)]
mod tests_gc_restart_cost {
use super::*;
use std::time::Instant;
use tempfile::TempDir;
#[tokio::test]
#[ignore = "measurement, not an assertion; run with --ignored --nocapture"]
async fn bench_restart_cost() {
let n: usize = std::env::var("XS_BENCH_RESTART_N")
.ok()
.and_then(|s| s.parse().ok())
.unwrap_or(200_000);
let dir = TempDir::new().unwrap().keep();
let store = Store::open(
dir.clone(),
StoreOptions::builder().fsync(Fsync::Never).build(),
)
.unwrap();
for i in 0..n {
let ttl = if i % 10 == 0 {
TTL::Forever
} else {
TTL::Time(Duration::from_millis(1))
};
store
.append(Frame::builder("restart.ev").ttl(ttl).build())
.unwrap();
}
let warm = Instant::now();
for _ in 0..40 {
store.sweep();
store.wait_for_gc().await;
if store.read_sync(ReadOptions::default()).count() <= n / 10 {
break;
}
}
let warm_ms = warm.elapsed().as_millis();
let live_before = store.read_sync(ReadOptions::default()).count();
let t = Instant::now();
drop(store);
let drop_ms = t.elapsed().as_millis();
let t = Instant::now();
let store = Store::open(
dir.clone(),
StoreOptions::builder().fsync(Fsync::Never).build(),
)
.unwrap();
let open_ms = t.elapsed().as_millis();
for _ in 0..1_000 {
store
.append(
Frame::builder("restart.ev")
.ttl(TTL::Time(Duration::from_millis(1)))
.build(),
)
.unwrap();
}
tokio::time::sleep(Duration::from_millis(50)).await;
let t = Instant::now();
store.sweep();
store.wait_for_gc().await;
let first_ms = t.elapsed().as_millis();
let t = Instant::now();
store.sweep();
store.wait_for_gc().await;
let second_ms = t.elapsed().as_millis();
println!(
"RESTART n={n} live={live_before} warm_drain={warm_ms}ms drop={drop_ms}ms open={open_ms}ms \
first_sweep_after_restart={first_ms}ms second_sweep={second_ms}ms"
);
std::mem::forget(store);
let _ = std::fs::remove_dir_all(&dir);
}
}
#[cfg(test)]
mod tests_last_burst_cost {
use super::*;
use std::time::Instant;
use tempfile::TempDir;
#[tokio::test]
#[ignore = "measurement; run with --ignored --nocapture"]
async fn bench_last_burst_then_drop() {
for (n, keep) in [(20_000usize, 1_000u32), (20_000, 10_000)] {
let dir = TempDir::new().unwrap().keep();
let store = Store::open(
dir.clone(),
StoreOptions::builder().fsync(Fsync::Never).build(),
)
.unwrap();
let t = Instant::now();
for _ in 0..n {
store
.append(Frame::builder("burst.ev").ttl(TTL::Last(keep)).build())
.unwrap();
}
let append_ms = t.elapsed().as_millis();
let t = Instant::now();
store.wait_for_gc().await;
let gc_ms = t.elapsed().as_millis();
let t = Instant::now();
drop(store);
println!(
"BURST n={n} keep={keep} append={append_ms}ms gc_drain={gc_ms}ms drop={}ms",
t.elapsed().as_millis()
);
let _ = std::fs::remove_dir_all(&dir);
}
}
}
mod tests_reimport_orphans {
use super::*;
use tempfile::TempDir;
fn store() -> Store {
let options = StoreOptions::builder()
.ttl_sweep(Duration::from_secs(600))
.build();
Store::open(TempDir::new().unwrap().keep(), options).unwrap()
}
fn topic_ids(store: &Store, topic: &str) -> Vec<Scru128Id> {
let options = ReadOptions::builder().topic(topic.to_string()).build();
store.read_sync(options).map(|f| f.id).collect()
}
fn none() -> Vec<Scru128Id> {
Vec::new()
}
#[test]
fn reimport_under_a_new_topic_orphans_the_old_entry() {
let store = store();
let mut frame = store.append(Frame::builder("before").build()).unwrap();
frame.topic = "after".to_string();
store.insert_frame(&frame).unwrap();
assert_eq!(topic_ids(&store, "after"), vec![frame.id]);
assert_eq!(
topic_ids(&store, "before"),
none(),
"the frame still answers to the topic it no longer has",
);
}
#[test]
fn reimport_with_a_new_ttl_orphans_the_old_expiry_entry() {
let store = store();
let mut frame = store
.append(
Frame::builder("test")
.ttl(TTL::Time(Duration::from_secs(600)))
.build(),
)
.unwrap();
assert_eq!(store.idx_expiry_len(), 1);
frame.ttl = Some(TTL::Forever);
store.insert_frame(&frame).unwrap();
assert_eq!(
store.idx_expiry_len(),
0,
"the old expiry entry outlived the ttl that made it",
);
}
#[test]
fn a_dotted_topic_takes_its_prefix_keys_with_it() {
let store = store();
let mut frame = store.append(Frame::builder("a.b").build()).unwrap();
frame.topic = "c.d".to_string();
store.insert_frame(&frame).unwrap();
assert_eq!(topic_ids(&store, "c.d"), vec![frame.id]);
assert_eq!(topic_ids(&store, "c.*"), vec![frame.id]);
assert_eq!(topic_ids(&store, "a.b"), none());
assert_eq!(
topic_ids(&store, "a.*"),
none(),
"the prefix key of the topic it left is still there",
);
}
#[test]
fn a_move_within_a_shared_prefix_keeps_the_shared_keys() {
let store = store();
let mut frame = store.append(Frame::builder("a.b.c").build()).unwrap();
frame.topic = "a.b.d".to_string();
store.insert_frame(&frame).unwrap();
assert_eq!(topic_ids(&store, "a.b.d"), vec![frame.id]);
assert_eq!(topic_ids(&store, "a.b.c"), none());
assert_eq!(
topic_ids(&store, "a.b.*"),
vec![frame.id],
"a key both topics hold was dropped with the old one",
);
assert_eq!(topic_ids(&store, "a.*"), vec![frame.id]);
}
#[test]
fn a_ttl_moving_to_forever_and_back_moves_the_expiry_entry() {
let store = store();
let mut frame = store
.append(
Frame::builder("test")
.ttl(TTL::Time(Duration::from_secs(600)))
.build(),
)
.unwrap();
assert_eq!(store.idx_expiry_len(), 1);
frame.ttl = Some(TTL::Forever);
store.insert_frame(&frame).unwrap();
assert_eq!(store.idx_expiry_len(), 0);
frame.ttl = Some(TTL::Time(Duration::from_secs(900)));
store.insert_frame(&frame).unwrap();
assert_eq!(store.idx_expiry_len(), 1);
frame.ttl = Some(TTL::Time(Duration::from_secs(1200)));
store.insert_frame(&frame).unwrap();
assert_eq!(
store.idx_expiry_len(),
1,
"one frame left two entries in the expiry index",
);
assert_eq!(topic_ids(&store, "test"), vec![frame.id]);
}
#[test]
fn a_second_move_does_not_resurrect_the_first_topic() {
let store = store();
let mut frame = store.append(Frame::builder("one").build()).unwrap();
frame.topic = "two".to_string();
store.insert_frame(&frame).unwrap();
frame.topic = "three".to_string();
store.insert_frame(&frame).unwrap();
assert_eq!(topic_ids(&store, "three"), vec![frame.id]);
assert_eq!(topic_ids(&store, "two"), none());
assert_eq!(topic_ids(&store, "one"), none());
}
#[tokio::test]
async fn a_move_between_counted_topics_moves_both_counts() {
let store = store();
let frame = store
.append(Frame::builder("src").ttl(TTL::Last(5)).build())
.unwrap();
store
.append(Frame::builder("dst").ttl(TTL::Last(5)).build())
.unwrap();
store.wait_for_gc().await;
let mut frame = frame;
frame.topic = "dst".to_string();
store.insert_frame(&frame).unwrap();
assert_eq!(store.count_of("src"), Some(0));
assert_eq!(store.count_of("dst"), Some(2));
store.assert_count_matches_index("src");
store.assert_count_matches_index("dst");
}
#[tokio::test]
async fn a_move_that_overfills_the_new_topic_trims_on_the_same_write() {
let store = store();
let full: Vec<Frame> = (0..3)
.map(|_| {
store
.append(Frame::builder("dst").ttl(TTL::Last(3)).build())
.unwrap()
})
.collect();
let mut frame = store
.append(Frame::builder("src").ttl(TTL::Last(3)).build())
.unwrap();
store.wait_for_gc().await;
frame.topic = "dst".to_string();
store.insert_frame(&frame).unwrap();
assert_eq!(
topic_ids(&store, "dst"),
vec![full[1].id, full[2].id, frame.id],
"the oldest frame on the topic it arrived at was not trimmed",
);
assert_eq!(store.count_of("dst"), Some(3));
store.assert_count_matches_index("dst");
store.assert_count_matches_index("src");
}
}
mod tests_last_count {
use super::*;
use tempfile::TempDir;
use tokio::time::sleep;
fn store_at(path: std::path::PathBuf) -> Store {
let options = StoreOptions::builder()
.ttl_sweep(Duration::from_secs(600))
.build();
Store::open(path, options).unwrap()
}
fn store_without_tick() -> Store {
store_at(TempDir::new().unwrap().keep())
}
fn last(store: &Store, topic: &str, keep: u32) -> Frame {
store
.append(Frame::builder(topic).ttl(TTL::Last(keep)).build())
.unwrap()
}
fn topic_len(store: &Store, topic: &str) -> usize {
let options = ReadOptions::builder().topic(topic.to_string()).build();
store.read_sync(options).count()
}
fn assert_count_is_honest(store: &Store, topic: &str) {
store.assert_count_matches_index(topic);
}
#[tokio::test]
async fn a_settled_topic_reads_one_index_entry_per_append() {
const KEEP: u32 = 500;
let store = store_without_tick();
for _ in 0..KEEP {
last(&store, "test", KEEP);
}
store.wait_for_gc().await;
let before = store.stats.trim_scanned.load(Ordering::Relaxed);
for _ in 0..100 {
last(&store, "test", KEEP);
}
store.wait_for_gc().await;
let scanned = store.stats.trim_scanned.load(Ordering::Relaxed) - before;
assert_eq!(scanned, 100, "one entry per append, not {KEEP} of them");
assert_eq!(topic_len(&store, "test"), KEEP as usize);
assert_count_is_honest(&store, "test");
}
#[tokio::test]
async fn a_settled_topic_is_never_over_its_cap() {
let store = store_without_tick();
for i in 0..50 {
last(&store, "test", 10);
let held = topic_len(&store, "test");
assert!(held <= 10, "held {held} after append {i}");
}
assert_eq!(topic_len(&store, "test"), 10);
assert_count_is_honest(&store, "test");
}
#[tokio::test]
async fn the_count_survives_a_restart() {
let dir = TempDir::new().unwrap().keep();
let store = store_at(dir.clone());
for _ in 0..10 {
last(&store, "test", 4);
}
store.wait_for_gc().await;
store.flush().unwrap();
drop(store);
let store = store_at(dir);
assert_eq!(store.count_of("test"), Some(4), "count came back wrong");
let before = store.stats.trim_scanned.load(Ordering::Relaxed);
last(&store, "test", 4);
store.wait_for_gc().await;
assert_eq!(
store.stats.trim_scanned.load(Ordering::Relaxed) - before,
1,
"a reopened store re-derived the count instead of reading it",
);
assert_eq!(topic_len(&store, "test"), 4);
assert_count_is_honest(&store, "test");
}
#[tokio::test]
async fn a_topic_already_at_its_cap_still_writes_its_count() {
let dir = TempDir::new().unwrap().keep();
let store = store_at(dir.clone());
for _ in 0..4 {
store.append(Frame::builder("test").build()).unwrap();
}
last(&store, "test", 4);
store.wait_for_gc().await;
assert_eq!(topic_len(&store, "test"), 4);
assert!(
store.meta.get(count_key("test")).unwrap().is_some(),
"the topic is counted but nothing was written down",
);
store.flush().unwrap();
drop(store);
let store = store_at(dir);
assert_eq!(
store.count_of("test"),
Some(4),
"the count did not come back"
);
let before = store.stats.trim_scanned.load(Ordering::Relaxed);
last(&store, "test", 4);
store.wait_for_gc().await;
assert_eq!(
store.stats.trim_scanned.load(Ordering::Relaxed) - before,
1,
"the reopened store scanned the topic instead of reading its count",
);
assert_count_is_honest(&store, "test");
}
#[tokio::test]
async fn a_last_n_append_collapses_whatever_accumulated() {
let store = store_without_tick();
last(&store, "test", 3);
for _ in 0..20 {
store.append(Frame::builder("test").build()).unwrap();
}
store.wait_for_gc().await;
assert_eq!(
topic_len(&store, "test"),
21,
"frames with no ttl trimmed something",
);
last(&store, "test", 3);
store.wait_for_gc().await;
assert_eq!(topic_len(&store, "test"), 3, "the trim did not collapse it");
for _ in 0..5 {
store.append(Frame::builder("test").build()).unwrap();
}
store.wait_for_gc().await;
assert_eq!(topic_len(&store, "test"), 8);
assert_count_is_honest(&store, "test");
}
#[tokio::test]
async fn a_trim_sharing_a_drain_with_a_sweep_accounts_for_it_once() {
let store = store_without_tick();
let ids: Vec<Scru128Id> = (0..15).map(|_| last(&store, "test", 1000).id).collect();
store.wait_for_gc().await;
assert_eq!(store.count_of("test"), Some(15));
let sweeping: HashSet<Scru128Id> = ids[..3].iter().copied().collect();
let overflow = store.last_overflow("test", 10, &sweeping, 3, 16);
assert_eq!(
overflow.len(),
2,
"asked for the wrong number: 15 held, 3 being swept, 10 to keep",
);
for frame in &overflow {
assert!(
!sweeping.contains(&frame.id),
"returned {} which the drain is already removing",
frame.id,
);
}
assert_eq!(
overflow.iter().map(|f| f.id).collect::<Vec<_>>(),
ids[3..5].to_vec(),
"took the wrong frames",
);
}
#[tokio::test]
async fn a_removal_of_a_frame_that_is_already_gone_does_not_count() {
let store = store_without_tick();
let ids: Vec<Scru128Id> = (0..5).map(|_| last(&store, "test", 1000).id).collect();
store.wait_for_gc().await;
assert_eq!(store.count_of("test"), Some(5));
store.remove(&ids[0]).unwrap();
assert_eq!(store.count_of("test"), Some(4));
store
.remove_many([Removal::Indexed {
id: ids[0],
topic: "test".to_string(),
expires_at: None,
}])
.unwrap();
assert_eq!(
store.count_of("test"),
Some(4),
"counted a frame that was already gone",
);
assert_count_is_honest(&store, "test");
}
#[tokio::test]
async fn a_manual_remove_lets_the_topic_refill() {
let store = store_without_tick();
let mut ids = Vec::new();
for _ in 0..5 {
ids.push(last(&store, "test", 5).id);
}
store.wait_for_gc().await;
assert_eq!(store.count_of("test"), Some(5));
store.remove(&ids[2]).unwrap();
assert_eq!(store.count_of("test"), Some(4), "remove did not decrement");
last(&store, "test", 5);
store.wait_for_gc().await;
assert_eq!(topic_len(&store, "test"), 5, "the topic never refilled");
assert_count_is_honest(&store, "test");
}
#[tokio::test]
async fn the_sweeper_taking_a_frame_off_a_last_topic_decrements() {
let store = store_without_tick();
last(&store, "test", 4);
store
.append(
Frame::builder("test")
.ttl(TTL::Time(Duration::from_millis(1)))
.build(),
)
.unwrap();
last(&store, "test", 4);
store.wait_for_gc().await;
assert_eq!(store.count_of("test"), Some(3));
sleep(Duration::from_millis(20)).await;
store.sweep();
store.wait_for_gc().await;
assert_eq!(
store.count_of("test"),
Some(2),
"the sweep did not move the count",
);
assert_count_is_honest(&store, "test");
}
#[tokio::test]
async fn a_replayed_restore_does_not_double_count() {
let store = store_without_tick();
let frames: Vec<Frame> = (0..3).map(|_| last(&store, "test", 3)).collect();
store.wait_for_gc().await;
assert_eq!(store.count_of("test"), Some(3));
for frame in &frames {
store.insert_frame(frame).unwrap();
}
assert_eq!(
store.count_of("test"),
Some(3),
"a replayed restore counted frames that were already there",
);
assert_eq!(topic_len(&store, "test"), 3);
assert_count_is_honest(&store, "test");
}
#[tokio::test]
async fn a_late_last_n_counts_what_is_already_there() {
let store = store_without_tick();
for _ in 0..20 {
store.append(Frame::builder("test").build()).unwrap();
}
assert_eq!(
store.count_of("test"),
None,
"counted before it was asked to"
);
last(&store, "test", 5);
assert_eq!(store.count_of("test"), Some(20));
store.wait_for_gc().await;
assert_eq!(topic_len(&store, "test"), 5, "the backlog never came down");
assert_count_is_honest(&store, "test");
}
#[tokio::test]
async fn a_dropped_n_catches_up() {
let store = store_without_tick();
for _ in 0..200 {
last(&store, "test", 200);
}
store.wait_for_gc().await;
assert_eq!(topic_len(&store, "test"), 200);
last(&store, "test", 3);
store.wait_for_gc().await;
assert_eq!(topic_len(&store, "test"), 3, "the drop never caught up");
assert_count_is_honest(&store, "test");
}
#[tokio::test]
async fn the_count_stays_honest_under_a_mixed_workload() {
let store = store_without_tick();
let mut ids = vec![last(&store, "test", 12).id];
for i in 0..60 {
match i % 4 {
0 => {
store
.append(
Frame::builder("test")
.ttl(TTL::Time(Duration::from_millis(1)))
.build(),
)
.unwrap();
}
1 if !ids.is_empty() => {
let id: Scru128Id = ids.remove(0);
store.remove(&id).unwrap();
}
_ => ids.push(last(&store, "test", 12).id),
}
assert_count_is_honest(&store, "test");
}
sleep(Duration::from_millis(20)).await;
store.sweep();
store.wait_for_gc().await;
assert_count_is_honest(&store, "test");
assert!(topic_len(&store, "test") <= 12);
}
#[tokio::test]
async fn concurrent_writers_land_on_exactly_the_cap() {
let store = store_without_tick();
let mut handles = Vec::new();
for _ in 0..4 {
let store = store.clone();
handles.push(std::thread::spawn(move || {
for _ in 0..100 {
store
.append(Frame::builder("test").ttl(TTL::Last(25)).build())
.unwrap();
}
}));
}
for handle in handles {
handle.join().unwrap();
}
store.wait_for_gc().await;
assert_eq!(
topic_len(&store, "test"),
25,
"400 appends did not settle on 25"
);
assert_count_is_honest(&store, "test");
}
#[tokio::test]
async fn a_store_from_before_counts_opens_and_counts_on_first_use() {
let dir = tempfile::TempDir::new().unwrap().keep();
{
let store = Store::open(dir.clone(), StoreOptions::default()).unwrap();
for _ in 0..6 {
store.append(Frame::builder("old").build()).unwrap();
}
}
{
let db = fjall::Database::builder(dir.join("fjall"))
.worker_threads(2)
.open()
.unwrap();
let meta = db
.keyspace("meta", fjall::KeyspaceCreateOptions::default)
.unwrap();
db.delete_keyspace(meta).unwrap();
}
let store = Store::open(dir, StoreOptions::default()).unwrap();
assert_eq!(topic_len(&store, "old"), 6);
last(&store, "old", 3);
store.wait_for_gc().await;
assert_eq!(topic_len(&store, "old"), 3);
assert_count_is_honest(&store, "old");
}
#[tokio::test]
async fn a_batch_of_last_frames_on_one_topic_settles_at_its_cap() {
let store = store_without_tick();
last(&store, "b", 1);
store
.append_many(vec![
Frame::builder("b").ttl(TTL::Last(1)).build(),
Frame::builder("b").ttl(TTL::Last(1)).build(),
Frame::builder("b").ttl(TTL::Last(1)).build(),
])
.unwrap();
store.wait_for_gc().await;
assert_eq!(topic_len(&store, "b"), 1);
assert_count_is_honest(&store, "b");
}
#[tokio::test]
async fn a_batch_that_starts_counting_a_topic_counts_its_earlier_frames() {
let store = store_without_tick();
store.append(Frame::builder("c").build()).unwrap();
store
.append_many(vec![
Frame::builder("c").build(),
Frame::builder("c").ttl(TTL::Last(10)).build(),
])
.unwrap();
store.wait_for_gc().await;
assert_eq!(topic_len(&store, "c"), 3);
assert_count_is_honest(&store, "c");
}
}
mod tests_append_many {
use super::*;
use tempfile::TempDir;
use tokio::sync::mpsc::Receiver;
async fn follow(store: &Store) -> Receiver<crate::store::ReadItem> {
let mut rx = store.read(ReadOptions::builder().follow(FollowOption::On).build());
assert_eq!(rx.recv().await.unwrap().unwrap().topic, "xs.threshold");
rx
}
async fn assert_no_broadcast(rx: &mut Receiver<crate::store::ReadItem>) {
if let Ok(frame) = tokio::time::timeout(Duration::from_millis(50), rx.recv()).await {
panic!("unexpected broadcast: {frame:?}");
}
}
#[tokio::test]
async fn test_append_many_writes_and_broadcasts_in_order() {
let temp_dir = TempDir::new().unwrap();
let store = Store::new(temp_dir.keep()).unwrap();
let mut rx = follow(&store).await;
let frames = store
.append_many(vec![
Frame::builder("batch.a").build(),
Frame::builder("batch.b").ttl(TTL::Last(5)).build(),
Frame::builder("batch.a").build(),
])
.unwrap();
assert_eq!(frames.len(), 3);
assert!(frames.windows(2).all(|w| w[0].id < w[1].id));
for frame in &frames {
assert_eq!(rx.recv().await.unwrap().unwrap(), *frame);
assert_eq!(store.get(&frame.id), Some(frame.clone()));
}
assert_no_broadcast(&mut rx).await;
let stored: Vec<Frame> = store.read_sync(ReadOptions::default()).collect();
assert_eq!(stored, frames);
let by_topic: Vec<Frame> = store
.read_sync(ReadOptions::builder().topic("batch.a".to_string()).build())
.collect();
assert_eq!(by_topic, vec![frames[0].clone(), frames[2].clone()]);
}
#[tokio::test]
async fn test_append_many_invalid_frame_writes_nothing() {
let temp_dir = TempDir::new().unwrap();
let store = Store::new(temp_dir.keep()).unwrap();
let mut rx = follow(&store).await;
let result = store.append_many(vec![
Frame::builder("batch.ok").build(),
Frame::builder("batch\0bad").build(),
Frame::builder("batch.ok").build(),
]);
assert!(result.is_err());
assert_eq!(store.read_sync(ReadOptions::default()).count(), 0);
assert_no_broadcast(&mut rx).await;
}
#[tokio::test]
async fn test_append_many_invalid_ephemeral_frame_writes_nothing() {
let temp_dir = TempDir::new().unwrap();
let store = Store::new(temp_dir.keep()).unwrap();
let mut rx = follow(&store).await;
let result = store.append_many(vec![
Frame::builder("batch.ok").build(),
Frame::builder("batch\0bad").ttl(TTL::Ephemeral).build(),
]);
assert!(result.is_err());
assert_eq!(store.read_sync(ReadOptions::default()).count(), 0);
assert_no_broadcast(&mut rx).await;
}
#[tokio::test]
async fn test_append_many_ephemeral_broadcast_not_stored() {
let temp_dir = TempDir::new().unwrap();
let store = Store::new(temp_dir.keep()).unwrap();
let mut rx = follow(&store).await;
let frames = store
.append_many(vec![
Frame::builder("batch.kept").build(),
Frame::builder("batch.live").ttl(TTL::Ephemeral).build(),
Frame::builder("batch.kept").build(),
])
.unwrap();
for frame in &frames {
assert_eq!(rx.recv().await.unwrap().unwrap(), *frame);
}
assert_no_broadcast(&mut rx).await;
let stored: Vec<Frame> = store.read_sync(ReadOptions::default()).collect();
assert_eq!(stored, vec![frames[0].clone(), frames[2].clone()]);
assert_eq!(store.get(&frames[1].id), None);
}
#[tokio::test]
async fn test_append_many_all_ephemeral() {
let temp_dir = TempDir::new().unwrap();
let store = Store::new(temp_dir.keep()).unwrap();
let mut rx = follow(&store).await;
let frames = store
.append_many(vec![
Frame::builder("batch.live").ttl(TTL::Ephemeral).build(),
Frame::builder("batch.live").ttl(TTL::Ephemeral).build(),
])
.unwrap();
for frame in &frames {
assert_eq!(rx.recv().await.unwrap().unwrap(), *frame);
}
assert_eq!(store.read_sync(ReadOptions::default()).count(), 0);
}
}
#[cfg(test)]
mod tests_cas_gc {
use super::*;
use tempfile::TempDir;
fn age(store: &Store, hash: &ssri::Integrity, by: Duration) {
let (algorithm, hex) = hash.to_hex();
let path = store
.path
.join("cacache")
.join("content-v2")
.join(algorithm.to_string())
.join(&hex[0..2])
.join(&hex[2..4])
.join(&hex[4..]);
let when = std::time::SystemTime::now() - by;
std::fs::File::options()
.write(true)
.open(path)
.unwrap()
.set_modified(when)
.unwrap();
}
fn exists(store: &Store, hash: &ssri::Integrity) -> bool {
store.cas_reader_sync(hash.clone()).is_ok()
}
#[tokio::test]
async fn test_cas_gc_deletes_only_unused_old_content() {
let temp_dir = TempDir::new().unwrap();
let store = Store::new(temp_dir.path().to_path_buf()).unwrap();
let hour = Duration::from_secs(3600);
let trimmed = store.cas_insert_sync("first screen").unwrap();
let kept = store.cas_insert_sync("second screen").unwrap();
let ephemeral = store.cas_insert_sync("a keystroke").unwrap();
let orphan = store.cas_insert_sync("uploaded, never used").unwrap();
for hash in [&trimmed, &kept] {
store
.append(
Frame::builder("screen")
.hash(hash.clone())
.ttl(TTL::Last(1))
.build(),
)
.unwrap();
}
store
.append(
Frame::builder("send")
.hash(ephemeral.clone())
.ttl(TTL::Ephemeral)
.build(),
)
.unwrap();
store.wait_for_gc().await;
let report = store.cas_gc(hour).unwrap();
assert_eq!(
report,
CasGcReport {
in_use: 1,
recent: 3,
deleted: 0,
bytes_freed: 0
}
);
for hash in [&trimmed, &kept, &ephemeral, &orphan] {
age(&store, hash, 2 * hour);
}
let report = store.cas_gc(hour).unwrap();
assert_eq!(report.in_use, 1);
assert_eq!(report.deleted, 3);
assert_eq!(
report.bytes_freed,
("first screen".len() + "a keystroke".len() + "uploaded, never used".len()) as u64
);
assert!(exists(&store, &kept));
for hash in [&trimmed, &ephemeral, &orphan] {
assert!(!exists(&store, hash));
}
}
#[test]
fn test_cas_gc_keeps_content_another_frame_shares() {
let temp_dir = TempDir::new().unwrap();
let store = Store::new(temp_dir.path().to_path_buf()).unwrap();
let hash = store.cas_insert_sync("shared").unwrap();
let a = store
.append(Frame::builder("a").hash(hash.clone()).build())
.unwrap();
store
.append(Frame::builder("b").hash(hash.clone()).build())
.unwrap();
store.remove(&a.id).unwrap();
age(&store, &hash, Duration::from_secs(7200));
let report = store.cas_gc(Duration::from_secs(3600)).unwrap();
assert_eq!(report.in_use, 1);
assert_eq!(report.deleted, 0);
assert!(exists(&store, &hash));
}
#[test]
fn test_cas_rewrite_restarts_the_grace() {
let temp_dir = TempDir::new().unwrap();
let store = Store::new(temp_dir.path().to_path_buf()).unwrap();
let hash = store.cas_insert_sync("again").unwrap();
age(&store, &hash, Duration::from_secs(7200));
assert_eq!(store.cas_insert_sync("again").unwrap(), hash);
let report = store.cas_gc(Duration::from_secs(3600)).unwrap();
assert_eq!(report.recent, 1);
assert_eq!(report.deleted, 0);
}
#[test]
fn test_cas_gc_on_an_empty_store() {
let temp_dir = TempDir::new().unwrap();
let store = Store::new(temp_dir.path().to_path_buf()).unwrap();
assert_eq!(
store.cas_gc(Duration::ZERO).unwrap(),
CasGcReport::default()
);
}
}