168 lines
6.6 KiB
Rust
168 lines
6.6 KiB
Rust
|
|
use super::*;
|
||
|
|
|
||
|
|
#[cfg(unix)]
|
||
|
|
fn mode_of(path: &Path) -> u32 {
|
||
|
|
use std::os::unix::fs::PermissionsExt;
|
||
|
|
fs::metadata(path).unwrap().permissions().mode() & 0o777
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Editing a script keeps it a script. The rename puts a new file where the old one was, so a
|
||
|
|
/// mode not carried over is lost: every edit of an executable left it unrunnable.
|
||
|
|
#[cfg(unix)]
|
||
|
|
#[test]
|
||
|
|
fn a_replace_keeping_mode_leaves_a_script_executable() {
|
||
|
|
use std::os::unix::fs::PermissionsExt;
|
||
|
|
let dir = tempfile::tempdir().unwrap();
|
||
|
|
let script = dir.path().join("run.sh");
|
||
|
|
fs::write(&script, b"#!/bin/sh\n").unwrap();
|
||
|
|
fs::set_permissions(&script, fs::Permissions::from_mode(0o755)).unwrap();
|
||
|
|
replace_keeping_mode(&script, b"#!/bin/sh\necho hi\n").unwrap();
|
||
|
|
assert_eq!(mode_of(&script), 0o755);
|
||
|
|
assert_eq!(fs::read(&script).unwrap(), b"#!/bin/sh\necho hi\n");
|
||
|
|
}
|
||
|
|
|
||
|
|
/// The mode kept is the mode the file had, bit for bit, not one the umask trimmed on the way.
|
||
|
|
#[cfg(unix)]
|
||
|
|
#[test]
|
||
|
|
fn a_kept_mode_is_exact_whatever_the_umask() {
|
||
|
|
use std::os::unix::fs::PermissionsExt;
|
||
|
|
let dir = tempfile::tempdir().unwrap();
|
||
|
|
let shared = dir.path().join("shared");
|
||
|
|
fs::write(&shared, b"a").unwrap();
|
||
|
|
// World-writable on purpose: any umask that is not 000 strips at least one of these bits
|
||
|
|
fs::set_permissions(&shared, fs::Permissions::from_mode(0o777)).unwrap();
|
||
|
|
replace_keeping_mode(&shared, b"b").unwrap();
|
||
|
|
assert_eq!(mode_of(&shared), 0o777);
|
||
|
|
}
|
||
|
|
|
||
|
|
/// A file that did not exist gets the mode any new file would, not the owner-only one secrets get.
|
||
|
|
#[cfg(unix)]
|
||
|
|
#[test]
|
||
|
|
fn a_new_file_kept_mode_gets_the_ordinary_default() {
|
||
|
|
let dir = tempfile::tempdir().unwrap();
|
||
|
|
let ordinary = dir.path().join("ordinary");
|
||
|
|
File::create(&ordinary).unwrap();
|
||
|
|
let fresh = dir.path().join("fresh");
|
||
|
|
replace_keeping_mode(&fresh, b"new").unwrap();
|
||
|
|
assert_eq!(mode_of(&fresh), mode_of(&ordinary));
|
||
|
|
}
|
||
|
|
|
||
|
|
/// An unsynced replace still lands whole and leaves no staging file behind.
|
||
|
|
#[test]
|
||
|
|
fn an_unsynced_replace_lands_whole_and_leaves_nothing_behind() {
|
||
|
|
let dir = tempfile::tempdir().unwrap();
|
||
|
|
let target = dir.path().join("cache").join("shard.json");
|
||
|
|
replace_unsynced(&target, b"first").unwrap();
|
||
|
|
replace_unsynced(&target, b"second").unwrap();
|
||
|
|
assert_eq!(fs::read(&target).unwrap(), b"second");
|
||
|
|
let left: Vec<_> = fs::read_dir(target.parent().unwrap()).unwrap().flatten().collect();
|
||
|
|
assert_eq!(left.len(), 1, "only the shard: {left:?}");
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Every directory `create_private_dir` makes is owner-only, not just the last one; one that was
|
||
|
|
/// already there keeps its mode.
|
||
|
|
#[cfg(unix)]
|
||
|
|
#[test]
|
||
|
|
fn every_directory_created_is_private() {
|
||
|
|
use std::os::unix::fs::PermissionsExt;
|
||
|
|
let mode = |path: &Path| fs::metadata(path).unwrap().permissions().mode() & 0o777;
|
||
|
|
let dir = tempfile::tempdir().unwrap();
|
||
|
|
fs::set_permissions(dir.path(), fs::Permissions::from_mode(0o755)).unwrap();
|
||
|
|
let leaf = dir.path().join("a").join("b").join("c");
|
||
|
|
create_private_dir(&leaf).unwrap();
|
||
|
|
for created in [dir.path().join("a"), dir.path().join("a/b"), leaf] {
|
||
|
|
assert_eq!(mode(&created), 0o700, "{}", created.display());
|
||
|
|
}
|
||
|
|
assert_eq!(mode(dir.path()), 0o755, "an existing parent is left alone");
|
||
|
|
}
|
||
|
|
|
||
|
|
/// A fresh private directory refuses to adopt one that exists.
|
||
|
|
#[test]
|
||
|
|
fn a_new_private_directory_is_never_an_existing_one() {
|
||
|
|
let dir = tempfile::tempdir().unwrap();
|
||
|
|
let fresh = dir.path().join("fresh");
|
||
|
|
create_private_dir_new(&fresh).unwrap();
|
||
|
|
let error = create_private_dir_new(&fresh).unwrap_err();
|
||
|
|
assert_eq!(error.kind(), io::ErrorKind::AlreadyExists);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn a_replacement_lands_and_leaves_no_staging_file_behind() {
|
||
|
|
let dir = tempfile::tempdir().unwrap();
|
||
|
|
let path = dir.path().join("state.json");
|
||
|
|
replace(&path, b"first").unwrap();
|
||
|
|
replace(&path, b"second").unwrap();
|
||
|
|
|
||
|
|
assert_eq!(fs::read(&path).unwrap(), b"second");
|
||
|
|
let strays: Vec<_> = fs::read_dir(dir.path())
|
||
|
|
.unwrap()
|
||
|
|
.filter_map(Result::ok)
|
||
|
|
.map(|entry| entry.file_name().to_string_lossy().into_owned())
|
||
|
|
.filter(|name| name != "state.json")
|
||
|
|
.collect();
|
||
|
|
assert!(strays.is_empty(), "left behind: {strays:?}");
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn missing_parents_are_created() {
|
||
|
|
let dir = tempfile::tempdir().unwrap();
|
||
|
|
let path = dir.path().join("a").join("b").join("c.json");
|
||
|
|
replace(&path, b"{}").unwrap();
|
||
|
|
assert_eq!(fs::read(&path).unwrap(), b"{}");
|
||
|
|
}
|
||
|
|
|
||
|
|
/// The staging name has to survive a real extension, or `main.rs` and `main.md` stage to the
|
||
|
|
/// same file and the last writer wins a race nobody knew they were in.
|
||
|
|
#[test]
|
||
|
|
fn two_files_sharing_a_stem_do_not_share_a_staging_name() {
|
||
|
|
let dir = tempfile::tempdir().unwrap();
|
||
|
|
let rust = staging_path(&dir.path().join("main.rs"));
|
||
|
|
let markdown = staging_path(&dir.path().join("main.md"));
|
||
|
|
assert_ne!(rust, markdown);
|
||
|
|
assert_eq!(rust.parent(), Some(dir.path()), "staging stays on the target's filesystem");
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Two writers of the *same* file must not collide on the staging name either — one would
|
||
|
|
/// truncate the other's half-written bytes and then rename them into place.
|
||
|
|
#[test]
|
||
|
|
fn concurrent_writers_of_one_file_get_distinct_staging_names() {
|
||
|
|
let path = Path::new("/tmp/luxe/thing.json");
|
||
|
|
assert_ne!(staging_path(path), staging_path(path));
|
||
|
|
}
|
||
|
|
|
||
|
|
#[cfg(unix)]
|
||
|
|
#[test]
|
||
|
|
fn a_private_replacement_is_owner_only_from_the_moment_it_exists() {
|
||
|
|
use std::os::unix::fs::PermissionsExt;
|
||
|
|
let dir = tempfile::tempdir().unwrap();
|
||
|
|
let path = dir.path().join("auth.json");
|
||
|
|
replace_private(&path, b"secret").unwrap();
|
||
|
|
assert_eq!(fs::metadata(&path).unwrap().permissions().mode() & 0o777, 0o600);
|
||
|
|
|
||
|
|
let nested = dir.path().join("private");
|
||
|
|
create_private_dir(&nested).unwrap();
|
||
|
|
assert_eq!(fs::metadata(&nested).unwrap().permissions().mode() & 0o777, 0o700);
|
||
|
|
}
|
||
|
|
|
||
|
|
/// A failed write must not leave a stray staging file, and must not damage what was there.
|
||
|
|
#[test]
|
||
|
|
fn a_failure_leaves_the_previous_contents_alone() {
|
||
|
|
let dir = tempfile::tempdir().unwrap();
|
||
|
|
let path = dir.path().join("kept.json");
|
||
|
|
replace(&path, b"original").unwrap();
|
||
|
|
|
||
|
|
// A directory in the target's place: the rename cannot succeed.
|
||
|
|
let blocked = dir.path().join("blocked.json");
|
||
|
|
fs::create_dir(&blocked).unwrap();
|
||
|
|
assert!(replace(&blocked, b"nope").is_err());
|
||
|
|
|
||
|
|
assert_eq!(fs::read(&path).unwrap(), b"original");
|
||
|
|
let strays: Vec<_> = fs::read_dir(dir.path())
|
||
|
|
.unwrap()
|
||
|
|
.filter_map(Result::ok)
|
||
|
|
.map(|entry| entry.file_name().to_string_lossy().into_owned())
|
||
|
|
.filter(|name| name.ends_with(".tmp"))
|
||
|
|
.collect();
|
||
|
|
assert!(strays.is_empty(), "left behind: {strays:?}");
|
||
|
|
}
|