A failed backup is not reported to the backend correctly

[david-allison]

Retries (and force retries) and then skipped

[david-allison]

Subject: [PATCH] test(backup): reproduce skipped retries after a failed backup

Issue 22182
Base: d1d484c8249a8266a6fe9203694f9087726c6ba2 (ankitects/anki main)

Add regression tests for retries after a backup write fails, including when
starting another backup consumes the previous failure. Both tests currently
fail because the unchanged collection is treated as already backed up.

Apply from the Anki source root:
    git apply /path/to/22182-rslib-backup-tests.patch

Run:
    cargo test -p anki --lib backend::collection::tests::backup_retries

diff --git a/rslib/src/backend/collection.rs b/rslib/src/backend/collection.rs
--- a/rslib/src/backend/collection.rs
+++ b/rslib/src/backend/collection.rs
@@ -117,3 +117,84 @@
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use anki_proto::collection::CreateBackupRequest;
+    use tempfile::TempDir;
+
+    use super::*;
+
+    fn backend_with_collection(dir: &TempDir) -> Backend {
+        let backend = Backend::new(I18n::template_only(), false);
+        *backend.col.lock().unwrap() = Some(
+            CollectionBuilder::new(dir.path().join("collection.anki2"))
+                .build()
+                .unwrap(),
+        );
+        backend
+    }
+
+    #[test]
+    fn backup_retries_after_write_failure() {
+        for wait_for_completion in [false, true] {
+            for force in [false, true] {
+                let dir = TempDir::new().unwrap();
+                let backend = backend_with_collection(&dir);
+                // A file where the backup directory should be makes the writer fail.
+                let backup_folder = dir.path().join("backups");
+                std::fs::write(&backup_folder, b"").unwrap();
+                let request = CreateBackupRequest {
+                    backup_folder: backup_folder.to_str().unwrap().into(),
+                    force: true,
+                    wait_for_completion,
+                };
+                let result = backend.create_backup(request.clone());
+                let error = if wait_for_completion {
+                    result.unwrap_err()
+                } else {
+                    assert!(result.unwrap().val);
+                    backend.await_backup_completion().unwrap_err()
+                };
+                assert!(matches!(error, AnkiError::FileIoError { .. }));
+                // A failed task is consumed; checking again must not repeat the error.
+                backend.await_backup_completion().unwrap();
+
+                std::fs::remove_file(&backup_folder).unwrap();
+                std::fs::create_dir(&backup_folder).unwrap();
+                let retry = CreateBackupRequest { force, ..request };
+                assert!(
+                    backend.create_backup(retry.clone()).unwrap().val,
+                    "retry was skipped: wait_for_completion={wait_for_completion}, force={force}"
+                );
+                backend.await_backup_completion().unwrap();
+                assert_eq!(std::fs::read_dir(&backup_folder).unwrap().count(), 1);
+                // An unchanged collection is skipped only after a successful backup.
+                assert!(!backend.create_backup(retry).unwrap().val);
+            }
+        }
+    }
+
+    #[test]
+    fn backup_retries_after_consuming_previous_failure() {
+        let dir = TempDir::new().unwrap();
+        let backend = backend_with_collection(&dir);
+        let backup_folder = dir.path().join("backups");
+        std::fs::write(&backup_folder, b"").unwrap();
+        let request = CreateBackupRequest {
+            backup_folder: backup_folder.to_str().unwrap().into(),
+            force: true,
+            wait_for_completion: false,
+        };
+        assert!(backend.create_backup(request.clone()).unwrap().val);
+        // Starting another backup also waits for and reports a previous failure.
+        let error = backend.create_backup(request.clone()).unwrap_err();
+        assert!(matches!(error, AnkiError::FileIoError { .. }));
+
+        std::fs::remove_file(&backup_folder).unwrap();
+        std::fs::create_dir(&backup_folder).unwrap();
+        assert!(backend.create_backup(request).unwrap().val);
+        backend.await_backup_completion().unwrap();
+        assert_eq!(std::fs::read_dir(&backup_folder).unwrap().count(), 1);
+    }
+}

[david-allison]

• Various problems causing/handling backup corruption ankitects/anki#5728