From 974c7745cf410a871c8fc85d8d7de8047bf6c2d7 Mon Sep 17 00:00:00 2001 From: John Coffey Date: Fri, 30 Oct 2026 08:08:14 -0700 Subject: [PATCH] import carddav: a card in two address books is one card in both The archive keeps one row per card UID, so a CardDAV server that lists the same card in two address books made the second INSERT fail, on every run. The second book now joins the first row's address_book_ids, and sync_id_dav lets two server items map to one local row (older archives are rebuilt without that UNIQUE). A vanished item takes only its book off a card another item still maps; deleting an address book deletes only the cards no other book holds. The in-memory DAV server from mock_export_dav moves to tests/fake_dav, gaining multiget and DELETE, and drives a new import test that fails on the old code. --- CHANGELOG.md | 3 + docs/usage.md | 5 +- src/db/cards.rs | 101 +++++++++++ src/db/dav_ids.rs | 50 +++--- src/db/init.rs | 86 +++++++++ src/db/mod.rs | 1 + src/db/schema.sql | 5 +- src/sync/import_dav/collections.rs | 8 +- src/sync/import_dav/items.rs | 106 +++++++---- tests/fake_dav/mod.rs | 275 +++++++++++++++++++++++++++++ tests/mock_export_dav.rs | 218 +---------------------- tests/mock_import_carddav_books.rs | 149 ++++++++++++++++ 12 files changed, 727 insertions(+), 280 deletions(-) create mode 100644 src/db/cards.rs create mode 100644 tests/fake_dav/mod.rs create mode 100644 tests/mock_import_carddav_books.rs diff --git a/CHANGELOG.md b/CHANGELOG.md index 97f097f..69aebe9 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -12,6 +12,9 @@ candidates before a series ships (`27.1-rc.1`). The tag is the version with a at a mistyped path and bring an older archive's layout up to date; now the first is an error and the second is refused, and reading a closed archive leaves no files beside it. +- `import carddav` takes a card that is in two address books into both. + It used to fail on that card on every run. Taking it out of one book, or + deleting that book, now leaves it in the other. ## [27.1-rc.3] diff --git a/docs/usage.md b/docs/usage.md index a930b3e..97cdf93 100644 --- a/docs/usage.md +++ b/docs/usage.md @@ -121,7 +121,10 @@ inbuxa-migrate import carddav \ ``` -Same shape as `caldav`, but for address books and contacts. +Same shape as `caldav`, but for address books and contacts. A card the +server keeps in two address books, by the same UID, is one card in both. If +it leaves one book, or that book is deleted, it stays in the other; if the +copies differ, the one read last is kept. ### WebDAV diff --git a/src/db/cards.rs b/src/db/cards.rs new file mode 100644 index 0000000..df6ee59 --- /dev/null +++ b/src/db/cards.rs @@ -0,0 +1,101 @@ +/* + * SPDX-FileCopyrightText: 2026 Coffey Labs LLC + * + * SPDX-License-Identifier: Apache-2.0 OR MIT + */ + +//! A contact card is one row however many address books hold it, with the +//! books in `address_book_ids`. Sources that list a card once per book +//! (CardDAV, Takeout) add each book they find it in to the same row. + +use rusqlite::{Connection, params}; + +/// `address_book_ids` with `book` added, in the order first seen. +pub fn with_book(ids_json: &str, book: i64) -> String { + let mut ids: Vec = serde_json::from_str(ids_json).unwrap_or_default(); + if !ids.contains(&book) { + ids.push(book); + } + serde_json::to_string(&ids).unwrap_or_else(|_| "[]".to_owned()) +} + +/// Takes `book` off one card, leaving the card in its other books. +pub fn leave_book(conn: &Connection, card: i64, book: i64) -> Result<(), rusqlite::Error> { + conn.execute( + "UPDATE contact_cards + SET address_book_ids = (SELECT json_group_array(value) FROM json_each(address_book_ids) + WHERE value != ?2) + WHERE id = ?1", + params![card, book], + )?; + Ok(()) +} + +/// An address book going away: the cards only it held go with it, and the +/// others stay in their other books. +pub fn remove_book(conn: &Connection, book: i64) -> Result<(), rusqlite::Error> { + conn.execute( + "DELETE FROM contact_cards + WHERE EXISTS (SELECT 1 FROM json_each(address_book_ids) WHERE value = ?1) + AND NOT EXISTS (SELECT 1 FROM json_each(address_book_ids) WHERE value != ?1)", + params![book], + )?; + conn.execute( + "UPDATE contact_cards + SET address_book_ids = (SELECT json_group_array(value) FROM json_each(address_book_ids) + WHERE value != ?1) + WHERE EXISTS (SELECT 1 FROM json_each(address_book_ids) WHERE value = ?1)", + params![book], + )?; + Ok(()) +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::db::init; + + fn books(conn: &Connection, uid: &str) -> Option { + conn.query_row( + "SELECT address_book_ids FROM contact_cards WHERE uid = ?1", + [uid], + |r| r.get(0), + ) + .ok() + } + + #[test] + fn a_book_is_added_once() { + assert_eq!(with_book("[1]", 2), "[1,2]"); + assert_eq!(with_book("[1,2]", 1), "[1,2]"); + assert_eq!(with_book("not json", 3), "[3]"); + } + + #[test] + fn removing_a_book_keeps_cards_another_book_holds() { + let conn = Connection::open_in_memory().unwrap(); + init::apply_schema(&conn).unwrap(); + conn.execute_batch( + "INSERT INTO contact_cards (uid, address_book_ids, data) VALUES + ('only-1', '[1]', '{}'), ('both', '[1,2]', '{}'), ('only-2', '[2]', '{}');", + ) + .unwrap(); + remove_book(&conn, 1).unwrap(); + assert_eq!(books(&conn, "only-1"), None); + assert_eq!(books(&conn, "both").as_deref(), Some("[2]")); + assert_eq!(books(&conn, "only-2").as_deref(), Some("[2]")); + + let id: i64 = conn + .query_row("SELECT id FROM contact_cards WHERE uid = 'both'", [], |r| { + r.get(0) + }) + .unwrap(); + conn.execute( + "UPDATE contact_cards SET address_book_ids = '[2,3]' WHERE id = ?1", + [id], + ) + .unwrap(); + leave_book(&conn, id, 2).unwrap(); + assert_eq!(books(&conn, "both").as_deref(), Some("[3]")); + } +} diff --git a/src/db/dav_ids.rs b/src/db/dav_ids.rs index a7cf537..f8cb4e5 100644 --- a/src/db/dav_ids.rs +++ b/src/db/dav_ids.rs @@ -121,6 +121,22 @@ pub fn collections_of_type( Ok(map) } +/// How many server items stand for one local row: a card in two address +/// books has two. +pub fn items_for_local( + conn: &Connection, + source_id: i64, + type_name: &str, + local_id: i64, +) -> Result { + conn.query_row( + "SELECT count(*) FROM sync_id_dav + WHERE source_id = ?1 AND type_name = ?2 AND local_id = ?3", + params![source_id, type_name, local_id], + |row| row.get(0), + ) +} + pub fn delete_item( conn: &Connection, source_id: i64, @@ -305,32 +321,14 @@ mod tests { } #[test] - fn unique_local_id_per_type_enforced() { + fn two_items_can_stand_for_one_card() { let (conn, sid) = setup(); - insert( - &conn, - sid, - CALENDAR_EVENT, - "/cal/a/", - "/cal/a/e1.ics", - "v", - 1, - ) - .unwrap(); - let err = insert( - &conn, - sid, - CALENDAR_EVENT, - "/cal/a/", - "/cal/a/e2.ics", - "v", - 1, - ) - .unwrap_err(); - let msg = format!("{err}"); - assert!( - msg.contains("UNIQUE"), - "expected UNIQUE violation, got {msg}" - ); + for (book, href) in [("/card/a/", "/card/a/x.vcf"), ("/card/b/", "/card/b/x.vcf")] { + insert(&conn, sid, CONTACT_CARD, book, href, "v", 1).unwrap(); + } + assert_eq!(items_for_local(&conn, sid, CONTACT_CARD, 1).unwrap(), 2); + delete_item(&conn, sid, CONTACT_CARD, "/card/a/x.vcf").unwrap(); + assert_eq!(items_for_local(&conn, sid, CONTACT_CARD, 1).unwrap(), 1); + assert_eq!(items_for_local(&conn, sid, CALENDAR_EVENT, 1).unwrap(), 0); } } diff --git a/src/db/init.rs b/src/db/init.rs index 248e541..7baa167 100644 --- a/src/db/init.rs +++ b/src/db/init.rs @@ -123,6 +123,7 @@ pub fn apply_schema(conn: &Connection) -> Result<(), OpenError> { tx.execute_batch(SCHEMA_SQL)?; ensure_calendar_events_data_type(&tx)?; ensure_graph_ids_accept_file_nodes(&tx)?; + ensure_dav_ids_share_local_rows(&tx)?; tx.commit()?; Ok(()) } @@ -175,6 +176,47 @@ fn ensure_graph_ids_accept_file_nodes(conn: &Connection) -> Result<(), OpenError Ok(()) } +/// A card in two address books is one archive row reached from two server +/// items, so the DAV map no longer holds a local row to one item. An +/// archive from before that is rebuilt without the constraint. +fn ensure_dav_ids_share_local_rows(conn: &Connection) -> Result<(), OpenError> { + let sql: Option = conn + .query_row( + "SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'sync_id_dav'", + [], + |row| row.get(0), + ) + .ok(); + let Some(sql) = sql else { return Ok(()) }; + if !sql.contains("UNIQUE (source_id, type_name, local_id)") { + return Ok(()); + } + conn.execute_batch( + "DROP INDEX IF EXISTS sync_id_dav_collection_idx; + DROP INDEX IF EXISTS sync_id_dav_local_idx; + ALTER TABLE sync_id_dav RENAME TO sync_id_dav_old; + CREATE TABLE sync_id_dav ( + source_id INTEGER NOT NULL REFERENCES sources(id) ON DELETE CASCADE, + type_name TEXT NOT NULL CHECK (type_name IN ( + 'calendar','calendarevent', + 'addressbook','contactcard', + 'filenode')), + collection_href TEXT NOT NULL, + item_href TEXT NOT NULL, + etag TEXT NOT NULL DEFAULT '', + local_id INTEGER NOT NULL, + PRIMARY KEY (source_id, type_name, item_href) + ); + INSERT INTO sync_id_dav SELECT * FROM sync_id_dav_old; + DROP TABLE sync_id_dav_old; + CREATE INDEX sync_id_dav_collection_idx + ON sync_id_dav (source_id, type_name, collection_href); + CREATE INDEX sync_id_dav_local_idx + ON sync_id_dav (source_id, type_name, local_id);", + )?; + Ok(()) +} + /// An archive holds a whole mailbox, so it is created readable by its owner /// only. SQLite gives its `-wal` and `-shm` files the database file's mode, /// so they follow. An existing archive others can read is left as it is, @@ -419,3 +461,47 @@ mod permission_tests { ); } } + +#[cfg(test)] +mod migration_tests { + use super::*; + + #[test] + fn an_older_dav_map_is_rebuilt_to_share_local_rows() { + let conn = Connection::open_in_memory().unwrap(); + conn.execute_batch( + "CREATE TABLE sources (id INTEGER PRIMARY KEY); + INSERT INTO sources (id) VALUES (1); + CREATE TABLE sync_id_dav ( + source_id INTEGER NOT NULL REFERENCES sources(id) ON DELETE CASCADE, + type_name TEXT NOT NULL, + collection_href TEXT NOT NULL, + item_href TEXT NOT NULL, + etag TEXT NOT NULL DEFAULT '', + local_id INTEGER NOT NULL, + PRIMARY KEY (source_id, type_name, item_href), + UNIQUE (source_id, type_name, local_id) + ); + INSERT INTO sync_id_dav VALUES (1, 'contactcard', '/a/', '/a/x.vcf', 'e1', 7);", + ) + .unwrap(); + ensure_dav_ids_share_local_rows(&conn).unwrap(); + conn.execute( + "INSERT INTO sync_id_dav VALUES (1, 'contactcard', '/b/', '/b/x.vcf', 'e2', 7)", + [], + ) + .expect("two items may stand for one card"); + let rows: i64 = conn + .query_row( + "SELECT count(*) FROM sync_id_dav WHERE local_id = 7", + [], + |r| r.get(0), + ) + .unwrap(); + assert_eq!(rows, 2, "the old row was kept"); + // A second pass finds nothing to do. + ensure_dav_ids_share_local_rows(&conn).unwrap(); + // And a full schema pass over it is clean. + apply_schema(&conn).unwrap(); + } +} diff --git a/src/db/mod.rs b/src/db/mod.rs index c638fc3..14a313a 100644 --- a/src/db/mod.rs +++ b/src/db/mod.rs @@ -5,6 +5,7 @@ */ pub mod blobs; +pub mod cards; pub mod dav_ids; pub mod defaults; pub mod exchange_ews_ids; diff --git a/src/db/schema.sql b/src/db/schema.sql index 5ed1f37..b0674af 100644 --- a/src/db/schema.sql +++ b/src/db/schema.sql @@ -68,12 +68,13 @@ CREATE TABLE IF NOT EXISTS sync_id_dav ( item_href TEXT NOT NULL, etag TEXT NOT NULL DEFAULT '', local_id INTEGER NOT NULL, - PRIMARY KEY (source_id, type_name, item_href), - UNIQUE (source_id, type_name, local_id) + PRIMARY KEY (source_id, type_name, item_href) ); CREATE INDEX IF NOT EXISTS sync_id_dav_collection_idx ON sync_id_dav (source_id, type_name, collection_href); +CREATE INDEX IF NOT EXISTS sync_id_dav_local_idx + ON sync_id_dav (source_id, type_name, local_id); CREATE TABLE IF NOT EXISTS sync_id_managesieve ( source_id INTEGER NOT NULL REFERENCES sources(id) ON DELETE CASCADE, diff --git a/src/sync/import_dav/collections.rs b/src/sync/import_dav/collections.rs index 9507468..1a02b27 100644 --- a/src/sync/import_dav/collections.rs +++ b/src/sync/import_dav/collections.rs @@ -231,13 +231,7 @@ fn upsert_address_book_row( } fn delete_address_book_row(conn: &Connection, local_id: i64) -> Result<(), rusqlite::Error> { - conn.execute( - "DELETE FROM contact_cards - WHERE EXISTS ( - SELECT 1 FROM json_each(address_book_ids) WHERE value = ?1 - )", - params![local_id], - )?; + crate::db::cards::remove_book(conn, local_id)?; conn.execute("DELETE FROM address_books WHERE id = ?1", params![local_id])?; Ok(()) } diff --git a/src/sync/import_dav/items.rs b/src/sync/import_dav/items.rs index dac1ffc..6461887 100644 --- a/src/sync/import_dav/items.rs +++ b/src/sync/import_dav/items.rs @@ -6,13 +6,13 @@ use std::collections::{HashMap, HashSet}; -use rusqlite::{Connection, params}; +use rusqlite::{Connection, OptionalExtension, params}; use crate::dav::client::{DavClient, MultiStatus}; use crate::dav::href::{Href, join_absolute, normalise}; use crate::dav::parse::DavResponse; use crate::dav::xml; -use crate::db::dav_ids; +use crate::db::{cards, dav_ids}; use crate::error::Error; use crate::jmap::error::JmapError; use crate::logging::{LEVEL_PROGRESS, Logger}; @@ -214,17 +214,26 @@ fn reconcile_items_generic( let tx = conn .unchecked_transaction() .map_err(|e| Error::Partial(e.to_string()))?; - let table = match pcc.kind { - ItemKind::CalendarEvent => "calendar_events", - ItemKind::ContactCard => "contact_cards", - }; - tx.execute( - &format!("DELETE FROM {table} WHERE id = ?1"), - params![local_id], - ) - .map_err(|e| Error::Partial(e.to_string()))?; dav_ids::delete_item(&tx, pcc.run.source_id, type_name, href) .map_err(|e| Error::Partial(e.to_string()))?; + let elsewhere = dav_ids::items_for_local(&tx, pcc.run.source_id, type_name, local_id) + .map_err(|e| Error::Partial(e.to_string()))?; + let removed = match pcc.kind { + // Still in another address book: only this one lets it go. + ItemKind::ContactCard if elsewhere > 0 => { + cards::leave_book(&tx, local_id, pcc.container_local_id) + } + ItemKind::ContactCard => tx + .execute("DELETE FROM contact_cards WHERE id = ?1", params![local_id]) + .map(drop), + ItemKind::CalendarEvent => tx + .execute( + "DELETE FROM calendar_events WHERE id = ?1", + params![local_id], + ) + .map(drop), + }; + removed.map_err(|e| Error::Partial(e.to_string()))?; tx.commit().map_err(|e| Error::Partial(e.to_string()))?; counts.deleted += 1; } @@ -471,7 +480,7 @@ fn insert_or_update_tx( local_map: &HashMap, ) -> Result<(), Error> { let existing = local_map.get(item_href).map(|(_, id)| *id); - match pcc.kind { + let local = match pcc.kind { ItemKind::CalendarEvent => insert_or_update_event( tx, pcc.container_local_id, @@ -485,7 +494,6 @@ fn insert_or_update_tx( } }; if existing.is_none() { - let new_local = tx.last_insert_rowid(); dav_ids::insert( tx, pcc.run.source_id, @@ -493,7 +501,7 @@ fn insert_or_update_tx( pcc.collection_href, item_href, etag, - new_local, + local, ) .map_err(|e| Error::Partial(e.to_string()))?; } else { @@ -510,7 +518,7 @@ fn insert_or_update_event( raw: &str, item_href: &str, logger: Logger, -) -> Result<(), Error> { +) -> Result { let entries = calcard::ical_to_jscalendar_entries(raw) .map_err(|e| Error::Partial(format!("iCalendar parse: {e}")))?; if entries.len() > 1 && logger.enabled(crate::logging::LEVEL_DEFAULT) { @@ -544,6 +552,7 @@ fn insert_or_update_event( ], ) .map_err(|e| Error::Partial(e.to_string()))?; + Ok(local) } else { tx.execute( "INSERT INTO calendar_events (calendar_ids, is_draft, use_default_alerts, data, data_type) @@ -557,8 +566,8 @@ fn insert_or_update_event( ], ) .map_err(|e| Error::Partial(e.to_string()))?; + Ok(tx.last_insert_rowid()) } - Ok(()) } fn insert_or_update_card( @@ -567,25 +576,58 @@ fn insert_or_update_card( existing: Option, raw: &str, item_href: &str, -) -> Result<(), Error> { +) -> Result { let card = calcard::vcard_to_jscontact(raw, item_href) .map_err(|e| Error::Partial(format!("vCard parse: {e}")))?; - let address_book_ids = format!("[{address_book_local}]"); - if let Some(local) = existing { - tx.execute( - "UPDATE contact_cards SET uid = ?1, address_book_ids = ?2, data = ?3 - WHERE id = ?4", - params![card.uid, address_book_ids, card.data.to_string(), local], - ) - .map_err(|e| Error::Partial(e.to_string()))?; - } else { - tx.execute( - "INSERT INTO contact_cards (uid, address_book_ids, data) VALUES (?1, ?2, ?3)", - params![card.uid, address_book_ids, card.data.to_string()], - ) - .map_err(|e| Error::Partial(e.to_string()))?; + let db = |e: rusqlite::Error| Error::Partial(e.to_string()); + // The same card met in another address book is the same row: this + // book joins its others, and the copy read last is kept. + let local = match existing { + Some(local) => Some(local), + None => tx + .query_row( + "SELECT id FROM contact_cards WHERE uid = ?1", + params![card.uid], + |r| r.get(0), + ) + .optional() + .map_err(db)?, + }; + match local { + Some(local) => { + let books: String = tx + .query_row( + "SELECT address_book_ids FROM contact_cards WHERE id = ?1", + params![local], + |r| r.get(0), + ) + .map_err(db)?; + tx.execute( + "UPDATE contact_cards SET uid = ?1, address_book_ids = ?2, data = ?3 + WHERE id = ?4", + params![ + card.uid, + cards::with_book(&books, address_book_local), + card.data.to_string(), + local + ], + ) + .map_err(db)?; + Ok(local) + } + None => { + tx.execute( + "INSERT INTO contact_cards (uid, address_book_ids, data) VALUES (?1, ?2, ?3)", + params![ + card.uid, + format!("[{address_book_local}]"), + card.data.to_string() + ], + ) + .map_err(db)?; + Ok(tx.last_insert_rowid()) + } } - Ok(()) } fn response_indicates_vanished(response: &DavResponse) -> bool { diff --git a/tests/fake_dav/mod.rs b/tests/fake_dav/mod.rs new file mode 100644 index 0000000..14d981d --- /dev/null +++ b/tests/fake_dav/mod.rs @@ -0,0 +1,275 @@ +/* + * SPDX-FileCopyrightText: 2026 Coffey Labs LLC + * + * SPDX-License-Identifier: Apache-2.0 OR MIT + */ + +//! A small in-memory CalDAV and CardDAV server for tests: discovery, depth-1 +//! listings, multiget, GET, conditional PUT, MKCALENDAR, MKCOL and DELETE, +//! one request per connection. The home sets are `/cal/` and `/card/`. + +#![allow(dead_code)] + +use std::collections::BTreeMap; +use std::io::{BufRead, BufReader, Read, Write}; +use std::net::TcpListener; +use std::sync::{Arc, Mutex}; +use std::thread; + +/// What the server holds, by path: a collection's name, or an item's body +/// and etag. +#[derive(Clone)] +pub enum Resource { + Collection { name: String, calendar: bool }, + Item { body: String, etag: u32 }, +} + +#[derive(Default)] +pub struct Store { + pub resources: BTreeMap, + pub next_etag: u32, + /// Each write as (method, path, condition header). + pub writes: Vec<(String, String, String)>, + /// Paths a PUT to is refused with 415. + pub refuse: Vec, +} + +impl Store { + pub fn collection(&mut self, path: &str, name: &str, calendar: bool) { + self.resources.insert( + path.to_owned(), + Resource::Collection { + name: name.to_owned(), + calendar, + }, + ); + } + + pub fn put_item(&mut self, path: &str, body: &str) { + self.next_etag += 1; + self.resources.insert( + path.to_owned(), + Resource::Item { + body: body.to_owned(), + etag: self.next_etag, + }, + ); + } + + /// A path and everything under it. + pub fn remove(&mut self, path: &str) { + self.resources.retain(|p, _| !p.starts_with(path)); + } +} + +fn escape(text: &str) -> String { + text.replace('&', "&") + .replace('<', "<") + .replace('>', ">") +} + +fn props(path: &str, resource: Option<&Resource>, with_data: bool) -> String { + let inner = match resource { + None => "".to_owned(), + Some(Resource::Collection { name, calendar }) => format!( + "{}{name}", + if *calendar { + "" + } else { + "" + } + ), + Some(Resource::Item { etag, body }) => { + let data = match (with_data, path.starts_with("/cal/")) { + (false, _) => String::new(), + (true, true) => format!("{}", escape(body)), + (true, false) => format!("{}", escape(body)), + }; + format!("\"{etag}\"{data}") + } + }; + format!( + "{path}{inner}\ + HTTP/1.1 200 OK" + ) +} + +fn multistatus(responses: &str) -> String { + format!( + "{responses}" + ) +} + +fn displayname(body: &str) -> String { + let start = body.find("displayname>").map(|i| i + "displayname>".len()); + start + .and_then(|s| body[s..].find('<').map(|e| body[s..s + e].to_owned())) + .unwrap_or_default() +} + +/// Every `<…href>` in a request body. +fn hrefs(body: &str) -> Vec { + let mut out = Vec::new(); + let mut rest = body; + while let Some(i) = rest.find("href>") { + rest = &rest[i + "href>".len()..]; + if let Some(end) = rest.find('<') { + if !rest[..end].trim().is_empty() { + out.push(rest[..end].trim().to_owned()); + } + rest = &rest[end..]; + } + } + out +} + +/// One request against the store, as (status, etag, body). +fn handle( + store: &mut Store, + method: &str, + path: &str, + headers: &BTreeMap, + body: &str, +) -> (u16, Option, String) { + match method { + "PROPFIND" if headers.get("depth").map(String::as_str) == Some("0") => { + let home = "/p/\ + /cal/\ + /card/"; + let response = format!( + "{path}{home}\ + HTTP/1.1 200 OK" + ); + (207, None, multistatus(&response)) + } + "PROPFIND" => { + let mut out = props(path, store.resources.get(path), false); + for (child, resource) in store.resources.range(path.to_owned()..) { + let Some(rest) = child.strip_prefix(path) else { + break; + }; + let direct = !rest.is_empty() && !rest.trim_end_matches('/').contains('/'); + if direct { + out.push_str(&props(child, Some(resource), false)); + } + } + (207, None, multistatus(&out)) + } + "REPORT" => { + let mut out = String::new(); + for href in hrefs(body) { + match store.resources.get(&href) { + Some(item @ Resource::Item { .. }) => { + out.push_str(&props(&href, Some(item), true)) + } + _ => out.push_str(&format!( + "{href}\ + HTTP/1.1 404 Not Found" + )), + } + } + (207, None, multistatus(&out)) + } + "MKCALENDAR" | "MKCOL" => { + store + .writes + .push((method.to_owned(), path.to_owned(), String::new())); + if store.resources.contains_key(path) { + return (405, None, String::new()); + } + store.collection(path, &displayname(body), method == "MKCALENDAR"); + (201, None, String::new()) + } + "GET" => match store.resources.get(path) { + Some(Resource::Item { body, etag }) => (200, Some(*etag), body.clone()), + _ => (404, None, String::new()), + }, + "DELETE" => { + store.remove(path); + (204, None, String::new()) + } + "PUT" => { + let condition = headers + .get("if-none-match") + .map(|v| format!("If-None-Match: {v}")) + .or_else(|| headers.get("if-match").map(|v| format!("If-Match: {v}"))) + .unwrap_or_default(); + store + .writes + .push(("PUT".to_owned(), path.to_owned(), condition)); + if store.refuse.iter().any(|r| r == path) { + return (415, None, String::new()); + } + let current = match store.resources.get(path) { + Some(Resource::Item { etag, .. }) => Some(format!("\"{etag}\"")), + _ => None, + }; + let allowed = match (headers.get("if-none-match"), headers.get("if-match")) { + (Some(_), _) => current.is_none(), + (_, Some(want)) => current.as_deref() == Some(want.as_str()), + _ => false, + }; + if !allowed { + return (412, None, String::new()); + } + let status = if current.is_some() { 204 } else { 201 }; + store.put_item(path, body); + (status, Some(store.next_etag), String::new()) + } + _ => (405, None, String::new()), + } +} + +/// Serves `store` on a local port; the URL of its root. +pub fn serve(store: Arc>) -> String { + let listener = TcpListener::bind("127.0.0.1:0").unwrap(); + let url = format!("http://{}/", listener.local_addr().unwrap()); + thread::spawn(move || { + for stream in listener.incoming() { + let Ok(mut stream) = stream else { break }; + let mut reader = BufReader::new(stream.try_clone().unwrap()); + let mut line = String::new(); + if reader.read_line(&mut line).unwrap_or(0) == 0 { + continue; + } + let mut parts = line.split_whitespace(); + let method = parts.next().unwrap_or_default().to_owned(); + let path = parts.next().unwrap_or_default().to_owned(); + let mut headers = BTreeMap::new(); + loop { + let mut h = String::new(); + if reader.read_line(&mut h).unwrap_or(0) == 0 || h.trim().is_empty() { + break; + } + if let Some((k, v)) = h.split_once(':') { + headers.insert(k.trim().to_ascii_lowercase(), v.trim().to_owned()); + } + } + let length: usize = headers + .get("content-length") + .and_then(|v| v.parse().ok()) + .unwrap_or(0); + let mut body = vec![0; length]; + reader.read_exact(&mut body).unwrap(); + let body = String::from_utf8_lossy(&body); + let (status, etag, out) = + handle(&mut store.lock().unwrap(), &method, &path, &headers, &body); + let etag = etag + .map(|e| format!("ETag: \"{e}\"\r\n")) + .unwrap_or_default(); + let kind = if status == 207 { + "Content-Type: application/xml; charset=utf-8\r\n" + } else { + "" + }; + let _ = write!( + stream, + "HTTP/1.1 {status} X\r\n{etag}{kind}Content-Length: {}\r\nConnection: close\r\n\r\n{out}", + out.len() + ); + } + }); + url +} diff --git a/tests/mock_export_dav.rs b/tests/mock_export_dav.rs index 34031bc..a0f7595 100644 --- a/tests/mock_export_dav.rs +++ b/tests/mock_export_dav.rs @@ -9,12 +9,12 @@ //! replaced under its etag, a refused card is counted without stopping the //! rest, and a second run writes nothing. -use std::collections::BTreeMap; -use std::io::{BufRead, BufReader, Read, Write}; -use std::net::TcpListener; +mod fake_dav; + use std::path::Path; use std::sync::{Arc, Mutex}; -use std::thread; + +use fake_dav::{Resource, Store, serve}; use inbuxa_migrate::db::init; use inbuxa_migrate::logging::Logger; @@ -33,207 +33,6 @@ const EVENT: &str = "BEGIN:VCALENDAR\r\nVERSION:2.0\r\nPRODID:x\r\nBEGIN:VEVENT\ DTSTAMP:20240101T000000Z\r\nDTSTART:20240301T090000Z\r\nDURATION:PT15M\r\n\ SUMMARY:Standup\r\nEND:VEVENT\r\nEND:VCALENDAR\r\n"; -/// What the server holds, by path: a collection's name, or an item's body -/// and etag. -#[derive(Clone)] -enum Resource { - Collection { name: String, calendar: bool }, - Item { body: String, etag: u32 }, -} - -#[derive(Default)] -struct Store { - resources: BTreeMap, - next_etag: u32, - /// Each write as (method, path, condition header). - writes: Vec<(String, String, String)>, -} - -impl Store { - fn put_item(&mut self, path: &str, body: &str) { - self.next_etag += 1; - self.resources.insert( - path.to_owned(), - Resource::Item { - body: body.to_owned(), - etag: self.next_etag, - }, - ); - } -} - -fn props(path: &str, resource: Option<&Resource>) -> String { - let inner = match resource { - None => "".to_owned(), - Some(Resource::Collection { name, calendar }) => format!( - "{}{name}", - if *calendar { - "" - } else { - "" - } - ), - Some(Resource::Item { etag, .. }) => { - format!("\"{etag}\"") - } - }; - format!( - "{path}{inner}\ - HTTP/1.1 200 OK" - ) -} - -fn multistatus(responses: &str) -> String { - format!( - "{responses}" - ) -} - -fn displayname(body: &str) -> String { - let start = body.find("displayname>").map(|i| i + "displayname>".len()); - start - .and_then(|s| body[s..].find('<').map(|e| body[s..s + e].to_owned())) - .unwrap_or_default() -} - -/// One request against the store, as (status, etag, body). -fn handle( - store: &mut Store, - method: &str, - path: &str, - headers: &BTreeMap, - body: &str, -) -> (u16, Option, String) { - match method { - "PROPFIND" if headers.get("depth").map(String::as_str) == Some("0") => { - let home = "/p/\ - /cal/\ - /card/"; - let response = format!( - "{path}{home}\ - HTTP/1.1 200 OK" - ); - (207, None, multistatus(&response)) - } - "PROPFIND" => { - let mut out = props(path, store.resources.get(path)); - for (child, resource) in store.resources.range(path.to_owned()..) { - let Some(rest) = child.strip_prefix(path) else { - break; - }; - let direct = !rest.is_empty() && !rest.trim_end_matches('/').contains('/'); - if direct { - out.push_str(&props(child, Some(resource))); - } - } - (207, None, multistatus(&out)) - } - "MKCALENDAR" | "MKCOL" => { - store - .writes - .push((method.to_owned(), path.to_owned(), String::new())); - if store.resources.contains_key(path) { - return (405, None, String::new()); - } - store.resources.insert( - path.to_owned(), - Resource::Collection { - name: displayname(body), - calendar: method == "MKCALENDAR", - }, - ); - (201, None, String::new()) - } - "GET" => match store.resources.get(path) { - Some(Resource::Item { body, etag }) => (200, Some(*etag), body.clone()), - _ => (404, None, String::new()), - }, - "PUT" => { - let condition = headers - .get("if-none-match") - .map(|v| format!("If-None-Match: {v}")) - .or_else(|| headers.get("if-match").map(|v| format!("If-Match: {v}"))) - .unwrap_or_default(); - store - .writes - .push(("PUT".to_owned(), path.to_owned(), condition)); - if path.contains("card-carol") { - return (415, None, String::new()); - } - let current = match store.resources.get(path) { - Some(Resource::Item { etag, .. }) => Some(format!("\"{etag}\"")), - _ => None, - }; - let allowed = match (headers.get("if-none-match"), headers.get("if-match")) { - (Some(_), _) => current.is_none(), - (_, Some(want)) => current.as_deref() == Some(want.as_str()), - _ => false, - }; - if !allowed { - return (412, None, String::new()); - } - let status = if current.is_some() { 204 } else { 201 }; - store.put_item(path, body); - (status, Some(store.next_etag), String::new()) - } - _ => (405, None, String::new()), - } -} - -/// A DAV server on a local port, one request per connection. -fn serve(store: Arc>) -> String { - let listener = TcpListener::bind("127.0.0.1:0").unwrap(); - let url = format!("http://{}/", listener.local_addr().unwrap()); - thread::spawn(move || { - for stream in listener.incoming() { - let Ok(mut stream) = stream else { break }; - let mut reader = BufReader::new(stream.try_clone().unwrap()); - let mut line = String::new(); - if reader.read_line(&mut line).unwrap_or(0) == 0 { - continue; - } - let mut parts = line.split_whitespace(); - let method = parts.next().unwrap_or_default().to_owned(); - let path = parts.next().unwrap_or_default().to_owned(); - let mut headers = BTreeMap::new(); - loop { - let mut h = String::new(); - if reader.read_line(&mut h).unwrap_or(0) == 0 || h.trim().is_empty() { - break; - } - if let Some((k, v)) = h.split_once(':') { - headers.insert(k.trim().to_ascii_lowercase(), v.trim().to_owned()); - } - } - let length: usize = headers - .get("content-length") - .and_then(|v| v.parse().ok()) - .unwrap_or(0); - let mut body = vec![0; length]; - reader.read_exact(&mut body).unwrap(); - let body = String::from_utf8_lossy(&body); - let (status, etag, out) = - handle(&mut store.lock().unwrap(), &method, &path, &headers, &body); - let etag = etag - .map(|e| format!("ETag: \"{e}\"\r\n")) - .unwrap_or_default(); - let kind = if status == 207 { - "Content-Type: application/xml; charset=utf-8\r\n" - } else { - "" - }; - let _ = write!( - stream, - "HTTP/1.1 {status} X\r\n{etag}{kind}Content-Length: {}\r\nConnection: close\r\n\r\n{out}", - out.len() - ); - } - }); - url -} - fn common(archive: &Path) -> CommonConfig { CommonConfig { archive: archive.to_path_buf(), @@ -310,13 +109,8 @@ fn carddav_export_matches_by_name_replaces_under_etag_and_converges() { { // The target already has a "Personal" book holding an older Alice. let mut s = store.lock().unwrap(); - s.resources.insert( - "/card/contacts/".into(), - Resource::Collection { - name: "Personal".into(), - calendar: false, - }, - ); + s.collection("/card/contacts/", "Personal", false); + s.refuse.push("/card/work/card-carol.vcf".into()); s.put_item( "/card/contacts/card-alice.vcf", "BEGIN:VCARD\r\nVERSION:4.0\r\nUID:card-alice\r\nFN:Alice Old\r\nEND:VCARD\r\n", diff --git a/tests/mock_import_carddav_books.rs b/tests/mock_import_carddav_books.rs new file mode 100644 index 0000000..6482b53 --- /dev/null +++ b/tests/mock_import_carddav_books.rs @@ -0,0 +1,149 @@ +/* + * SPDX-FileCopyrightText: 2026 Coffey Labs LLC + * + * SPDX-License-Identifier: Apache-2.0 OR MIT + */ + +//! `import carddav` with one card in two address books: it is one card in +//! both books, every run succeeds, and taking it out of one book, or +//! deleting that book, leaves it in the other. + +mod fake_dav; + +use std::path::Path; +use std::sync::{Arc, Mutex}; + +use fake_dav::{Store, serve}; +use inbuxa_migrate::logging::Logger; +use inbuxa_migrate::sync::import_dav::{self, DavAuth, DavImportConfig, DavKindArg}; +use inbuxa_migrate::sync::{CommonConfig, Summary, TypeCounts}; +use rusqlite::Connection; +use tempfile::TempDir; + +const ALICE: &str = + "BEGIN:VCARD\r\nVERSION:4.0\r\nUID:card-alice\r\nFN:Alice Smith\r\nEND:VCARD\r\n"; +const BOB: &str = "BEGIN:VCARD\r\nVERSION:4.0\r\nUID:card-bob\r\nFN:Bob Jones\r\nEND:VCARD\r\n"; + +fn import(url: &str, archive: &Path) -> Summary { + let summary = import_dav::run( + CommonConfig { + archive: archive.to_path_buf(), + threads: 1, + dry_run: false, + max_retries: 0, + allow_invalid_certs: false, + logger: Logger::from_flags(false, 0), + }, + DavImportConfig { + kind: DavKindArg::Carddav, + url: url.to_owned(), + auth: DavAuth::Basic { + user: "u".into(), + password: "p".into(), + }, + allow_cleartext: true, + dav_connections: 1, + multiget_batch: 25, + allow_source_change: false, + }, + ) + .expect("import"); + assert!(!summary.any_failed(), "{summary:?}"); + summary +} + +fn cards(summary: &Summary) -> &TypeCounts { + &summary + .per_type + .iter() + .find(|(t, _)| *t == "contactcard") + .unwrap() + .1 +} + +/// Each card's UID with the names of the books it is in. +fn books(archive: &Path) -> Vec<(String, Vec)> { + let conn = Connection::open(archive).unwrap(); + let mut stmt = conn + .prepare( + "SELECT c.uid, coalesce((SELECT json_group_array(name) FROM + (SELECT b.name FROM json_each(c.address_book_ids) j + JOIN address_books b ON b.id = j.value ORDER BY b.name)), '[]') + FROM contact_cards c ORDER BY c.uid", + ) + .unwrap(); + stmt.query_map([], |r| { + let names: String = r.get(1)?; + Ok((r.get(0)?, serde_json::from_str(&names).unwrap())) + }) + .unwrap() + .map(Result::unwrap) + .collect() +} + +fn names(list: &[(&str, &[&str])]) -> Vec<(String, Vec)> { + list.iter() + .map(|(uid, books)| { + ( + uid.to_string(), + books.iter().map(|b| b.to_string()).collect(), + ) + }) + .collect() +} + +#[test] +fn a_card_in_two_address_books_is_one_card_in_both() { + let dir = TempDir::new().unwrap(); + let archive = dir.path().join("archive.sqlite"); + let store = Arc::new(Mutex::new(Store::default())); + { + let mut s = store.lock().unwrap(); + s.collection("/card/personal/", "Personal", false); + s.collection("/card/work/", "Work", false); + s.put_item("/card/personal/alice.vcf", ALICE); + s.put_item("/card/work/alice-copy.vcf", ALICE); + s.put_item("/card/work/bob.vcf", BOB); + } + let url = serve(store.clone()); + + let first = import(&url, &archive); + assert_eq!(cards(&first).fetched, 3, "{first:?}"); + let both = names(&[ + ("card-alice", &["Personal", "Work"]), + ("card-bob", &["Work"]), + ]); + assert_eq!(books(&archive), both); + + let again = import(&url, &archive); + assert_eq!(cards(&again).fetched, 0, "nothing changed: {again:?}"); + assert_eq!(books(&archive), both); + + // Out of Work only: still in Personal. + store.lock().unwrap().remove("/card/work/alice-copy.vcf"); + let left = import(&url, &archive); + assert_eq!(cards(&left).deleted, 1, "{left:?}"); + assert_eq!( + books(&archive), + names(&[("card-alice", &["Personal"]), ("card-bob", &["Work"])]) + ); + + // Back in Work, then Personal deleted as a whole: still in Work. + store + .lock() + .unwrap() + .put_item("/card/work/alice-copy.vcf", ALICE); + import(&url, &archive); + assert_eq!(books(&archive), both); + store.lock().unwrap().remove("/card/personal/"); + import(&url, &archive); + assert_eq!( + books(&archive), + names(&[("card-alice", &["Work"]), ("card-bob", &["Work"])]) + ); + + // Gone from every book: gone. + store.lock().unwrap().remove("/card/work/alice-copy.vcf"); + import(&url, &archive); + assert_eq!(books(&archive), names(&[("card-bob", &["Work"])])); +} -- 2.54.0