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, cases: Vec, } #[derive(Debug, Deserialize)] struct Case { path: String, formatted: String, expected_rules: BTreeSet, 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::>(); 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::>(); 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_spans_prose_source_and_severities() { 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")) .arg(root.join("examples/diagnostic-showcase/source.rs")) .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("unicode-ascii-confusable")); assert!(stdout.contains("unicode-invisible-control")); assert!(stdout.contains("source-placeholder-todo")); assert!(stdout.contains("source-tutorial-narration")); assert!(stdout.contains('‐')); assert!(stdout.contains('-')); assert!(stdout.contains("low-care evidence score: 71 (medium)")); assert!(stdout.matches("low-care evidence score:").count() >= 2); assert!(stdout.contains("advice")); assert!(stdout.contains("warning")); assert!(stdout.contains("error")); #[cfg(feature = "fancy-diagnostics")] { assert!(stdout.contains('\u{1b}')); assert!(stdout.contains('╭')); assert!(stdout.matches("◆ ").count() >= 12); let lines = stdout.lines().collect::>(); for (index, line) in lines.iter().enumerate() { if line.starts_with("◆ ") { assert!(!lines[index + 1].is_empty()); } if line.contains("help:") { assert_eq!(lines[index + 1], ""); } } } } #[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/**"]); }