use second_brain_core::{
schema::{Memory, MemoryType},
sqlite_store::SqliteStore,
store::{Store, StoreAdmin},
};
fn memory(content: &str) -> Memory {
Memory::new(
content.to_string(),
MemoryType::Semantic,
"test".to_string(),
String::new(),
)
}
#[test]
fn record_access_adds_no_log_row() {
let store = SqliteStore::in_memory("test-machine-access".to_string()).unwrap();
let m = memory("access bump test");
store.store_memory(&m).unwrap();
assert_eq!(
store.sync_log_since(0).unwrap().len(),
1,
"store_memory must produce exactly one sync_log row"
);
for _ in 0..3 {
let mut bumped = m.clone();
bumped.access_count += 1;
store.record_access(&bumped).unwrap();
}
assert_eq!(
store.sync_log_since(0).unwrap().len(),
1,
"record_access must not append any sync_log rows"
);
}
#[test]
fn write_creates_node_and_log_row() {
let store = SqliteStore::in_memory("test-machine".to_string()).unwrap();
let m = memory("sync log test");
store.store_memory(&m).unwrap();
let machine_id = store.machine_id().to_string();
let entries = store.sync_log_since(0).unwrap();
assert_eq!(entries.len(), 1, "expected exactly one sync_log row");
let entry = &entries[0];
assert_eq!(entry.origin_machine_id, machine_id);
assert_eq!(entry.local_seq, entry.origin_seq);
assert_eq!(entry.id, format!("{}:{}", machine_id, entry.origin_seq));
assert_eq!(store.memory_count().unwrap(), 1);
}
#[test]
fn sequential_writes_increment_local_seq() {
let store = SqliteStore::in_memory("test-machine-seq".to_string()).unwrap();
store.store_memory(&memory("first memory")).unwrap();
store.store_memory(&memory("second memory")).unwrap();
let entries = store.sync_log_since(0).unwrap();
assert_eq!(entries.len(), 2, "expected two sync_log rows");
assert_eq!(
entries[1].local_seq,
entries[0].local_seq + 1,
"local_seq values must be consecutive with no gap"
);
}
#[test]
fn sync_log_page_bounds_and_orders() {
let store = SqliteStore::in_memory("test-machine-page".to_string()).unwrap();
for i in 0..5 {
store.store_memory(&memory(&format!("memory {i}"))).unwrap();
}
let page = store.sync_log_page(1, Some(2)).unwrap();
assert_eq!(page.len(), 2);
assert_eq!(page[0].local_seq, 2);
assert_eq!(page[1].local_seq, 3);
assert_eq!(store.max_sync_seq().unwrap(), 5);
}
#[test]
fn paged_export_cursor_covers_every_entry_exactly_once() {
let store = SqliteStore::in_memory("test-machine-cursor".to_string()).unwrap();
for i in 0..25 {
store.store_memory(&memory(&format!("memory {i}"))).unwrap();
}
const BATCH: usize = 4;
let mut cursor = 0u64;
let mut seen: Vec<u64> = Vec::new();
loop {
let page = store.sync_log_page(cursor, Some(BATCH)).unwrap();
if page.is_empty() {
break;
}
let count = page.len();
cursor = page.iter().map(|e| e.local_seq as u64).max().unwrap();
seen.extend(page.iter().map(|e| e.local_seq as u64));
if count < BATCH {
break;
}
}
let full: Vec<u64> = store
.sync_log_since(0)
.unwrap()
.iter()
.map(|e| e.local_seq as u64)
.collect();
assert_eq!(
seen, full,
"advancing the cursor by each page's max local_seq must yield the unpaged log exactly"
);
assert_eq!(seen.len(), 25);
}
fn to_record(
entry: &second_brain_core::schema::SyncEntry,
) -> second_brain_core::schema::SyncRecord {
second_brain_core::schema::SyncRecord {
local_seq: entry.local_seq as u64,
origin_machine_id: entry.origin_machine_id.clone(),
origin_seq: entry.origin_seq as u64,
op: entry.op,
node_type: entry.node_type,
node_id: entry.node_id.clone(),
timestamp: entry.timestamp,
data: entry
.data
.as_deref()
.map(|d| serde_json::from_str(d).unwrap()),
}
}
fn embedded(content: &str) -> Memory {
let mut m = memory(content);
m.embedding = vec![0.5; 384];
m
}
#[test]
fn archive_replicates_tier_and_evicts_on_the_peer() {
use second_brain_core::schema::{SyncOp, Tier};
use second_brain_core::store::ApplyOutcome;
let a = SqliteStore::in_memory("machine-a".to_string()).unwrap();
let b = SqliteStore::in_memory("machine-b".to_string()).unwrap();
let m = embedded("archive me on both sides");
a.store_memory(&m).unwrap();
for entry in a.sync_log_since(0).unwrap() {
b.apply_record(&to_record(&entry)).unwrap();
}
let before = b.get_memory(m.id).unwrap().unwrap();
assert_eq!(before.tier, Tier::Hot);
let outbox_before = b.outbox_after(0).unwrap().len();
a.archive_memory(m.id).unwrap();
let local = a.get_memory_with_embedding(m.id).unwrap().unwrap();
assert_eq!(local.tier, Tier::Archived);
assert!(
local.archived_segment.is_none(),
"local cold rows carry no segment"
);
assert_eq!(local.content, m.content, "content stays intact");
assert_eq!(local.embedding.len(), 384, "embedding stays intact");
assert!(
local.updated_at > before.updated_at,
"archive must bump updated_at"
);
let last = a.outbox_after(0).unwrap().pop().unwrap();
assert_eq!((last.memory_id, last.op.as_str()), (m.id, "delete"));
let entries = a.sync_log_since(1).unwrap();
assert_eq!(entries.len(), 1);
assert_eq!(entries[0].op, SyncOp::Update);
let outcome = b.apply_record(&to_record(&entries[0])).unwrap();
assert_eq!(outcome, ApplyOutcome::Updated);
let peer = b.get_memory_with_embedding(m.id).unwrap().unwrap();
assert_eq!(peer.tier, Tier::Archived);
assert_eq!(peer.embedding.len(), 384, "the peer keeps its embedding");
let peer_outbox = b.outbox_after(0).unwrap();
assert_eq!(peer_outbox.len(), outbox_before + 1);
assert_eq!(peer_outbox.last().unwrap().memory_id, m.id);
assert_eq!(
b.indexable_count().unwrap(),
0,
"an archived row must leave the peer's indexable set"
);
}
#[test]
fn supersede_replicates_to_the_peer() {
use second_brain_core::schema::SyncOp;
let a = SqliteStore::in_memory("machine-a".to_string()).unwrap();
let b = SqliteStore::in_memory("machine-b".to_string()).unwrap();
let old = embedded("first version");
let new = embedded("second version");
a.store_memory(&old).unwrap();
a.store_memory(&new).unwrap();
for entry in a.sync_log_since(0).unwrap() {
b.apply_record(&to_record(&entry)).unwrap();
}
a.supersede_memory(old.id, new.id).unwrap();
let entries = a.sync_log_since(2).unwrap();
assert_eq!(entries.len(), 1);
assert_eq!(entries[0].op, SyncOp::Update);
b.apply_record(&to_record(&entries[0])).unwrap();
let peer = b.get_memory_with_embedding(old.id).unwrap().unwrap();
assert_eq!(peer.superseded_by, Some(new.id));
assert_eq!(peer.embedding.len(), 384);
assert_eq!(b.indexable_count().unwrap(), 1);
}