john-slop/tests/example_fixtures.rs

204 lines
6.9 KiB
Rust

use std::{collections::BTreeSet, fs, path::Path, process::Command};
use john_slop::{
AnalysisContext, Config, ConfigLoader, ConfigPaths, 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
);
}
}
#[test]
fn diagnostic_showcase_is_an_expected_threshold_failure() {
let root = Path::new(env!("CARGO_MANIFEST_DIR"));
let config_home = tempfile::tempdir().expect("temp config home");
let output = Command::new(env!("CARGO_BIN_EXE_john-slop"))
.env("XDG_CONFIG_HOME", config_home.path())
.args(["--output", "miette", "--fail-level", "low", "--config"])
.arg(root.join("examples/diagnostic-showcase.toml"))
.arg(root.join("examples/diagnostic-showcase.txt"))
.output()
.expect("run expected-failure diagnostic showcase");
let stdout = String::from_utf8(output.stdout).expect("UTF-8 diagnostic output");
// `--nocapture` makes this a convenient manual tour of every diagnostic.
print!("{stdout}");
assert_eq!(output.status.code(), Some(1));
assert!(output.stderr.is_empty());
assert!(stdout.contains("assistant-self-identification"));
assert!(stdout.contains("prompt-response-scaffolding"));
assert!(stdout.contains("typography-non-ascii-hyphen"));
assert!(stdout.contains("low-care evidence score: 71 (medium)"));
assert!(stdout.contains("advice"));
assert!(stdout.contains("warning"));
assert!(stdout.contains("error"));
#[cfg(feature = "fancy-diagnostics")]
{
assert!(stdout.contains('\u{1b}'));
assert!(stdout.contains('╭'));
}
}
#[test]
fn commented_base_and_named_configs_form_a_valid_layered_example() {
let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("examples/config");
let config = ConfigLoader::from_paths(ConfigPaths {
directory: root.clone(),
base: root.join("config.toml"),
named: Some(root.join("editorial.toml")),
explicit: None,
})
.load()
.expect("load commented sample layers");
assert_eq!(config.input.max_document_bytes, 4_194_304);
assert_eq!(config.thresholds.low, 15);
assert_eq!(config.thresholds.medium, 40);
assert_eq!(config.thresholds.high, 70);
assert!(
!config
.replacements
.iter()
.find(|replacement| replacement.id == "em-dash")
.expect("embedded replacement remains present")
.enabled
);
let rule = config
.rules
.iter()
.find(|rule| rule.id == "assistant-self-identification")
.expect("embedded rule remains present");
assert_eq!(rule.scope.include, vec!["articles/**", "docs/**"]);
}