use super::*;
#[test]
fn the_default_set_is_the_tracked_files() {
let root = Path::new(env!("CARGO_MANIFEST_DIR"));
if !root.join(".git").exists() {
return;
}
let set = select(root, &[]).unwrap_or_default();
assert!(set.iter().any(|p| p.ends_with("Cargo.toml")), "{set:?}");
}
#[test]
fn a_named_path_reaches_an_untracked_file() {
let root = Path::new(env!("CARGO_MANIFEST_DIR"));
let Some(shown) = untracked(root) else {
return;
};
let picked = select(root, std::slice::from_ref(&shown));
assert_eq!(picked, Ok(vec![root.join(&shown)]));
let _ = std::fs::remove_file(root.join(&shown));
}
fn untracked(root: &Path) -> Option<String> {
let name = "ctrm-untracked-fixture.txt";
let dir = root.join("target");
std::fs::create_dir_all(&dir).ok()?;
std::fs::write(dir.join(name), "x").ok()?;
Some(format!("target/{name}"))
}
#[test]
fn a_missing_named_path_is_an_error_naming_it() {
let root = Path::new(env!("CARGO_MANIFEST_DIR"));
let err = select(root, &["no/such/file".to_owned()]).err();
assert_eq!(err.map(|e| e.path), Some(root.join("no/such/file")));
}
#[test]
fn a_named_directory_expands_to_its_tracked_files() {
let root = Path::new(env!("CARGO_MANIFEST_DIR"));
if !root.join(".git").exists() {
return;
}
let set = select(root, &["src".to_owned()]).unwrap_or_default();
assert!(set.iter().any(|p| p.ends_with("src/lib.rs")), "{set:?}");
assert!(!set.iter().any(|p| p.ends_with("Cargo.toml")), "{set:?}");
}
#[test]
fn a_directory_with_nothing_tracked_is_refused_with_its_reason() {
let root = Path::new(env!("CARGO_MANIFEST_DIR"));
if std::fs::create_dir_all(root.join("target")).is_err() {
return;
}
let err = select(root, &["target".to_owned()]).err();
let reason = err.map(|e| e.reason).unwrap_or_default();
assert!(reason.contains("no git-tracked file"), "{reason}");
}
#[cfg(unix)]
#[test]
fn a_symlink_is_told_apart_from_what_it_points_at() {
let Some(root) = links() else {
return;
};
assert!(is_link(&root.join("to-dir")));
assert!(is_link(&root.join("to-file")));
assert!(!is_link(&root.join("real.md")));
assert!(!is_link(&root.join("dir")));
assert!(!is_link(&root.join("absent")));
}
#[cfg(unix)]
fn links() -> Option<PathBuf> {
use std::os::unix::fs::symlink;
let root = Path::new(env!("CARGO_MANIFEST_DIR"))
.join("target")
.join("ctrm-symlink-fixture");
let _ = std::fs::remove_dir_all(&root);
std::fs::create_dir_all(root.join("dir"))
.and_then(|()| std::fs::write(root.join("real.md"), "x"))
.and_then(|()| symlink("dir", root.join("to-dir")))
.and_then(|()| symlink("real.md", root.join("to-file")))
.ok()?;
Some(root)
}
#[test]
fn a_root_that_cannot_answer_is_refused_by_name() {
let manifest = Path::new(env!("CARGO_MANIFEST_DIR")).join("Cargo.toml");
for root in [Path::new("/no/such/ctrm/root"), manifest.as_path()] {
let said = select(root, &[]).err().map(|e| (e.path, e.reason));
assert_eq!(said, Some((root.to_owned(), NOT_A_DIR.to_owned())));
}
let Some(bare) = outside_git() else {
return;
};
let said = select(&bare, &[]).err().map(|e| e.reason);
assert_eq!(said.as_deref(), Some(NO_GIT));
assert!(select(&bare, &["a.md".to_owned()]).is_ok());
}
fn outside_git() -> Option<PathBuf> {
let root = std::env::temp_dir().join("ctrm-outside-git-fixture");
std::fs::create_dir_all(&root).ok()?;
std::fs::write(root.join("a.md"), "x").ok()?;
(!in_work_tree(&root)).then_some(root)
}
#[test]
fn a_tracked_file_deleted_from_the_tree_is_left_out() {
let Some(root) = deleted() else {
return;
};
assert_eq!(select(&root, &[]), Ok(vec![root.join("kept.md")]));
}
fn deleted() -> Option<PathBuf> {
let root = Path::new(env!("CARGO_MANIFEST_DIR"))
.join("target")
.join("ctrm-deleted-fixture");
let _ = std::fs::remove_dir_all(&root);
std::fs::create_dir_all(&root).ok()?;
std::fs::write(root.join("kept.md"), "x").ok()?;
std::fs::write(root.join("gone.md"), "x").ok()?;
git(&root, &["init", "-q"])?;
git(&root, &["add", "kept.md", "gone.md"])?;
std::fs::remove_file(root.join("gone.md")).ok()?;
Some(root)
}
fn git(root: &Path, args: &[&str]) -> Option<()> {
std::process::Command::new("git")
.arg("-C")
.arg(root)
.args(args)
.env_remove("GIT_DIR")
.env_remove("GIT_INDEX_FILE")
.env_remove("GIT_WORK_TREE")
.status()
.ok()?
.success()
.then_some(())
}
#[test]
fn a_file_reached_two_ways_appears_once() {
let root = Path::new(env!("CARGO_MANIFEST_DIR"));
if !root.join(".git").exists() {
return;
}
let asked = ["src".to_owned(), "src/lib.rs".to_owned()];
let set = select(root, &asked).unwrap_or_default();
let hits = set.iter().filter(|p| p.ends_with("src/lib.rs")).count();
assert_eq!(hits, 1, "{set:?}");
}
#[test]
fn two_spellings_of_one_path_are_one_file() {
let Some(root) = spelled("twice") else {
return;
};
let asked = ["sub/../a.md".to_owned(), "a.md".to_owned()];
assert_eq!(select(&root, &asked).map(|set| set.len()), Ok(1));
}
#[test]
fn a_directory_spelled_with_dot_dot_still_expands() {
let Some(root) = spelled("dotdot") else {
return;
};
let set = select(&root, &["d/e/../e".to_owned()]).unwrap_or_default();
assert_eq!(set.len(), 1, "{set:?}");
assert!(set.iter().all(|p| p.ends_with("x.md")), "{set:?}");
}
#[cfg(unix)]
#[test]
fn a_named_link_to_a_directory_is_followed() {
let Some(root) = spelled("dirlink") else {
return;
};
if std::os::unix::fs::symlink("d", root.join("dl")).is_err() {
return;
}
let want = Ok(vec![root.join("d/e/x.md")]);
assert_eq!(select(&root, &["dl".to_owned()]), want);
assert_eq!(select(&root, &["d".to_owned(), "dl/e".to_owned()]), want);
}
#[cfg(unix)]
#[test]
fn a_named_link_leaving_the_root_says_so() {
let Some(root) = spelled("outlink") else {
return;
};
let away = root.with_file_name("ctrm-spelling-away");
let made = std::fs::create_dir_all(&away)
.and_then(|()| std::os::unix::fs::symlink(&away, root.join("out")));
if made.is_err() {
return;
}
let said = select(&root, &["out".to_owned()]).err().map(|e| e.reason);
assert_eq!(said.as_deref(), Some(OUTSIDE));
}
fn spelled(name: &str) -> Option<PathBuf> {
let root = Path::new(env!("CARGO_MANIFEST_DIR"))
.join("target")
.join(format!("ctrm-spelling-{name}"));
let _ = std::fs::remove_dir_all(&root);
std::fs::create_dir_all(root.join("sub")).ok()?;
std::fs::create_dir_all(root.join("d/e")).ok()?;
for file in ["a.md", "sub/b.md", "d/e/x.md"] {
std::fs::write(root.join(file), "x").ok()?;
}
git(&root, &["init", "-q"])?;
git(&root, &["add", "."])?;
Some(root)
}