From af0383165c913471e3199a73a6ac49f4d2d84b3d Mon Sep 17 00:00:00 2001 From: John Coffey Date: Fri, 30 Oct 2026 08:14:36 -0700 Subject: [PATCH] Keep each occurrence of a series sent without its master An iCalendar resource holding only RECURRENCE-ID occurrences of one UID (someone invited to single occurrences, not the series) became one row: import caldav stored the first and dropped the rest. Each occurrence is now its own row. sync_id_dav names the first; the others are found by calendar and UID among rows no other item names, so an update reuses, adds or drops rows as the resource changes, and a vanished resource takes them all. On the way out, JMAP export matched events by UID alone, so several such occurrences (from any source) all landed on one target event; it now matches by UID and recurrenceId. export-caldav writes every row sharing a UID in a calendar as one resource, as CalDAV holds them, counting them per row. tests/mock_dav_occurrences.rs covers import, change, export, a second export and re-import on the in-memory DAV server, and fails on the old code. --- CHANGELOG.md | 5 + docs/usage.md | 4 + src/export_files/cards.rs | 25 ++++ src/sync/export/uidtype.rs | 54 ++++++--- src/sync/export_dav.rs | 66 +++++++++- src/sync/import_dav/items.rs | 177 +++++++++++++++++++-------- src/sync/mod.rs | 19 +++ tests/mock_dav_occurrences.rs | 219 ++++++++++++++++++++++++++++++++++ 8 files changed, 503 insertions(+), 66 deletions(-) create mode 100644 tests/mock_dav_occurrences.rs diff --git a/CHANGELOG.md b/CHANGELOG.md index 69aebe9..758eaff 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -15,6 +15,11 @@ candidates before a series ships (`27.1-rc.1`). The tag is the version with a - `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. +- `import caldav` keeps every occurrence of a series someone was invited to + one occurrence at a time, with no master event. It used to keep the first + and drop the rest. `export` now tells such occurrences apart instead of + writing them all onto one event, and `export-caldav` writes them as one + resource, as CalDAV keeps them. ## [27.1-rc.3] diff --git a/docs/usage.md b/docs/usage.md index 97cdf93..241cd66 100644 --- a/docs/usage.md +++ b/docs/usage.md @@ -110,6 +110,10 @@ inbuxa-migrate import caldav \ ``` Discovers the user's CalDAV principal (or accepts a URL pointing straight at a calendar-home or calendar), then imports calendars and events. +A recurring event comes in with its changed occurrences. Someone invited to +single occurrences of a series, without the series itself, has each of those +occurrences as its own event, and `export`, `export-caldav` and +`export-files` write them back the same way. ### CardDAV diff --git a/src/export_files/cards.rs b/src/export_files/cards.rs index 0c2118d..08fcc2f 100644 --- a/src/export_files/cards.rs +++ b/src/export_files/cards.rs @@ -233,6 +233,31 @@ pub(crate) fn icalendar_text( } else { json!({ "@type": "Group", "entries": [value] }) }; + group_text(group) +} + +/// Several events as one iCalendar object, each `(data, data type)`: the +/// occurrences of one series that were sent on their own, which a CalDAV +/// resource holds together under their UID. +pub(crate) fn icalendar_entries_text( + conn: &Connection, + entries: &[(&str, &str)], +) -> Result { + let mut values = Vec::with_capacity(entries.len()); + for (data, data_type) in entries { + let mut value: Value = serde_json::from_str(data).map_err(|e| e.to_string())?; + value + .as_object_mut() + .ok_or("not a JSON object")? + .entry("@type") + .or_insert_with(|| json!(data_type)); + inline_blobs(conn, &mut value, InlineShape::JsCalendarLink)?; + values.push(value); + } + group_text(json!({ "@type": "Group", "entries": values })) +} + +fn group_text(group: Value) -> Result { let json = group.to_string(); let event = JSCalendar::::parse(&json)?; Ok(event diff --git a/src/sync/export/uidtype.rs b/src/sync/export/uidtype.rs index 34a6e33..7c6e9e9 100644 --- a/src/sync/export/uidtype.rs +++ b/src/sync/export/uidtype.rs @@ -26,6 +26,16 @@ fn target_uid(v: &Value) -> Option { v.get("uid").and_then(Value::as_str).map(str::to_owned) } +/// What an object is matched by: its UID, and for one occurrence of a +/// series sent on its own (no master event), which occurrence. Several +/// such occurrences share a UID and are each their own object. +fn match_key(uid: &str, v: &Value) -> String { + match v.get("recurrenceId").and_then(Value::as_str) { + Some(rid) => format!("{uid} {rid}"), + None => uid.to_owned(), + } +} + fn describe(ty: ObjectType, local: i64, uid: &str) -> String { let mut out = String::new(); let _ = write!(out, "{} local {local}", ty.jmap_name()); @@ -44,10 +54,10 @@ pub fn reconcile( logger: &Logger, ) -> Result { let targets = target_query_get(net, ty, None).map_err(Error::from)?; - let mut by_uid: HashMap = HashMap::new(); + let mut by_key: HashMap = HashMap::new(); for t in &targets { if let (Some(uid), Some(id)) = (target_uid(t), jid(t)) { - by_uid.entry(uid).or_insert((id, t)); + by_key.entry(match_key(&uid, t)).or_insert((id, t)); } } @@ -56,28 +66,32 @@ pub fn reconcile( } else { CALENDAR_EVENT_SELECT }; - let rows: Vec<(i64, String)> = { + // Each row as (local id, match key, uid). + let rows: Vec<(i64, String, String)> = { let mut stmt = ctx .conn .prepare(select) .map_err(|e| Error::Partial(e.to_string()))?; stmt.query_map([], |r| { if ty == ObjectType::ContactCard { - Ok((r.get::<_, i64>(0)?, r.get::<_, String>(1)?)) + let uid: String = r.get(1)?; + Ok((r.get::<_, i64>(0)?, uid.clone(), uid)) } else { let data: String = r.get(4)?; - let uid = serde_json::from_str::(&data) - .ok() - .and_then(|v| v.get("uid").and_then(Value::as_str).map(str::to_owned)) - .unwrap_or_default(); - Ok((r.get::<_, i64>(0)?, uid)) + let value = serde_json::from_str::(&data).unwrap_or(Value::Null); + let uid = value + .get("uid") + .and_then(Value::as_str) + .unwrap_or_default() + .to_owned(); + Ok((r.get::<_, i64>(0)?, match_key(&uid, &value), uid)) } }) .and_then(|m| m.collect::, _>>()) .map_err(|e| Error::Partial(e.to_string()))? }; - let mut matched_uids: HashSet = HashSet::new(); + let mut matched_keys: HashSet = HashSet::new(); let mut updates: Vec<(String, Value)> = Vec::new(); let blobs = Uploader::new(net, &ctx.conn); let mut progress = Progress::new( @@ -85,11 +99,11 @@ pub fn reconcile( rows.len() as u64, logger, ); - for (local, uid) in &rows { + for (local, key, uid) in &rows { progress.add(1); - if let Some((tid, existing)) = by_uid.get(uid) { + if let Some((tid, existing)) = by_key.get(key) { maps.insert(ty, *local, crate::jmap::wire::JmapId(tid.clone())); - matched_uids.insert(uid.clone()); + matched_keys.insert(key.clone()); match build_wire(ctx, ty, *local, maps, &blobs) { Ok(wire) => match changed_properties(&wire, existing) { Some(patch) => updates.push((tid.clone(), patch)), @@ -149,10 +163,10 @@ pub fn reconcile( .iter() .filter_map(|t| { let id = jid(t)?; - let uid = target_uid(t); + let key = target_uid(t).map(|uid| match_key(&uid, t)); Some(TargetObj { id: id.clone(), - matched: uid.map(|u| matched_uids.contains(&u)).unwrap_or(false), + matched: key.map(|k| matched_keys.contains(&k)).unwrap_or(false), protected: false, may_delete: true, parent: None, @@ -230,6 +244,16 @@ mod tests { use super::*; use serde_json::json; + #[test] + fn occurrences_sharing_a_uid_are_matched_apart() { + let week1 = json!({"uid": "s", "recurrenceId": "2024-03-04T09:00:00"}); + let week2 = json!({"uid": "s", "recurrenceId": "2024-03-11T09:00:00"}); + let series = json!({"uid": "s", "recurrenceRule": {"frequency": "weekly"}}); + assert_ne!(match_key("s", &week1), match_key("s", &week2)); + assert_ne!(match_key("s", &week1), match_key("s", &series)); + assert_eq!(match_key("s", &series), "s"); + } + #[test] fn unchanged_object_needs_no_update() { let wire = json!({"uid": "u", "name": {"full": "Ann"}, "addressBookIds": {"A": true}}); diff --git a/src/sync/export_dav.rs b/src/sync/export_dav.rs index 2c910fb..d3b7dae 100644 --- a/src/sync/export_dav.rs +++ b/src/sync/export_dav.rs @@ -21,7 +21,9 @@ use crate::dav::discover::{DavKind, discover_home}; use crate::dav::href::{Href, absolute_url, normalise}; use crate::dav::xml; use crate::error::Error; -use crate::export_files::cards::{Collection, icalendar_text, read_collections, vcard_text}; +use crate::export_files::cards::{ + Collection, icalendar_entries_text, icalendar_text, read_collections, vcard_text, +}; use crate::jmap::error::JmapError; use crate::jmap::http::RetryPolicy; use crate::logging::{LEVEL_PROGRESS, Logger}; @@ -77,6 +79,9 @@ struct Item { uid: String, text: String, collections: Vec, + /// An event's `(data, data type)`, for writing it with the other + /// occurrences that share its UID. + event: Option<(String, String)>, } /// id, uid (cards), collection ids, data, data type (events). @@ -121,10 +126,12 @@ fn read_items( counts.failed += 1; continue; }; + let event = data_type.map(|t| (data, t)); out.push(Item { uid, text, collections: serde_json::from_str(&collections).unwrap_or_default(), + event, }); } Ok(out) @@ -412,7 +419,26 @@ pub fn run(common: CommonConfig, config: ExportDavConfig) -> Result *one, + many => { + merged = occurrences(&conn, many); + match &merged { + Ok(item) => item, + Err(reason) => { + logger.warn(&format!( + "{} {}: can't be converted: {reason}", + kind.item_type, many[0].uid + )); + item_counts.failed += many.len() as u64; + continue; + } + } + } + }; + let before = item_counts.clone(); write_item( &client, kind, @@ -422,6 +448,8 @@ pub fn run(common: CommonConfig, config: ExportDavConfig) -> Result Result(items: &[&'a Item]) -> Vec> { + let mut groups: Vec> = Vec::new(); + let mut at: HashMap<&str, usize> = HashMap::new(); + for item in items { + match at.get(item.uid.as_str()) { + Some(&i) => groups[i].push(item), + None => { + at.insert(item.uid.as_str(), groups.len()); + groups.push(vec![item]); + } + } + } + groups +} + +/// Occurrences sharing a UID as one item. +fn occurrences(conn: &Connection, many: &[&Item]) -> Result { + let entries: Vec<(&str, &str)> = many + .iter() + .filter_map(|i| i.event.as_ref().map(|(d, t)| (d.as_str(), t.as_str()))) + .collect(); + if entries.len() != many.len() { + return Err("two cards share a UID".to_owned()); + } + Ok(Item { + uid: many[0].uid.clone(), + text: icalendar_entries_text(conn, &entries)?, + collections: Vec::new(), + event: None, + }) +} + /// A new collection under the home, named after the archive's, or `None` /// when the server won't make it. #[allow(clippy::too_many_arguments)] diff --git a/src/sync/import_dav/items.rs b/src/sync/import_dav/items.rs index 6461887..56cc61b 100644 --- a/src/sync/import_dav/items.rs +++ b/src/sync/import_dav/items.rs @@ -226,12 +226,16 @@ fn reconcile_items_generic( 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], + ItemKind::CalendarEvent => { + occurrence_rows(&tx, pcc.run.source_id, pcc.container_local_id, local_id).and_then( + |ids| { + ids.iter().try_for_each(|id| { + tx.execute("DELETE FROM calendar_events WHERE id = ?1", params![id]) + .map(drop) + }) + }, ) - .map(drop), + } }; removed.map_err(|e| Error::Partial(e.to_string()))?; tx.commit().map_err(|e| Error::Partial(e.to_string()))?; @@ -483,6 +487,7 @@ fn insert_or_update_tx( let local = match pcc.kind { ItemKind::CalendarEvent => insert_or_update_event( tx, + pcc.run.source_id, pcc.container_local_id, existing, raw, @@ -511,63 +516,137 @@ fn insert_or_update_tx( Ok(()) } +/// One event row as the archive keeps it. +struct EventRow { + is_draft: bool, + use_default_alerts: bool, + data: String, + data_type: &'static str, +} + +/// One CalDAV resource holds one UID: a master event with its overrides, +/// which is one row, or, when someone was invited to single occurrences of +/// a series without the series itself, those occurrences, a row each. The +/// first row is the one `sync_id_dav` names; the others are found by +/// calendar and UID among rows no other server item names. fn insert_or_update_event( tx: &rusqlite::Transaction<'_>, + source_id: i64, calendar_local: i64, existing: Option, raw: &str, item_href: &str, logger: Logger, ) -> Result { - let entries = calcard::ical_to_jscalendar_entries(raw) + let db = |e: rusqlite::Error| Error::Partial(e.to_string()); + let mut 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) { - logger.warn(&format!( - "{item_href}: iCalendar resource has {} entries; storing the first ({}), \ - others dropped (recurrence overrides on the master are preserved)", - entries.len(), - entries[0].data_type.as_column(), - )); + let uid_of = |v: &serde_json::Value| v.get("uid").and_then(|u| u.as_str()).map(str::to_owned); + let occurrences_only = entries.len() > 1 + && entries.iter().all(|e| e.data.get("recurrenceId").is_some()) + && entries + .iter() + .all(|e| uid_of(&e.data) == uid_of(&entries[0].data)); + if entries.len() > 1 && !occurrences_only { + if logger.enabled(crate::logging::LEVEL_DEFAULT) { + logger.warn(&format!( + "{item_href}: iCalendar resource has {} entries; storing the first ({}), \ + others dropped (recurrence overrides on the master are preserved)", + entries.len(), + entries[0].data_type.as_column(), + )); + } + entries.truncate(1); } - let mut first = entries + let rows: Vec = entries .into_iter() - .next() - .ok_or_else(|| Error::Partial("iCalendar contained no parseable entries".to_owned()))?; - let (is_draft, use_default_alerts, _uid) = - calcard::strip_extracted_fields_from_event(&mut first.data); - let data_type = first.data_type.as_column(); + .map(|mut entry| { + let (is_draft, use_default_alerts, _uid) = + calcard::strip_extracted_fields_from_event(&mut entry.data); + EventRow { + is_draft, + use_default_alerts, + data: entry.data.to_string(), + data_type: entry.data_type.as_column(), + } + }) + .collect(); let calendar_ids = format!("[{calendar_local}]"); - if let Some(local) = existing { - tx.execute( - "UPDATE calendar_events SET calendar_ids = ?1, is_draft = ?2, - use_default_alerts = ?3, data = ?4, data_type = ?5 - WHERE id = ?6", - params![ - calendar_ids, - is_draft as i64, - use_default_alerts as i64, - first.data.to_string(), - data_type, - local, - ], - ) - .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) - VALUES (?1, ?2, ?3, ?4, ?5)", - params![ - calendar_ids, - is_draft as i64, - use_default_alerts as i64, - first.data.to_string(), - data_type, - ], - ) - .map_err(|e| Error::Partial(e.to_string()))?; - Ok(tx.last_insert_rowid()) + let mut old = match existing { + Some(local) => occurrence_rows(tx, source_id, calendar_local, local).map_err(db)?, + None => Vec::new(), } + .into_iter(); + let mut first = None; + for row in &rows { + let id = match old.next() { + Some(local) => { + tx.execute( + "UPDATE calendar_events SET calendar_ids = ?1, is_draft = ?2, + use_default_alerts = ?3, data = ?4, data_type = ?5 + WHERE id = ?6", + params![ + calendar_ids, + row.is_draft as i64, + row.use_default_alerts as i64, + row.data, + row.data_type, + local, + ], + ) + .map_err(db)?; + local + } + None => { + tx.execute( + "INSERT INTO calendar_events (calendar_ids, is_draft, use_default_alerts, data, data_type) + VALUES (?1, ?2, ?3, ?4, ?5)", + params![ + calendar_ids, + row.is_draft as i64, + row.use_default_alerts as i64, + row.data, + row.data_type, + ], + ) + .map_err(db)?; + tx.last_insert_rowid() + } + }; + first.get_or_insert(id); + } + // Occurrences the resource no longer holds. + for gone in old { + tx.execute("DELETE FROM calendar_events WHERE id = ?1", params![gone]) + .map_err(db)?; + } + first.ok_or_else(|| Error::Partial("iCalendar contained no parseable entries".to_owned())) +} + +/// The rows one resource stands for: `local` first, then the other events +/// in its calendar with its UID that no server item names. +fn occurrence_rows( + conn: &Connection, + source_id: i64, + calendar_local: i64, + local: i64, +) -> Result, rusqlite::Error> { + let mut stmt = conn.prepare( + "SELECT e.id FROM calendar_events e, calendar_events m + WHERE m.id = ?3 + AND (e.id = ?3 OR ( + json_extract(e.data, '$.uid') = json_extract(m.data, '$.uid') + AND EXISTS (SELECT 1 FROM json_each(e.calendar_ids) WHERE value = ?2) + AND NOT EXISTS ( + SELECT 1 FROM sync_id_dav s + WHERE s.source_id = ?1 AND s.type_name = 'calendarevent' + AND s.local_id = e.id))) + ORDER BY e.id != ?3, e.id", + )?; + let ids = stmt + .query_map(params![source_id, calendar_local, local], |r| r.get(0))? + .collect::, _>>()?; + Ok(ids) } fn insert_or_update_card( diff --git a/src/sync/mod.rs b/src/sync/mod.rs index 02fb65b..1ea0bdf 100644 --- a/src/sync/mod.rs +++ b/src/sync/mod.rs @@ -88,6 +88,25 @@ pub struct TypeCounts { pub failed: u64, } +impl TypeCounts { + /// Counts `extra` more of whatever moved since `before`: one write + /// that stood for several rows. + pub fn repeat_last(&mut self, before: &TypeCounts, extra: u64) { + for (now, was) in [ + (&mut self.created, before.created), + (&mut self.fetched, before.fetched), + (&mut self.updated, before.updated), + (&mut self.deleted, before.deleted), + (&mut self.skipped, before.skipped), + (&mut self.failed, before.failed), + ] { + if *now > was { + *now += extra; + } + } + } +} + #[derive(Debug, Default, Clone)] pub struct Summary { pub per_type: Vec<(&'static str, TypeCounts)>, diff --git a/tests/mock_dav_occurrences.rs b/tests/mock_dav_occurrences.rs new file mode 100644 index 0000000..e1c255a --- /dev/null +++ b/tests/mock_dav_occurrences.rs @@ -0,0 +1,219 @@ +/* + * SPDX-FileCopyrightText: 2026 Coffey Labs LLC + * + * SPDX-License-Identifier: Apache-2.0 OR MIT + */ + +//! Invitations to single occurrences of a series, with no master event: +//! `import caldav` keeps every occurrence, follows the resource as it +//! changes, and `export-caldav` writes them back as one resource. + +mod fake_dav; + +use std::path::Path; +use std::sync::{Arc, Mutex}; + +use fake_dav::{Resource, Store, serve}; +use inbuxa_migrate::export_files::{self, ExportFilesConfig}; +use inbuxa_migrate::logging::Logger; +use inbuxa_migrate::sync::export_dav::{self, ExportDavConfig}; +use inbuxa_migrate::sync::import_dav::{self, DavAuth, DavImportConfig, DavKindArg}; +use inbuxa_migrate::sync::{CommonConfig, Summary, TypeCounts}; +use rusqlite::Connection; +use tempfile::TempDir; + +fn occurrence(week: u32, title: &str) -> String { + format!( + "BEGIN:VEVENT\r\nUID:series-1\r\nRECURRENCE-ID:202403{d:02}T090000Z\r\n\ + DTSTAMP:20240101T000000Z\r\nDTSTART:202403{d:02}T090000Z\r\nDURATION:PT30M\r\n\ + SUMMARY:{title}\r\nEND:VEVENT\r\n", + d = 4 + 7 * (week - 1) + ) +} + +fn calendar(components: &[String]) -> String { + format!( + "BEGIN:VCALENDAR\r\nVERSION:2.0\r\nPRODID:x\r\n{}END:VCALENDAR\r\n", + components.concat() + ) +} + +const LUNCH: &str = "BEGIN:VCALENDAR\r\nVERSION:2.0\r\nPRODID:x\r\nBEGIN:VEVENT\r\nUID:lunch\r\n\ +DTSTAMP:20240101T000000Z\r\nDTSTART:20240305T120000Z\r\nDURATION:PT1H\r\nSUMMARY:Lunch\r\n\ +END:VEVENT\r\nEND:VCALENDAR\r\n"; + +fn common(archive: &Path) -> CommonConfig { + CommonConfig { + archive: archive.to_path_buf(), + threads: 1, + dry_run: false, + max_retries: 0, + allow_invalid_certs: false, + logger: Logger::from_flags(false, 0), + } +} + +fn auth() -> DavAuth { + DavAuth::Basic { + user: "u".into(), + password: "p".into(), + } +} + +fn import(url: &str, archive: &Path) -> Summary { + let summary = import_dav::run( + common(archive), + DavImportConfig { + kind: DavKindArg::Caldav, + url: url.to_owned(), + auth: auth(), + allow_cleartext: true, + dav_connections: 1, + multiget_batch: 25, + allow_source_change: false, + }, + ) + .expect("import"); + assert!(!summary.any_failed(), "{summary:?}"); + summary +} + +fn events(summary: &Summary) -> &TypeCounts { + &summary + .per_type + .iter() + .find(|(t, _)| *t == "calendarevent") + .unwrap() + .1 +} + +/// Each event as (uid, occurrence, title). +fn rows(archive: &Path) -> Vec<(String, Option, String)> { + let conn = Connection::open(archive).unwrap(); + let mut stmt = conn + .prepare( + "SELECT json_extract(data, '$.uid'), json_extract(data, '$.recurrenceId'), + json_extract(data, '$.title') + FROM calendar_events ORDER BY 1, 2", + ) + .unwrap(); + stmt.query_map([], |r| Ok((r.get(0)?, r.get(1)?, r.get(2)?))) + .unwrap() + .map(Result::unwrap) + .collect() +} + +fn row(uid: &str, rid: Option<&str>, title: &str) -> (String, Option, String) { + (uid.to_owned(), rid.map(str::to_owned), title.to_owned()) +} + +#[test] +fn occurrences_without_a_master_are_each_kept_and_written_back_together() { + 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("/cal/team/", "Team", true); + s.put_item( + "/cal/team/series.ics", + &calendar(&[occurrence(1, "Week 1"), occurrence(2, "Week 2")]), + ); + s.put_item("/cal/team/lunch.ics", LUNCH); + } + let url = serve(store.clone()); + + import(&url, &archive); + let week1 = row("series-1", Some("2024-03-04T09:00:00"), "Week 1"); + let week2 = row("series-1", Some("2024-03-11T09:00:00"), "Week 2"); + let week3 = row("series-1", Some("2024-03-18T09:00:00"), "Week 3"); + let lunch = row("lunch", None, "Lunch"); + assert_eq!( + rows(&archive), + [lunch.clone(), week1.clone(), week2.clone()] + ); + + let again = import(&url, &archive); + assert_eq!(events(&again).fetched, 0, "{again:?}"); + assert_eq!( + rows(&archive), + [lunch.clone(), week1.clone(), week2.clone()] + ); + + // A third invitation, then one withdrawn: the rows follow. + let path = "/cal/team/series.ics"; + let three = calendar(&[ + occurrence(1, "Week 1"), + occurrence(2, "Week 2"), + occurrence(3, "Week 3"), + ]); + store.lock().unwrap().put_item(path, &three); + import(&url, &archive); + assert_eq!( + rows(&archive), + [lunch.clone(), week1.clone(), week2.clone(), week3.clone()] + ); + store + .lock() + .unwrap() + .put_item(path, &calendar(&[occurrence(2, "Week 2")])); + import(&url, &archive); + assert_eq!(rows(&archive), [lunch.clone(), week2.clone()]); + + store.lock().unwrap().put_item(path, &three); + import(&url, &archive); + + // Out again, into an empty server: one resource for the series. + let target = Arc::new(Mutex::new(Store::default())); + let target_url = serve(target.clone()); + let export = |archive: &Path| { + export_dav::run( + common(archive), + ExportDavConfig { + kind: DavKindArg::Caldav, + url: target_url.clone(), + auth: auth(), + allow_cleartext: true, + }, + ) + .expect("export") + }; + let first = export(&archive); + assert_eq!(events(&first).created, 4, "counted per row: {first:?}"); + { + let t = target.lock().unwrap(); + let Some(Resource::Item { body, .. }) = t.resources.get("/cal/team/series-1.ics") else { + panic!("no series: {:?}", t.resources.keys().collect::>()); + }; + assert_eq!(body.matches("BEGIN:VEVENT").count(), 3, "{body}"); + assert_eq!(body.matches("RECURRENCE-ID").count(), 3, "{body}"); + } + let second = export(&archive); + let c = events(&second); + assert_eq!((c.created, c.updated, c.skipped), (0, 0, 4), "{second:?}"); + + // As files: the calendar's .ics holds each occurrence. + let out = dir.path().join("files"); + let files = export_files::run(ExportFilesConfig { + archive: archive.clone(), + dir: out.clone(), + objects: None, + dry_run: false, + logger: Logger::from_flags(false, 0), + }) + .expect("export-files"); + assert!(!files.any_failed(), "{files:?}"); + let ics = std::fs::read_to_string(out.join("calendars/Team.ics")).unwrap(); + assert_eq!(ics.matches("RECURRENCE-ID").count(), 3, "{ics}"); + assert_eq!(ics.matches("UID:series-1").count(), 3, "{ics}"); + + // And back in, from the exported copy: the same rows. + let back = dir.path().join("back.sqlite"); + import(&target_url, &back); + assert_eq!(rows(&back), rows(&archive)); + + // The resource deleted: every occurrence goes. + store.lock().unwrap().remove(path); + import(&url, &archive); + assert_eq!(rows(&archive), [lunch]); +} -- 2.54.0