use std::sync::{Arc, Mutex};
use crate::{
Registries, RetireOrigin, RetiredMirror, RetiredRow, RetiredStore, RetiredStoreError,
RetiredTable, Retirement, RootState, Stamp, Timestamp,
drive::retired::{Landing, rebuild},
};
fn at(second: i64) -> Timestamp {
Timestamp::from_parts(second, 0).expect("a whole second is a timestamp")
}
#[test]
fn a_family_names_its_own_table() {
let table = RetiredTable::new("media").expect("`media` is a bare identifier");
assert_eq!(table.family(), "media");
assert_eq!(table.name(), "__ig_retired_media");
assert_eq!(
RetiredTable::new("track")
.expect("`track` is a bare identifier")
.name(),
"__ig_retired_track"
);
}
#[test]
fn a_family_that_could_not_be_spliced_is_refused() {
for hostile in [
"media\"; DROP TABLE x --",
"media x",
"media;",
"media'",
"",
"9lives",
"média",
] {
let refused = RetiredTable::new(hostile).expect_err("a spliced name has to be an identifier");
assert_eq!(refused.family(), hostile);
}
for legal in ["media", "track", "media_asset", "_private", "v2"] {
assert!(RetiredTable::new(legal).is_ok());
}
}
#[test]
fn only_vanished_restores_itself() {
assert!(RetireOrigin::Vanished.restores_itself());
assert!(!RetireOrigin::User.restores_itself());
assert!(!RetireOrigin::Other("policy".into()).restores_itself());
}
#[test]
fn the_rank_is_the_resurrection_question() {
let vanished = RetireOrigin::Vanished;
let user = RetireOrigin::User;
let other = RetireOrigin::Other("quota".into());
assert!(user.outranks(&vanished));
assert!(other.outranks(&vanished));
assert!(!vanished.outranks(&user));
assert!(!user.outranks(&other));
assert!(!other.outranks(&user));
assert!(!user.outranks(&user));
assert!(!vanished.outranks(&vanished));
}
#[test]
fn an_origin_round_trips_through_its_word() {
for origin in [
RetireOrigin::Vanished,
RetireOrigin::User,
RetireOrigin::Other("tenancy-ended".into()),
] {
let word = origin.as_str().to_owned();
assert_eq!(RetireOrigin::from(word), origin);
}
assert_eq!(RetireOrigin::from("vanished"), RetireOrigin::Vanished);
assert_eq!(RetireOrigin::from("user"), RetireOrigin::User);
assert_eq!(
RetireOrigin::from("something-else"),
RetireOrigin::Other("something-else".into())
);
}
#[test]
fn the_mirror_holds_what_was_marked() {
let mirror = RetiredMirror::<i64>::new();
let reader = mirror.reader();
assert!(!reader.retired(&7));
mirror.mark(7);
assert!(reader.retired(&7));
assert_eq!(reader.held(), 1);
mirror.unmark(7);
assert!(!reader.retired(&7));
assert_eq!(reader.held(), 0);
}
#[test]
fn a_rebuilt_mirror_publishes_once_and_holds_everything() {
let mirror = RetiredMirror::rebuilt([1_i64, 2, 3]);
let reader = mirror.reader();
assert_eq!(reader.held(), 3);
for key in [1_i64, 2, 3] {
assert!(reader.retired(&key));
}
assert!(!reader.retired(&4));
}
#[test]
fn a_reader_minted_after_the_fact_sees_what_was_published() {
let mirror = RetiredMirror::<i64>::new();
mirror.mark(11);
assert!(mirror.readers().reader().retired(&11));
}
#[derive(Debug, Clone, PartialEq, Eq)]
enum Seen {
Record { key: i64, mirrored: bool },
Erase { key: i64, mirrored: bool },
}
struct Probe {
seen: Mutex<Vec<Seen>>,
mirror: Arc<RetiredMirror<i64>>,
rows: Mutex<Vec<RetiredRow<i64>>>,
refuse: bool,
}
impl Probe {
fn new(mirror: &Arc<RetiredMirror<i64>>, refuse: bool) -> Arc<Self> {
Arc::new(Self {
seen: Mutex::new(Vec::new()),
mirror: Arc::clone(mirror),
rows: Mutex::new(Vec::new()),
refuse,
})
}
fn seen(&self) -> Vec<Seen> {
self.seen.lock().expect("the probe's own log").clone()
}
fn refusal(&self, verb: &'static str) -> Option<RetiredStoreError> {
self
.refuse
.then(|| RetiredStoreError::new(verb, "__ig_retired_probe", std::fmt::Error))
}
}
impl RetiredStore<i64> for Probe {
fn ready(&self) -> Landing<'_, ()> {
Box::pin(core::future::ready(Ok(())))
}
fn record<'a>(&'a self, row: &'a RetiredRow<i64>) -> Landing<'a, ()> {
Box::pin(async move {
self
.seen
.lock()
.expect("the probe's own log")
.push(Seen::Record {
key: *row.key(),
mirrored: self.mirror.retired(row.key()),
});
if let Some(refusal) = self.refusal("record") {
return Err(refusal);
}
let mut rows = self.rows.lock().expect("the probe's own rows");
rows.retain(|held| held.key() != row.key());
rows.push(row.clone());
Ok(())
})
}
fn erase<'a>(&'a self, key: &'a i64) -> Landing<'a, ()> {
Box::pin(async move {
self
.seen
.lock()
.expect("the probe's own log")
.push(Seen::Erase {
key: *key,
mirrored: self.mirror.retired(key),
});
if let Some(refusal) = self.refusal("erase") {
return Err(refusal);
}
self
.rows
.lock()
.expect("the probe's own rows")
.retain(|held| held.key() != key);
Ok(())
})
}
fn roll(&self) -> Landing<'_, Vec<RetiredRow<i64>>> {
Box::pin(async move { Ok(self.rows.lock().expect("the probe's own rows").clone()) })
}
}
#[tokio::test]
async fn the_row_lands_before_the_mirror_is_told() {
let registries = Registries::default();
let registry = registries.open::<i64>("probe");
let mirror = Arc::new(RetiredMirror::<i64>::new());
let store = Probe::new(&mirror, false);
let body = crate::Keeper::seated(
®istry,
store.clone() as Arc<dyn RetiredStore<i64>>,
Arc::clone(&mirror),
)
.expect("nothing is seated on a fresh family");
body
.perform(
&42,
Retirement::Recorded {
at: at(1_700_000_000),
origin: RetireOrigin::User,
late_tails: false,
},
)
.await;
assert_eq!(
store.seen(),
vec![Seen::Record {
key: 42,
mirrored: false
}]
);
assert!(mirror.retired(&42));
assert_eq!(
store.roll().await.expect("the probe never refuses").len(),
1
);
}
#[tokio::test]
async fn a_refused_row_publishes_nothing() {
let registries = Registries::default();
let registry = registries.open::<i64>("probe");
let mirror = Arc::new(RetiredMirror::<i64>::new());
let store = Probe::new(&mirror, true);
let body = crate::Keeper::seated(
®istry,
store.clone() as Arc<dyn RetiredStore<i64>>,
Arc::clone(&mirror),
)
.expect("nothing is seated on a fresh family");
body
.perform(
&42,
Retirement::Recorded {
at: at(1_700_000_000),
origin: RetireOrigin::Vanished,
late_tails: true,
},
)
.await;
assert!(
!mirror.retired(&42),
"a refused write must leave the mirror exactly where it was"
);
assert_eq!(body.report().recorded, 0);
assert_eq!(body.report().refused, 1);
}
#[tokio::test]
async fn an_erase_unmarks_and_then_tells_the_waiting_state() {
let registries = Registries::default();
let registry = registries.open::<i64>("probe");
let mirror = Arc::new(RetiredMirror::<i64>::new());
let store = Probe::new(&mirror, false);
let body = crate::Keeper::seated(
®istry,
store.clone() as Arc<dyn RetiredStore<i64>>,
Arc::clone(&mirror),
)
.expect("nothing is seated on a fresh family");
body
.perform(
&7,
Retirement::Recorded {
at: at(1),
origin: RetireOrigin::Vanished,
late_tails: false,
},
)
.await;
registry.rebuilt(&7, at(1), RetireOrigin::Vanished, false);
let _asked = registry.restore(&7, Stamp::now());
assert!(matches!(registry.state(&7), RootState::Restoring));
body.perform(&7, Retirement::Erased).await;
assert_eq!(
store.seen().last(),
Some(&Seen::Erase {
key: 7,
mirrored: true
}),
"the row is erased while the mirror still says retired — the durable half first"
);
assert!(!mirror.retired(&7));
assert!(matches!(registry.state(&7), RootState::Idle));
assert_eq!(body.report().erased, 1);
}
#[tokio::test]
async fn a_refused_erase_leaves_the_key_restoring() {
let registries = Registries::default();
let registry = registries.open::<i64>("probe");
let mirror = Arc::new(RetiredMirror::<i64>::new());
let store = Probe::new(&mirror, true);
let body = crate::Keeper::seated(
®istry,
store as Arc<dyn RetiredStore<i64>>,
Arc::clone(&mirror),
)
.expect("nothing is seated on a fresh family");
registry.rebuilt(&7, at(1), RetireOrigin::User, false);
mirror.mark(7);
let _asked = registry.restore(&7, Stamp::now());
body.perform(&7, Retirement::Erased).await;
assert!(mirror.retired(&7), "a refused erase publishes nothing");
assert!(
matches!(registry.state(&7), RootState::Restoring),
"a key whose erase did not land has not been restored, and is not told that it has"
);
assert_eq!(body.report().refused, 1);
}
#[tokio::test]
async fn the_seat_queues_and_the_body_spends() {
let registries = Registries::default();
let registry = registries.open::<i64>("probe");
let mirror = Arc::new(RetiredMirror::<i64>::new());
let store = Probe::new(&mirror, false);
let body = crate::Keeper::seated(
®istry,
store.clone() as Arc<dyn RetiredStore<i64>>,
Arc::clone(&mirror),
)
.expect("nothing is seated on a fresh family");
let _went = registry.retire(&5, RetireOrigin::User, Stamp::now());
assert!(store.seen().is_empty());
assert!(!mirror.retired(&5));
drop(registry);
drop(registries);
body.run().await;
assert_eq!(store.seen().len(), 1);
assert!(mirror.retired(&5));
}
#[tokio::test]
async fn a_second_ledger_is_refused_and_the_first_keeps_the_acts() {
let registries = Registries::default();
let registry = registries.open::<i64>("probe");
let mirror = Arc::new(RetiredMirror::<i64>::new());
let first = crate::Keeper::seated(
®istry,
Probe::new(&mirror, false) as Arc<dyn RetiredStore<i64>>,
Arc::clone(&mirror),
);
assert!(first.is_some());
let second = crate::Keeper::seated(
®istry,
Probe::new(&mirror, false) as Arc<dyn RetiredStore<i64>>,
Arc::clone(&mirror),
);
assert!(
second.is_none(),
"two writers for one family's rows is two parties disagreeing about what a retirement means"
);
}
#[tokio::test]
async fn a_boot_states_what_the_ledger_says_and_earns_no_act() {
let registries = Registries::default();
let registry = registries.open::<i64>("probe");
let mirror = Arc::new(RetiredMirror::<i64>::new());
let store = Probe::new(&mirror, false);
store
.record(&RetiredRow::new(
1,
at(1_000),
RetireOrigin::Vanished,
false,
))
.await
.expect("the probe never refuses");
store
.record(&RetiredRow::new(
2,
at(2_000),
RetireOrigin::Other("policy".into()),
true,
))
.await
.expect("the probe never refuses");
let booted = Arc::new(RetiredMirror::<i64>::new());
let seen = store.seen().len();
let read = rebuild(store.as_ref(), ®istry, &booted)
.await
.expect("the probe never refuses");
assert_eq!(read, 2);
assert_eq!(
store.seen().len(),
seen,
"a rebuild WRITES NOTHING — it would otherwise re-record every row it had just read"
);
assert!(booted.retired(&1));
assert!(booted.retired(&2));
assert!(matches!(
registry.state(&1),
RootState::Retired {
origin: RetireOrigin::Vanished,
late_tails: false,
..
}
));
let RootState::Retired {
at: second_at,
origin,
late_tails,
} = registry.state(&2)
else {
panic!("the ledger said this key was out");
};
assert_eq!(second_at, at(2_000));
assert_eq!(origin, RetireOrigin::Other("policy".into()));
assert!(late_tails);
}
#[tokio::test]
async fn a_rebuilt_vanished_key_still_comes_back_on_its_own() {
let registries = Registries::default();
let registry = registries.open::<i64>("probe");
let mirror = Arc::new(RetiredMirror::<i64>::new());
let store = Probe::new(&mirror, false);
store
.record(&RetiredRow::new(3, at(9), RetireOrigin::Vanished, false))
.await
.expect("the probe never refuses");
let booted = Arc::new(RetiredMirror::<i64>::new());
let _read = rebuild(store.as_ref(), ®istry, &booted)
.await
.expect("the probe never refuses");
let _seen = registry.reappear(&3, Stamp::now());
assert!(matches!(registry.state(&3), RootState::Restoring));
}
#[cfg(feature = "sqlite")]
mod sqlite {
use crate::SqlRetired;
fn ledger() -> SqlRetired<sqlx::Sqlite, i64> {
SqlRetired::new(
sqlx::Pool::connect_lazy("sqlite::memory:").expect("a lazy pool opens nothing"),
"media",
)
.expect("`media` is a bare identifier")
}
#[tokio::test]
async fn the_four_statements_are_the_bytes_they_were() {
let ledger = ledger();
assert_eq!(
ledger.create_statement(),
r#"CREATE TABLE IF NOT EXISTS "__ig_retired_media" ("root" TEXT NOT NULL, "retired_second" INTEGER NOT NULL, "retired_nanosecond" INTEGER NOT NULL, "origin" TEXT NOT NULL, "late_tails" INTEGER NOT NULL, PRIMARY KEY ("root"))"#
);
assert_eq!(
ledger.record_statement(),
r#"INSERT INTO "__ig_retired_media" ("root", "retired_second", "retired_nanosecond", "origin", "late_tails") VALUES (?, ?, ?, ?, ?) ON CONFLICT ("root") DO UPDATE SET "origin" = excluded."origin""#
);
assert_eq!(
ledger.erase_statement(),
r#"DELETE FROM "__ig_retired_media" WHERE "root" = ?"#
);
assert_eq!(
ledger.roll_statement(),
r#"SELECT "root", "retired_second", "retired_nanosecond", "origin", "late_tails" FROM "__ig_retired_media""#
);
}
}
#[cfg(feature = "postgres")]
mod postgres {
use crate::SqlRetired;
#[tokio::test]
async fn the_one_dialect_that_counts_its_parameters() {
let ledger: SqlRetired<sqlx::Postgres, i64> = SqlRetired::new(
sqlx::Pool::connect_lazy("postgres://ingraph@localhost/ingraph")
.expect("a lazy pool opens nothing"),
"media",
)
.expect("`media` is a bare identifier");
assert_eq!(
ledger.create_statement(),
r#"CREATE TABLE IF NOT EXISTS "__ig_retired_media" ("root" text NOT NULL, "retired_second" bigint NOT NULL, "retired_nanosecond" integer NOT NULL, "origin" text NOT NULL, "late_tails" boolean NOT NULL, PRIMARY KEY ("root"))"#
);
assert_eq!(
ledger.record_statement(),
r#"INSERT INTO "__ig_retired_media" ("root", "retired_second", "retired_nanosecond", "origin", "late_tails") VALUES ($1, $2, $3, $4, $5) ON CONFLICT ("root") DO UPDATE SET "origin" = EXCLUDED."origin""#
);
assert_eq!(
ledger.erase_statement(),
r#"DELETE FROM "__ig_retired_media" WHERE "root" = $1"#
);
}
}
#[cfg(feature = "mysql")]
mod mysql {
use crate::SqlRetired;
#[tokio::test]
async fn the_backticked_dialect_names_no_conflict_target() {
let ledger: SqlRetired<sqlx::MySql, i64> = SqlRetired::new(
sqlx::Pool::connect_lazy("mysql://ingraph@localhost/ingraph")
.expect("a lazy pool opens nothing"),
"media",
)
.expect("`media` is a bare identifier");
assert_eq!(
ledger.create_statement(),
"CREATE TABLE IF NOT EXISTS `__ig_retired_media` (`root` varchar(255) NOT NULL, \
`retired_second` bigint NOT NULL, `retired_nanosecond` int NOT NULL, `origin` \
varchar(255) NOT NULL, `late_tails` tinyint(1) NOT NULL, PRIMARY KEY (`root`))"
);
assert_eq!(
ledger.record_statement(),
"INSERT INTO `__ig_retired_media` (`root`, `retired_second`, `retired_nanosecond`, \
`origin`, `late_tails`) VALUES (?, ?, ?, ?, ?) ON DUPLICATE KEY UPDATE `origin` = \
VALUES(`origin`)"
);
}
}
#[cfg(feature = "sqlite")]
mod live {
use super::{at, rebuild};
use std::sync::Arc;
use crate::{
Registries, RetireOrigin, RetiredMirror, RetiredRow, RetiredStore, RootState, SqlRetired,
};
async fn ledger() -> SqlRetired<sqlx::Sqlite, i64> {
let pool = sqlx::sqlite::SqlitePoolOptions::new()
.max_connections(1)
.connect("sqlite::memory:")
.await
.expect("an in-memory database");
let ledger = SqlRetired::new(pool, "media").expect("`media` is a bare identifier");
ledger.ready().await.expect("the table is created");
ledger
}
#[tokio::test]
async fn a_row_round_trips() {
let ledger = ledger().await;
assert!(ledger.roll().await.expect("an empty ledger").is_empty());
let row = RetiredRow::new(7_i64, at(1_700_000_123), RetireOrigin::Vanished, true);
ledger.record(&row).await.expect("the row is written");
let rolled = ledger.roll().await.expect("the ledger reads back");
assert_eq!(rolled, vec![row]);
}
#[tokio::test]
async fn ready_is_idempotent() {
let ledger = ledger().await;
ledger
.record(&RetiredRow::new(1_i64, at(5), RetireOrigin::User, false))
.await
.expect("the row is written");
ledger.ready().await.expect("the table already exists");
assert_eq!(ledger.roll().await.expect("the ledger reads back").len(), 1);
}
#[tokio::test]
async fn a_second_record_moves_the_origin_and_nothing_else() {
let ledger = ledger().await;
let first = RetiredRow::new(7_i64, at(1_000), RetireOrigin::Vanished, true);
ledger.record(&first).await.expect("the row is written");
let second = RetiredRow::new(7_i64, at(9_999), RetireOrigin::User, false);
ledger.record(&second).await.expect("the row is rewritten");
let rolled = ledger.roll().await.expect("the ledger reads back");
assert_eq!(rolled.len(), 1);
assert_eq!(rolled[0].origin(), &RetireOrigin::User);
assert_eq!(rolled[0].at(), at(1_000));
assert!(rolled[0].late_tails());
}
#[tokio::test]
async fn an_erase_is_total_on_a_key_that_is_not_there() {
let ledger = ledger().await;
ledger.erase(&404_i64).await.expect("erasing nothing is Ok");
assert!(ledger.roll().await.expect("an empty ledger").is_empty());
}
#[tokio::test]
async fn an_open_origin_survives_the_round_trip() {
let ledger = ledger().await;
let row = RetiredRow::new(
3_i64,
at(42),
RetireOrigin::Other("tenancy-ended".into()),
false,
);
ledger.record(&row).await.expect("the row is written");
assert_eq!(
ledger.roll().await.expect("the ledger reads back")[0].origin(),
&RetireOrigin::Other("tenancy-ended".into())
);
}
#[tokio::test]
async fn the_whole_road_end_to_end() {
let ledger = Arc::new(ledger().await);
let registries = Registries::default();
let registry = registries.open::<i64>("media");
let mirror = Arc::new(RetiredMirror::<i64>::new());
let body = crate::Keeper::seated(
®istry,
Arc::clone(&ledger) as Arc<dyn RetiredStore<i64>>,
Arc::clone(&mirror),
)
.expect("nothing is seated on a fresh family");
let _went = registry.retire(&7_i64, RetireOrigin::User, crate::Stamp::now());
let _brought = registry.restore(&7_i64, crate::Stamp::now());
drop(registry);
drop(registries);
body.run().await;
assert!(
ledger
.roll()
.await
.expect("the ledger reads back")
.is_empty(),
"the retire's row was written and the restore's erase took it away"
);
assert!(!mirror.retired(&7));
let registries = Registries::default();
let booted = registries.open::<i64>("media");
let cold = RetiredMirror::<i64>::new();
let read = rebuild(ledger.as_ref(), &booted, &cold)
.await
.expect("the ledger reads back");
assert_eq!(read, 0);
assert!(matches!(booted.state(&7), RootState::Idle));
}
}