mirror of
https://github.com/storytold/craft-anything.git
synced 2026-11-19 05:50:53 +01:00
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.
90 lines
4.2 KiB
Rust
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);
|
|
}
|