138 lines
4.4 KiB
Rust
138 lines
4.4 KiB
Rust
use std::{collections::BTreeSet, fs, path::Path, process::Command};
|
|
|
|
use john_slop::{AnalysisContext, Config, Detector, apply_replacements, plan_replacements};
|
|
use serde::Deserialize;
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
struct Manifest {
|
|
schema_version: u32,
|
|
targets: BTreeSet<String>,
|
|
cases: Vec<Case>,
|
|
}
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
struct Case {
|
|
path: String,
|
|
formatted: String,
|
|
expected_rules: BTreeSet<String>,
|
|
expected_replacements: usize,
|
|
}
|
|
|
|
fn load_manifest(root: &Path) -> Manifest {
|
|
let source = fs::read_to_string(root.join("manifest.toml")).expect("read fixture manifest");
|
|
toml::from_str(&source).expect("parse fixture manifest")
|
|
}
|
|
|
|
fn apply_planned_edits(source: &str, config: &Config) -> String {
|
|
apply_replacements(source, &plan_replacements(config, source))
|
|
.expect("apply valid planned edits")
|
|
.into_owned()
|
|
}
|
|
|
|
#[test]
|
|
fn shared_examples_pin_detection_and_formatted_text() {
|
|
let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("examples/fixtures");
|
|
let manifest = load_manifest(&root);
|
|
assert_eq!(manifest.schema_version, 1);
|
|
assert_eq!(
|
|
manifest.targets,
|
|
["cli", "fmt", "lsp"].map(String::from).into()
|
|
);
|
|
|
|
let config = Config::embedded();
|
|
let detector = Detector::new(&config).expect("build detector");
|
|
for case in manifest.cases {
|
|
let source = fs::read_to_string(root.join(&case.path)).expect("read example input");
|
|
let expected = fs::read_to_string(root.join(&case.formatted)).expect("read formatted text");
|
|
let analysis = detector.analyze_with(&source, &AnalysisContext::for_path(&case.path));
|
|
let actual_rules = analysis
|
|
.findings
|
|
.into_iter()
|
|
.map(|finding| finding.rule_id.to_string())
|
|
.collect::<BTreeSet<_>>();
|
|
let edits = plan_replacements(&config, &source);
|
|
|
|
assert_eq!(actual_rules, case.expected_rules, "rules for {}", case.path);
|
|
assert_eq!(
|
|
edits.len(),
|
|
case.expected_replacements,
|
|
"replacement count for {}",
|
|
case.path
|
|
);
|
|
assert_eq!(
|
|
apply_planned_edits(&source, &config),
|
|
expected,
|
|
"formatted output for {}",
|
|
case.path
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn detector_cli_accepts_every_shared_example() {
|
|
let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("examples/fixtures");
|
|
let manifest = load_manifest(&root);
|
|
|
|
for case in manifest.cases {
|
|
let output = Command::new(env!("CARGO_BIN_EXE_john-slop"))
|
|
.args(["--output", "json"])
|
|
.arg(root.join(&case.path))
|
|
.output()
|
|
.expect("run detector against example");
|
|
assert!(
|
|
output.status.success(),
|
|
"CLI failed for {}: {}",
|
|
case.path,
|
|
String::from_utf8_lossy(&output.stderr)
|
|
);
|
|
|
|
let record: serde_json::Value =
|
|
serde_json::from_slice(&output.stdout).expect("parse detector JSON record");
|
|
let actual_rules = record["findings"]
|
|
.as_array()
|
|
.expect("findings array")
|
|
.iter()
|
|
.map(|finding| {
|
|
finding["rule_id"]
|
|
.as_str()
|
|
.expect("rule ID string")
|
|
.to_owned()
|
|
})
|
|
.collect::<BTreeSet<_>>();
|
|
assert_eq!(
|
|
actual_rules, case.expected_rules,
|
|
"CLI rules for {}",
|
|
case.path
|
|
);
|
|
}
|
|
}
|
|
|
|
#[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
|
|
);
|
|
}
|
|
}
|