diff --git a/src-tauri/src/sync.rs b/src-tauri/src/sync.rs
index 2ec9348..b4527cc 100644
--- a/src-tauri/src/sync.rs
+++ b/src-tauri/src/sync.rs
@@ -820,6 +820,17 @@ fn manifest_entry(hash: String, etag: &str) -> ManifestEntry {
}
}
+/// `fetched_hash` is the remote content read because the server has no ETag or reports a
+/// different one. Only different bytes are a remote change: some servers hand out a new ETag
+/// for a file nobody touched, and a local edit would then become a conflict copy.
+fn remote_changed(old: Option<&ManifestEntry>, fetched_hash: Option<&str>) -> bool {
+ match (old, fetched_hash) {
+ (None, _) => true,
+ (Some(_), None) => false,
+ (Some(old), Some(hash)) => old.remote_hash.is_empty() || old.remote_hash != hash,
+ }
+}
+
fn apply_changes(
client: &WebdavClient,
vault: &str,
@@ -857,12 +868,7 @@ fn apply_changes(
None
};
let remote_hash = remote_bytes.as_ref().map(|bytes| sha256_hex(bytes));
- let remote_changed = m.is_none_or(|old| {
- old.remote_etag != *etag
- || (etag.is_empty()
- && (old.remote_hash.is_empty()
- || remote_hash.as_deref() != Some(old.remote_hash.as_str())))
- });
+ let remote_changed = remote_changed(m, remote_hash.as_deref());
let local_changed = m.is_none_or(|old| old.local_hash != lf.hash);
if !local_changed && !remote_changed {
new_m.files.insert(
@@ -952,12 +958,7 @@ fn apply_changes(
None
};
let remote_hash = bytes.as_ref().map(|bytes| sha256_hex(bytes));
- let remote_changed = m.is_none_or(|old| {
- old.remote_etag != *etag
- || (etag.is_empty()
- && (old.remote_hash.is_empty()
- || remote_hash.as_deref() != Some(old.remote_hash.as_str())))
- });
+ let remote_changed = remote_changed(m, remote_hash.as_deref());
if remote_changed {
let bytes = match bytes {
Some(bytes) => bytes,
@@ -1832,6 +1833,97 @@ mod tests {
assert_eq!(requests.join().unwrap().len(), 1); // GET only, never DELETE
}
+ // Some servers hand out a new ETag for bytes that did not change. That is not a remote
+ // edit, so a local edit must upload instead of becoming a conflict copy.
+ #[test]
+ fn a_new_etag_for_the_same_remote_bytes_is_not_a_remote_change() {
+ let vault = tempfile::tempdir().unwrap();
+ fs::write(vault.path().join("note.md"), b"mine").unwrap();
+ let root = vault.path().to_str().unwrap();
+ let manifest = SyncManifest {
+ identity: String::new(),
+ files: HashMap::from([(
+ "note.md".into(),
+ manifest_entry(sha256_hex(b"old"), "\"e1\""),
+ )]),
+ };
+ let remote = HashMap::from([("note.md".to_string(), "\"e2\"".to_string())]);
+ // Every download is followed by a PROPFIND that rechecks the ETag.
+ let e2 = r#"/vault/note.md"e2""#;
+ let e3 = r#"/vault/note.md"e3""#;
+ let (client, requests) = webdav_test_client(vec![
+ ("200 OK\r\nETag: \"e2\"", "old"),
+ ("207 Multi-Status", e2),
+ ("204 No Content", ""),
+ ("207 Multi-Status", e3),
+ ("200 OK\r\nETag: \"e3\"", "mine"),
+ ("207 Multi-Status", e3),
+ ]);
+ let (next, summary) = apply_changes(
+ &client,
+ root,
+ &scan_local(root).unwrap(),
+ &remote,
+ &manifest,
+ &mut HashMap::new(),
+ &tokio::sync::Mutex::new(()),
+ )
+ .unwrap();
+ assert_eq!((summary.conflicts, summary.uploaded), (0, 1));
+ assert_eq!(fs::read(vault.path().join("note.md")).unwrap(), b"mine");
+ assert_eq!(fs::read_dir(vault.path()).unwrap().count(), 1);
+ assert_eq!(next.files["note.md"].remote_etag, "\"e3\"");
+ let requests = requests.join().unwrap();
+ assert!(requests[2].starts_with("PUT /vault/note.md "));
+ assert!(requests[2]
+ .to_ascii_lowercase()
+ .contains("if-match: \"e2\""));
+
+ // An untouched note only records the new ETag.
+ fs::write(vault.path().join("note.md"), b"old").unwrap();
+ let (client, requests) = webdav_test_client(vec![
+ ("200 OK\r\nETag: \"e2\"", "old"),
+ ("207 Multi-Status", e2),
+ ]);
+ let (next, summary) = apply_changes(
+ &client,
+ root,
+ &scan_local(root).unwrap(),
+ &remote,
+ &manifest,
+ &mut HashMap::new(),
+ &tokio::sync::Mutex::new(()),
+ )
+ .unwrap();
+ assert_eq!(
+ (summary.conflicts, summary.uploaded, summary.downloaded),
+ (0, 0, 0)
+ );
+ assert_eq!(next.files["note.md"].remote_etag, "\"e2\"");
+ assert_eq!(requests.join().unwrap().len(), 2);
+
+ // A note deleted locally is deleted remotely instead of coming back.
+ fs::remove_file(vault.path().join("note.md")).unwrap();
+ let (client, requests) = webdav_test_client(vec![
+ ("200 OK\r\nETag: \"e2\"", "old"),
+ ("207 Multi-Status", e2),
+ ("204 No Content", ""),
+ ]);
+ let (_, summary) = apply_changes(
+ &client,
+ root,
+ &HashMap::new(),
+ &remote,
+ &manifest,
+ &mut HashMap::new(),
+ &tokio::sync::Mutex::new(()),
+ )
+ .unwrap();
+ assert_eq!((summary.deleted_remote, summary.downloaded), (1, 0));
+ assert!(!vault.path().join("note.md").exists());
+ assert!(requests.join().unwrap()[2].starts_with("DELETE /vault/note.md "));
+ }
+
#[test]
fn changed_get_etag_never_installs_stale_snapshot() {
let (client, requests) = webdav_test_client(vec![("200 OK\r\nETag: \"new\"", "newer")]);