use core::time::Duration;
use std::collections::HashSet;
use super::super::{Ack, AsyncChanges, Lifecycle, Positions, Rings, Rung, Wake, doorbell};
#[test]
fn a_doorbell_coalesces_and_a_sweep_stands_in_for_a_ring_that_never_came() {
let (hint, bell) = doorbell();
for _ in 0..1_000 {
assert!(hint.ring());
}
assert_eq!(bell.wait(Duration::from_millis(10)), Rung::Rung);
assert_eq!(bell.wait(Duration::from_millis(10)), Rung::Swept);
assert_eq!(bell.take(), Rung::Swept);
}
#[test]
fn a_doorbell_with_no_writers_left_goes_silent() {
let (hint, bell) = doorbell();
drop(hint);
assert_eq!(bell.wait(Duration::from_millis(10)), Rung::Silent);
assert_eq!(bell.take(), Rung::Silent);
}
#[test]
fn ringing_a_doorbell_nobody_listens_to_reports_that() {
let (hint, bell) = doorbell();
drop(bell);
assert!(!Rings::ring(&hint));
}
#[tokio::test]
async fn the_async_wait_takes_a_ring_and_ends_on_silence() {
let (hint, bell) = doorbell();
assert!(hint.ring());
assert_eq!(bell.rung().await, Rung::Rung);
drop(hint);
assert_eq!(bell.rung().await, Rung::Silent);
}
mod corpus {
use super::super::super::{AsyncChanges, Doorbell, Item, Page};
pub(super) struct Rows {
pub(super) rows: Vec<(i64, &'static str)>,
pub(super) doorbell: Doorbell,
pub(super) pulls: usize,
}
pub(super) struct InMemory;
impl AsyncChanges<InMemory> for Rows {
type Error = core::convert::Infallible;
type Item = &'static str;
type Key = i64;
type Message = ();
fn doorbell(&self) -> &Doorbell {
&self.doorbell
}
async fn pull(
&mut self,
after: Option<&i64>,
limit: usize,
) -> Result<Page<&'static str, i64>, Self::Error> {
self.pulls += 1;
Ok(
self
.rows
.iter()
.filter(|(key, _)| after.is_none_or(|after| key > after))
.take(limit)
.map(|&(key, row)| Item::new(key, row))
.collect(),
)
}
}
}
use corpus::{InMemory, Rows};
use super::super::{ChangeIntake, Item, ItemId, Payload, RecordedPositions, Track, channel};
fn feed(rows: &[(i64, &'static str)]) -> (super::super::Hint, Rows) {
let (hint, bell) = doorbell();
(
hint,
Rows {
rows: rows.to_vec(),
doorbell: bell,
pulls: 0,
},
)
}
fn take_and_release(inbox: &super::super::Inbox<ItemId, &'static str>) -> Vec<&'static str> {
let mut seen = Vec::new();
for wake in inbox.drain() {
let Wake::Delivered(delivery) = wake else {
continue;
};
let (payload, ack) = delivery.into_parts();
let ack = ack.expect("a delivery off the wire carries its custody token");
let released: HashSet<ItemId> = payload.keys().copied().collect();
for item in payload {
seen.push(*item.value());
}
ack.send(Ack::new(released, "consumer", Lifecycle::Persisted(())));
}
seen
}
#[tokio::test]
async fn a_backlog_is_drained_with_no_replay_path_of_its_own() {
let (_hint, rows) = feed(&[(1, "a"), (2, "b"), (3, "c")]);
let (out, inbox) = channel(8);
let mut intake = ChangeIntake::<InMemory, _, _>::new(
Track::new("keyframes", "scene"),
rows,
RecordedPositions::new(),
out,
)
.with_page(2);
let report = intake.drain().await.expect("the walk");
assert_eq!(report.pulled(), 3);
assert_eq!(report.delivered(), 2, "a page of two, then the remainder");
assert_eq!(take_and_release(&inbox), ["a", "b", "c"]);
}
#[tokio::test]
async fn the_position_advances_only_after_the_consumer_answers() {
let (_hint, rows) = feed(&[(1, "a"), (2, "b")]);
let (out, inbox) = channel(8);
let mut intake = ChangeIntake::<InMemory, _, _>::new(
Track::new("keyframes", "scene"),
rows,
RecordedPositions::new(),
out,
);
let report = intake.drain().await.expect("the walk");
assert_eq!(report.pulled(), 2);
assert!(!report.advanced());
assert_eq!(intake.position(), None, "sent is not settled");
assert_eq!(take_and_release(&inbox), ["a", "b"]);
let report = intake.drain().await.expect("the second pass");
assert!(report.advanced());
assert_eq!(intake.position(), Some(&2));
}
#[tokio::test]
async fn a_partial_answer_stops_the_position_at_the_gap() {
let (_hint, rows) = feed(&[(1, "a"), (2, "b"), (3, "c")]);
let (out, inbox) = channel(8);
let mut intake = ChangeIntake::<InMemory, _, _>::new(
Track::new("keyframes", "scene"),
rows,
RecordedPositions::new(),
out,
);
intake.drain().await.expect("the walk");
for wake in inbox.drain() {
let Wake::Delivered(delivery) = wake else {
continue;
};
let (payload, ack) = delivery.into_parts();
let ack = ack.expect("a delivery off the wire carries its custody token");
let keys: Vec<ItemId> = payload.keys().copied().collect();
ack.send(Ack::new(
[keys[0], keys[2]].into_iter().collect(),
"consumer",
Lifecycle::Persisted(()),
));
}
intake.drain().await.expect("the second pass");
assert_eq!(intake.position(), Some(&1));
}
#[tokio::test]
async fn a_dropped_answer_rewinds_the_read_head_and_the_rows_come_back() {
let (_hint, rows) = feed(&[(1, "a"), (2, "b"), (3, "c")]);
let (out, inbox) = channel(8);
let mut intake = ChangeIntake::<InMemory, _, _>::new(
Track::new("keyframes", "scene"),
rows,
RecordedPositions::new(),
out,
);
intake.drain().await.expect("the walk");
let mut dropped = 0usize;
for wake in inbox.drain() {
if let Wake::Delivered(delivery) = wake {
let (payload, ack) = delivery.into_parts();
let ack = ack.expect("a delivery off the wire carries its custody token");
dropped += payload.len();
drop(ack);
}
}
assert_eq!(dropped, 3);
let report = intake.drain().await.expect("the sweep");
assert_eq!(report.retracted(), 3, "the whole tail came back");
assert_eq!(report.pulled(), 3, "and was re-read from the position");
assert_eq!(intake.position(), None);
assert_eq!(take_and_release(&inbox), ["a", "b", "c"]);
}
#[tokio::test]
async fn a_position_read_at_start_up_resumes_past_it() {
let mut positions = RecordedPositions::new();
let track = Track::new("keyframes", "scene");
positions
.advance_async(&track, 2i64, &[])
.await
.expect("in memory");
let (_hint, rows) = feed(&[(1, "a"), (2, "b"), (3, "c")]);
let (out, inbox) = channel(8);
let mut intake = ChangeIntake::<InMemory, _, _>::new(track, rows, positions, out);
intake.drain().await.expect("the walk");
assert_eq!(
take_and_release(&inbox),
["c"],
"the first two are behind it"
);
}
#[tokio::test]
async fn an_intake_stops_when_the_consumer_is_gone() {
let (_hint, rows) = feed(&[(1, "a")]);
let (out, inbox) = channel::<ItemId, &'static str>(1);
drop(inbox);
let mut intake = ChangeIntake::<InMemory, _, _>::new(
Track::new("keyframes", "scene"),
rows,
RecordedPositions::new(),
out,
);
assert!(
intake
.drain()
.await
.expect_err("nowhere to send")
.is_disconnected()
);
}
#[tokio::test]
async fn a_change_intake_is_one_more_producer_on_a_shared_inbox() {
let (_hint, rows) = feed(&[(1, "a")]);
let (out, inbox) = channel(8);
let channel_side = out.clone();
let mut intake = ChangeIntake::<InMemory, _, _>::new(
Track::new("keyframes", "scene"),
rows,
RecordedPositions::new(),
out,
);
intake.drain().await.expect("the walk");
let (ack, _answers) = super::super::ack_channel();
channel_side
.deliver(super::super::Delivery::new(
Payload::One(Item::new(ItemId::new(999), "direct")),
ack,
))
.expect("the inbox is open");
let mut seen = Vec::new();
for wake in inbox.drain() {
if let Wake::Delivered(delivery) = wake {
for item in delivery.into_parts().0 {
seen.push(*item.value());
}
}
}
assert_eq!(seen, ["a", "direct"]);
}
#[cfg(feature = "sqlite")]
mod floor {
use std::collections::HashSet;
use sqlx::Connection as _;
use super::super::super::{
Ack, AsyncChanges, ChangeIntake, ItemId, Lifecycle, RecordedPositions, SqliteFeed,
SqliteFeedError, Track, Wake, channel, doorbell,
};
#[derive(Debug, PartialEq, Eq)]
struct Scene {
id: i64,
title: String,
}
impl<'r> sqlx::FromRow<'r, sqlx::sqlite::SqliteRow> for Scene {
fn from_row(row: &'r sqlx::sqlite::SqliteRow) -> sqlx::Result<Self> {
use sqlx::Row as _;
Ok(Self {
id: row.try_get("id")?,
title: row.try_get("title")?,
})
}
}
async fn corpus(rows: &[(i64, &str)]) -> sqlx::sqlite::SqliteConnection {
let mut db = sqlx::sqlite::SqliteConnection::connect("sqlite::memory:")
.await
.expect("an in-memory database");
sqlx::query("CREATE TABLE scene (id INTEGER PRIMARY KEY, title TEXT NOT NULL)")
.execute(&mut db)
.await
.expect("the table");
for (id, title) in rows {
sqlx::query("INSERT INTO scene (id, title) VALUES (?, ?)")
.bind(id)
.bind(title)
.execute(&mut db)
.await
.expect("the row");
}
db
}
#[tokio::test]
async fn the_pull_is_ordered_bounded_and_strictly_past_the_cursor() {
let db = corpus(&[(1, "one"), (2, "two"), (3, "three"), (4, "four")]).await;
let (_hint, bell) = doorbell();
let mut feed: SqliteFeed<Scene> = SqliteFeed::new(db, "scene", "id", bell).expect("the feed");
let page = AsyncChanges::<sqlx::Sqlite>::pull(&mut feed, None, 2)
.await
.expect("the first page");
assert_eq!(
page.items().iter().map(|i| *i.key()).collect::<Vec<_>>(),
[1, 2]
);
assert_eq!(page.items()[0].value().title, "one");
assert_eq!(page.items()[0].value().id, 1);
let page = AsyncChanges::<sqlx::Sqlite>::pull(&mut feed, Some(&2), 10)
.await
.expect("the next page");
assert_eq!(
page.items().iter().map(|i| *i.key()).collect::<Vec<_>>(),
[3, 4]
);
let page = AsyncChanges::<sqlx::Sqlite>::pull(&mut feed, Some(&4), 10)
.await
.expect("the end");
assert!(page.is_empty());
}
#[tokio::test]
async fn a_table_or_column_name_that_is_not_an_identifier_is_refused_at_construction() {
let db = corpus(&[]).await;
let (_hint, bell) = doorbell();
let refused = SqliteFeed::<Scene>::new(db, "scene; DROP TABLE scene", "id", bell)
.expect_err("not an identifier");
assert!(matches!(refused, SqliteFeedError::Identifier(_)));
assert!(refused.to_string().contains("bare identifier"));
let db = corpus(&[]).await;
let (_hint, bell) = doorbell();
assert!(SqliteFeed::<Scene>::new(db, "scene", "id\"", bell).is_err());
}
#[tokio::test]
async fn the_floor_drives_a_real_table_from_the_backlog_to_the_position() {
let db = corpus(&[(1, "one"), (2, "two"), (3, "three")]).await;
let (_hint, bell) = doorbell();
let feed: SqliteFeed<Scene> = SqliteFeed::new(db, "scene", "id", bell).expect("the feed");
let (out, inbox) = channel(8);
let mut intake = ChangeIntake::<sqlx::Sqlite, _, _>::new(
Track::new("keyframes", "scene"),
feed,
RecordedPositions::new(),
out,
)
.with_page(2);
let report = intake.drain().await.expect("the walk");
assert_eq!(report.pulled(), 3);
assert_eq!(intake.position(), None, "nothing answered yet");
let mut titles = Vec::new();
for wake in inbox.drain() {
let Wake::Delivered(delivery) = wake else {
continue;
};
let (payload, ack) = delivery.into_parts();
let ack = ack.expect("a delivery off the wire carries its custody token");
let released: HashSet<ItemId> = payload.keys().copied().collect();
for item in payload {
titles.push(item.into_parts().1.title);
}
ack.send(Ack::new(released, "consumer", Lifecycle::Persisted(())));
}
assert_eq!(titles, ["one", "two", "three"]);
intake.drain().await.expect("the second pass");
assert_eq!(intake.position(), Some(&3));
}
#[tokio::test]
async fn rows_written_after_the_walk_arrive_on_the_next_look() {
let db = corpus(&[(1, "one")]).await;
let (_hint, bell) = doorbell();
let feed: SqliteFeed<Scene> = SqliteFeed::new(db, "scene", "id", bell).expect("the feed");
let (out, inbox) = channel(8);
let mut intake = ChangeIntake::<sqlx::Sqlite, _, _>::new(
Track::new("keyframes", "scene"),
feed,
RecordedPositions::new(),
out,
);
intake.drain().await.expect("the walk");
for wake in inbox.drain() {
if let Wake::Delivered(delivery) = wake {
let (payload, ack) = delivery.into_parts();
let ack = ack.expect("a delivery off the wire carries its custody token");
let released: HashSet<ItemId> = payload.keys().copied().collect();
ack.send(Ack::new(released, "consumer", Lifecycle::Persisted(())));
}
}
intake.drain().await.expect("settle");
assert_eq!(intake.position(), Some(&1));
let mut feed = intake.into_feed();
{
let page = AsyncChanges::<sqlx::Sqlite>::pull(&mut feed, Some(&1), 10)
.await
.expect("nothing yet");
assert!(page.is_empty());
}
let mut db = feed.into_connection();
sqlx::query("INSERT INTO scene (id, title) VALUES (2, 'two')")
.execute(&mut db)
.await
.expect("the append");
let (_hint, bell) = doorbell();
let mut feed: SqliteFeed<Scene> = SqliteFeed::new(db, "scene", "id", bell).expect("the feed");
let page = AsyncChanges::<sqlx::Sqlite>::pull(&mut feed, Some(&1), 10)
.await
.expect("the append");
assert_eq!(page.len(), 1);
assert_eq!(page.items()[0].value().title, "two");
}
}
#[test]
fn an_intake_reads_back_what_it_was_wired_with_and_both_halves_of_a_knob_agree() {
let (_hint, rows) = feed(&[(1, "a"), (2, "b")]);
let (out, _inbox) = channel(8);
let track = Track::new("keyframes", "scene");
let fluent =
ChangeIntake::<InMemory, _, _>::new(track.clone(), rows, RecordedPositions::<i64>::new(), out)
.with_page(64);
assert_eq!(fluent.page(), 64);
assert_eq!(fluent.track(), &track);
assert_eq!(fluent.position(), None, "nothing is durable before a pass");
assert!(fluent.taps().is_empty());
assert_eq!(fluent.attribution(), &());
assert_eq!(fluent.feed().rows.len(), 2);
assert_eq!(fluent.positions().len(), 0);
assert_eq!(fluent.doorbell().take(), Rung::Swept);
let (_second, rows) = feed(&[(1, "a")]);
let (out, _inbox) = channel(8);
let mut in_place =
ChangeIntake::<InMemory, _, _>::new(track, rows, RecordedPositions::<i64>::new(), out);
assert_eq!(
in_place.page(),
ChangeIntake::<InMemory, Rows, RecordedPositions<i64>>::PAGE,
"the record's own page, until something says otherwise"
);
in_place.set_page(64).set_taps(super::super::Taps::new());
assert_eq!(in_place.page(), fluent.page());
}
#[test]
fn the_message_parameter_defaults_away_so_no_caller_spells_it() {
use super::super::{Doorbell, Hint};
let bare: (Hint, Doorbell) = doorbell();
let spelled: (Hint<()>, Doorbell<()>) = bare;
assert!(spelled.0.ring());
assert_eq!(spelled.1.take(), Rung::Rung);
fn rings_with_nothing<S: AsyncChanges<Db, Message = ()>, Db>() {}
rings_with_nothing::<Rows, InMemory>();
#[cfg(feature = "sqlite")]
rings_with_nothing::<super::super::SqliteFeed<(i64,)>, sqlx::Sqlite>();
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
struct MediaId(u64);
const MEDIA: MediaId = MediaId(3);
struct OneMedia;
impl crate::Attributes<&'static str> for OneMedia {
const FAMILY: &'static str = "media";
type Root = MediaId;
fn root(&self, _record: &&'static str) -> MediaId {
MEDIA
}
fn observe(&self, _root: &MediaId, _worker: &crate::NodeName, _arrival: &super::super::Arrival) {}
}
fn inflight(registries: &super::super::Registries) -> u32 {
registries
.of::<MediaId>()
.map_or(0, |family| family.inflight(&MEDIA))
}
#[tokio::test]
async fn an_intake_counts_the_rows_it_sends_and_credits_the_answers() {
let registries = std::sync::Arc::new(super::super::Registries::default());
let (_hint, rows) = feed(&[(1, "a"), (2, "b"), (3, "c")]);
let (out, inbox) = channel(8);
let mut intake = ChangeIntake::<InMemory, _, _>::new(
Track::new("keyframes", "scene"),
rows,
RecordedPositions::new(),
out,
)
.attributing(OneMedia)
.with_registries(std::sync::Arc::clone(®istries));
intake.drain().await.expect("the walk");
assert_eq!(
inflight(®istries),
3,
"three rows out, and the position has not moved"
);
assert_eq!(intake.position(), None);
assert_eq!(take_and_release(&inbox), ["a", "b", "c"]);
intake.drain().await.expect("the second pass");
assert_eq!(
inflight(®istries),
0,
"every row was answered, so nothing is out"
);
assert_eq!(intake.position(), Some(&3));
}
#[tokio::test]
async fn a_rewind_gives_the_retracted_rows_count_back() {
let registries = std::sync::Arc::new(super::super::Registries::default());
let (_hint, rows) = feed(&[(1, "a"), (2, "b"), (3, "c")]);
let (out, inbox) = channel(8);
let mut intake = ChangeIntake::<InMemory, _, _>::new(
Track::new("keyframes", "scene"),
rows,
RecordedPositions::new(),
out,
)
.attributing(OneMedia)
.with_registries(std::sync::Arc::clone(®istries));
intake.drain().await.expect("the walk");
assert_eq!(inflight(®istries), 3);
for wake in inbox.drain() {
if let Wake::Delivered(delivery) = wake {
let (_payload, ack) = delivery.into_parts();
drop(ack.expect("a delivery off the wire carries its custody token"));
}
}
let report = intake.drain().await.expect("the sweep");
assert_eq!(report.retracted(), 3);
assert_eq!(
inflight(®istries),
3,
"the three that came back were credited, and the three re-read were counted out — a net \
three, never six"
);
assert_eq!(take_and_release(&inbox), ["a", "b", "c"]);
intake.drain().await.expect("the third pass");
assert_eq!(inflight(®istries), 0);
}
#[tokio::test]
async fn a_partial_answer_leaves_the_unanswered_rows_counted() {
let registries = std::sync::Arc::new(super::super::Registries::default());
let (_hint, rows) = feed(&[(1, "a"), (2, "b"), (3, "c")]);
let (out, inbox) = channel(8);
let mut intake = ChangeIntake::<InMemory, _, _>::new(
Track::new("keyframes", "scene"),
rows,
RecordedPositions::new(),
out,
)
.attributing(OneMedia)
.with_registries(std::sync::Arc::clone(®istries));
intake.drain().await.expect("the walk");
for wake in inbox.drain() {
let Wake::Delivered(delivery) = wake else {
continue;
};
let (payload, ack) = delivery.into_parts();
let ack = ack.expect("a delivery off the wire carries its custody token");
let keys: Vec<ItemId> = payload.keys().copied().collect();
ack.send(Ack::new(
[keys[0], keys[2]].into_iter().collect(),
"consumer",
Lifecycle::Persisted(()),
));
}
intake.drain().await.expect("the second pass");
assert_eq!(
inflight(®istries),
0,
"an answer SPEAKS FOR every key it covered, released or not — the held row comes back under \
a fresh id, which is a fresh count"
);
assert_eq!(intake.position(), Some(&1));
}
#[tokio::test]
async fn an_intake_with_no_attribution_opens_no_family() {
let registries = std::sync::Arc::new(super::super::Registries::default());
let (_hint, rows) = feed(&[(1, "a")]);
let (out, inbox) = channel(8);
let mut intake = ChangeIntake::<InMemory, _, _>::new(
Track::new("keyframes", "scene"),
rows,
RecordedPositions::new(),
out,
)
.with_registries(std::sync::Arc::clone(®istries));
intake.drain().await.expect("the walk");
assert_eq!(take_and_release(&inbox), ["a"]);
intake.drain().await.expect("the second pass");
assert!(registries.is_empty(), "no projection, no family");
}