use std::cell::RefCell;
use std::path::{Path, PathBuf};
use std::rc::Rc;
use std::sync::Arc;
use std::time::Duration;
use zero_client::ast::System;
use zero_client::client::{Mutator, Transaction, Zero, ZeroOptions, ZeroStorage};
use zero_client::json::{self, Object, Value};
use zero_client::query::AnyQuery;
use zero_client::schema::Schema;
use zero_client::testing::ManualScheduler;
use zero_client::ttl::Ttl;
const DAY_MS: f64 = 24.0 * 60.0 * 60_000.0;
fn schema() -> Arc<Schema> {
let schema = json::parse(
r#"{"tables": {"issue": {"name": "issue", "columns": {
"id": {"type": "string"}, "title": {"type": "string"}}, "primaryKey": ["id"]}}}"#,
)
.unwrap();
Arc::new(Schema::from_json(&schema).unwrap())
}
fn directory(test: &str) -> PathBuf {
let dir = std::env::temp_dir().join(format!("zero-sqlite-{test}-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
dir
}
fn files(dir: &Path) -> Vec<PathBuf> {
let mut out: Vec<PathBuf> = std::fs::read_dir(dir)
.map(|d| {
d.filter_map(|e| e.ok())
.map(|e| e.path())
.filter(|p| {
let n = p.file_name().unwrap().to_str().unwrap();
n.starts_with("zero-v1-") && n.ends_with(".sqlite")
})
.collect()
})
.unwrap_or_default();
out.sort();
out
}
struct Client {
zero: Zero,
scheduler: Rc<ManualScheduler>,
events: Rc<RefCell<Vec<String>>>,
}
fn client(storage: ZeroStorage, key: &str, now: f64) -> Client {
let scheduler = ManualScheduler::new(now);
let events = Rc::new(RefCell::new(Vec::new()));
let (e1, e2) = (events.clone(), events.clone());
let create = Mutator::new("create", |tx: &Transaction, args, _: &()| {
let args = args.unwrap();
let mut row = Object::new();
row.insert("id", args.get("id").unwrap().clone());
row.insert("title", args.get("title").unwrap().clone());
tx.table("issue").insert(&row)?;
Ok(None)
});
let zero = Zero::new(
schema(),
(),
vec![create],
ZeroOptions {
storage,
storage_key: Some(key.to_owned()),
on_client_state_not_found: Some(Rc::new(move || {
e1.borrow_mut().push("clientStateNotFound".into())
})),
on_storage_failure: Some(Rc::new(move |f| {
e2.borrow_mut()
.push(format!("storageFailure {}", f.kind.as_str()))
})),
log_sink: Some(Rc::new(zero_client::testing::RecordingLogSink::default())),
..ZeroOptions::default()
},
scheduler.clone(),
None,
)
.unwrap();
scheduler.run_checkpoints();
Client {
zero,
scheduler,
events,
}
}
impl Client {
fn create(&self, id: &str, title: &str) {
let mut args = Object::new();
args.insert("id", Value::from(id));
args.insert("title", Value::from(title));
self.zero.mutate("create", Some(Value::Object(args)));
self.scheduler.run_checkpoints();
}
fn issues(&self) -> Vec<String> {
let q = AnyQuery::new(schema(), "issue", System::Client);
let view = self.zero.materialize(&q, &Ttl::default()).unwrap();
self.scheduler.run_checkpoints();
let rows: Vec<String> = view
.data()
.entries()
.iter()
.map(|e| {
format!(
"{}:{}",
e.row.get("id").unwrap().as_str().unwrap(),
e.row.get("title").unwrap().as_str().unwrap()
)
})
.collect();
view.destroy();
rows
}
}
fn sqlite(dir: &Path) -> ZeroStorage {
ZeroStorage::Sqlite {
directory: Some(dir.to_owned()),
}
}
fn edit(file: &Path, sql: &str) {
let db = rusqlite::Connection::open(file).unwrap();
db.execute_batch(sql).unwrap();
}
fn count(file: &Path, sql: &str) -> i64 {
let db = rusqlite::Connection::open(file).unwrap();
db.query_row(sql, [], |r| r.get(0)).unwrap()
}
#[test]
fn a_relaunch_reads_what_the_last_client_wrote_to_disk() {
let dir = directory("relaunch");
let first = client(sqlite(&dir), "k", 1_000.0);
first.create("i1", "Written");
assert_eq!(first.issues(), ["i1:Written"]);
first.zero.flush_storage();
let [file] = files(&dir).try_into().unwrap();
assert_eq!(count(&file, "SELECT count(*) FROM mutations"), 1);
assert_eq!(count(&file, "SELECT count(*) FROM clients"), 1);
let group = first.zero.client_group_id();
drop(first);
edit(
&file,
r#"UPDATE mutations SET args = '{"id":"i1","title":"From disk"}'"#,
);
let second = client(sqlite(&dir), "k", 2_000.0);
assert_eq!(second.zero.client_group_id(), group);
assert_eq!(second.issues(), ["i1:From disk"]);
second.zero.flush_storage();
assert_eq!(count(&file, "SELECT count(*) FROM clients"), 2);
assert!(second.events.borrow().is_empty(), "{:?}", second.events);
drop(second);
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn a_store_that_does_not_decode_is_dropped_as_lost_client_state() {
let dir = directory("corrupt");
let first = client(sqlite(&dir), "k", 1_000.0);
first.create("i1", "Lost");
let group = first.zero.client_group_id();
drop(first);
let [file] = files(&dir).try_into().unwrap();
edit(&file, "UPDATE mutations SET args = '{not json'");
let second = client(sqlite(&dir), "k", 2_000.0);
assert_eq!(*second.events.borrow(), ["clientStateNotFound"]);
assert_ne!(second.zero.client_group_id(), group);
assert!(second.issues().is_empty());
second.zero.flush_storage();
let [file] = files(&dir).try_into().unwrap();
assert_eq!(count(&file, "SELECT count(*) FROM mutations"), 0);
assert_eq!(count(&file, "SELECT count(*) FROM client_groups"), 1);
drop(second);
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn a_store_that_cannot_open_falls_back_to_memory_and_says_so_once() {
let dir = directory("cannot-open");
std::fs::create_dir_all(&dir).unwrap();
let not_a_directory = dir.join("file");
std::fs::write(¬_a_directory, "x").unwrap();
let c = client(sqlite(¬_a_directory), "k", 1_000.0);
assert_eq!(*c.events.borrow(), ["storageFailure cannot-open"]);
c.create("i1", "In memory");
assert_eq!(c.issues(), ["i1:In memory"]);
c.zero.flush_storage();
assert_eq!(c.events.borrow().len(), 1);
drop(c);
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn delete_closes_the_client_and_removes_its_file() {
let dir = directory("delete");
let other = client(sqlite(&dir), "other", 1_000.0);
other.create("o1", "Other user's");
drop(other);
let c = client(sqlite(&dir), "k", 1_000.0);
c.create("i1", "Gone");
assert_eq!(files(&dir).len(), 2);
let dropped = c.zero.delete();
assert!(c.zero.closed());
assert_eq!(dropped.deleted.len(), 1, "{dropped:?}");
assert!(dropped.errors.is_empty());
assert_eq!(files(&dir).len(), 1);
drop(c);
let again = client(sqlite(&dir), "k", 2_000.0);
assert!(again.issues().is_empty());
let other = client(sqlite(&dir), "other", 2_000.0);
assert_eq!(other.issues(), ["o1:Other user's"]);
drop((again, other));
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn the_database_gc_deletes_old_files_and_keeps_current_ones() {
let dir = directory("gc");
let old = client(sqlite(&dir), "old", 1_000.0);
drop(old);
let [old_file] = files(&dir).try_into().unwrap();
let recent = client(sqlite(&dir), "recent", 1_000.0 + 2.5 * DAY_MS);
drop(recent);
assert_eq!(files(&dir).len(), 2);
let c = client(sqlite(&dir), "current", 1_000.0 + 3.0 * DAY_MS);
c.create("i1", "Kept");
let before = files(&dir);
assert_eq!(before.len(), 3);
c.scheduler.advance(5.0 * 60_000.0);
let deadline = std::time::Instant::now() + Duration::from_secs(10);
while files(&dir).len() == 3 && std::time::Instant::now() < deadline {
std::thread::sleep(Duration::from_millis(10));
}
let after = files(&dir);
assert_eq!(after.len(), 2, "{after:?}");
assert!(!old_file.exists());
assert_eq!(c.issues(), ["i1:Kept"]);
drop(c);
let recent = client(sqlite(&dir), "recent", 1_000.0 + 3.0 * DAY_MS);
assert!(recent.events.borrow().is_empty());
drop(recent);
let _ = std::fs::remove_dir_all(&dir);
}