john-slop/tests/formatter.rs

299 lines
9.4 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.

use std::{
fs,
io::Write,
path::Path,
process::{Command, Output, Stdio},
};
use tempfile::tempdir;
fn formatter(config_home: &Path) -> Command {
let mut command = Command::new(env!("CARGO_BIN_EXE_john-slop-fmt"));
command.env("XDG_CONFIG_HOME", config_home);
command
}
fn formatter_with_stdin(config_home: &Path, arguments: &[&str], input: &[u8]) -> Output {
let mut child = formatter(config_home)
.args(arguments)
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.spawn()
.expect("spawn formatter");
child
.stdin
.take()
.expect("formatter stdin")
.write_all(input)
.expect("write formatter stdin");
child.wait_with_output().expect("wait for formatter")
}
#[test]
fn stdin_stdout_is_pure_and_idempotent() {
let directory = tempdir().expect("temp dir");
let source = "Résumé—value 5−2\r\n";
let first = formatter_with_stdin(directory.path(), &[], source.as_bytes());
let second = formatter_with_stdin(directory.path(), &[], &first.stdout);
assert!(first.status.success());
assert!(first.stderr.is_empty());
assert_eq!(first.stdout, "Résumé-value 5-2\r\n".as_bytes());
assert!(second.status.success());
assert!(second.stderr.is_empty());
assert_eq!(second.stdout, first.stdout);
}
#[test]
fn check_and_diff_have_stable_exit_statuses() {
let directory = tempdir().expect("temp dir");
let clean = directory.path().join("clean.txt");
let dirty = directory.path().join("dirty.txt");
fs::write(&clean, "plain-ascii\n").expect("write clean input");
fs::write(&dirty, "review—this\n").expect("write dirty input");
let clean_check = formatter(directory.path())
.args(["--check"])
.arg(&clean)
.output()
.expect("check clean file");
let dirty_check = formatter(directory.path())
.args(["--check"])
.arg(&dirty)
.output()
.expect("check dirty file");
let diff = formatter(directory.path())
.arg("--diff")
.arg(&dirty)
.output()
.expect("diff dirty file");
assert_eq!(clean_check.status.code(), Some(0));
assert!(clean_check.stdout.is_empty());
assert!(clean_check.stderr.is_empty());
assert_eq!(dirty_check.status.code(), Some(1));
assert!(dirty_check.stdout.is_empty());
assert!(dirty_check.stderr.is_empty());
assert_eq!(diff.status.code(), Some(1));
assert!(diff.stderr.is_empty());
let stdout = String::from_utf8(diff.stdout).expect("UTF-8 diff");
assert!(stdout.contains("--- "));
assert!(stdout.contains("+++ "));
assert!(stdout.contains("-review—this"));
assert!(stdout.contains("+review-this"));
}
#[test]
fn default_file_mode_does_not_modify_the_source() {
let directory = tempdir().expect("temp dir");
let path = directory.path().join("article.txt");
let source = "review—this\n";
fs::write(&path, source).expect("write input");
let output = formatter(directory.path())
.arg(&path)
.output()
.expect("format file");
assert!(output.status.success());
assert!(output.stderr.is_empty());
assert_eq!(output.stdout, b"review-this\n");
assert_eq!(fs::read_to_string(path).expect("read source"), source);
}
#[test]
fn explicit_write_is_idempotent_and_leaves_no_temporary_file() {
let directory = tempdir().expect("temp dir");
let path = directory.path().join("article.txt");
fs::write(&path, "one—two−three\n").expect("write input");
for _ in 0..2 {
let output = formatter(directory.path())
.arg("--write")
.arg(&path)
.output()
.expect("write formatted file");
assert!(output.status.success());
assert!(output.stdout.is_empty());
assert!(output.stderr.is_empty());
}
assert_eq!(
fs::read_to_string(&path).expect("read formatted file"),
"one-two-three\n"
);
assert_eq!(
fs::read_dir(directory.path())
.expect("read temp directory")
.count(),
1
);
}
#[cfg(unix)]
#[test]
fn atomic_write_preserves_unix_permissions() {
use std::os::unix::fs::PermissionsExt;
let directory = tempdir().expect("temp dir");
let path = directory.path().join("script.txt");
fs::write(&path, "run—this\n").expect("write input");
fs::set_permissions(&path, fs::Permissions::from_mode(0o754)).expect("set permissions");
let output = formatter(directory.path())
.arg("--write")
.arg(&path)
.output()
.expect("write formatted file");
assert!(output.status.success());
assert_eq!(
fs::metadata(path)
.expect("file metadata")
.permissions()
.mode()
& 0o777,
0o754
);
}
#[test]
fn explicit_configuration_controls_formatter_output() {
let directory = tempdir().expect("temp dir");
let config = directory.path().join("custom.toml");
fs::write(
&config,
r#"
[[replacements]]
id = "em-dash"
replacement = "--"
"#,
)
.expect("write config");
let output = formatter_with_stdin(
directory.path(),
&["--config", config.to_str().expect("UTF-8 path")],
"a—b".as_bytes(),
);
assert!(output.status.success());
assert!(output.stderr.is_empty());
assert_eq!(output.stdout, b"a--b");
}
#[test]
fn recursive_write_plans_every_input_before_mutation() {
let directory = tempdir().expect("temp dir");
let valid = directory.path().join("a-valid.txt");
let invalid = directory.path().join("z-invalid.txt");
fs::write(&valid, "still—original\n").expect("write valid input");
fs::write(&invalid, [0xff]).expect("write invalid input");
let output = formatter(directory.path())
.args(["--write", "--recursive"])
.arg(directory.path())
.output()
.expect("run recursive write");
assert_eq!(output.status.code(), Some(2));
assert!(output.stdout.is_empty());
assert!(!output.stderr.is_empty());
assert_eq!(
fs::read_to_string(valid).expect("read untouched valid input"),
"still—original\n"
);
}
#[test]
fn malformed_configuration_never_rewrites_the_input() {
let directory = tempdir().expect("temp dir");
let path = directory.path().join("article.txt");
let config = directory.path().join("broken.toml");
fs::write(&path, "still—original\n").expect("write input");
fs::write(&config, "[replacements\n").expect("write malformed config");
let output = formatter(directory.path())
.args(["--write", "--config"])
.arg(&config)
.arg(&path)
.output()
.expect("run formatter with malformed config");
assert_eq!(output.status.code(), Some(2));
assert_eq!(
fs::read_to_string(path).expect("read untouched input"),
"still—original\n"
);
}
#[test]
fn detector_fixes_reconstruct_formatter_output() {
let directory = tempdir().expect("temp dir");
let path = directory.path().join("article.txt");
let source = "a—b−c\n";
fs::write(&path, source).expect("write input");
let formatted = formatter(directory.path())
.arg(&path)
.output()
.expect("run formatter");
let detected = Command::new(env!("CARGO_BIN_EXE_john-slop"))
.env("XDG_CONFIG_HOME", directory.path())
.args(["--output", "json"])
.arg(&path)
.output()
.expect("run detector");
let record: serde_json::Value =
serde_json::from_slice(&detected.stdout).expect("parse detector JSON");
let mut reconstructed = source.to_owned();
for finding in record["findings"]
.as_array()
.expect("findings array")
.iter()
.rev()
{
let fix = &finding["fix"];
let start = fix["byte_span"]["start"].as_u64().expect("start") as usize;
let end = fix["byte_span"]["end"].as_u64().expect("end") as usize;
let replacement = fix["replacement"].as_str().expect("replacement");
reconstructed.replace_range(start..end, replacement);
}
assert!(formatted.status.success());
assert!(detected.status.success());
assert_eq!(formatted.stdout, reconstructed.as_bytes());
}
#[test]
fn directories_and_archives_require_explicit_supported_policies() {
let directory = tempdir().expect("temp dir");
let archive = directory.path().join("report.docx");
fs::write(&archive, b"not opened").expect("write archive placeholder");
let implicit_directory = formatter(directory.path())
.arg(directory.path())
.output()
.expect("format directory without recursive policy");
let invalid_recursive = formatter(directory.path())
.arg("--recursive")
.arg(directory.path())
.output()
.expect("format recursive stdout");
let archive_output = formatter(directory.path())
.arg("--write")
.arg(&archive)
.output()
.expect("format archive");
assert_eq!(implicit_directory.status.code(), Some(2));
assert!(String::from_utf8_lossy(&implicit_directory.stderr).contains("requires --recursive"));
assert_eq!(invalid_recursive.status.code(), Some(2));
assert!(
String::from_utf8_lossy(&invalid_recursive.stderr).contains("requires --check or --write")
);
assert_eq!(archive_output.status.code(), Some(2));
assert!(String::from_utf8_lossy(&archive_output.stderr).contains("unsupported"));
}