test(client): Plan 3 — remote (wiremock) + syncer integration coverage

client/src/lib.rs

@@ -107,8 +107,7 @@ pub fn run_download_once(
 
     let storage_dir = &PathBuf::from(storage_dir);
     let chunk_cache = InMemoryCache::new(INMEMORY_CACHE_MAX_REC, INMEMORY_CACHE_MAX_MEM);
-    let chunker = &mut Chunker::new(chunk_cache, storage_dir.clone());
-    let chunker = Arc::new(Mutex::new(chunker));
+    let chunker = Arc::new(Mutex::new(Chunker::new(chunk_cache, storage_dir.clone())));
     let remote = &remote::Remote::new(api_endpoint, remote_token);
 
     let pool = connection::get_connection_pool(db_file_path)?;
@@ -138,8 +137,7 @@ pub fn run_upload_once(
 ) -> Result<(), errors::SyncError> {
     let storage_dir = &PathBuf::from(storage_dir);
     let chunk_cache = InMemoryCache::new(INMEMORY_CACHE_MAX_REC, INMEMORY_CACHE_MAX_MEM);
-    let chunker = &mut Chunker::new(chunk_cache, storage_dir.clone());
-    let chunker = Arc::new(Mutex::new(chunker));
+    let chunker = Arc::new(Mutex::new(Chunker::new(chunk_cache, storage_dir.clone())));
     let remote = &remote::Remote::new(api_endpoint, remote_token);
 
     let pool = connection::get_connection_pool(db_file_path)?;
@@ -188,7 +186,7 @@ pub async fn run_async(
 
     let storage_dir = &PathBuf::from(storage_dir);
     let chunk_cache = InMemoryCache::new(INMEMORY_CACHE_MAX_REC, INMEMORY_CACHE_MAX_MEM);
-    let chunker = &mut Chunker::new(chunk_cache, storage_dir.clone());
+    let chunker = Chunker::new(chunk_cache, storage_dir.clone());
     let remote = &remote::Remote::new(api_endpoint, remote_token);
 
     let pool = connection::get_connection_pool(db_file_path)?;

client/src/models.rs

@@ -219,7 +219,7 @@ mod tests {
 
         assert_eq!(form.jid, Some(42));
         assert_eq!(form.path, "recipes/test.cook");
-        assert_eq!(form.deleted, false);
+        assert!(!form.deleted);
         assert_eq!(form.size, 512);
         assert_eq!(form.namespace_id, 5);
     }
@@ -238,7 +238,7 @@ mod tests {
         };
 
         assert_eq!(form.path, "recipes/deleted.cook");
-        assert_eq!(form.deleted, true);
+        assert!(form.deleted);
         assert_eq!(form.size, 0);
     }
 

client/src/registry.rs

@@ -10,7 +10,7 @@ use crate::schema::*;
 
 type Result<T, E = diesel::result::Error> = std::result::Result<T, E>;
 
-pub fn create(conn: &mut Connection, forms: &Vec<CreateForm>) -> Result<usize> {
+pub fn create(conn: &mut Connection, forms: &[CreateForm]) -> Result<usize> {
     trace!("inserting {:?}", forms);
 
     insert_into(file_records::table).values(forms).execute(conn)
@@ -25,7 +25,7 @@ pub fn update_jid(conn: &mut Connection, record: &FileRecord, jid: i32) -> Resul
         .execute(conn)
 }
 
-pub fn delete(conn: &mut Connection, forms: &Vec<DeleteForm>) -> Result<usize> {
+pub fn delete(conn: &mut Connection, forms: &[DeleteForm]) -> Result<usize> {
     trace!("marking as deleted {:?}", forms);
 
     insert_into(file_records::table).values(forms).execute(conn)

client/src/syncer.rs

@@ -31,7 +31,7 @@ pub async fn run(
     pool: &ConnectionPool,
     storage_path: &Path,
     namespace_id: i32,
-    chunker: &mut Chunker,
+    chunker: Chunker,
     remote: &Remote,
     local_registry_updated_rx: Receiver<models::IndexerUpdateEvent>,
     read_only: bool,
@@ -78,7 +78,7 @@ async fn download_loop(
     token: CancellationToken,
     listener: Option<Arc<dyn SyncStatusListener>>,
     pool: &ConnectionPool,
-    chunker: Arc<Mutex<&mut Chunker>>,
+    chunker: Arc<Mutex<Chunker>>,
     remote: &Remote,
     storage_path: &Path,
     namespace_id: i32,
@@ -134,7 +134,7 @@ pub async fn upload_loop(
     token: CancellationToken,
     listener: Option<Arc<dyn SyncStatusListener>>,
     pool: &ConnectionPool,
-    chunker: Arc<Mutex<&mut Chunker>>,
+    chunker: Arc<Mutex<Chunker>>,
     remote: &Remote,
     namespace_id: i32,
     mut local_registry_updated_rx: Receiver<models::IndexerUpdateEvent>,
@@ -182,7 +182,7 @@ pub async fn upload_loop(
 
 pub async fn check_upload_once(
     pool: &ConnectionPool,
-    chunker: Arc<Mutex<&mut Chunker>>,
+    chunker: Arc<Mutex<Chunker>>,
     remote: &Remote,
     namespace_id: i32,
 ) -> Result<bool> {
@@ -246,7 +246,7 @@ pub async fn check_upload_once(
 
 pub async fn check_download_once(
     pool: &ConnectionPool,
-    chunker: Arc<Mutex<&mut Chunker>>,
+    chunker: Arc<Mutex<Chunker>>,
     remote: &Remote,
     storage_path: &Path,
     namespace_id: i32,

client/tests/common/mod.rs

@@ -54,3 +54,23 @@ fn base64_url_nopad(bytes: &[u8]) -> String {
     use base64::Engine;
     URL_SAFE_NO_PAD.encode(bytes)
 }
+
+use cooklang_sync_client::chunker::{Chunker, InMemoryCache};
+
+/// Bundle of the three things every syncer integration test needs:
+/// a fresh SQLite pool, a tempdir root, and a `Chunker` rooted at that dir.
+///
+/// The tempdir is returned separately (not moved into the `Chunker`) so the
+/// test can write fixture files into it before invoking the syncer.
+pub struct ClientBase {
+    pub pool: cooklang_sync_client::connection::ConnectionPool,
+    pub dir: TempDir,
+    pub chunker: Chunker,
+}
+
+pub fn client_base() -> ClientBase {
+    let (pool, dir) = fresh_client_pool();
+    let cache = InMemoryCache::new(100, 10_000_000);
+    let chunker = Chunker::new(cache, dir.path().to_path_buf());
+    ClientBase { pool, dir, chunker }
+}

client/tests/connection_tests.rs

@@ -42,8 +42,7 @@ fn get_connection_pool_returns_error_for_unwritable_path() {
     // directory, causing SQLite to fail to open the file.
     let bogus = "/dev/null/does_not_exist/db.sqlite3";
     let err = get_connection_pool(bogus)
-        .err()
-        .expect("pool creation should fail on unwritable parent");
+        .expect_err("pool creation should fail on unwritable parent");
     let msg = format!("{err}");
     assert!(
         msg.to_lowercase().contains("connection"),

client/tests/indexer_tests.rs

@@ -260,3 +260,16 @@ fn check_index_once_does_not_tombstone_just_downloaded_file() {
     assert_eq!(live[0].path, rel);
     assert!(!live[0].deleted, "downloaded file must not be soft-deleted by the indexer");
 }
+
+#[test]
+fn check_index_once_on_empty_dir_is_noop() {
+    let (pool, _dir) = common::fresh_client_pool();
+    let storage = TempDir::new().expect("tempdir");
+
+    let changed = check_index_once(&pool, storage.path(), 1).expect("check_index_once");
+    assert!(!changed, "empty dir must return Ok(false)");
+
+    let conn = &mut get_connection(&pool).expect("checkout");
+    let rows = registry::non_deleted(conn, 1).expect("non_deleted");
+    assert!(rows.is_empty(), "empty dir must not produce any registry rows");
+}

client/tests/registry_tests.rs

@@ -263,3 +263,38 @@ fn latest_jid_returns_highest_jid_in_namespace_and_ignores_null_jid_rows() {
     assert_eq!(registry::latest_jid(conn, 1).unwrap(), 7);
     assert_eq!(registry::latest_jid(conn, 2).unwrap(), 100);
 }
+
+#[test]
+fn updated_locally_surfaces_unsynced_tombstone() {
+    let (pool, _dir) = common::fresh_client_pool();
+    let conn = &mut get_connection(&pool).expect("checkout");
+
+    // Create then delete (tombstone is appended; jid still None on both rows).
+    registry::create(conn, &vec![sample_create("gone.cook", 10, 1)]).expect("create");
+    let existing: Vec<FileRecord> = registry::non_deleted(conn, 1).expect("non_deleted");
+    let sample = existing.first().expect("row present");
+    registry::delete(conn, &vec![sample_delete(sample)]).expect("delete");
+
+    // Latest row per path is the tombstone, which still has jid=None, so
+    // updated_locally must surface it - this is what lets the upload path
+    // retry tombstones that never reached the server.
+    let unsynced = registry::updated_locally(conn, 1).expect("updated_locally");
+    assert_eq!(unsynced.len(), 1, "tombstone with jid=None must appear in updated_locally");
+    assert_eq!(unsynced[0].path, "gone.cook");
+    assert!(unsynced[0].deleted, "latest row is the tombstone");
+    assert!(unsynced[0].jid.is_none());
+}
+
+#[test]
+fn latest_jid_returns_zero_for_explicit_jid_zero() {
+    let (pool, _dir) = common::fresh_client_pool();
+    let conn = &mut get_connection(&pool).expect("checkout");
+
+    // Insert a single row with jid=Some(0).
+    let mut form = sample_create("a.cook", 5, 1);
+    form.jid = Some(0);
+    registry::create(conn, &vec![form]).expect("create");
+
+    let latest = registry::latest_jid(conn, 1).expect("latest_jid");
+    assert_eq!(latest, 0, "Some(0) must unwrap to 0, not NotFound");
+}