use std::collections::HashSet;
use std::path::Path;
use std::sync::Arc;
use std::sync::atomic::{AtomicI64, Ordering};
use chrono::{DateTime, Duration, Utc};
use second_brain_core::{
schema::{
Distillation, Entity, Memory, MemoryType, Relation, RelationType, SyncEntry, SyncNodeType,
SyncOp, SyncRecord,
},
sqlite_store::{ClockFloorRejected, ClockFloors, SqliteStore, WallClock},
store::{ApplyOutcome, SkipReason, Store, StoreAdmin},
};
use tempfile::tempdir;
const SECOND: i64 = 1_000_000;
const T0: i64 = 1_790_000_000 * SECOND;
struct TestClock(AtomicI64);
impl TestClock {
fn at(micros: i64) -> Arc<Self> {
Arc::new(Self(AtomicI64::new(micros)))
}
}
impl WallClock for TestClock {
fn now_micros(&self) -> Option<i64> {
Some(self.0.load(Ordering::SeqCst))
}
}
fn open(path: &Path, clock: &Arc<TestClock>) -> SqliteStore {
SqliteStore::open(path, "machine-a".to_string())
.unwrap()
.with_wall_clock(clock.clone())
}
fn copy_db(from: &Path, to: &Path) {
for suffix in ["", "-wal"] {
let src = Path::new(&format!("{}{suffix}", from.display())).to_path_buf();
if src.exists() {
std::fs::copy(&src, format!("{}{suffix}", to.display())).unwrap();
}
}
}
fn memory(content: &str) -> Memory {
Memory::new(
content.to_string(),
MemoryType::Semantic,
"test".to_string(),
String::new(),
)
}
fn write(store: &SqliteStore, n: usize, tag: &str) {
for i in 0..n {
store.store_memory(&memory(&format!("{tag} {i}"))).unwrap();
}
}
fn own_entries(store: &SqliteStore) -> Vec<SyncEntry> {
store
.sync_log_since(0)
.unwrap()
.into_iter()
.filter(|e| e.origin_machine_id == "machine-a")
.collect()
}
fn seqs_and_keys(entries: &[SyncEntry]) -> (HashSet<i64>, HashSet<String>) {
(
entries.iter().map(|e| e.local_seq).collect(),
entries.iter().map(|e| e.id.clone()).collect(),
)
}
fn as_record(e: &SyncEntry) -> SyncRecord {
SyncRecord {
local_seq: e.local_seq as u64,
origin_machine_id: e.origin_machine_id.clone(),
origin_seq: e.origin_seq as u64,
op: e.op,
node_type: e.node_type,
node_id: e.node_id.clone(),
timestamp: e.timestamp,
data: e.data.as_deref().map(|d| serde_json::from_str(d).unwrap()),
}
}
fn assert_disjoint(original: &[SyncEntry], restored_new: &[SyncEntry]) {
let (seqs, keys) = seqs_and_keys(original);
for e in restored_new {
assert!(
!seqs.contains(&e.local_seq),
"restored store reissued local_seq {}",
e.local_seq
);
assert!(
!keys.contains(&e.id),
"restored store reissued key {}",
e.id
);
}
}
fn new_since(store: &SqliteStore, before: &[SyncEntry]) -> Vec<SyncEntry> {
let (_, keys) = seqs_and_keys(before);
own_entries(store)
.into_iter()
.filter(|e| !keys.contains(&e.id))
.collect()
}
fn original_and_copy(dir: &Path, clock: &Arc<TestClock>) -> (Vec<SyncEntry>, std::path::PathBuf) {
let a_path = dir.join("a.db");
let b_path = dir.join("b.db");
{
let a = open(&a_path, clock);
write(&a, 2, "before copy");
}
copy_db(&a_path, &b_path);
let a = open(&a_path, clock);
write(&a, 2, "after copy");
(own_entries(&a), b_path)
}
#[test]
fn a_restored_copy_with_a_later_clock_never_reissues_a_seq_or_key() {
let dir = tempdir().unwrap();
let clock = TestClock::at(T0);
let (original, b_path) = original_and_copy(dir.path(), &clock);
let later = TestClock::at(T0 + 3600 * SECOND);
let restored = open(&b_path, &later);
let copied = own_entries(&restored);
write(&restored, 3, "restored");
let minted = new_since(&restored, &copied);
assert_eq!(minted.len(), 3);
assert_disjoint(&original, &minted);
}
#[test]
fn a_restored_copy_with_a_clock_behind_is_made_safe_by_a_peer_report() {
let dir = tempdir().unwrap();
let clock = TestClock::at(T0);
let (original, b_path) = original_and_copy(dir.path(), &clock);
let peer = SqliteStore::in_memory("machine-p".to_string()).unwrap();
let records: Vec<SyncRecord> = original.iter().map(as_record).collect();
peer.apply_batch(&records).unwrap();
let cursor = original.iter().map(|e| e.local_seq).max().unwrap();
let floors = ClockFloors {
basis_micros: None,
last_seq: Some(cursor),
held_origin_seq: peer.highest_origin_seq("machine-a").unwrap(),
};
assert_eq!(
floors.held_origin_seq,
original.iter().map(|e| e.origin_seq).max()
);
let behind = TestClock::at(T0 - 3600 * SECOND);
let restored = open(&b_path, &behind);
let copied = own_entries(&restored);
assert!(
restored.clock_state().unwrap().last < cursor,
"the copy alone would mint inside the original's range"
);
restored.raise_clock_floors(&floors).unwrap();
write(&restored, 3, "restored");
let minted = new_since(&restored, &copied);
assert_eq!(minted.len(), 3);
assert_disjoint(&original, &minted);
}
fn authored_at(origin_seq: u64) -> DateTime<Utc> {
DateTime::from_timestamp_micros(1_790_000_000_000_000 + (origin_seq & 0xffff_ffff) as i64)
.unwrap()
}
fn update_record(origin_seq: u64, entity: &Entity) -> SyncRecord {
SyncRecord {
local_seq: origin_seq,
origin_machine_id: "machine-a".to_string(),
origin_seq,
op: SyncOp::Update,
node_type: SyncNodeType::Entity,
node_id: entity.id.to_string(),
timestamp: authored_at(origin_seq),
data: Some(serde_json::to_value(entity).unwrap()),
}
}
fn entity_name(store: &SqliteStore, entity: &Entity) -> String {
store.get_entity(entity.id).unwrap().unwrap().name
}
#[test]
fn a_record_relayed_twice_is_applied_once_while_logged_and_after_compaction() {
let b = SqliteStore::in_memory("machine-b".to_string()).unwrap();
let incarnation = 7u64 << 32;
let first = Entity::new("first name".to_string(), "tool".to_string());
let mut second = first.clone();
second.name = "second name".to_string();
let r1 = update_record(incarnation | 1, &first);
let r2 = update_record(incarnation | 2, &second);
assert_eq!(b.apply_record(&r1).unwrap(), ApplyOutcome::Created);
assert_eq!(b.apply_record(&r2).unwrap(), ApplyOutcome::Updated);
assert_eq!(
b.apply_record(&r1).unwrap(),
ApplyOutcome::Skipped(SkipReason::AlreadyPresent)
);
assert_eq!(entity_name(&b, &first), "second name");
let stats = b.compact_sync_log(&[SyncOp::Update], false).unwrap();
assert_eq!(stats.rows_deleted, 1);
let r1_key = format!("machine-a:{}", incarnation | 1);
assert!(
b.sync_log_since(0).unwrap().iter().all(|e| e.id != r1_key),
"compaction dropped the first update's relay row"
);
assert_eq!(
b.apply_batch(std::slice::from_ref(&r1)).unwrap(),
vec![ApplyOutcome::Skipped(SkipReason::AlreadyPresent)]
);
assert_eq!(entity_name(&b, &first), "second name");
}
#[test]
fn a_record_relayed_after_gc_moved_its_key_is_skipped_as_already_present() {
let b = SqliteStore::in_memory("machine-b".to_string()).unwrap();
let incarnation = 9u64 << 32;
let mut m = memory("relayed memory");
let record = |seq: u64, op: SyncOp, data: Option<&Memory>| SyncRecord {
local_seq: seq,
origin_machine_id: "machine-a".to_string(),
origin_seq: seq,
op,
node_type: SyncNodeType::Memory,
node_id: m.id.to_string(),
timestamp: authored_at(seq),
data: data.map(|d| serde_json::to_value(d).unwrap()),
};
let create = record(incarnation | 1, SyncOp::Create, Some(&m));
m.updated_at += Duration::seconds(5);
m.content = "relayed memory, edited".to_string();
let update = record(incarnation | 2, SyncOp::Update, Some(&m));
let delete = record(incarnation | 3, SyncOp::Delete, None);
for r in [&create, &update, &delete] {
b.apply_record(r).unwrap();
}
let stats = b.repair(None, None, false).unwrap();
assert_eq!(
stats.sync_log_rows_deleted, 0,
"applying the delete already reclaimed the create and update"
);
for r in [&create, &update] {
assert_eq!(
b.apply_record(r).unwrap(),
ApplyOutcome::Skipped(SkipReason::AlreadyPresent),
"a key gc moved into sync_dedup is caught before apply"
);
}
}
#[test]
fn a_delete_arriving_before_its_create_keeps_a_tombstone_that_refuses_the_create() {
let c = SqliteStore::in_memory("machine-c".to_string()).unwrap();
let from = memory("relation source");
let to = memory("relation target, late");
c.store_memory(&from).unwrap();
let relation = Relation {
from_id: from.id,
to_id: to.id,
relation_type: RelationType::RelatesTo,
strength: 1.0,
context: None,
};
let incarnation = 11u64 << 32;
let record = |seq: u64, op: SyncOp| SyncRecord {
local_seq: seq,
origin_machine_id: "machine-a".to_string(),
origin_seq: seq,
op,
node_type: SyncNodeType::Relation,
node_id: format!("{}->{}", from.id, to.id),
timestamp: authored_at(seq),
data: Some(serde_json::to_value(&relation).unwrap()),
};
let create = record(incarnation | 1, SyncOp::Create);
let delete = record(incarnation | 2, SyncOp::Delete);
assert_eq!(
c.apply_batch(&[create.clone(), delete.clone()]).unwrap(),
vec![
ApplyOutcome::Skipped(SkipReason::DanglingEndpoint),
ApplyOutcome::Deleted,
]
);
c.store_memory(&to).unwrap();
assert_eq!(
c.apply_batch(&[create, delete]).unwrap(),
vec![
ApplyOutcome::Skipped(SkipReason::StaleWrite),
ApplyOutcome::Skipped(SkipReason::AlreadyPresent),
]
);
assert!(c.get_relations(from.id, None).unwrap().is_empty());
}
#[test]
fn an_older_relayed_relation_record_never_undoes_a_newer_one_from_its_origin_while_logged() {
let c = SqliteStore::in_memory("machine-c".to_string()).unwrap();
let from = memory("relation source");
let to = memory("relation target");
c.store_memory(&from).unwrap();
c.store_memory(&to).unwrap();
let relation = Relation {
from_id: from.id,
to_id: to.id,
relation_type: RelationType::RelatesTo,
strength: 1.0,
context: None,
};
let incarnation = 13u64 << 32;
let record = |seq: u64, op: SyncOp| SyncRecord {
local_seq: seq,
origin_machine_id: "machine-a".to_string(),
origin_seq: seq,
op,
node_type: SyncNodeType::Relation,
node_id: format!("{}:{}:relates_to", from.id, to.id),
timestamp: authored_at(seq),
data: Some(serde_json::to_value(&relation).unwrap()),
};
let create = record(incarnation | 1, SyncOp::Create);
let delete = record(incarnation | 2, SyncOp::Delete);
let recreate = record(incarnation | 3, SyncOp::Create);
assert_eq!(
c.apply_batch(&[delete.clone(), recreate.clone()]).unwrap(),
vec![ApplyOutcome::Deleted, ApplyOutcome::Created]
);
assert_eq!(
c.apply_batch(&[create, delete, recreate]).unwrap(),
vec![
ApplyOutcome::Skipped(SkipReason::StaleWrite),
ApplyOutcome::Skipped(SkipReason::AlreadyPresent),
ApplyOutcome::Skipped(SkipReason::AlreadyPresent),
]
);
assert_eq!(c.get_relations(from.id, None).unwrap().len(), 1);
}
#[test]
fn an_older_relayed_distillation_marker_never_undoes_a_newer_one_from_its_origin() {
let c = SqliteStore::in_memory("machine-c".to_string()).unwrap();
let raw = memory("distilled raw");
c.store_memory(&raw).unwrap();
let marker = Distillation {
memory_id: raw.id,
distilled_id: None,
distilled_at: None,
model: None,
status: "skipped".to_string(),
};
let incarnation = 15u64 << 32;
let record = |seq: u64, op: SyncOp| SyncRecord {
local_seq: seq,
origin_machine_id: "machine-a".to_string(),
origin_seq: seq,
op,
node_type: SyncNodeType::Distillation,
node_id: raw.id.to_string(),
timestamp: authored_at(seq),
data: Some(serde_json::to_value(&marker).unwrap()),
};
let create = record(incarnation | 1, SyncOp::Create);
let delete = record(incarnation | 2, SyncOp::Delete);
let recreate = record(incarnation | 3, SyncOp::Create);
let marked = |store: &SqliteStore| {
store
.unconsolidated_memories(10)
.unwrap()
.iter()
.all(|m| m.id != raw.id)
};
assert!(!marked(&c));
assert_eq!(
c.apply_batch(&[delete.clone(), recreate.clone()]).unwrap(),
vec![ApplyOutcome::Deleted, ApplyOutcome::Created]
);
assert_eq!(
c.apply_batch(&[create, delete.clone()]).unwrap(),
vec![
ApplyOutcome::Skipped(SkipReason::Tombstoned),
ApplyOutcome::Skipped(SkipReason::AlreadyPresent),
]
);
assert!(
marked(&c),
"the older create left the recreated marker in place"
);
assert_eq!(
c.apply_record(&delete).unwrap(),
ApplyOutcome::Skipped(SkipReason::AlreadyPresent),
"the stale delete was settled into sync_dedup"
);
}
#[test]
fn a_relayed_marker_skipped_on_an_existing_marker_still_outlives_an_older_delete_from_its_origin() {
let c = SqliteStore::in_memory("machine-c".to_string()).unwrap();
let raw = memory("distilled raw");
c.store_memory(&raw).unwrap();
let marker = Distillation {
memory_id: raw.id,
distilled_id: None,
distilled_at: None,
model: None,
status: "skipped".to_string(),
};
let incarnation = 16u64 << 32;
let record = |seq: u64, op: SyncOp| SyncRecord {
local_seq: seq,
origin_machine_id: "machine-a".to_string(),
origin_seq: seq,
op,
node_type: SyncNodeType::Distillation,
node_id: raw.id.to_string(),
timestamp: authored_at(seq),
data: Some(serde_json::to_value(&marker).unwrap()),
};
let create = record(incarnation | 1, SyncOp::Create);
let delete = record(incarnation | 2, SyncOp::Delete);
let recreate = record(incarnation | 3, SyncOp::Create);
assert_eq!(c.apply_record(&create).unwrap(), ApplyOutcome::Created);
assert_eq!(c.apply_record(&recreate).unwrap(), ApplyOutcome::Updated);
c.apply_batch(&[delete, recreate]).unwrap();
assert_eq!(
c.pending_distillation().unwrap().count,
0,
"the newer marker from the origin was lost"
);
}
#[test]
fn sqlite_store_stays_unwind_safe() {
fn unwind_safe<T: std::panic::UnwindSafe + std::panic::RefUnwindSafe>() {}
unwind_safe::<SqliteStore>();
}
#[test]
fn a_floor_past_the_ceiling_is_told_apart_from_a_store_error() {
let store = SqliteStore::in_memory("machine-a".to_string()).unwrap();
let err = store
.raise_clock_floors(&ClockFloors {
basis_micros: Some(i64::MAX),
..Default::default()
})
.unwrap_err();
assert!(
err.downcast_ref::<ClockFloorRejected>().is_some(),
"{err:#}"
);
}