#![cfg(not(target_arch = "wasm32"))]
use day_persistence::{
DatabaseWorker, DbError, DbErrorKind, Model, ModelContainer, Sqlite, WorkerOptions, schema,
};
use day_reactive::Binding;
use std::{
future::Future,
sync::{Arc, Barrier, mpsc},
task::{Context, Poll, Wake, Waker},
time::{Duration, Instant},
};
#[derive(Model, Clone, Default, PartialEq, Debug)]
#[model(table = "notes", fts("title"))]
struct Note {
#[model(id)]
id: u64,
#[model(unique)]
title: String,
read: bool,
}
fn block_on<F: Future>(f: F) -> F::Output {
struct Unpark(std::thread::Thread);
impl Wake for Unpark {
fn wake(self: Arc<Self>) {
self.0.unpark();
}
}
let w = Waker::from(Arc::new(Unpark(std::thread::current())));
let mut cx = Context::from_waker(&w);
let mut f = std::pin::pin!(f);
let deadline = Instant::now() + Duration::from_secs(20);
loop {
if let Poll::Ready(v) = f.as_mut().poll(&mut cx) {
return v;
}
assert!(Instant::now() < deadline, "worker future never completed");
std::thread::park_timeout(Duration::from_millis(20));
}
}
fn open() -> DatabaseWorker {
block_on(DatabaseWorker::open(|| {
ModelContainer::open(Sqlite::memory(), schema![Note])
}))
.unwrap()
}
fn note(id: u64) -> Note {
Note {
id,
title: format!("Synthetic note {id}"),
read: false,
}
}
fn count(w: &DatabaseWorker) -> u64 {
block_on(w.read(|db| db.table_count::<Note>())).unwrap()
}
#[test]
fn open_queries_mutations_and_drop_stay_on_the_owning_thread() {
let ui = std::thread::current().id();
let w = block_on(DatabaseWorker::open(move || {
assert_ne!(ui, std::thread::current().id());
ModelContainer::open(Sqlite::memory(), schema![Note])
}))
.unwrap();
let thread = block_on(w.write(|db| {
db.insert(note(1));
Ok(std::thread::current().id())
}))
.unwrap();
assert_ne!(ui, thread);
assert_eq!(
thread,
block_on(w.read(|_| Ok(std::thread::current().id()))).unwrap()
);
assert_eq!(count(&w), 1);
block_on(w.close()).unwrap();
}
#[test]
fn fifo_and_read_your_writes_work_without_awaiting_each_submission() {
let w = open();
let mut pending = vec![];
for id in 0..100 {
pending.push(w.write(move |db| {
db.insert(note(id));
Ok(())
}));
}
let counted = w.read(|db| db.table_count::<Note>());
for r in pending {
block_on(r).unwrap();
}
assert_eq!(block_on(counted).unwrap(), 100);
block_on(w.close()).unwrap();
}
#[test]
fn failed_closure_rolls_back_even_its_explicit_saves_and_restores_cache() {
let w = open();
block_on(w.write(|db| {
db.insert(note(1));
Ok(())
}))
.unwrap();
let e = block_on(w.write::<()>(|db| {
db.get::<Note>(1u64)
.unwrap()
.title()
.write("changed".into());
db.insert(note(2));
db.save()?;
Err(DbError::driver("synthetic rejection"))
}))
.unwrap_err();
assert_eq!(e.kind, DbErrorKind::Driver);
assert_eq!(
block_on(w.read(|db| Ok(db.get::<Note>(1u64).unwrap().title().read()))).unwrap(),
"Synthetic note 1"
);
assert_eq!(count(&w), 1);
block_on(w.write(|db| {
db.insert(note(2));
Ok(())
}))
.unwrap();
assert_eq!(count(&w), 2);
block_on(w.close()).unwrap();
}
#[test]
fn constraint_failure_rolls_back_every_row_then_allows_retry() {
let w = open();
let e = block_on(w.write(|db| {
db.insert(note(1));
db.insert(Note { id: 2, ..note(1) });
Ok(())
}))
.unwrap_err();
assert_eq!(e.kind, DbErrorKind::Driver);
assert_eq!(count(&w), 0);
block_on(w.write(|db| {
db.insert(note(1));
Ok(())
}))
.unwrap();
assert_eq!(count(&w), 1);
block_on(w.close()).unwrap();
}
#[test]
fn accidental_model_mutations_in_reads_are_rejected_and_undone() {
let w = open();
block_on(w.write(|db| {
db.insert(note(1));
Ok(())
}))
.unwrap();
assert!(
block_on(w.read(|db| {
db.get::<Note>(1u64).unwrap().read().write(true);
Ok(())
}))
.is_err()
);
assert!(!block_on(w.read(|db| Ok(db.get::<Note>(1u64).unwrap().read().read()))).unwrap());
block_on(w.close()).unwrap();
}
#[test]
fn accidental_sql_writes_in_reads_are_rejected() {
let w = open();
assert!(
block_on(w.read(|db| db.try_with_connection(|c| c.execute("DELETE FROM notes", &[]))))
.is_err()
);
block_on(w.write(|db| {
db.insert(note(1));
Ok(())
}))
.unwrap();
assert_eq!(count(&w), 1);
block_on(w.close()).unwrap();
}
#[test]
fn dropping_accepted_write_futures_preserves_commits() {
let w = open();
for id in 0..100 {
drop(w.write(move |db| {
db.insert(note(id));
Ok(())
}));
}
assert_eq!(count(&w), 100);
block_on(w.close()).unwrap();
}
#[test]
fn dropped_queued_reads_do_not_execute() {
let w = open();
let gate = Arc::new(Barrier::new(2));
let gate2 = gate.clone();
let (tx, rx) = mpsc::channel();
let first = w.read(move |_| {
tx.send(()).unwrap();
gate2.wait();
Ok(())
});
rx.recv_timeout(Duration::from_secs(5)).unwrap();
let ran = Arc::new(std::sync::atomic::AtomicBool::new(false));
let copy = ran.clone();
drop(w.read(move |_| {
copy.store(true, std::sync::atomic::Ordering::SeqCst);
Ok(())
}));
gate.wait();
block_on(first).unwrap();
block_on(w.close()).unwrap();
assert!(!ran.load(std::sync::atomic::Ordering::SeqCst));
}
#[test]
fn bounded_admission_never_blocks_or_silently_drops_writes() {
let w = block_on(DatabaseWorker::open_with(
WorkerOptions {
capacity: 1,
..Default::default()
},
|| ModelContainer::open(Sqlite::memory(), schema![Note]),
))
.unwrap();
let gate = Arc::new(Barrier::new(2));
let gate2 = gate.clone();
let (tx, rx) = mpsc::channel();
let first = w.read(move |_| {
tx.send(()).unwrap();
gate2.wait();
Ok(())
});
rx.recv_timeout(Duration::from_secs(5)).unwrap();
let accepted = w.write(|db| {
db.insert(note(1));
Ok(())
});
assert_eq!(
block_on(w.write(|db| {
db.insert(note(2));
Ok(())
}))
.unwrap_err()
.kind,
DbErrorKind::Busy
);
gate.wait();
block_on(first).unwrap();
block_on(accepted).unwrap();
assert_eq!(count(&w), 1);
block_on(w.close()).unwrap();
}
#[test]
fn close_drains_accepted_writes_and_rejects_later_requests_on_all_clones() {
let w = open();
let clone = w.clone();
for id in 0..100 {
drop(w.write(move |db| {
db.insert(note(id));
Ok(())
}));
}
block_on(w.close()).unwrap();
block_on(clone.close()).unwrap();
assert_eq!(
block_on(clone.read(|_| Ok(()))).unwrap_err().kind,
DbErrorKind::Closed
);
}
#[test]
fn panic_closes_worker_and_completes_queued_requests() {
let w = open();
let bad = w.write::<()>(|db| {
db.insert(note(1));
panic!("synthetic worker failure")
});
let after = w.read(|db| db.table_count::<Note>());
assert_eq!(block_on(bad).unwrap_err().kind, DbErrorKind::Panicked);
assert!(block_on(after).is_err());
assert!(block_on(w.close()).is_err());
}
#[test]
fn factory_failure_and_factory_panic_complete_open() {
assert!(
block_on(DatabaseWorker::open(|| Err(DbError::driver(
"synthetic open failure"
))))
.is_err()
);
assert!(block_on(DatabaseWorker::open(|| panic!("synthetic factory panic"))).is_err());
}
#[test]
fn recursive_queue_access_is_rejected_instead_of_deadlocking() {
let w = open();
let clone = w.clone();
let kind =
block_on(w.read(move |_| Ok(block_on(clone.read(|_| Ok(()))).unwrap_err().kind))).unwrap();
assert_eq!(kind, DbErrorKind::Driver);
let clone = w.clone();
assert!(block_on(w.read(move |_| block_on(clone.close()))).is_err());
block_on(w.close()).unwrap();
}
#[test]
fn clones_serialize_concurrent_updates_without_lost_writes() {
let w = open();
block_on(w.write(|db| {
db.insert(note(1));
Ok(())
}))
.unwrap();
let threads: Vec<_> = (0..8)
.map(|_| {
let w = w.clone();
std::thread::spawn(move || {
for _ in 0..25 {
block_on(w.write(|db| {
let n = db.get::<Note>(1u64).unwrap();
let value = n.read().read();
n.read().write(!value);
Ok(())
}))
.unwrap();
}
})
})
.collect();
for t in threads {
t.join().unwrap();
}
assert!(!block_on(w.read(|db| Ok(db.get::<Note>(1u64).unwrap().read().read()))).unwrap());
block_on(w.close()).unwrap();
}
#[test]
fn observations_deliver_committed_values_and_monotonic_revisions() {
let w = open();
let mut subscription = block_on(w.observe(|db| db.table_count::<Note>())).unwrap();
let first = block_on(subscription.next()).unwrap().unwrap();
assert_eq!(first.value, 0);
block_on(w.write(|db| {
db.insert(note(1));
Ok(())
}))
.unwrap();
let next = block_on(subscription.next()).unwrap().unwrap();
assert_eq!(next.value, 1);
assert!(next.revision > first.revision);
block_on(w.close()).unwrap();
assert!(block_on(subscription.next()).is_none());
}
#[test]
fn observations_coalesce_a_slow_consumer_and_do_not_hold_worker_alive() {
let w = open();
let mut sub = block_on(w.observe(|db| db.table_count::<Note>())).unwrap();
assert_eq!(block_on(sub.next()).unwrap().unwrap().value, 0);
for id in 0..100 {
block_on(w.write(move |db| {
db.insert(note(id));
Ok(())
}))
.unwrap();
}
block_on(w.close()).unwrap();
assert_eq!(block_on(sub.next()).unwrap().unwrap().value, 100);
assert!(block_on(sub.next()).is_none());
}
#[test]
fn failed_transactions_never_publish_speculative_values() {
let w = open();
let mut sub = block_on(w.observe(|db| db.table_count::<Note>())).unwrap();
assert_eq!(block_on(sub.next()).unwrap().unwrap().value, 0);
assert!(
block_on(w.write::<()>(|db| {
db.insert(note(1));
db.save()?;
Err(DbError::driver("synthetic rollback"))
}))
.is_err()
);
block_on(w.close()).unwrap();
assert!(block_on(sub.next()).is_none());
}
#[test]
fn unchanged_projections_do_not_wake_the_consumer() {
let w = open();
let mut sub = block_on(w.observe(|db| db.table_count::<Note>())).unwrap();
block_on(sub.next()).unwrap().unwrap();
for _ in 0..20 {
block_on(w.write(|_| Ok(()))).unwrap();
}
block_on(w.close()).unwrap();
assert!(block_on(sub.next()).is_none());
}
#[test]
fn dropping_observation_stops_evaluation() {
use std::sync::atomic::{AtomicUsize, Ordering};
let w = open();
let calls = Arc::new(AtomicUsize::new(0));
let called = calls.clone();
let mut sub = block_on(w.observe(move |db| {
called.fetch_add(1, Ordering::SeqCst);
db.table_count::<Note>()
}))
.unwrap();
block_on(sub.next()).unwrap().unwrap();
drop(sub);
let count = calls.load(Ordering::SeqCst);
for _ in 0..5 {
block_on(w.write(|_| Ok(()))).unwrap();
}
block_on(w.close()).unwrap();
assert_eq!(calls.load(Ordering::SeqCst), count);
}
#[test]
fn projection_errors_are_reported_and_recover_on_next_commit() {
let w = open();
let mut sub = block_on(w.observe(|db| {
let count = db.table_count::<Note>()?;
if count == 0 {
Err(DbError::driver("synthetic projection failure"))
} else {
Ok(count)
}
}))
.unwrap();
assert!(block_on(sub.next()).unwrap().is_err());
block_on(w.write(|db| {
db.insert(note(1));
Ok(())
}))
.unwrap();
assert_eq!(block_on(sub.next()).unwrap().unwrap().value, 1);
block_on(w.close()).unwrap();
}
#[test]
fn projection_panic_closes_and_wakes_pending_subscription() {
let w = open();
let mut sub = block_on(w.observe::<u64>(|_| panic!("synthetic projection panic"))).unwrap();
assert!(block_on(sub.next()).is_none());
assert_eq!(block_on(w.close()).unwrap_err().kind, DbErrorKind::Panicked);
}
#[test]
fn undo_redo_are_committed_and_background_authors_are_excluded() {
let w = open();
block_on(w.enable_undo(10)).unwrap();
block_on(w.write(|db| {
db.insert(note(1));
Ok(())
}))
.unwrap();
assert_eq!(
block_on(w.undo_status()).unwrap(),
(true, false),
"before background import"
);
block_on(w.write(|db| {
day_model::with_author("synthetic-import", || {
db.insert(note(2));
Ok(())
})
}))
.unwrap();
assert_eq!(block_on(w.undo_status()).unwrap(), (true, false));
assert!(block_on(w.undo(false)).unwrap());
assert_eq!(count(&w), 1);
assert_eq!(block_on(w.undo_status()).unwrap(), (false, true));
assert!(block_on(w.undo(true)).unwrap());
assert_eq!(count(&w), 2);
block_on(w.close()).unwrap();
}
#[test]
fn failed_edit_preserves_a_redo_branch() {
let w = open();
block_on(w.enable_undo(10)).unwrap();
block_on(w.write(|db| {
db.insert(note(1));
Ok(())
}))
.unwrap();
block_on(w.undo(false)).unwrap();
assert!(
block_on(w.write::<()>(|db| {
db.insert(note(2));
db.save()?;
Err(DbError::driver("synthetic failure"))
}))
.is_err()
);
assert_eq!(block_on(w.undo_status()).unwrap(), (false, true));
assert!(block_on(w.undo(true)).unwrap());
assert_eq!(count(&w), 1);
assert!(block_on(w.read(|db| Ok(db.get::<Note>(1u64).is_some()))).unwrap());
block_on(w.close()).unwrap();
}
#[test]
fn fts_and_cache_restore_after_failed_delete_and_update() {
let w = open();
block_on(w.write(|db| {
db.insert(note(1));
db.insert(note(2));
Ok(())
}))
.unwrap();
assert!(
block_on(w.write::<()>(|db| {
db.delete::<Note>(1u64)?;
db.get::<Note>(2u64)
.unwrap()
.title()
.write("rollbackword".into());
db.save()?;
Err(DbError::driver("synthetic failure"))
}))
.is_err()
);
let hits = block_on(w.read(|db| {
db.query::<Note>()
.filter(Note::fts().matches("Synthetic"))
.live()
.try_collect()
}))
.unwrap();
assert_eq!(hits.len(), 2);
assert!(
block_on(w.read(|db| {
db.query::<Note>()
.filter(Note::fts().matches("rollbackword"))
.live()
.try_collect()
}))
.unwrap()
.is_empty()
);
block_on(w.close()).unwrap();
}
fn temporary_db(test: &str) -> std::path::PathBuf {
static NEXT: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
let dir = std::env::temp_dir().join(format!(
"day-worker-{test}-{}-{}",
std::process::id(),
NEXT.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
));
std::fs::create_dir_all(&dir).unwrap();
dir.join("test.db")
}
#[test]
fn acknowledged_commits_survive_reopen_and_panics_do_not_leave_partial_writes() {
let file = temporary_db("durability");
let path = file.clone();
let w = block_on(DatabaseWorker::open(move || {
ModelContainer::open(Sqlite::at(path), schema![Note])
}))
.unwrap();
block_on(w.write(|db| {
db.insert(note(1));
Ok(())
}))
.unwrap();
assert_eq!(
block_on(w.write::<()>(|db| {
db.insert(note(2));
db.save()?;
panic!("synthetic panic after flush")
}))
.unwrap_err()
.kind,
DbErrorKind::Panicked
);
assert!(block_on(w.close()).is_err());
let path = file.clone();
let reopened = block_on(DatabaseWorker::open(move || {
ModelContainer::open(Sqlite::at(path), schema![Note])
}))
.unwrap();
assert_eq!(count(&reopened), 1);
block_on(reopened.close()).unwrap();
std::fs::remove_dir_all(file.parent().unwrap()).unwrap();
}
#[test]
fn dropping_last_handle_drains_accepted_writes_and_releases_subscription() {
let file = temporary_db("drop");
let path = file.clone();
let w = block_on(DatabaseWorker::open(move || {
ModelContainer::open(Sqlite::at(path), schema![Note])
}))
.unwrap();
let mut sub = block_on(w.observe(|db| db.table_count::<Note>())).unwrap();
for id in 0..100 {
drop(w.write(move |db| {
db.insert(note(id));
Ok(())
}));
}
drop(w);
while block_on(sub.next()).is_some() {}
let db = ModelContainer::open(Sqlite::at(&file), schema![Note]).unwrap();
assert_eq!(db.table_count::<Note>().unwrap(), 100);
drop(db);
std::fs::remove_dir_all(file.parent().unwrap()).unwrap();
}
#[test]
fn external_commits_are_merged_on_worker_and_publish_new_revision() {
let file = temporary_db("external");
let path = file.clone();
let w = block_on(DatabaseWorker::open(move || {
ModelContainer::open(Sqlite::at(path), schema![Note])
}))
.unwrap();
let mut sub = block_on(w.observe(|db| db.table_count::<Note>())).unwrap();
block_on(sub.next()).unwrap().unwrap();
let db = ModelContainer::open(Sqlite::at(&file), schema![Note]).unwrap();
db.insert(note(1));
db.save().unwrap();
assert!(block_on(w.check_external()).unwrap());
assert_eq!(block_on(sub.next()).unwrap().unwrap().value, 1);
assert!(!block_on(w.check_external()).unwrap());
block_on(w.close()).unwrap();
drop(db);
std::fs::remove_dir_all(file.parent().unwrap()).unwrap();
}
#[test]
fn multi_statement_read_has_a_consistent_sqlite_snapshot() {
let file = temporary_db("snapshot");
let path = file.clone();
let w = block_on(DatabaseWorker::open(move || {
ModelContainer::open(Sqlite::at(path), schema![Note])
}))
.unwrap();
let (tx, rx) = mpsc::channel();
let (go, wait) = mpsc::channel();
let read = w.read(move |db| {
let before = db.table_count::<Note>()?;
tx.send(()).unwrap();
wait.recv_timeout(Duration::from_secs(5)).unwrap();
Ok((before, db.table_count::<Note>()?))
});
rx.recv_timeout(Duration::from_secs(5)).unwrap();
let db = ModelContainer::open(Sqlite::at(&file), schema![Note]).unwrap();
db.insert(note(1));
db.save().unwrap();
go.send(()).unwrap();
assert_eq!(block_on(read).unwrap(), (0, 0));
assert_eq!(count(&w), 1);
block_on(w.close()).unwrap();
drop(db);
std::fs::remove_dir_all(file.parent().unwrap()).unwrap();
}
#[test]
fn rejected_closure_captures_drop_outside_admission_lock() {
struct Reenter(DatabaseWorker, mpsc::Sender<()>);
impl Drop for Reenter {
fn drop(&mut self) {
drop(self.0.read(|_| Ok(())));
self.1.send(()).unwrap();
}
}
let w = block_on(DatabaseWorker::open_with(
WorkerOptions {
capacity: 1,
..Default::default()
},
|| ModelContainer::open(Sqlite::memory(), schema![Note]),
))
.unwrap();
let gate = Arc::new(Barrier::new(2));
let g = gate.clone();
let (tx, rx) = mpsc::channel();
let first = w.read(move |_| {
tx.send(()).unwrap();
g.wait();
Ok(())
});
rx.recv_timeout(Duration::from_secs(5)).unwrap();
let pending = w.write(|db| {
db.insert(note(1));
Ok(())
});
let (tx, rx) = mpsc::channel();
let capture = Reenter(w.clone(), tx);
let e = block_on(w.read(move |_| {
let _keep = capture;
Ok(())
}))
.unwrap_err();
assert_eq!(e.kind, DbErrorKind::Busy);
rx.recv_timeout(Duration::from_secs(5)).unwrap();
gate.wait();
block_on(first).unwrap();
block_on(pending).unwrap();
block_on(w.close()).unwrap();
}
#[test]
fn many_concurrent_closers_finish_while_writers_race_admission() {
let w = open();
let accepted = Arc::new(std::sync::atomic::AtomicUsize::new(0));
let mut threads = vec![];
for lane in 0..8 {
let w = w.clone();
let accepted = accepted.clone();
threads.push(std::thread::spawn(move || {
for index in 0..100 {
match block_on(w.write(move |db| {
db.insert(note(lane * 100 + index));
Ok(())
})) {
Ok(()) => {
accepted.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
}
Err(e) => assert!(matches!(e.kind, DbErrorKind::Closed | DbErrorKind::Busy)),
}
}
}));
}
let mut closers = vec![];
for _ in 0..8 {
let w = w.clone();
closers.push(std::thread::spawn(move || block_on(w.close()).unwrap()));
}
for t in threads {
t.join().unwrap();
}
for t in closers {
t.join().unwrap();
}
assert_eq!(
block_on(w.read(|_| Ok(()))).unwrap_err().kind,
DbErrorKind::Closed
);
}
#[test]
fn rejected_read_mutation_does_not_pollute_undo_or_destroy_redo() {
let w = open();
block_on(w.enable_undo(10)).unwrap();
block_on(w.write(|db| {
db.insert(note(1));
Ok(())
}))
.unwrap();
block_on(w.undo(false)).unwrap();
assert_eq!(block_on(w.undo_status()).unwrap(), (false, true));
assert!(
block_on(w.read(|db| {
db.insert(note(2));
Ok(())
}))
.is_err()
);
assert_eq!(block_on(w.undo_status()).unwrap(), (false, true));
assert_eq!(count(&w), 0);
assert!(block_on(w.undo(true)).unwrap());
assert_eq!(count(&w), 1);
w.close_blocking().unwrap();
w.close_blocking().unwrap();
}
#[test]
fn deferred_constraint_commit_failure_rolls_back_and_worker_remains_usable() {
let w = block_on(DatabaseWorker::open(|| {
let db = ModelContainer::open(Sqlite::memory(), schema![Note])?;
db.try_with_connection(|c| c.execute_batch(
"CREATE TABLE parents(id INTEGER PRIMARY KEY); CREATE TABLE children(parent INTEGER REFERENCES parents(id) DEFERRABLE INITIALLY DEFERRED);"
))?;
Ok(db)
})).unwrap();
assert!(
block_on(w.write(|db| {
db.insert(note(1));
db.try_with_connection(|c| c.execute("INSERT INTO children VALUES(99)", &[]))
}))
.is_err()
);
assert_eq!(count(&w), 0);
block_on(w.write(|db| {
db.insert(note(1));
db.try_with_connection(|c| {
c.execute_batch("INSERT INTO parents VALUES(99); INSERT INTO children VALUES(99);")
})
}))
.unwrap();
assert_eq!(count(&w), 1);
w.close_blocking().unwrap();
}
#[test]
fn cancellation_and_failed_transactions_stress_preserve_exact_committed_state() {
for round in 0..10 {
let w = open();
let mut requests = Vec::new();
for i in 0..100 {
requests.push(w.write(move |db| {
db.insert(note(i));
if (i + round) % 3 == 0 {
db.save()?;
Err(DbError::driver("synthetic rollback"))
} else {
Ok(())
}
}));
drop(w.read(|db| db.table_count::<Note>()));
}
let committed = requests
.into_iter()
.map(block_on)
.filter(Result::is_ok)
.count();
assert_eq!(count(&w), committed as u64);
w.close_blocking().unwrap();
}
}
#[test]
fn backup_on_read_queue_is_a_reopenable_committed_snapshot() {
let file = temporary_db("backup");
let w = open();
block_on(w.write(|db| {
db.insert(note(1));
Ok(())
}))
.unwrap();
let destination = file.clone();
block_on(w.backup_to(destination)).unwrap();
block_on(w.write(|db| {
db.insert(note(2));
Ok(())
}))
.unwrap();
let backup = ModelContainer::open(Sqlite::at(&file), schema![Note]).unwrap();
assert_eq!(backup.table_count::<Note>().unwrap(), 1);
w.close_blocking().unwrap();
drop(backup);
std::fs::remove_dir_all(file.parent().unwrap()).unwrap();
}
struct FaultDriver {
fail: Arc<std::sync::atomic::AtomicU8>,
dropped: mpsc::Sender<std::thread::ThreadId>,
}
struct FaultConnection {
inner: Box<dyn day_persistence::SqliteConnection>,
fail: Arc<std::sync::atomic::AtomicU8>,
dropped: mpsc::Sender<std::thread::ThreadId>,
owner: std::thread::ThreadId,
}
impl Drop for FaultConnection {
fn drop(&mut self) {
assert_eq!(self.owner, std::thread::current().id());
let _ = self.dropped.send(self.owner);
}
}
impl day_persistence::SqliteDriver for FaultDriver {
type Connection = FaultConnection;
fn capabilities(&self) -> day_persistence::Capabilities {
let mut caps = Sqlite::memory().capabilities();
caps.external_changes = true;
caps
}
fn open(self) -> Result<Self::Connection, DbError> {
Ok(FaultConnection {
inner: Box::new(Sqlite::memory().open()?),
fail: self.fail,
dropped: self.dropped,
owner: std::thread::current().id(),
})
}
}
impl day_persistence::SqliteConnection for FaultConnection {
fn execute(&mut self, sql: &str, params: &[day_persistence::Value]) -> Result<u64, DbError> {
assert_eq!(self.owner, std::thread::current().id());
if self.fail.load(std::sync::atomic::Ordering::SeqCst) == 1 && sql == "ROLLBACK" {
return Err(DbError::driver("synthetic rollback failure"));
}
self.inner.execute(sql, params)
}
fn query(
&mut self,
sql: &str,
params: &[day_persistence::Value],
row: &mut dyn FnMut(&dyn day_persistence::Row),
) -> Result<(), DbError> {
assert_eq!(self.owner, std::thread::current().id());
if self
.fail
.compare_exchange(
3,
0,
std::sync::atomic::Ordering::SeqCst,
std::sync::atomic::Ordering::SeqCst,
)
.is_ok()
{
return Err(DbError::driver("synthetic post-commit refresh failure"));
}
self.inner.query(sql, params, row)
}
fn execute_batch(&mut self, sql: &str) -> Result<(), DbError> {
assert_eq!(self.owner, std::thread::current().id());
if self.fail.load(std::sync::atomic::Ordering::SeqCst) == 2
&& sql == "PRAGMA query_only = OFF"
{
return Err(DbError::driver("synthetic read-mode recovery failure"));
}
self.inner.execute_batch(sql)
}
}
fn fault_worker() -> (
DatabaseWorker,
Arc<std::sync::atomic::AtomicU8>,
mpsc::Receiver<std::thread::ThreadId>,
) {
let fail = Arc::new(std::sync::atomic::AtomicU8::new(0));
let flag = fail.clone();
let (tx, rx) = mpsc::channel();
let w = block_on(DatabaseWorker::open(move || {
ModelContainer::open(
FaultDriver {
fail: flag,
dropped: tx,
},
schema![Note],
)
}))
.unwrap();
(w, fail, rx)
}
#[test]
fn failed_rollback_closes_connection_on_owner_thread_and_rejects_further_work() {
let (w, fail, dropped) = fault_worker();
fail.store(1, std::sync::atomic::Ordering::SeqCst);
let error = block_on(w.write::<()>(|db| {
db.insert(note(1));
Err(DbError::driver("synthetic failed edit"))
}))
.unwrap_err();
assert_eq!(error.kind, DbErrorKind::Closed);
assert_eq!(block_on(w.close()).unwrap_err().kind, DbErrorKind::Closed);
assert_ne!(
dropped.recv_timeout(Duration::from_secs(5)).unwrap(),
std::thread::current().id()
);
assert!(block_on(w.write(|_| Ok(()))).is_err());
}
#[test]
fn projection_recovery_failure_reports_error_then_ends_subscription() {
let (w, fail, dropped) = fault_worker();
let mut sub = block_on(w.observe(|db| db.table_count::<Note>())).unwrap();
assert_eq!(block_on(sub.next()).unwrap().unwrap().value, 0);
fail.store(2, std::sync::atomic::Ordering::SeqCst);
block_on(w.write(|db| {
db.insert(note(1));
Ok(())
}))
.unwrap();
assert_eq!(
block_on(sub.next()).unwrap().unwrap_err().kind,
DbErrorKind::Closed
);
assert!(block_on(sub.next()).is_none());
assert!(block_on(w.close()).is_err());
dropped.recv_timeout(Duration::from_secs(5)).unwrap();
}
#[test]
fn cancelled_open_still_closes_its_eventual_connection_on_worker() {
let (started, begin) = mpsc::channel();
let (release, gate) = mpsc::channel();
let (dropped, finished) = mpsc::channel();
let mut opening = Box::pin(DatabaseWorker::open(move || {
started.send(()).unwrap();
gate.recv_timeout(Duration::from_secs(5)).unwrap();
ModelContainer::open(
FaultDriver {
fail: Arc::new(std::sync::atomic::AtomicU8::new(0)),
dropped,
},
schema![Note],
)
}));
assert!(
opening
.as_mut()
.poll(&mut Context::from_waker(Waker::noop()))
.is_pending()
);
begin.recv_timeout(Duration::from_secs(5)).unwrap();
drop(opening);
release.send(()).unwrap();
assert_ne!(
finished.recv_timeout(Duration::from_secs(5)).unwrap(),
std::thread::current().id()
);
}
#[test]
fn normal_close_and_panic_both_drop_connections_on_worker() {
for panic in [false, true] {
let (w, _, dropped) = fault_worker();
if panic {
assert!(block_on(w.write::<()>(|_| panic!("synthetic operation failure"))).is_err());
}
let result = w.close_blocking();
assert_eq!(result.is_err(), panic);
assert_ne!(
dropped.recv_timeout(Duration::from_secs(5)).unwrap(),
std::thread::current().id()
);
}
}
#[test]
fn wholesale_reset_clears_history_only_after_successful_commit() {
let w = open();
block_on(w.enable_undo(10)).unwrap();
block_on(w.write(|db| {
db.insert(note(1));
Ok(())
}))
.unwrap();
assert!(
block_on(w.write_resetting_undo::<()>(|db| {
db.delete::<Note>(1u64)?;
Err(DbError::driver("synthetic reset failure"))
}))
.is_err()
);
assert_eq!(count(&w), 1);
assert_eq!(block_on(w.undo_status()).unwrap(), (true, false));
assert!(block_on(w.undo(false)).unwrap());
assert!(block_on(w.undo(true)).unwrap());
block_on(w.write_resetting_undo(|db| db.delete::<Note>(1u64))).unwrap();
assert_eq!(count(&w), 0);
assert_eq!(block_on(w.undo_status()).unwrap(), (false, false));
assert!(!block_on(w.undo(false)).unwrap());
block_on(w.write(|db| {
db.insert(note(2));
Ok(())
}))
.unwrap();
assert!(block_on(w.undo(false)).unwrap());
assert_eq!(count(&w), 0);
block_on(w.close()).unwrap();
}
#[test]
fn transaction_participant_covers_intermediate_saves_reactions_and_rolls_back_atomically() {
use day_persistence::{
Refresh, RowChange, SqliteConnection, TransactionParticipant, Value, WriteOrigin,
};
use std::sync::atomic::{AtomicBool, Ordering};
struct Audit(Arc<AtomicBool>);
impl TransactionParticipant for Audit {
fn begin(&self, c: &mut dyn SqliteConnection, _: WriteOrigin) -> Result<(), DbError> {
c.execute("INSERT INTO audit_begin VALUES(1)", &[])?;
Ok(())
}
fn before_commit(
&self,
c: &mut dyn SqliteConnection,
origin: WriteOrigin,
_: &[RowChange],
) -> Result<Refresh, DbError> {
c.execute(
"INSERT INTO audit SELECT count(*),? FROM notes",
&[Value::Text(format!("{origin:?}"))],
)?;
if self.0.load(Ordering::SeqCst) {
return Err(DbError::driver("synthetic participant failure"));
}
Ok(Refresh::None)
}
}
let fail = Arc::new(AtomicBool::new(false));
let hook = fail.clone();
let w = block_on(DatabaseWorker::open(move || {
let db = ModelContainer::open(Sqlite::memory(), schema![Note])?;
db.try_with_connection(|c| {
c.execute_batch(
"CREATE TABLE audit(n INTEGER,origin TEXT); CREATE TABLE audit_begin(n INTEGER);",
)
})?;
db.install_transaction_participant(Audit(hook))?;
Ok(db)
}))
.unwrap();
block_on(w.write(|db| {
let signal = day_reactive::Signal::new(false);
let target = db.clone();
day_reactive::watch(
move || signal.get(),
move |ready, _| {
if *ready {
target.insert(note(2));
}
},
);
db.insert(note(1));
db.save()?;
db.insert(note(3));
signal.set(true);
Ok(())
}))
.unwrap();
assert_eq!(count(&w), 3);
let audit = block_on(w.read(|db| {
db.try_with_connection(|c| {
let mut out = vec![];
c.query("SELECT n,origin FROM audit", &[], &mut |r| {
out.push((r.get(0), r.get(1)))
})?;
Ok(out)
})
}))
.unwrap();
assert_eq!(audit, vec![(Value::Int(3), Value::Text("Local".into()))]);
fail.store(true, Ordering::SeqCst);
assert!(
block_on(w.write(|db| {
db.insert(note(4));
Ok(())
}))
.is_err()
);
assert_eq!(count(&w), 3);
fail.store(false, Ordering::SeqCst);
block_on(w.write_with_origin(WriteOrigin::RemoteImport, |db| {
db.insert(note(5));
Ok(())
}))
.unwrap();
block_on(w.read(|db| {
db.try_with_connection(|c| {
let mut rows = vec![];
c.query("SELECT n,origin FROM audit", &[], &mut |r| {
rows.push((r.get(0), r.get(1)))
})?;
assert_eq!(
rows,
vec![
(Value::Int(3), Value::Text("Local".into())),
(Value::Int(4), Value::Text("RemoteImport".into()))
]
);
c.query("SELECT count(*) FROM audit_begin", &[], &mut |r| {
assert_eq!(r.get(0), Value::Int(2))
})?;
Ok(())
})
}))
.unwrap();
block_on(w.close()).unwrap();
}
#[test]
fn failed_participant_admission_rollback_closes_the_worker() {
struct Reject;
impl day_persistence::TransactionParticipant for Reject {
fn begin(
&self,
_: &mut dyn day_persistence::SqliteConnection,
_: day_persistence::WriteOrigin,
) -> Result<(), DbError> {
Err(DbError::driver("synthetic admission failure"))
}
fn before_commit(
&self,
_: &mut dyn day_persistence::SqliteConnection,
_: day_persistence::WriteOrigin,
_: &[day_persistence::RowChange],
) -> Result<day_persistence::Refresh, DbError> {
unreachable!()
}
}
let fail = Arc::new(std::sync::atomic::AtomicU8::new(0));
let flag = fail.clone();
let (tx, rx) = mpsc::channel();
let w = block_on(DatabaseWorker::open(move || {
let db = ModelContainer::open(
FaultDriver {
fail: flag,
dropped: tx,
},
schema![Note],
)?;
db.install_transaction_participant(Reject)?;
Ok(db)
}))
.unwrap();
fail.store(1, std::sync::atomic::Ordering::SeqCst);
assert_eq!(
block_on(w.write(|_| Ok(()))).unwrap_err().kind,
DbErrorKind::Closed
);
assert_eq!(block_on(w.close()).unwrap_err().kind, DbErrorKind::Closed);
assert_ne!(
rx.recv_timeout(Duration::from_secs(5)).unwrap(),
std::thread::current().id()
);
assert!(block_on(w.write(|_| Ok(()))).is_err());
}
#[test]
fn committed_refresh_failure_preserves_revision_and_undo_including_reset() {
use day_persistence::{
Refresh, RowChange, SqliteConnection, TransactionParticipant, WriteOrigin,
};
struct RefreshFault(Arc<std::sync::atomic::AtomicU8>);
impl TransactionParticipant for RefreshFault {
fn begin(&self, _: &mut dyn SqliteConnection, _: WriteOrigin) -> Result<(), DbError> {
Ok(())
}
fn before_commit(
&self,
_: &mut dyn SqliteConnection,
_: WriteOrigin,
_: &[RowChange],
) -> Result<Refresh, DbError> {
self.0.store(3, std::sync::atomic::Ordering::SeqCst);
Ok(Refresh::All)
}
}
let flag = Arc::new(std::sync::atomic::AtomicU8::new(0));
let (tx, _rx) = mpsc::channel();
let w = block_on(DatabaseWorker::open(move || {
let db = ModelContainer::open(
FaultDriver {
fail: flag.clone(),
dropped: tx,
},
schema![Note],
)?;
db.install_transaction_participant(RefreshFault(flag))?;
Ok(db)
}))
.unwrap();
block_on(w.enable_undo(10)).unwrap();
let mut observed = block_on(w.observe(|db| db.table_count::<Note>())).unwrap();
assert_eq!(block_on(observed.next()).unwrap().unwrap().revision, 0);
let err = block_on(w.write(|db| {
db.insert(note(1));
Ok(())
}))
.unwrap_err();
assert_eq!(err.kind, DbErrorKind::CommittedRefreshFailed);
assert_eq!(count(&w), 1);
let snapshot = block_on(observed.next()).unwrap().unwrap();
assert_eq!((snapshot.revision, snapshot.value), (1, 1));
assert_eq!(block_on(w.undo_status()).unwrap(), (true, false));
assert_eq!(
block_on(w.undo(false)).unwrap_err().kind,
DbErrorKind::CommittedRefreshFailed
);
assert_eq!(count(&w), 0);
assert_eq!(block_on(w.undo_status()).unwrap(), (false, true));
assert_eq!(
block_on(w.undo(true)).unwrap_err().kind,
DbErrorKind::CommittedRefreshFailed
);
assert_eq!(count(&w), 1);
assert_eq!(
block_on(w.write_resetting_undo(|db| db.delete::<Note>(1u64)))
.unwrap_err()
.kind,
DbErrorKind::CommittedRefreshFailed
);
assert_eq!(count(&w), 0);
assert_eq!(block_on(w.undo_status()).unwrap(), (false, false));
block_on(w.close()).unwrap();
}
#[test]
fn participant_refreshes_direct_save_autosave_and_nonlocal_worker_origins() {
use day_persistence::{
Refresh, RowChange, SqliteConnection, TransactionParticipant, WriteOrigin,
};
struct Project;
impl TransactionParticipant for Project {
fn begin(&self, _: &mut dyn SqliteConnection, _: WriteOrigin) -> Result<(), DbError> {
Ok(())
}
fn before_commit(
&self,
c: &mut dyn SqliteConnection,
origin: WriteOrigin,
_: &[RowChange],
) -> Result<Refresh, DbError> {
c.execute("UPDATE notes SET read=1", &[])?;
c.execute(
"INSERT INTO origins VALUES(?)",
&[day_persistence::Value::Text(format!("{origin:?}"))],
)?;
Ok(Refresh::All)
}
}
fn factory() -> Result<ModelContainer, DbError> {
let db = ModelContainer::open(Sqlite::memory(), schema![Note])?;
db.try_with_connection(|c| c.execute_batch("CREATE TABLE origins(value TEXT)"))?;
db.install_transaction_participant(Project)?;
Ok(db)
}
let scope = day_reactive::Scope::detached();
scope.enter(|| {
let db = factory().unwrap();
db.set_autosave(false);
db.insert(note(1));
db.save().unwrap();
assert!(db.get::<Note>(1u64).unwrap().read().read());
db.set_autosave(true);
day_reactive::batch(|| {
db.insert(note(2));
});
let rows = db.query::<Note>().live().try_collect().unwrap();
assert_eq!(rows.len(), 2);
assert!(rows.iter().all(|r| r.read));
});
scope.dispose();
let w = block_on(DatabaseWorker::open(factory)).unwrap();
for origin in [WriteOrigin::RemoteImport, WriteOrigin::Maintenance] {
block_on(w.write_with_origin(origin, |db| {
db.insert(note(1));
Ok(())
}))
.unwrap();
block_on(w.read(|db| {
assert!(db.query::<Note>().live().try_collect().unwrap()[0].read);
Ok(())
}))
.unwrap();
block_on(w.write_with_origin(WriteOrigin::Maintenance, |db| db.delete::<Note>(1u64)))
.unwrap();
}
block_on(w.close()).unwrap();
}
#[test]
fn direct_save_refresh_failure_does_not_rejournal_the_already_committed_edit() {
use day_persistence::{
Refresh, RowChange, SqliteConnection, TransactionParticipant, WriteOrigin,
};
struct CountCommits(Arc<std::sync::atomic::AtomicU8>);
impl TransactionParticipant for CountCommits {
fn begin(&self, _: &mut dyn SqliteConnection, _: WriteOrigin) -> Result<(), DbError> {
Ok(())
}
fn before_commit(
&self,
c: &mut dyn SqliteConnection,
_: WriteOrigin,
_: &[RowChange],
) -> Result<Refresh, DbError> {
c.execute("INSERT INTO committed_once VALUES(1)", &[])?;
self.0.store(3, std::sync::atomic::Ordering::SeqCst);
Ok(Refresh::All)
}
}
day_reactive::Scope::detached().enter(|| {
let flag = Arc::new(std::sync::atomic::AtomicU8::new(0));
let (tx, _rx) = mpsc::channel();
let db = ModelContainer::open(
FaultDriver {
fail: flag.clone(),
dropped: tx,
},
schema![Note],
)
.unwrap();
db.set_autosave(false);
db.try_with_connection(|c| c.execute_batch("CREATE TABLE committed_once(value INTEGER)"))
.unwrap();
db.install_transaction_participant(CountCommits(flag))
.unwrap();
db.insert(note(1));
assert_eq!(
db.save().unwrap_err().kind,
DbErrorKind::CommittedRefreshFailed
);
db.rescan().unwrap();
db.save().unwrap();
db.try_with_connection(|c| {
c.query("SELECT count(*) FROM committed_once", &[], &mut |r| {
assert_eq!(r.get(0), day_persistence::Value::Int(1))
})
})
.unwrap();
assert_eq!(db.table_count::<Note>().unwrap(), 1);
});
}
struct ChangeLog {
sets: Arc<std::sync::Mutex<Vec<Vec<day_persistence::RowChange>>>>,
fail: Arc<std::sync::atomic::AtomicBool>,
}
impl day_persistence::TransactionParticipant for ChangeLog {
fn begin(
&self,
_: &mut dyn day_persistence::SqliteConnection,
_: day_persistence::WriteOrigin,
) -> Result<(), DbError> {
Ok(())
}
fn before_commit(
&self,
_: &mut dyn day_persistence::SqliteConnection,
_: day_persistence::WriteOrigin,
changes: &[day_persistence::RowChange],
) -> Result<day_persistence::Refresh, DbError> {
self.sets.lock().unwrap().push(changes.to_vec());
if self.fail.swap(false, std::sync::atomic::Ordering::SeqCst) {
return Err(DbError::driver("synthetic participant failure"));
}
Ok(day_persistence::Refresh::None)
}
}
type ChangeSets = Arc<std::sync::Mutex<Vec<Vec<day_persistence::RowChange>>>>;
fn change_log_worker() -> (
DatabaseWorker,
ChangeSets,
Arc<std::sync::atomic::AtomicBool>,
) {
let sets: ChangeSets = Arc::default();
let fail = Arc::new(std::sync::atomic::AtomicBool::new(false));
let (log, flag) = (sets.clone(), fail.clone());
let w = block_on(DatabaseWorker::open(move || {
let db = ModelContainer::open(Sqlite::memory(), schema![Note])?;
db.install_transaction_participant(ChangeLog {
sets: log,
fail: flag,
})?;
Ok(db)
}))
.unwrap();
(w, sets, fail)
}
fn row_change(
key: u64,
kind: day_persistence::RowChangeKind,
authors: &[&'static str],
) -> day_persistence::RowChange {
day_persistence::RowChange {
table: "notes",
key: vec![day_persistence::Value::Int(key as i64)],
kind,
authors: authors.to_vec(),
}
}
#[test]
fn participant_receives_the_folded_change_set_with_kinds_columns_and_authors() {
use day_persistence::RowChangeKind::{Deleted, Inserted, Rewritten, Updated};
let (w, sets, _) = change_log_worker();
block_on(w.enable_undo(10)).unwrap();
block_on(w.write(|db| {
db.insert(note(1));
db.insert(note(2));
Ok(())
}))
.unwrap();
block_on(w.write(|db| {
day_model::with_author("importer", || {
db.get::<Note>(1u64)
.unwrap()
.title()
.write("renamed".into());
});
db.get::<Note>(1u64).unwrap().read().write(true);
db.delete::<Note>(2u64)
}))
.unwrap();
assert!(block_on(w.undo(false)).unwrap());
block_on(w.write(|db| {
day_model::with_author("catalog", || {
db.cache::<Note>().update("replace", |k| {
*k = day_model::Keyed::new(vec![note(7), note(8)]);
});
});
Ok(())
}))
.unwrap();
let sets = sets.lock().unwrap();
assert_eq!(sets.len(), 4);
assert_eq!(
sets[0],
vec![row_change(1, Inserted, &[]), row_change(2, Inserted, &[])]
);
assert_eq!(
sets[1],
vec![
row_change(1, Updated(vec!["title", "read"]), &["importer"]),
row_change(2, Deleted, &[]),
]
);
let mut undone = sets[2].clone();
undone.sort_by_key(|c| {
c.key
.clone()
.into_iter()
.map(|v| format!("{v:?}"))
.collect::<Vec<_>>()
});
assert_eq!(
undone,
vec![
row_change(1, Updated(vec!["read"]), &["undo"]),
row_change(2, Inserted, &["undo"]),
]
);
let mut rewritten = sets[3].clone();
rewritten.sort_by(|a, b| format!("{:?}", a.key).cmp(&format!("{:?}", b.key)));
assert_eq!(
rewritten,
vec![
row_change(7, Rewritten, &["catalog"]),
row_change(8, Rewritten, &["catalog"]),
]
);
block_on(w.close()).unwrap();
}
#[test]
fn participant_change_set_accumulates_across_intermediate_saves_and_clears_on_rollback() {
use day_persistence::RowChangeKind::{Inserted, Updated};
let (w, sets, fail) = change_log_worker();
block_on(w.write(|db| {
db.insert(note(1));
db.save()?;
db.get::<Note>(1u64).unwrap().read().write(true);
db.save()?;
db.insert(note(2));
Ok(())
}))
.unwrap();
assert!(
block_on(w.write::<()>(|db| {
db.insert(note(3));
db.save()?;
db.get::<Note>(1u64).unwrap().title().write("lost".into());
Err(DbError::driver("synthetic rejection"))
}))
.is_err()
);
block_on(w.write(|db| {
db.insert(note(4));
Ok(())
}))
.unwrap();
fail.store(true, std::sync::atomic::Ordering::SeqCst);
assert!(
block_on(w.write(|db| {
db.get::<Note>(4u64).unwrap().read().write(true);
Ok(())
}))
.is_err()
);
block_on(w.write(|db| {
db.insert(note(5));
Ok(())
}))
.unwrap();
assert_eq!(count(&w), 4);
let sets = sets.lock().unwrap();
assert_eq!(
*sets,
vec![
vec![row_change(1, Inserted, &[]), row_change(2, Inserted, &[])],
vec![row_change(4, Inserted, &[])],
vec![row_change(4, Updated(vec!["read"]), &[])],
vec![row_change(5, Inserted, &[])],
]
);
block_on(w.close()).unwrap();
}
#[derive(Model, Clone, Default, PartialEq, Debug)]
#[model(table = "tags")]
struct Tag {
#[model(id)]
id: u64,
label: String,
uses: i64,
}
#[test]
fn table_scoped_refresh_rereads_only_the_named_table() {
use day_persistence::{
Refresh, RowChange, SqliteConnection, TransactionParticipant, WriteOrigin,
};
use std::{cell::RefCell, rc::Rc};
struct Projector(Arc<std::sync::atomic::AtomicBool>);
impl TransactionParticipant for Projector {
fn begin(&self, _: &mut dyn SqliteConnection, _: WriteOrigin) -> Result<(), DbError> {
Ok(())
}
fn before_commit(
&self,
c: &mut dyn SqliteConnection,
_: WriteOrigin,
_: &[RowChange],
) -> Result<Refresh, DbError> {
c.execute("UPDATE notes SET read = 1", &[])?;
c.execute("UPDATE tags SET uses = uses + 1", &[])?;
Ok(if self.0.load(std::sync::atomic::Ordering::SeqCst) {
Refresh::All
} else {
Refresh::Tables(vec!["notes"])
})
}
}
let scope = day_reactive::Scope::detached();
scope.enter(|| {
let trace: Rc<RefCell<Vec<String>>> = Rc::default();
let sink = trace.clone();
let driver = Sqlite::memory().trace_sql(move |sql| sink.borrow_mut().push(sql.to_string()));
let everything = Arc::new(std::sync::atomic::AtomicBool::new(false));
let db = ModelContainer::open(driver, schema![Note, Tag]).unwrap();
db.set_autosave(false);
db.install_transaction_participant(Projector(everything.clone()))
.unwrap();
db.insert(note(1));
db.insert(Tag {
id: 1,
label: "fresh".into(),
uses: 0,
});
db.save().unwrap();
assert!(db.get::<Note>(1u64).unwrap().read().read());
assert_eq!(db.get::<Tag>(1u64).unwrap().uses().read(), 0);
let tags = db.query::<Tag>().live();
let notes = db.query::<Note>().live();
assert_eq!((tags.ids().len(), notes.ids().len()), (1, 1));
trace.borrow_mut().clear();
db.get::<Note>(1u64).unwrap().title().write("edited".into());
db.save().unwrap();
let touched_tags: Vec<String> = trace
.borrow()
.iter()
.filter(|s| s.starts_with("SELECT") && s.contains("\"tags\""))
.cloned()
.collect();
assert!(touched_tags.is_empty(), "{touched_tags:?}");
assert!(
trace
.borrow()
.iter()
.any(|s| s.starts_with("SELECT") && s.contains("\"notes\"")),
"{:?}",
trace.borrow()
);
assert_eq!(db.get::<Tag>(1u64).unwrap().uses().read(), 0);
everything.store(true, std::sync::atomic::Ordering::SeqCst);
trace.borrow_mut().clear();
db.get::<Note>(1u64).unwrap().read().write(false);
db.save().unwrap();
assert_eq!(db.get::<Tag>(1u64).unwrap().uses().read(), 3);
assert!(
trace
.borrow()
.iter()
.any(|s| s.starts_with("SELECT") && s.contains("\"tags\"")),
"{:?}",
trace.borrow()
);
assert_eq!((tags.ids().len(), notes.ids().len()), (1, 1));
});
scope.dispose();
}