Files
craft-anything/crates/platform/tests/regression_atomic_temp_creation.rs
BFlat e0922f4ff4 Keep pasted picture names unique, create atomic-write temp files exclusively, and keep distinct replay samples (#995)
Pasted pictures get a counter in their name; atomic-write temp files are created exclusively and private from the start; stand-in replay samples keep differing response details.
2026-11-07 00:50:18 +08:00

90 lines
4.2 KiB
Rust

use craft_anything_platform::fs::write_atomic;
#[cfg(unix)]
use craft_anything_platform::fs::write_atomic_private;
use std::path::{Path, PathBuf};
fn temporary(dir: &Path, counter: u64) -> PathBuf {
dir.join(format!(".craft-anything.tmp-{}-{counter}", std::process::id()))
}
#[test]
fn atomic_writes_preserve_colliding_files_and_links() {
let dir = tempfile::tempdir().unwrap();
let target = dir.path().join("settings.json");
let stale: Vec<_> = (0..4).map(|n| temporary(dir.path(), n)).collect();
for file in &stale {
std::fs::write(file, b"existing temporary data").unwrap();
}
write_atomic(&target, b"new settings").unwrap();
assert_eq!(std::fs::read(&target).unwrap(), b"new settings");
for file in &stale {
assert_eq!(std::fs::read(file).unwrap(), b"existing temporary data");
}
#[cfg(unix)]
{
use std::os::unix::fs::{PermissionsExt, symlink};
let private_dir = tempfile::tempdir().unwrap();
let other = private_dir.path().join("other.txt");
std::fs::write(&other, b"keep this file").unwrap();
let links: Vec<_> = (0..16).map(|n| temporary(private_dir.path(), n)).collect();
for link in &links {
symlink(&other, link).unwrap();
}
let private = private_dir.path().join("private.json");
write_atomic_private(&private, b"private fixture").unwrap();
assert_eq!(std::fs::read(&other).unwrap(), b"keep this file");
assert_eq!(std::fs::read(&private).unwrap(), b"private fixture");
assert_eq!(std::fs::metadata(&private).unwrap().permissions().mode() & 0o777, 0o600);
assert!(links.iter().all(|link| std::fs::symlink_metadata(link).unwrap().file_type().is_symlink()));
std::fs::set_permissions(&target, std::fs::Permissions::from_mode(0o640)).unwrap();
write_atomic(&target, b"replacement settings").unwrap();
assert_eq!(std::fs::metadata(&target).unwrap().permissions().mode() & 0o777, 0o640);
}
// A bounded retry must leave both the destination and every colliding file alone.
let crowded_dir = tempfile::tempdir().unwrap();
let destination = crowded_dir.path().join("crowded.json");
std::fs::write(&destination, b"original settings").unwrap();
let occupied: Vec<_> = (0..256).map(|n| temporary(crowded_dir.path(), n)).collect();
for file in &occupied {
std::fs::write(file, b"someone else's temporary data").unwrap();
}
assert!(write_atomic(&destination, b"replacement").is_err());
assert_eq!(std::fs::read(&destination).unwrap(), b"original settings");
for file in &occupied {
assert_eq!(std::fs::read(file).unwrap(), b"someone else's temporary data");
}
// An error after creating our temporary file cleans up only that new file.
let blocked_dir = tempfile::tempdir().unwrap();
let blocked = blocked_dir.path().join("directory.json");
std::fs::create_dir(&blocked).unwrap();
let mut before: Vec<_> = std::fs::read_dir(blocked_dir.path()).unwrap().map(|entry| entry.unwrap().path()).collect();
before.sort();
assert!(write_atomic(&blocked, b"cannot replace a directory").is_err());
let mut after: Vec<_> = std::fs::read_dir(blocked_dir.path()).unwrap().map(|entry| entry.unwrap().path()).collect();
after.sort();
assert_eq!(after, before);
// Probe at most 255 names, retaining the longest this filesystem can create.
let long_dir = tempfile::tempdir().unwrap();
let mut long_target = None;
for length in (1..=255).rev() {
let path = long_dir.path().join("s".repeat(length));
match std::fs::write(&path, b"original long-name settings") {
Ok(()) => {
long_target = Some(path);
break;
}
Err(error) if error.kind() == std::io::ErrorKind::InvalidFilename => continue,
Err(error) => panic!("could not create the long-name fixture: {error}"),
}
}
let long_target = long_target.expect("the test filesystem must support a destination filename");
write_atomic(&long_target, b"replacement long-name settings").unwrap();
assert_eq!(std::fs::read(&long_target).unwrap(), b"replacement long-name settings");
assert_eq!(std::fs::read_dir(long_dir.path()).unwrap().count(), 1);
}