Files
photocraft/crates/format/tests/it/autosave.rs
T
Michael Higginsandkayrockscreenprinting 6a676ee1be Save over a flat JPEG: JPEG Options, then in place; transparent ones offered as PNG (#2223)
Fixes #2223. Carries the in-place flat Save of #5865 (closed as superseded by this PR) and revives what #2515 (@kayrockscreenprinting, closed when its author stepped away) added beyond it.

File › Save now writes back over a flat file when that file still holds the document: one plain opaque layer the format can store, and only when the file held a single image. A JPEG (and a TIFF, Targa or DDS) asks its format options first, as Photoshop does; Cancel writes nothing. A JPEG whose lone layer has transparency it can't keep is offered as a PNG. Multi-image files (animations, multi-page TIFFs, multi-size icons, multi-part EXRs) still go through Save As; the source image count is kept through crash recovery.

Co-authored-by: kayrockscreenprinting <257643019+kayrockscreenprinting@users.noreply.github.com>
2026-11-10 20:26:48 +01:00

383 lines
17 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! Background autosave and crash recovery.
use crate::common;
use std::sync::Arc;
use common::*;
use photocraft_color::{ColorMode, SampleType};
use photocraft_doc::{DocId, Document};
use photocraft_format::*;
#[test]
fn autosave_then_recover() {
let dir = temp_dir("recovery");
let doc = Arc::new(rich_doc(ColorMode::Rgb, SampleType::U16));
let saver = Autosaver::new(&dir, "doc-1");
saver.request(doc.clone(), 7, Some("/work/a.pcraft".into()), SaveOptions::default());
let r = saver.flush().expect("a save ran");
let stats = r.unwrap();
assert!(stats.tiles_written > 0);
let entries = list_recovery(&dir);
assert_eq!(entries.len(), 1);
assert_eq!(entries[0].info.revision, 7);
assert_eq!(entries[0].info.original_path.as_deref(), Some("/work/a.pcraft"));
assert_eq!(entries[0].info.document_name, "Rich");
assert_eq!(recover(&entries[0]).unwrap(), *doc);
discard_recovery(&dir, &entries[0]).unwrap();
assert!(list_recovery(&dir).is_empty());
std::fs::remove_dir_all(dir).unwrap();
}
/// A recovered document opened from a multi-frame GIF comes back at its original path with its
/// frame count, so File › Save still goes through Save As rather than writing one frame over
/// the animation (#5733).
#[test]
fn recovery_keeps_the_source_image_count() {
let dir = temp_dir("recovery-source-images");
let mut doc = rich_doc(ColorMode::Rgb, SampleType::U8);
doc.file_encoding.source_images = Some(4);
let saver = Autosaver::new(&dir, "gif-1");
saver.request(Arc::new(doc), 1, Some("/work/anim.gif".into()), SaveOptions::default());
saver.flush().expect("a save ran").unwrap();
let entries = list_recovery(&dir);
assert_eq!(entries.len(), 1);
assert_eq!(entries[0].info.original_path.as_deref(), Some("/work/anim.gif"));
assert_eq!(recover(&entries[0]).unwrap().file_encoding.source_images, Some(4));
std::fs::remove_dir_all(dir).unwrap();
}
/// A queued snapshot can fail later; callers must observe and retry that revision.
#[test]
fn background_save_outcomes_report_failure_then_recovery() {
let root = temp_dir("retry-failed-write");
let blocked = root.join("recovery");
std::fs::write(&blocked, b"not a directory").unwrap();
// Not dropped on a failure: dropping joins the worker, which waits for a write in progress,
// so a stuck write would hold the test past its own bound until nextest kills it.
let saver = std::mem::ManuallyDrop::new(Autosaver::new(&blocked, "doc"));
let doc = Arc::new(rich_doc(ColorMode::Rgb, SampleType::U8));
saver.request_checked(doc.clone(), 7, None, SaveOptions::default()).unwrap();
// The bound only turns a worker that never reports into a failure instead of a hang. A real
// write flushes every tile to disk and took over 30 s on a busy Windows CI runner (normally
// 2-3 s), so it is generous, and still under the 10 minutes after which nextest's `ci`
// profile kills a test.
const PATIENCE: std::time::Duration = std::time::Duration::from_secs(5 * 60);
let receive = |saver: &Autosaver| {
let deadline = std::time::Instant::now() + PATIENCE;
while std::time::Instant::now() < deadline {
if let Some(outcome) = saver.take_completed().into_iter().next() {
return outcome;
}
std::thread::sleep(std::time::Duration::from_millis(10));
}
panic!("autosave worker did not report its completed write within {PATIENCE:?}");
};
let (revision, result) = receive(&saver);
assert_eq!(revision, 7);
assert!(result.is_err(), "the recovery location is not a directory");
std::fs::remove_file(&blocked).unwrap();
std::fs::create_dir(&blocked).unwrap();
saver.request_checked(doc.clone(), 7, None, SaveOptions::default()).unwrap();
let (revision, result) = receive(&saver);
assert_eq!(revision, 7);
result.unwrap();
assert_eq!(list_recovery(&blocked).len(), 1);
assert_eq!(recover(&list_recovery(&blocked)[0]).unwrap(), *doc);
drop(std::mem::ManuallyDrop::into_inner(saver));
std::fs::remove_dir_all(root).unwrap();
}
#[test]
fn repeated_autosaves_are_incremental_and_coalesced() {
let dir = temp_dir("coalesce");
let saver = Autosaver::new(&dir, "k");
let mut doc = rich_doc(ColorMode::Rgb, SampleType::U8);
for i in 0..5 {
let id = doc.layers[1].id;
doc.layer_mut(id).unwrap().surface_mut().unwrap().write_pixel(i, 0, &[1.0, 0.0, 0.0, 1.0]);
saver.request(Arc::new(doc.clone()), i as u64, None, SaveOptions::default());
}
saver.flush().unwrap().unwrap();
let e = list_recovery(&dir);
assert_eq!(e[0].info.revision, 4, "newest snapshot wins");
assert_eq!(recover(&e[0]).unwrap(), doc);
std::fs::remove_dir_all(dir).unwrap();
}
#[test]
fn discard_removes_everything() {
let dir = temp_dir("discard");
let saver = Autosaver::new(&dir, "x y/z");
saver.request(Arc::new(rich_doc(ColorMode::Grayscale, SampleType::U8)), 1, None, SaveOptions::default());
let path = saver.bundle_path();
assert!(path.file_name().unwrap().to_string_lossy().starts_with("x_y_z"));
saver.discard().unwrap();
assert!(list_recovery(&dir).is_empty());
assert!(!path.exists());
std::fs::remove_dir_all(dir).unwrap();
}
#[test]
fn list_ignores_junk() {
let dir = temp_dir("junk");
std::fs::write(dir.join("bogus.json"), b"{}").unwrap();
std::fs::write(dir.join("other.txt"), b"x").unwrap();
assert!(list_recovery(&dir).is_empty());
assert!(list_recovery(&dir.join("missing")).is_empty());
std::fs::remove_dir_all(dir).unwrap();
}
/// `doc` as document `id` with pixel (x, 0) of its paint layer set, so versions are told apart.
fn edit(mut doc: Document, id: u64, x: i32) -> Document {
doc.id = DocId(id);
let layer = doc.layers[1].id;
doc.layer_mut(layer).unwrap().surface_mut().unwrap().write_pixel(x, 0, &[1.0, 0.0, 0.0, 1.0]);
doc
}
fn version(id: u64, x: i32, mode: ColorMode) -> Document {
edit(rich_doc(mode, SampleType::U8), id, x)
}
/// Save one snapshot under `key` and wait for it.
fn save_once(dir: &std::path::Path, key: &str, doc: Document) {
let saver = Autosaver::new(dir, key);
saver.request(Arc::new(doc), 1, None, SaveOptions::default());
saver.flush().unwrap().unwrap();
}
/// The recovered documents by entry key, ids cleared (they're reassigned on open).
fn recovered(store: &RecoveryStore) -> std::collections::BTreeMap<String, Document> {
store
.recover()
.into_iter()
.map(|(e, mut doc)| {
doc.id = DocId(0);
(e.info.key, doc)
})
.collect()
}
fn same(mut doc: Document) -> Document {
doc.id = DocId(0);
doc
}
#[test]
fn recovered_entries_survive_a_second_crash_until_saved_or_closed() {
let dir = temp_dir("second-crash");
let (a, b) = (version(1, 3, ColorMode::Rgb), version(2, 5, ColorMode::Grayscale));
// Launch 1 autosaves two unsaved documents, then crashes (dropping waits for the writes).
{
let mut launch = RecoveryStore::new(&dir);
launch.autosave(&Arc::new(a.clone()), 4, None);
launch.autosave(&Arc::new(b.clone()), 6, Some("/work/b.pcraft".into()));
}
assert_eq!(list_recovery(&dir).len(), 2);
// Launch 2 recovers both and crashes before its first autosave: nothing may be lost.
let keys: Vec<String> = {
let mut launch = RecoveryStore::new(&dir);
let docs = recovered(&launch);
assert_eq!(docs.len(), 2);
assert_eq!(list_recovery(&dir).len(), 2, "recovering must not delete the entries");
for (i, key) in docs.keys().enumerate() {
launch.adopt(10 + i as u64, key);
}
docs.into_keys().collect()
};
// Launch 3 still has both, pixels intact; one is edited and autosaved, the other closed.
let edited = edit(a.clone(), 20, 9);
{
let mut launch = RecoveryStore::new(&dir);
let docs = recovered(&launch);
assert_eq!(docs.values().cloned().collect::<Vec<_>>(), vec![same(a.clone()), same(b.clone())]);
launch.adopt(20, &keys[0]);
launch.adopt(21, &keys[1]);
launch.autosave(&Arc::new(edited.clone()), 9, None);
launch.discard(21).unwrap();
assert_eq!(list_recovery(&dir).len(), 1, "closing removes the adopted entry");
}
// The autosave replaced the adopted entry in place: no duplicate, newest content.
let entries = list_recovery(&dir);
assert_eq!(entries.len(), 1);
assert_eq!((entries[0].info.key.as_str(), entries[0].info.revision), (keys[0].as_str(), 9));
// Launch 4 recovers it once more and saves it: the entry goes.
let mut launch = RecoveryStore::new(&dir);
assert_eq!(recovered(&launch).into_values().collect::<Vec<_>>(), vec![same(edited)]);
launch.adopt(30, &keys[0]);
launch.discard(30).unwrap();
assert!(list_recovery(&dir).is_empty());
drop(launch);
std::fs::remove_dir_all(dir).unwrap();
}
/// #3438: a session about to end without asking (its window's graphics device was lost) writes
/// everything queued before it returns, so the next launch recovers it.
#[test]
fn flush_writes_every_queued_autosave_before_returning() {
let dir = temp_dir("flush");
let (a, b) = (version(1, 3, ColorMode::Rgb), version(2, 5, ColorMode::Grayscale));
let mut store = RecoveryStore::new(&dir);
store.autosave_checked(&Arc::new(a.clone()), 4, None).unwrap();
store.autosave_checked(&Arc::new(b.clone()), 6, Some("/work/b.pcraft".into())).unwrap();
let mut done = store.flush();
done.sort_by_key(|(id, ..)| *id);
assert_eq!(done, vec![(1, 4, Ok(())), (2, 6, Ok(()))]);
// On disk while the store is still alive, not only once it is dropped.
let docs = recovered(&RecoveryStore::new(&dir));
assert_eq!(docs.len(), 2);
assert!(docs.values().any(|d| *d == same(a.clone())) && docs.values().any(|d| *d == same(b.clone())));
// A later autosave (trying a failed write again) starts a new worker on the same entry.
let newer = version(1, 4, ColorMode::Rgb);
store.autosave_checked(&Arc::new(newer.clone()), 5, None).unwrap();
assert_eq!(store.flush(), vec![(1, 5, Ok(()))]);
let docs = recovered(&RecoveryStore::new(&dir));
assert_eq!(docs.len(), 2, "the same entry, not a new one");
assert!(docs.values().any(|d| *d == same(newer.clone())) && !docs.values().any(|d| *d == same(a.clone())));
drop(store);
std::fs::remove_dir_all(dir).unwrap();
}
/// #6464 review: a document saved or closed after a flush (the app stayed open because a recovery
/// write failed) still has its entry removed, so it doesn't come back at the next launch.
#[test]
fn discard_after_flush_removes_the_entry() {
let dir = temp_dir("discard-after-flush");
let mut store = RecoveryStore::new(&dir);
store.autosave_checked(&Arc::new(version(1, 3, ColorMode::Rgb)), 4, None).unwrap();
assert_eq!(store.flush(), vec![(1, 4, Ok(()))]);
assert_eq!(list_recovery(&dir).len(), 1);
store.discard(1).unwrap();
assert!(list_recovery(&dir).is_empty(), "the flushed document's entry is gone");
// And after a retry wrote the entry again through a new worker.
store.autosave_checked(&Arc::new(version(2, 5, ColorMode::Rgb)), 6, None).unwrap();
store.flush();
store.autosave_checked(&Arc::new(version(2, 6, ColorMode::Rgb)), 7, None).unwrap();
store.flush();
assert_eq!(list_recovery(&dir).len(), 1, "one entry per document");
store.discard(2).unwrap();
assert!(list_recovery(&dir).is_empty());
drop(store);
std::fs::remove_dir_all(dir).unwrap();
}
#[test]
fn new_documents_never_overwrite_surviving_entries() {
let dir = temp_dir("collision");
// An earlier launch (including builds that keyed entries by bare document id) left `doc-1`.
let old = version(1, 3, ColorMode::Rgb);
save_once(&dir, "doc-1", old.clone());
// A store from another launch left an entry for its own document 1 too.
let other = version(1, 6, ColorMode::Grayscale);
RecoveryStore::new(&dir).autosave(&Arc::new(other.clone()), 2, None);
assert_eq!(list_recovery(&dir).len(), 2);
// This launch adopts `doc-1` for its document 5, and its own new document 1 autosaves.
let fresh = version(1, 8, ColorMode::Rgb);
{
let mut launch = RecoveryStore::new(&dir);
launch.adopt(5, "doc-1");
launch.autosave(&Arc::new(fresh.clone()), 3, None);
}
let docs = recovered(&RecoveryStore::new(&dir));
assert_eq!(docs.len(), 3, "the new document got an entry of its own");
assert_eq!(docs.get("doc-1"), Some(&same(old)), "the adopted entry is untouched");
assert!(docs.values().any(|d| *d == same(other.clone())));
assert!(docs.values().any(|d| *d == same(fresh.clone())));
// Closing the new document removes only its own entry.
let mut launch = RecoveryStore::new(&dir);
launch.adopt(5, "doc-1");
launch.autosave(&Arc::new(fresh), 3, None);
launch.discard(1).unwrap();
assert_eq!(list_recovery(&dir).len(), 3);
launch.discard(5).unwrap();
assert_eq!(list_recovery(&dir).len(), 2);
drop(launch);
std::fs::remove_dir_all(dir).unwrap();
}
#[test]
fn sidecars_cannot_point_at_other_bundles() {
let dir = temp_dir("sidecar-key");
let inner = dir.join("Recovery");
save_once(&dir, "outside", rich_doc(ColorMode::Rgb, SampleType::U8));
save_once(&inner, "k", rich_doc(ColorMode::Rgb, SampleType::U8));
let info = std::fs::read_to_string(inner.join("k.json")).unwrap();
// A copied sidecar (its name isn't its key) and one whose key leaves the directory.
std::fs::write(inner.join("copy.json"), &info).unwrap();
std::fs::write(inner.join("escape.json"), info.replace("\"k\"", "\"../outside\"")).unwrap();
let entries = list_recovery(&inner);
assert_eq!(entries.iter().map(|e| e.info.key.as_str()).collect::<Vec<_>>(), ["k"]);
std::fs::remove_dir_all(dir).unwrap();
}
/// Once the manifest is committed the save has succeeded: an unreferenced object that cannot be
/// removed (here a folder squatting on a tile name, like a locked or vanished file) must not turn
/// the directory save (autosave's path) into a reported failure.
#[test]
fn failed_cleanup_after_commit_does_not_fail_the_save() {
let dir = temp_dir("cleanup-best-effort").join("doc.pcraft");
std::fs::create_dir_all(&dir).unwrap();
let doc = rich_doc(ColorMode::Rgb, SampleType::U8);
let mut w = PcraftWriter::new();
w.save_dir(&doc, &dir, &SaveOptions::default()).unwrap();
let stuck = dir.join("tiles").join("0000000000000000000000000000000000000000000000000000000000000000.zst");
std::fs::create_dir_all(stuck.join("inner")).unwrap();
let stats = w.save_dir(&doc, &dir, &SaveOptions::default()).expect("the committed save reports success");
assert_eq!(stats.objects_removed, 0, "nothing was actually removed");
assert_eq!(load_path(&dir).unwrap(), doc);
std::fs::remove_dir_all(dir.parent().unwrap()).unwrap();
}
/// #9034: while a document's autosave replaces its entry, a listing (another launch's recovery
/// prompt, or the launch's own check after closing a second document) sees that entry exactly
/// once. On Windows the sidecar used to be replaced through `ReplaceFileW`, which moves the old
/// sidecar to a backup name before moving the new one in: a listing in between found the bundle
/// without a sidecar and listed it a second time (or, the other way round, not at all).
#[test]
fn a_listing_during_an_autosave_sees_the_entry_exactly_once() {
let dir = temp_dir("listing-during-autosave");
let doc = Document::new("Busy", photocraft_doc::Size { width: 4, height: 4 }, ColorMode::Rgb, SampleType::U8);
save_once(&dir, "busy", doc.clone());
let done = Arc::new(std::sync::atomic::AtomicBool::new(false));
let writer = {
let (dir, done) = (dir.clone(), done.clone());
std::thread::spawn(move || {
// Sets `done` however the thread ends, so a failing writer stops the listing loop
// and `join` reports its panic instead of the test hanging.
struct SetOnDrop(Arc<std::sync::atomic::AtomicBool>);
impl Drop for SetOnDrop {
fn drop(&mut self) {
self.0.store(true, std::sync::atomic::Ordering::SeqCst);
}
}
let _done = SetOnDrop(done);
let saver = Autosaver::new(&dir, "busy");
for revision in 2..=200 {
saver.request(Arc::new(doc.clone()), revision, None, SaveOptions::default());
// Wait for this write, so every revision replaces the sidecar once.
let completed = loop {
let completed = saver.take_completed();
if !completed.is_empty() {
break completed;
}
std::thread::yield_now();
};
assert!(completed.iter().all(|(_, result)| result.is_ok()), "revision {revision}: {completed:?}");
}
saver.flush()
})
};
let mut listings = 0u32;
while !done.load(std::sync::atomic::Ordering::SeqCst) {
let entries = list_recovery(&dir);
let keys: Vec<&str> = entries.iter().map(|e| e.info.key.as_str()).collect();
assert_eq!(keys, ["busy"], "listing {listings} during an autosave: {entries:?}");
listings += 1;
}
assert!(writer.join().unwrap().is_some_and(|r| r.is_ok()));
assert!(listings > 0);
std::fs::remove_dir_all(dir).unwrap();
}