mod common;
use axum::http::StatusCode;
use tower::ServiceExt;
use common::{app, json_body, post_json};
#[tokio::test]
async fn an_unknown_ingest_source_is_a_400_naming_the_adapters() {
let response = app()
.oneshot(post_json(
"/v1/ingest",
serde_json::json!({"source": "bogus"}),
))
.await
.unwrap();
assert_eq!(response.status(), StatusCode::BAD_REQUEST);
let error = json_body(response).await["error"]
.as_str()
.unwrap()
.to_string();
assert!(error.contains("bogus"), "{error}");
for name in ["claude-code", "claude-memory", "cursor"] {
assert!(error.contains(name), "{error} lacks {name}");
}
}
mod dedupe {
use std::fs;
use std::path::{Path, PathBuf};
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
use anyhow::Result;
use axum::http::StatusCode;
use second_brain_adapters::claude_code::ClaudeCodeAdapter;
use second_brain_adapters::{Adapter, ConversationSource, IngestResult, store_ingest_result};
use second_brain_api::ingest::{
IngestStats, ingest_file, ingest_memory_file, ingest_with_adapters, legacy_file_hash,
reingest_with_adapters,
};
use second_brain_core::schema::{IngestRecord, SyncNodeType, SyncOp};
use second_brain_core::sqlite_store::{SqliteStore, WallClock};
use second_brain_core::store::{Store, StoreAdmin};
use serde_json::{Value, json};
use tower::ServiceExt;
use uuid::Uuid;
use super::common::{app, post_json};
const TURNS: [&str; 4] = [
"The watcher waits ten seconds for a transcript to settle before it ingests it, because Claude Code writes each turn in several appends.",
"We store the session key in ingest_log so a copied transcript is recognised by its content and session instead of by its absolute path.",
"Sync skips a memory create whose id already exists, so two stores that parsed the same session converge on a single row per chunk.",
"A tombstone always wins over a replayed create, which is why a raw deleted on one peer never comes back from a later re-ingest.",
];
struct Counting {
inner: ClaudeCodeAdapter,
parsed: Arc<AtomicUsize>,
}
impl Adapter for Counting {
fn name(&self) -> &str {
self.inner.name()
}
fn discover_conversations(&self) -> Result<Vec<ConversationSource>> {
self.inner.discover_conversations()
}
fn ingest_conversation(&self, source: &ConversationSource) -> Result<IngestResult> {
self.parsed.fetch_add(1, Ordering::SeqCst);
self.inner.ingest_conversation(source)
}
fn session_key(&self, path: &Path, content: &str) -> Option<String> {
self.inner.session_key(path, content)
}
}
struct Home {
dir: tempfile::TempDir,
parsed: Arc<AtomicUsize>,
}
impl Home {
fn new() -> Self {
Self {
dir: tempfile::tempdir().unwrap(),
parsed: Arc::new(AtomicUsize::new(0)),
}
}
fn root(&self) -> PathBuf {
self.dir.path().join(".claude")
}
fn write(&self, rel: &str, session: &str, turns: &[&str]) -> PathBuf {
let path = self.root().join("projects").join(rel);
fs::create_dir_all(path.parent().unwrap()).unwrap();
fs::write(&path, transcript(session, turns)).unwrap();
path
}
fn adapters(&self) -> Vec<Box<dyn Adapter>> {
vec![Box::new(Counting {
inner: ClaudeCodeAdapter::with_path(self.root(), "m".to_string()),
parsed: self.parsed.clone(),
})]
}
fn ingest(&self, store: &dyn StoreAdmin) -> IngestStats {
ingest_with_adapters(store, None, "m", &self.adapters())
}
fn parsed(&self) -> usize {
self.parsed.load(Ordering::SeqCst)
}
}
fn transcript(session: &str, turns: &[&str]) -> String {
let mut lines = vec![json!({"type": "summary", "summary": "s"}).to_string()];
for (i, turn) in turns.iter().enumerate() {
lines.push(
json!({"type": "user", "sessionId": session, "message": {"content": format!("question {i}")}})
.to_string(),
);
lines.push(
json!({"type": "assistant", "sessionId": session,
"message": {"content": [{"type": "text", "text": turn}]}})
.to_string(),
);
}
lines.join("\n") + "\n"
}
fn store() -> SqliteStore {
SqliteStore::in_memory("m".to_string()).unwrap()
}
fn sha256_like(hash: &str) -> bool {
hash.len() == 64 && hash.chars().all(|c| c.is_ascii_hexdigit())
}
fn log_count(store: &SqliteStore, node_type: SyncNodeType) -> usize {
store
.sync_log_since(0)
.unwrap()
.iter()
.filter(|e| e.node_type == node_type && e.op == SyncOp::Create)
.count()
}
fn conversation_rows(store: &SqliteStore) -> usize {
store
.sync_log_since(0)
.unwrap()
.iter()
.filter(|e| e.node_type == SyncNodeType::Conversation)
.map(|e| e.node_id.clone())
.collect::<std::collections::HashSet<_>>()
.iter()
.filter(|id| {
store
.get_conversation(id.parse().unwrap())
.unwrap()
.is_some()
})
.count()
}
fn seed_legacy(store: &SqliteStore, home: &Home, path: &Path) -> Vec<Uuid> {
let adapter = ClaudeCodeAdapter::with_path(home.root(), "m".to_string());
let p = path.to_string_lossy().to_string();
let mut result = adapter
.ingest_conversation(&ConversationSource {
id: p.clone(),
path: p.clone(),
source_name: "claude-code".to_string(),
machine_id: "m".to_string(),
})
.unwrap();
result.conversation.id = Uuid::new_v4();
for m in &mut result.memories {
m.id = Uuid::new_v4();
}
result.entities.clear();
let outcome = store_ingest_result(store, None, &result, "m");
assert_eq!(outcome.stored, result.memories.len());
let bytes = fs::read(path).unwrap();
store
.record_ingested(&IngestRecord {
file_path: &p,
content_hash: "unused",
session_key: None,
legacy_ids: true,
memory_count: outcome.stored,
source: "claude-code",
})
.unwrap();
store
.mark_ingested(&p, &legacy_file_hash(&bytes), outcome.stored, "claude-code")
.unwrap();
result.memories.iter().map(|m| m.id).collect()
}
fn contents(store: &SqliteStore) -> Vec<String> {
let mut c: Vec<String> = store
.memories_by_project_path("p")
.unwrap()
.into_iter()
.map(|m| m.content)
.collect();
c.sort();
c
}
struct Trust(AtomicBool);
impl WallClock for Trust {
fn now_micros(&self) -> Option<i64> {
self.0
.load(Ordering::SeqCst)
.then(|| chrono::Utc::now().timestamp_micros())
}
}
#[test]
fn a_pass_whose_writes_fail_leaves_the_file_for_the_next_pass() {
let home = Home::new();
let trust = Arc::new(Trust(AtomicBool::new(false)));
let store = store().with_wall_clock(trust.clone());
home.write("p/s.jsonl", "sess-1", &TURNS[..2]);
let failed = home.ingest(&store);
assert!(failed.errors > 0);
assert_eq!(store.memory_count().unwrap(), 0);
trust.0.store(true, Ordering::SeqCst);
let retried = home.ingest(&store);
assert_eq!((retried.errors, retried.new_memories), (0, 2));
assert_eq!(store.memory_count().unwrap(), 2);
}
#[test]
fn one_session_under_two_paths_is_parsed_once() {
let home = Home::new();
let store = store();
home.write("p/s.jsonl", "sess-1", &TURNS[..2]);
let first = home.ingest(&store);
assert_eq!((first.new_memories, home.parsed()), (2, 1));
let copy = home.write("q/renamed.jsonl", "sess-1", &TURNS[..2]);
let second = home.ingest(&store);
assert_eq!(home.parsed(), 1, "the copy must not be parsed");
assert_eq!((second.unchanged, second.new_memories), (2, 0));
assert_eq!(store.memory_count().unwrap(), 2);
let row = store
.ingest_log_entry(©.to_string_lossy())
.unwrap()
.unwrap();
assert_eq!(row.session_key.as_deref(), Some("sess-1"));
assert!(sha256_like(row.content_hash.as_deref().unwrap()));
assert_eq!(row.file_hash, row.content_hash.clone().unwrap());
}
#[test]
fn a_resumed_copy_adds_only_its_new_chunks() {
let home = Home::new();
let store = store();
home.write("p/s.jsonl", "sess-1", &TURNS[..2]);
home.ingest(&store);
home.write("q/s.jsonl", "sess-1", &TURNS[..3]);
let stats = home.ingest(&store);
assert_eq!((stats.new_memories, stats.skipped_dupes), (1, 2));
assert_eq!(store.memory_count().unwrap(), 3);
}
#[test]
fn appending_turns_stores_exactly_the_new_chunks_under_one_conversation() {
let home = Home::new();
let store = Arc::new(store());
let dyn_store: Arc<dyn StoreAdmin> = store.clone();
let path = home.write("p/s.jsonl", "sess-1", &TURNS[..2]);
ingest_file(&dyn_store, None, &path, "m").unwrap();
assert_eq!(store.memory_count().unwrap(), 2);
let memory_creates = log_count(&store, SyncNodeType::Memory);
home.write("p/s.jsonl", "sess-1", &TURNS[..3]);
ingest_file(&dyn_store, None, &path, "m").unwrap();
home.write("p/s.jsonl", "sess-1", &TURNS);
ingest_file(&dyn_store, None, &path, "m").unwrap();
ingest_file(&dyn_store, None, &path, "m").unwrap();
assert_eq!(store.memory_count().unwrap(), 4);
assert_eq!(log_count(&store, SyncNodeType::Memory), memory_creates + 2);
assert_eq!(log_count(&store, SyncNodeType::Conversation), 1);
assert_eq!(conversation_rows(&store), 1);
}
#[test]
fn two_stores_that_ingest_one_session_hold_one_row_per_chunk_after_sync() {
let home_a = Home::new();
let home_b = Home::new();
let a = SqliteStore::in_memory("machine-a".to_string()).unwrap();
let b = SqliteStore::in_memory("machine-b".to_string()).unwrap();
home_a.write("p/s.jsonl", "sess-1", &TURNS[..3]);
home_b.write("other/s.jsonl", "sess-1", &TURNS[..3]);
home_a.ingest(&a);
home_b.ingest(&b);
for (from, to) in [(&a, &b), (&b, &a)] {
let mut buf = Vec::new();
second_brain_sync::export::export_changes(from, 0, &mut buf).unwrap();
second_brain_sync::import::import_changes(to, buf.as_slice()).unwrap();
}
assert_eq!(a.memory_count().unwrap(), 3);
assert_eq!(b.memory_count().unwrap(), 3);
assert_eq!(conversation_rows(&a), 1);
assert_eq!(conversation_rows(&b), 1);
}
#[test]
fn an_old_format_hash_is_upgraded_in_place_without_a_reparse() {
let home = Home::new();
let store = store();
let path = home.write("p/s.jsonl", "sess-1", &TURNS[..2]);
seed_legacy(&store, &home, &path);
let stats = home.ingest(&store);
assert_eq!((home.parsed(), stats.unchanged), (0, 1));
let row = store
.ingest_log_entry(&path.to_string_lossy())
.unwrap()
.unwrap();
assert!(row.legacy_ids);
assert_eq!(row.session_key.as_deref(), Some("sess-1"));
assert!(sha256_like(row.content_hash.as_deref().unwrap()));
}
#[test]
fn a_copy_of_a_legacy_file_seen_first_by_the_watcher_is_skipped() {
let home = Home::new();
let store = Arc::new(store());
let dyn_store: Arc<dyn StoreAdmin> = store.clone();
let original = home.write("p/s.jsonl", "sess-1", &TURNS[..3]);
let ids = seed_legacy(&store, &home, &original);
store.delete_memory(ids[1]).unwrap();
let before = contents(&store);
let copy = home.dir.path().join("elsewhere/s.jsonl");
fs::create_dir_all(copy.parent().unwrap()).unwrap();
fs::copy(&original, ©).unwrap();
fs::remove_file(&original).unwrap();
ingest_file(&dyn_store, None, ©, "m").unwrap();
assert_eq!(store.memory_count().unwrap(), 2);
assert_eq!(contents(&store), before);
let upgraded = store
.ingest_log_entry(&original.to_string_lossy())
.unwrap()
.unwrap();
assert!(upgraded.legacy_ids);
assert_eq!(upgraded.session_key.as_deref(), Some("sess-1"));
let copy_row = store
.ingest_log_entry(©.to_string_lossy())
.unwrap()
.unwrap();
assert!(copy_row.legacy_ids);
}
#[test]
fn reingest_leaves_legacy_files_alone() {
let home = Home::new();
let store = store();
let path = home.write("p/s.jsonl", "sess-1", &TURNS[..3]);
let ids = seed_legacy(&store, &home, &path);
store.delete_memory(ids[0]).unwrap();
let before = contents(&store);
home.write("q/fresh.jsonl", "sess-2", &TURNS[3..]);
home.ingest(&store);
let parsed = home.parsed();
let (cleared, stats) = reingest_with_adapters(&store, None, "m", &home.adapters()).unwrap();
assert_eq!(cleared, 1);
assert_eq!(stats.new_memories, 0);
assert_eq!(
home.parsed(),
parsed + 1,
"only the non-legacy file is re-parsed"
);
assert_eq!(contents(&store), before);
assert!(store.get_memory(ids[0]).unwrap().is_none());
}
#[test]
fn an_old_format_memory_file_hash_is_upgraded_without_replacing_its_memory() {
let dir = tempfile::tempdir().unwrap();
let store = Arc::new(store());
let dyn_store: Arc<dyn StoreAdmin> = store.clone();
let path = dir.path().join("feedback_testing.md");
fs::write(
&path,
"---\nname: testing\ndescription: how tests run\ntype: feedback\n---\n\nRun the crate's tests through the wrapper so builds share the lock and never reach the live daemon.\n",
)
.unwrap();
ingest_memory_file(&dyn_store, None, &path, "m").unwrap();
let p = path.to_string_lossy().to_string();
let ids: Vec<Uuid> = store
.sync_log_since(0)
.unwrap()
.iter()
.filter(|e| e.node_type == SyncNodeType::Memory && e.op == SyncOp::Create)
.map(|e| e.node_id.parse().unwrap())
.collect();
assert_eq!(ids.len(), 1);
store
.mark_ingested(
&p,
&legacy_file_hash(&fs::read(&path).unwrap()),
1,
"claude-memory",
)
.unwrap();
ingest_memory_file(&dyn_store, None, &path, "m").unwrap();
assert!(store.get_memory(ids[0]).unwrap().is_some());
assert_eq!(store.memory_count().unwrap(), 1);
let row = store.ingest_log_entry(&p).unwrap().unwrap();
assert!(sha256_like(row.content_hash.as_deref().unwrap()));
}
#[tokio::test]
async fn reingest_refuses_clean() {
let response = app()
.oneshot(post_json("/v1/reingest", json!({"clean": true})))
.await
.unwrap();
assert_eq!(response.status(), StatusCode::BAD_REQUEST);
let body: Value = super::common::json_body(response).await;
assert!(body["error"].as_str().unwrap().contains("clean"), "{body}");
}
}