test: cover formatter workflows
This commit is contained in:
parent
2ceb6a6c5a
commit
d98db5252d
|
|
@ -32,10 +32,12 @@ Exercise the currently implemented boundaries with:
|
|||
|
||||
```sh
|
||||
cargo run --bin john-slop -- --output concise examples/fixtures/assistant/example.txt
|
||||
cargo run --bin john-slop-fmt -- examples/fixtures/typography/example.txt
|
||||
cargo run --bin john-slop-fmt -- --check examples/fixtures/clean/example.txt
|
||||
cargo run --example analyze_path -- examples/fixtures
|
||||
cargo test --test example_fixtures
|
||||
```
|
||||
|
||||
The manifest already names `fmt` and `lsp` as consumers, so their Milestone 5
|
||||
and 6 integration tests can reuse the same inputs and expected ASCII text. The
|
||||
two adapter binaries are still scaffolds and do not process these files yet.
|
||||
The formatter integration test now executes every case and compares stdout with
|
||||
its expected ASCII file. The manifest also names `lsp` as a consumer so the
|
||||
Milestone 6 protocol tests can reuse the same inputs and expected edits.
|
||||
|
|
|
|||
|
|
@ -106,3 +106,32 @@ fn detector_cli_accepts_every_shared_example() {
|
|||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn formatter_cli_matches_every_shared_expected_file() {
|
||||
let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("examples/fixtures");
|
||||
let manifest = load_manifest(&root);
|
||||
let config_home = tempfile::tempdir().expect("temp config home");
|
||||
|
||||
for case in manifest.cases {
|
||||
let expected = fs::read(root.join(&case.formatted)).expect("read expected formatted file");
|
||||
let output = Command::new(env!("CARGO_BIN_EXE_john-slop-fmt"))
|
||||
.env("XDG_CONFIG_HOME", config_home.path())
|
||||
.arg(root.join(&case.path))
|
||||
.output()
|
||||
.expect("run formatter against example");
|
||||
|
||||
assert!(
|
||||
output.status.success(),
|
||||
"formatter failed for {}: {}",
|
||||
case.path,
|
||||
String::from_utf8_lossy(&output.stderr)
|
||||
);
|
||||
assert!(output.stderr.is_empty(), "stderr for {}", case.path);
|
||||
assert_eq!(
|
||||
output.stdout, expected,
|
||||
"formatter output for {}",
|
||||
case.path
|
||||
);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -0,0 +1,298 @@
|
|||
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"));
|
||||
}
|
||||
Loading…
Reference in New Issue