use std::path::{Path, PathBuf};
use std::sync::Arc;
use std::time::{Duration, SystemTime};
use second_brain_api::vaults::{ScanStats, VaultSync, configured_vaults};
use second_brain_core::schema::{Memory, MemoryType, Tier};
use second_brain_core::sqlite_store::SqliteStore;
use second_brain_core::store::{Store, StoreAdmin};
const MACHINE: &str = "vault-test-machine";
struct Fixture {
_dir: tempfile::TempDir,
vault: PathBuf,
store: Arc<SqliteStore>,
sync: VaultSync,
}
impl Fixture {
fn new() -> Self {
let dir = tempfile::tempdir().unwrap();
let vault = dir.path().join("vault");
std::fs::create_dir_all(vault.join("folder")).unwrap();
let store = Arc::new(SqliteStore::in_memory(MACHINE.to_string()).unwrap());
let sync = VaultSync::new(store.clone(), None, MACHINE.to_string());
Self {
_dir: dir,
vault,
store,
sync,
}
}
fn scan(&mut self) -> ScanStats {
let vaults = vec![self.vault.clone()];
self.sync.scan(&vaults)
}
fn scan_with(&mut self, vaults: &[PathBuf]) -> ScanStats {
self.sync.scan(vaults)
}
fn restart(&mut self) {
self.sync = VaultSync::new(self.store.clone(), None, MACHINE.to_string());
}
fn write(&self, rel: &str, body: &str) -> PathBuf {
let path = self.vault.join(rel);
let mtime = std::fs::metadata(&path)
.and_then(|m| m.modified())
.unwrap_or(SystemTime::UNIX_EPOCH);
std::fs::write(&path, body).unwrap();
let bumped = mtime.max(SystemTime::now()) + Duration::from_secs(2);
std::fs::File::options()
.write(true)
.open(&path)
.unwrap()
.set_modified(bumped)
.unwrap();
path
}
fn notes(&self) -> Vec<Memory> {
let mut all = self.store.memories_by_source("markdown").unwrap();
all.sort_by_key(|m| m.created_at);
all
}
fn for_path(&self, path: &Path) -> Vec<Memory> {
let key = path.to_string_lossy();
self.notes()
.into_iter()
.filter(|m| m.source_id == key)
.collect()
}
fn live(&self) -> Vec<Memory> {
self.notes()
.into_iter()
.filter(|m| m.tier == Tier::Hot && m.superseded_by.is_none())
.collect()
}
}
#[test]
fn each_note_is_ingested_once() {
let mut f = Fixture::new();
let a = f.write("alpha.md", "# Alpha\n\nThe alpha note.");
let b = f.write("folder/beta.md", "---\ntags: x\n---\nThe beta note.");
f.write("folder/image.png", "not a note");
std::fs::create_dir_all(f.vault.join(".obsidian")).unwrap();
f.write(".obsidian/app.md", "settings");
let stats = f.scan();
assert_eq!(stats.ingested, 2, "{stats:?}");
assert_eq!(stats.errors, 0, "{stats:?}");
let alpha = f.for_path(&a);
assert_eq!(alpha.len(), 1);
assert_eq!(alpha[0].content, "alpha\n\n# Alpha\n\nThe alpha note.");
assert_eq!(alpha[0].machine_id, MACHINE);
assert!(alpha[0].session_at.is_some());
let beta = f.for_path(&b);
assert_eq!(beta.len(), 1);
assert_eq!(beta[0].content, "beta\n\nThe beta note.");
assert_eq!(f.notes().len(), 2);
}
#[test]
fn a_rerun_writes_nothing_in_the_same_process_or_after_a_restart() {
let mut f = Fixture::new();
f.write("alpha.md", "The alpha note.");
f.write("folder/beta.md", "The beta note.");
f.scan();
let seq = f.store.max_sync_seq().unwrap();
let again = f.scan();
f.restart();
let after_restart = f.scan();
assert_eq!(again, ScanStats::default());
assert_eq!(after_restart.ingested, 0, "{after_restart:?}");
assert_eq!(after_restart.unchanged, 2, "{after_restart:?}");
assert_eq!(f.store.max_sync_seq().unwrap(), seq);
assert_eq!(f.notes().len(), 2);
}
#[test]
fn an_edit_supersedes_the_previous_version() {
let mut f = Fixture::new();
let a = f.write("alpha.md", "The deploy runs at noon.");
f.scan();
let old = f.for_path(&a).remove(0);
f.write(
"alpha.md",
"The deploy runs at noon.\n\nIt moved to midnight.",
);
let stats = f.scan();
assert_eq!(stats.ingested, 1, "{stats:?}");
assert_eq!(stats.superseded, 1, "{stats:?}");
let versions = f.for_path(&a);
assert_eq!(versions.len(), 2);
let new = versions.iter().find(|m| m.id != old.id).unwrap();
assert!(new.content.ends_with("It moved to midnight."));
assert_eq!(new.superseded_by, None);
let old = f.store.get_memory(old.id).unwrap().unwrap();
assert_eq!(old.superseded_by, Some(new.id));
assert_eq!(f.live().len(), 1);
}
#[test]
fn an_edit_made_while_the_daemon_was_down_supersedes_on_the_first_scan() {
let mut f = Fixture::new();
let a = f.write("alpha.md", "first version");
f.scan();
f.restart();
f.write("alpha.md", "second version");
let stats = f.scan();
assert_eq!(stats.superseded, 1, "{stats:?}");
let live = f.live();
assert_eq!(live.len(), 1);
assert_eq!(live[0].source_id, a.to_string_lossy());
assert!(live[0].content.ends_with("second version"));
}
#[test]
fn touching_a_note_without_changing_it_writes_nothing() {
let mut f = Fixture::new();
f.write("alpha.md", "unchanged text");
f.scan();
let seq = f.store.max_sync_seq().unwrap();
f.write("alpha.md", "unchanged text");
let stats = f.scan();
assert_eq!(stats.ingested, 0, "{stats:?}");
assert_eq!(stats.unchanged, 1, "{stats:?}");
assert_eq!(f.store.max_sync_seq().unwrap(), seq);
}
#[test]
fn a_deletion_retires_the_note() {
let mut f = Fixture::new();
let a = f.write("alpha.md", "soon gone");
let b = f.write("folder/beta.md", "stays");
f.scan();
std::fs::remove_file(&a).unwrap();
let stats = f.scan();
assert_eq!(stats.retired, 1, "{stats:?}");
let gone = f.for_path(&a).remove(0);
assert_eq!(gone.tier, Tier::Archived);
assert!(gone.retired_reason.is_some());
let kept = f.for_path(&b).remove(0);
assert_eq!(kept.tier, Tier::Hot);
}
#[test]
fn a_deletion_made_while_the_daemon_was_down_retires_on_the_first_scan() {
let mut f = Fixture::new();
let a = f.write("alpha.md", "soon gone");
f.write("folder/keep.md", "keeps the vault from looking unmounted");
f.scan();
f.restart();
std::fs::remove_file(&a).unwrap();
let stats = f.scan();
assert_eq!(stats.retired, 1, "{stats:?}");
assert_eq!(f.for_path(&a)[0].tier, Tier::Archived);
}
#[test]
fn a_note_recreated_after_deletion_comes_back() {
let mut f = Fixture::new();
let a = f.write("alpha.md", "the same words");
f.write("folder/keep.md", "keeps the vault from looking unmounted");
f.scan();
std::fs::remove_file(&a).unwrap();
f.scan();
f.write("alpha.md", "the same words");
let stats = f.scan();
assert_eq!(stats.ingested, 1, "{stats:?}");
assert_eq!(f.live().len(), 2);
}
#[test]
fn emptying_a_note_retires_it() {
let mut f = Fixture::new();
let a = f.write("alpha.md", "some words");
f.scan();
f.write("alpha.md", "---\ntags: x\n---\n");
let stats = f.scan();
assert_eq!(stats.retired, 1, "{stats:?}");
assert!(f.live().is_empty());
assert_eq!(f.for_path(&a)[0].tier, Tier::Archived);
}
#[test]
fn a_missing_vault_retires_nothing() {
let mut f = Fixture::new();
f.write("alpha.md", "on a disk that gets unmounted");
f.scan();
let moved = f.vault.with_file_name("elsewhere");
std::fs::rename(&f.vault, &moved).unwrap();
let stats = f.scan();
f.restart();
let after_restart = f.scan();
assert_eq!(stats.retired, 0, "{stats:?}");
assert_eq!(after_restart.retired, 0, "{after_restart:?}");
assert_eq!(f.live().len(), 1);
}
#[test]
fn a_vault_that_lists_no_notes_retires_nothing() {
let mut f = Fixture::new();
let a = f.write("alpha.md", "on a disk whose mount point stays behind");
f.scan();
std::fs::remove_file(&a).unwrap();
std::fs::remove_dir(f.vault.join("folder")).unwrap();
let stats = f.scan();
f.restart();
let after_restart = f.scan();
assert_eq!(stats.retired, 0, "{stats:?}");
assert_eq!(after_restart.retired, 0, "{after_restart:?}");
assert_eq!(f.live().len(), 1);
}
#[test]
fn another_machines_note_at_the_same_path_is_left_alone() {
let mut f = Fixture::new();
let path = f.vault.join("theirs.md");
let mut theirs = Memory::new(
"theirs\n\nwritten on another machine".to_string(),
MemoryType::Semantic,
"markdown".to_string(),
path.to_string_lossy().to_string(),
);
theirs.machine_id = "another-machine".to_string();
f.store.store_memory(&theirs).unwrap();
f.write("keep.md", "a local note, so the deletion pass runs");
let stats = f.scan();
assert_eq!(stats.retired, 0, "{stats:?}");
assert_eq!(
f.store.get_memory(theirs.id).unwrap().unwrap().tier,
Tier::Hot
);
}
#[test]
fn a_forgotten_note_stays_forgotten_until_it_changes() {
let mut f = Fixture::new();
let a = f.write("alpha.md", "forget me");
f.scan();
let id = f.for_path(&a)[0].id;
f.store.retire_memory(id, "user forgot it").unwrap();
f.restart();
let stats = f.scan();
assert_eq!(stats.ingested, 0, "{stats:?}");
assert!(f.live().is_empty());
f.write("alpha.md", "forget me, now edited");
let edited = f.scan();
assert_eq!(edited.ingested, 1, "{edited:?}");
assert_eq!(f.live().len(), 1);
}
#[test]
fn a_planted_secret_is_redacted_everywhere_it_is_written() {
let mut f = Fixture::new();
let token = ["gh", "p_"].concat() + &"Ab3dE6gH9jK2".repeat(3);
f.write(
"secrets.md",
&format!("The release job pushes with {token} every night."),
);
f.scan();
let note = f.notes().remove(0);
assert!(!note.content.contains(&token), "{}", note.content);
assert!(note.content.contains("The release job pushes with"));
let log = format!("{:?}", f.store.sync_log_since(0).unwrap());
assert!(!log.contains(&token));
}
#[test]
fn a_note_is_filed_under_the_project_its_vault_maps_to() {
let mut f = Fixture::new();
let slug: String = f
.vault
.to_string_lossy()
.chars()
.map(|c| if c.is_ascii_alphanumeric() { c } else { '-' })
.collect();
let mut seed = Memory::new(
"a memory that makes the vault a known project".to_string(),
MemoryType::Semantic,
"claude-code".to_string(),
"seed".to_string(),
);
seed.project_path = Some(slug.clone());
f.store.store_memory(&seed).unwrap();
let a = f.write("alpha.md", "project note");
f.scan();
assert_eq!(
f.for_path(&a)[0].project_path.as_deref(),
Some(slug.as_str())
);
}
#[test]
fn a_note_outside_any_known_project_has_no_project() {
let mut f = Fixture::new();
let a = f.write("alpha.md", "loose note");
f.scan();
assert_eq!(f.for_path(&a)[0].project_path, None);
}
#[test]
fn vault_notes_are_never_handed_to_consolidation() {
let mut f = Fixture::new();
f.write("alpha.md", "an authored note");
f.scan();
assert!(f.store.unconsolidated_memories(100).unwrap().is_empty());
}
#[test]
fn nested_vaults_leave_each_others_notes_alone() {
let mut f = Fixture::new();
let inner = f.vault.join(".private/inner");
std::fs::create_dir_all(&inner).unwrap();
f.write("keep.md", "an outer note");
f.write(".private/inner/n.md", "an inner note");
let vaults = vec![f.vault.clone(), inner];
let first = f.scan_with(&vaults);
let second = f.scan_with(&vaults);
f.restart();
let after_restart = f.scan_with(&vaults);
assert_eq!(first.ingested, 2, "{first:?}");
assert_eq!(second, ScanStats::default());
assert_eq!(after_restart.ingested, 0, "{after_restart:?}");
assert_eq!(after_restart.retired, 0, "{after_restart:?}");
assert_eq!(f.live().len(), 2);
}
#[cfg(unix)]
#[test]
fn notes_in_an_unreadable_folder_are_kept() {
use std::os::unix::fs::PermissionsExt;
let mut f = Fixture::new();
f.write("alpha.md", "readable");
let b = f.write("folder/beta.md", "soon unreadable");
f.scan();
f.restart();
let folder = f.vault.join("folder");
std::fs::set_permissions(&folder, std::fs::Permissions::from_mode(0o000)).unwrap();
let stats = f.scan();
std::fs::set_permissions(&folder, std::fs::Permissions::from_mode(0o755)).unwrap();
assert_eq!(stats.retired, 0, "{stats:?}");
assert_eq!(f.for_path(&b)[0].tier, Tier::Hot);
}
#[test]
fn a_reingest_does_not_bring_back_a_forgotten_note() {
let mut f = Fixture::new();
let a = f.write("alpha.md", "forget me");
f.scan();
f.store
.retire_memory(f.for_path(&a)[0].id, "user forgot it")
.unwrap();
f.store.clear_reparseable_ingest_log().unwrap();
f.restart();
let stats = f.scan();
assert_eq!(stats.ingested, 0, "{stats:?}");
assert!(f.live().is_empty());
}
#[test]
fn a_note_grown_past_the_size_limit_is_retired_once() {
let mut f = Fixture::new();
let a = f.write("alpha.md", "small at first");
f.scan();
f.write("alpha.md", &"x".repeat(2 * 1024 * 1024));
let stats = f.scan();
let seq = f.store.max_sync_seq().unwrap();
f.restart();
let after_restart = f.scan();
assert_eq!(stats.retired, 1, "{stats:?}");
assert_eq!(f.for_path(&a)[0].tier, Tier::Archived);
assert_eq!(
after_restart,
ScanStats {
unchanged: 1,
..ScanStats::default()
}
);
assert_eq!(f.store.max_sync_seq().unwrap(), seq);
}
#[test]
fn a_moved_vault_retires_the_notes_left_at_its_old_path() {
let mut f = Fixture::new();
let a = f.write("alpha.md", "a note in a vault that moves");
f.scan();
let moved = f.vault.with_file_name("moved");
std::fs::rename(&f.vault, &moved).unwrap();
f.restart();
let stats = f.scan_with(&[moved]);
assert_eq!(stats.ingested, 1, "{stats:?}");
assert_eq!(stats.retired, 1, "{stats:?}");
assert_eq!(f.for_path(&a)[0].tier, Tier::Archived);
assert_eq!(f.live().len(), 1);
}
#[test]
fn a_vault_dropped_from_the_config_keeps_its_notes_while_they_exist() {
let mut f = Fixture::new();
f.write("alpha.md", "still on disk");
f.scan();
let other = f.vault.with_file_name("other");
std::fs::create_dir_all(&other).unwrap();
std::fs::write(other.join("o.md"), "another vault").unwrap();
f.restart();
let stats = f.scan_with(&[other]);
assert_eq!(stats.retired, 0, "{stats:?}");
assert_eq!(f.live().len(), 2);
}
#[test]
fn identical_notes_survive_the_scheduled_dedup_and_each_others_deletion() {
let mut f = Fixture::new();
std::fs::create_dir_all(f.vault.join("other")).unwrap();
let a = f.write("folder/index.md", "the same template body");
let b = f.write("other/index.md", "the same template body");
f.scan();
f.store.repair(None, None, false).unwrap();
std::fs::remove_file(&a).unwrap();
f.scan();
let live = f.live();
assert_eq!(live.len(), 1);
assert_eq!(live[0].source_id, b.to_string_lossy());
}
#[cfg(unix)]
#[test]
fn an_unreadable_note_is_reported_once_until_it_changes() {
use std::os::unix::fs::PermissionsExt;
let mut f = Fixture::new();
let a = f.write("alpha.md", "locked away");
std::fs::set_permissions(&a, std::fs::Permissions::from_mode(0o000)).unwrap();
let first = f.scan();
let second = f.scan();
std::fs::set_permissions(&a, std::fs::Permissions::from_mode(0o644)).unwrap();
f.write("alpha.md", "locked away, now readable");
let third = f.scan();
assert_eq!(first.errors, 1, "{first:?}");
assert_eq!(second, ScanStats::default());
assert_eq!(third.ingested, 1, "{third:?}");
}
#[test]
fn a_markdown_row_vault_sync_did_not_write_is_left_alone() {
let mut f = Fixture::new();
let mut stray = Memory::new(
"written through some other path".to_string(),
MemoryType::Semantic,
"markdown".to_string(),
String::new(),
);
stray.machine_id = MACHINE.to_string();
f.store.store_memory(&stray).unwrap();
f.write("alpha.md", "a note");
let stats = f.scan();
assert_eq!(stats.retired, 0, "{stats:?}");
assert_eq!(
f.store.get_memory(stray.id).unwrap().unwrap().tier,
Tier::Hot
);
}
#[cfg(unix)]
#[test]
fn a_note_deleted_while_unreadable_is_retired() {
use std::os::unix::fs::PermissionsExt;
let mut f = Fixture::new();
let a = f.write("alpha.md", "readable at first");
f.write("folder/keep.md", "keeps the vault from looking unmounted");
f.scan();
f.restart();
std::fs::set_permissions(&a, std::fs::Permissions::from_mode(0o000)).unwrap();
f.scan();
std::fs::remove_file(&a).unwrap();
let stats = f.scan();
assert_eq!(stats.retired, 1, "{stats:?}");
assert_eq!(f.for_path(&a)[0].tier, Tier::Archived);
}
#[test]
fn configured_vaults_are_absolute_and_normalized() {
let home = PathBuf::from(std::env::var_os("HOME").unwrap());
let vaults = configured_vaults(vec![
PathBuf::from("relative/vault"),
PathBuf::from("/srv//notes/./vault/"),
PathBuf::from("~/notes"),
]);
let mut expected = vec![PathBuf::from("/srv/notes/vault")];
if home.is_absolute() {
expected.push(home.join("notes"));
}
assert_eq!(vaults, expected);
}
#[test]
fn notes_are_refiled_once_their_vault_maps_to_a_project() {
let mut f = Fixture::new();
let a = f.write("alpha.md", "filed before the project existed");
f.scan();
assert_eq!(f.for_path(&a)[0].project_path, None);
let slug: String = f
.vault
.to_string_lossy()
.chars()
.map(|c| if c.is_ascii_alphanumeric() { c } else { '-' })
.collect();
let mut seed = Memory::new(
"a transcript memory from a session run in the vault".to_string(),
MemoryType::Semantic,
"claude-code".to_string(),
"seed".to_string(),
);
seed.project_path = Some(slug.clone());
f.store.store_memory(&seed).unwrap();
f.scan();
let seq = f.store.max_sync_seq().unwrap();
f.restart();
f.scan();
let notes = f.for_path(&a);
assert_eq!(notes.len(), 1);
assert_eq!(notes[0].project_path.as_deref(), Some(slug.as_str()));
assert_eq!(f.store.max_sync_seq().unwrap(), seq);
}