@owenlamont/ryl 0.4.1 → 0.4.2

package/tests/yamllint_compat_quoted_strings.rs

@@ -1,154 +0,0 @@
-use std::fs;
-
-use tempfile::tempdir;
-
-#[path = "common/compat.rs"]
-mod compat;
-
-use compat::{
-    SCENARIOS, build_ryl_command, build_yamllint_command, capture_with_env,
-    ensure_yamllint_installed,
-};
-
-struct Case<'a> {
-    label: &'a str,
-    config: &'a std::path::Path,
-    file: &'a std::path::Path,
-    exit: i32,
-}
-
-#[test]
-fn quoted_strings_rule_matches_yamllint() {
-    ensure_yamllint_installed();
-
-    let dir = tempdir().unwrap();
-
-    let default_cfg = dir.path().join("default.yaml");
-    fs::write(
-        &default_cfg,
-        "rules:\n  document-start: disable\n  quoted-strings: enable\n",
-    )
-    .unwrap();
-
-    let only_needed_cfg = dir.path().join("only-needed.yaml");
-    fs::write(
-        &only_needed_cfg,
-        "rules:\n  document-start: disable\n  quoted-strings:\n    required: only-when-needed\n",
-    )
-    .unwrap();
-
-    let extra_required_cfg = dir.path().join("extra-required.yaml");
-    fs::write(
-        &extra_required_cfg,
-        "rules:\n  document-start: disable\n  quoted-strings:\n    required: false\n    extra-required: ['^http']\n",
-    )
-    .unwrap();
-
-    let extra_allowed_cfg = dir.path().join("extra-allowed.yaml");
-    fs::write(
-        &extra_allowed_cfg,
-        "rules:\n  document-start: disable\n  quoted-strings:\n    required: only-when-needed\n    extra-allowed: ['^http']\n",
-    )
-    .unwrap();
-
-    let double_allow_cfg = dir.path().join("double-allow.yaml");
-    fs::write(
-        &double_allow_cfg,
-        "rules:\n  document-start: disable\n  quoted-strings:\n    quote-type: double\n    allow-quoted-quotes: true\n",
-    )
-    .unwrap();
-
-    let check_keys_cfg = dir.path().join("check-keys.yaml");
-    fs::write(
-        &check_keys_cfg,
-        "rules:\n  document-start: disable\n  quoted-strings:\n    required: only-when-needed\n    check-keys: true\n    extra-required: ['[:]']\n",
-    )
-    .unwrap();
-
-    let plain_file = dir.path().join("plain.yaml");
-    fs::write(&plain_file, "foo: bar\n").unwrap();
-
-    let quoted_file = dir.path().join("quoted.yaml");
-    fs::write(&quoted_file, "foo: \"bar\"\n").unwrap();
-
-    let url_file = dir.path().join("urls.yaml");
-    fs::write(&url_file, "- http://example.com\n").unwrap();
-
-    let allowed_url_file = dir.path().join("allowed-url.yaml");
-    fs::write(&allowed_url_file, "foo: \"http://example.com\"\n").unwrap();
-
-    let quoted_quotes_file = dir.path().join("quoted-quotes.yaml");
-    fs::write(&quoted_quotes_file, "foo: 'bar\"baz'\n").unwrap();
-
-    let key_file = dir.path().join("key.yaml");
-    fs::write(&key_file, "foo:bar: baz\n").unwrap();
-
-    let exe = env!("CARGO_BIN_EXE_ryl");
-
-    let cases = [
-        Case {
-            label: "default-plain",
-            config: &default_cfg,
-            file: &plain_file,
-            exit: 1,
-        },
-        Case {
-            label: "only-needed-quoted",
-            config: &only_needed_cfg,
-            file: &quoted_file,
-            exit: 1,
-        },
-        Case {
-            label: "extra-required-url",
-            config: &extra_required_cfg,
-            file: &url_file,
-            exit: 1,
-        },
-        Case {
-            label: "extra-allowed-url",
-            config: &extra_allowed_cfg,
-            file: &allowed_url_file,
-            exit: 0,
-        },
-        Case {
-            label: "double-allow-quotes",
-            config: &double_allow_cfg,
-            file: &quoted_quotes_file,
-            exit: 0,
-        },
-        Case {
-            label: "check-keys",
-            config: &check_keys_cfg,
-            file: &key_file,
-            exit: 1,
-        },
-    ];
-
-    for scenario in SCENARIOS {
-        for case in &cases {
-            let mut ryl_cmd = build_ryl_command(exe, scenario.ryl_format);
-            ryl_cmd.arg("-c").arg(case.config).arg(case.file);
-            let (ryl_code, ryl_msg) = capture_with_env(ryl_cmd, scenario.envs);
-
-            let mut yam_cmd = build_yamllint_command(scenario.yam_format);
-            yam_cmd.arg("-c").arg(case.config).arg(case.file);
-            let (yam_code, yam_msg) = capture_with_env(yam_cmd, scenario.envs);
-
-            assert_eq!(
-                ryl_code, case.exit,
-                "ryl exit mismatch {} ({})",
-                case.label, scenario.label
-            );
-            assert_eq!(
-                yam_code, case.exit,
-                "yamllint exit mismatch {} ({})",
-                case.label, scenario.label
-            );
-            assert_eq!(
-                ryl_msg, yam_msg,
-                "diagnostics mismatch {} ({})",
-                case.label, scenario.label
-            );
-        }
-    }
-}

package/tests/yamllint_compat_syntax.rs

@@ -1,200 +0,0 @@
-use std::fs;
-use std::path::PathBuf;
-use std::process::Command;
-
-use tempfile::tempdir;
-
-fn run_cmd(cmd: &mut Command) -> (i32, String, String) {
-    let out = cmd.output().expect("failed to spawn process");
-    let code = out.status.code().unwrap_or(-1);
-    let stdout = String::from_utf8_lossy(&out.stdout).into_owned();
-    let stderr = String::from_utf8_lossy(&out.stderr).into_owned();
-    (code, stdout, stderr)
-}
-
-fn run_with_env(
-    mut cmd: Command,
-    envs: &[(&str, Option<&str>)],
-) -> (i32, String, String) {
-    cmd.env_remove("GITHUB_ACTIONS");
-    cmd.env_remove("GITHUB_WORKFLOW");
-    cmd.env_remove("CI");
-    for (key, value) in envs {
-        if let Some(val) = value {
-            cmd.env(key, val);
-        } else {
-            cmd.env_remove(key);
-        }
-    }
-    run_cmd(&mut cmd)
-}
-
-fn write_file(dir: &std::path::Path, name: &str, content: &str) -> PathBuf {
-    let p = dir.join(name);
-    fs::write(&p, content).expect("write file");
-    p
-}
-
-fn ensure_yamllint_installed() {
-    let ok = Command::new("yamllint")
-        .arg("--version")
-        .output()
-        .map(|o| o.status.success())
-        .unwrap_or(false);
-    assert!(
-        ok,
-        "yamllint must be installed and in PATH for parity tests"
-    );
-}
-
-#[test]
-fn yamllint_exit_behavior_matches_for_syntax_only() {
-    ensure_yamllint_installed();
-
-    let dir = tempdir().unwrap();
-    let ok = write_file(dir.path(), "ok.yaml", "a: 1\n");
-    let bad = write_file(dir.path(), "bad.yaml", "a: [1, 2\n");
-
-    // Disable yamllint rules so we only compare syntax behavior.
-    let cfg = write_file(dir.path(), ".yamllint.yml", "rules: {}\n");
-
-    let ryl = env!("CARGO_BIN_EXE_ryl");
-
-    const STANDARD_ENV: &[(&str, Option<&str>)] = &[];
-    const GITHUB_ENV: &[(&str, Option<&str>)] = &[
-        ("GITHUB_ACTIONS", Some("true")),
-        ("GITHUB_WORKFLOW", Some("test-workflow")),
-        ("CI", Some("true")),
-    ];
-
-    #[derive(Clone, Copy)]
-    enum OutputKind {
-        Standard,
-        Github,
-    }
-
-    fn parse_loc(msg: &str, kind: OutputKind) -> Option<(String, usize, usize)> {
-        match kind {
-            OutputKind::Standard => {
-                let mut lines = msg.lines().filter(|l| !l.trim().is_empty());
-                let file = lines.next()?.trim().to_string();
-                let second = lines.next()?.trim_start();
-                let pos = second.split_whitespace().next()?;
-                let mut it = pos.split(':');
-                let line = it.next()?.parse().ok()?;
-                let col = it.next()?.parse().ok()?;
-                Some((file, line, col))
-            }
-            OutputKind::Github => {
-                let mut lines = msg.lines().filter(|l| !l.trim().is_empty());
-                let header = lines.next()?.trim();
-                let file = header.strip_prefix("::group::")?.to_string();
-                let detail = lines.next()?.trim();
-                let detail = detail.strip_prefix("::error ")?;
-                let mut parts = detail.splitn(2, "::");
-                let meta = parts.next()?; // file=...,line=...,col=...
-                let mut meta_parts = meta.split(',');
-                let file_part = meta_parts.next()?;
-                let line_part = meta_parts.next()?;
-                let col_part = meta_parts.next()?;
-                let file_path = file_part.strip_prefix("file=")?;
-                let line_str = line_part.strip_prefix("line=")?;
-                let col_str = col_part.strip_prefix("col=")?;
-                let line = line_str.parse().ok()?;
-                let col = col_str.parse().ok()?;
-                // Ensure metadata file matches header file after trimming.
-                if !file_path.ends_with(&file) {
-                    return None;
-                }
-                Some((file_path.to_string(), line, col))
-            }
-        }
-    }
-
-    let scenarios = [
-        ("standard", STANDARD_ENV, OutputKind::Standard, true),
-        ("github", GITHUB_ENV, OutputKind::Github, false),
-    ];
-
-    for (label, envs, kind, use_standard_format) in scenarios {
-        // Valid file should pass in both tools.
-        let mut ryl_ok_cmd = Command::new(ryl);
-        ryl_ok_cmd.arg(&ok);
-        let (ryl_ok, _, _) = run_with_env(ryl_ok_cmd, envs);
-        assert_eq!(ryl_ok, 0, "ryl should succeed for valid yaml ({label})");
-
-        let mut yam_ok_cmd = Command::new("yamllint");
-        if use_standard_format {
-            yam_ok_cmd.arg("-f").arg("standard");
-        }
-        yam_ok_cmd.arg("-c");
-        yam_ok_cmd.arg(&cfg);
-        yam_ok_cmd.arg(&ok);
-        let (yam_ok, _, yam_ok_err) = run_with_env(yam_ok_cmd, envs);
-        assert_eq!(
-            yam_ok, 0,
-            "yamllint should succeed for valid yaml ({label}): {yam_ok_err}"
-        );
-
-        // Invalid file should fail; capture whichever stream has content.
-        let mut ryl_bad_cmd = Command::new(ryl);
-        ryl_bad_cmd.arg(&bad);
-        let (ryl_bad_code, ryl_bad_out, ryl_bad_err) = run_with_env(ryl_bad_cmd, envs);
-        let mut yam_bad_cmd = Command::new("yamllint");
-        if use_standard_format {
-            yam_bad_cmd.arg("-f").arg("standard");
-        }
-        yam_bad_cmd.arg("-c");
-        yam_bad_cmd.arg(&cfg);
-        yam_bad_cmd.arg(&bad);
-        let (yam_bad_code, yam_bad_out, yam_bad_err) = run_with_env(yam_bad_cmd, envs);
-
-        assert_ne!(
-            ryl_bad_code, 0,
-            "ryl should fail for invalid yaml ({label})"
-        );
-        assert_ne!(
-            yam_bad_code, 0,
-            "yamllint should fail for invalid yaml ({label})"
-        );
-
-        let r_msg = if !ryl_bad_err.is_empty() {
-            ryl_bad_err
-        } else {
-            ryl_bad_out
-        };
-        let y_msg = if !yam_bad_out.is_empty() {
-            yam_bad_out
-        } else {
-            yam_bad_err
-        };
-
-        if let (Some((rf, rl, rc)), Some((yf, yl, yc))) =
-            (parse_loc(&r_msg, kind), parse_loc(&y_msg, kind))
-        {
-            assert!(
-                rf.ends_with("bad.yaml"),
-                "ryl location should reference bad.yaml ({label}): {rf}"
-            );
-            assert!(
-                yf.ends_with("bad.yaml"),
-                "yamllint location should reference bad.yaml ({label}): {yf}"
-            );
-            assert_eq!(rl, yl, "line numbers should match ({label})");
-            assert_eq!(rc, yc, "column numbers should match ({label})");
-        } else {
-            panic!(
-                "could not parse location ({label})\nryl:\n{r_msg}\nyamllint:\n{y_msg}"
-            );
-        }
-
-        assert!(
-            r_msg.contains("syntax error"),
-            "ryl output should mention syntax error ({label}): {r_msg}"
-        );
-        assert!(
-            y_msg.contains("syntax error"),
-            "yamllint output should mention syntax error ({label}): {y_msg}"
-        );
-    }
-}

package/tests/yamllint_compat_trailing_spaces.rs

@@ -1,162 +0,0 @@
-use std::fs;
-
-use tempfile::tempdir;
-
-#[path = "common/compat.rs"]
-mod compat;
-
-use compat::{
-    SCENARIOS, build_ryl_command, build_yamllint_command, capture_with_env,
-    ensure_yamllint_installed,
-};
-
-#[test]
-fn trailing_spaces_rule_matches_yamllint() {
-    ensure_yamllint_installed();
-
-    let dir = tempdir().unwrap();
-
-    let default_cfg = dir.path().join("trailing-default.yml");
-    fs::write(
-        &default_cfg,
-        "rules:\n  document-start: disable\n  trailing-spaces: enable\n",
-    )
-    .unwrap();
-
-    let warning_cfg = dir.path().join("trailing-warning.yml");
-    fs::write(
-        &warning_cfg,
-        "rules:\n  document-start: disable\n  trailing-spaces:\n    level: warning\n",
-    )
-    .unwrap();
-
-    let ignore_cfg = dir.path().join("trailing-ignore.yml");
-    fs::write(
-        &ignore_cfg,
-        "rules:\n  document-start: disable\n  trailing-spaces:\n    ignore:\n      - ignored.yaml\n",
-    )
-    .unwrap();
-
-    let ignore_list = dir.path().join("trailing-ignore.txt");
-    fs::write(&ignore_list, "ignored-from-file.yaml\n").unwrap();
-
-    let ignore_from_file_cfg = dir.path().join("trailing-ignore-from-file.yml");
-    let ignore_path = ignore_list.display().to_string().replace('\'', "''");
-    fs::write(
-        &ignore_from_file_cfg,
-        format!(
-            "rules:\n  document-start: disable\n  trailing-spaces:\n    ignore-from-file: '{}'\n",
-            ignore_path
-        ),
-    )
-    .unwrap();
-
-    let bad_file = dir.path().join("bad.yaml");
-    fs::write(&bad_file, "key: value \n").unwrap();
-
-    let ignored_file = dir.path().join("ignored.yaml");
-    fs::write(&ignored_file, "other: value \n").unwrap();
-
-    let ignored_from_file = dir.path().join("ignored-from-file.yaml");
-    fs::write(&ignored_from_file, "foo: bar \n").unwrap();
-
-    let exe = env!("CARGO_BIN_EXE_ryl");
-
-    for scenario in SCENARIOS {
-        // default configuration should produce an error
-        let mut ryl_default = build_ryl_command(exe, scenario.ryl_format);
-        ryl_default.arg("-c").arg(&default_cfg).arg(&bad_file);
-        let (ryl_code, ryl_output) = capture_with_env(ryl_default, scenario.envs);
-
-        let mut yam_default = build_yamllint_command(scenario.yam_format);
-        yam_default.arg("-c").arg(&default_cfg).arg(&bad_file);
-        let (yam_code, yam_output) = capture_with_env(yam_default, scenario.envs);
-
-        assert_eq!(ryl_code, 1, "ryl default exit ({})", scenario.label);
-        assert_eq!(yam_code, 1, "yamllint default exit ({})", scenario.label);
-        assert_eq!(
-            ryl_output, yam_output,
-            "default diagnostics mismatch ({})",
-            scenario.label
-        );
-
-        // warning configuration should keep diagnostics but exit 0
-        let mut ryl_warning = build_ryl_command(exe, scenario.ryl_format);
-        ryl_warning.arg("-c").arg(&warning_cfg).arg(&bad_file);
-        let (ryl_warn_code, ryl_warn_output) =
-            capture_with_env(ryl_warning, scenario.envs);
-
-        let mut yam_warning = build_yamllint_command(scenario.yam_format);
-        yam_warning.arg("-c").arg(&warning_cfg).arg(&bad_file);
-        let (yam_warn_code, yam_warn_output) =
-            capture_with_env(yam_warning, scenario.envs);
-
-        assert_eq!(ryl_warn_code, 0, "ryl warning exit ({})", scenario.label);
-        assert_eq!(
-            yam_warn_code, 0,
-            "yamllint warning exit ({})",
-            scenario.label
-        );
-        assert_eq!(
-            ryl_warn_output, yam_warn_output,
-            "warning diagnostics mismatch ({})",
-            scenario.label
-        );
-
-        // ignore pattern applied through inline config should skip diagnostics
-        let mut ryl_ignore = build_ryl_command(exe, scenario.ryl_format);
-        ryl_ignore.arg("-c").arg(&ignore_cfg).arg(&ignored_file);
-        let (ryl_ignore_code, ryl_ignore_output) =
-            capture_with_env(ryl_ignore, scenario.envs);
-
-        let mut yam_ignore = build_yamllint_command(scenario.yam_format);
-        yam_ignore.arg("-c").arg(&ignore_cfg).arg(&ignored_file);
-        let (yam_ignore_code, yam_ignore_output) =
-            capture_with_env(yam_ignore, scenario.envs);
-
-        assert_eq!(ryl_ignore_code, 0, "ryl ignore exit ({})", scenario.label);
-        assert_eq!(
-            yam_ignore_code, 0,
-            "yamllint ignore exit ({})",
-            scenario.label
-        );
-        assert_eq!(
-            ryl_ignore_output, yam_ignore_output,
-            "ignore diagnostics mismatch ({})",
-            scenario.label
-        );
-
-        // ignore-from-file should behave the same
-        let mut ryl_ignore_file = build_ryl_command(exe, scenario.ryl_format);
-        ryl_ignore_file
-            .arg("-c")
-            .arg(&ignore_from_file_cfg)
-            .arg(&ignored_from_file);
-        let (ryl_file_code, ryl_file_output) =
-            capture_with_env(ryl_ignore_file, scenario.envs);
-
-        let mut yam_ignore_file = build_yamllint_command(scenario.yam_format);
-        yam_ignore_file
-            .arg("-c")
-            .arg(&ignore_from_file_cfg)
-            .arg(&ignored_from_file);
-        let (yam_file_code, yam_file_output) =
-            capture_with_env(yam_ignore_file, scenario.envs);
-
-        assert_eq!(
-            ryl_file_code, 0,
-            "ryl ignore-from-file exit ({})",
-            scenario.label
-        );
-        assert_eq!(
-            yam_file_code, 0,
-            "yamllint ignore-from-file exit ({})",
-            scenario.label
-        );
-        assert_eq!(
-            ryl_file_output, yam_file_output,
-            "ignore-from-file diagnostics mismatch ({})",
-            scenario.label
-        );
-    }
-}

package/tests/yamllint_compat_truthy.rs

@@ -1,130 +0,0 @@
-use std::fs;
-
-use tempfile::tempdir;
-
-#[path = "common/compat.rs"]
-mod compat;
-
-use compat::{
-    SCENARIOS, build_ryl_command, build_yamllint_command, capture_with_env,
-    ensure_yamllint_installed,
-};
-
-#[test]
-fn truthy_rule_matches_yamllint() {
-    ensure_yamllint_installed();
-
-    let dir = tempdir().unwrap();
-
-    let default_cfg = dir.path().join("truthy-default.yml");
-    fs::write(
-        &default_cfg,
-        "rules:\n  document-start: disable\n  truthy: enable\n",
-    )
-    .unwrap();
-
-    let allowed_cfg = dir.path().join("truthy-allowed.yml");
-    fs::write(
-        &allowed_cfg,
-        "rules:\n  document-start: disable\n  truthy:\n    allowed-values: [\"yes\", \"no\"]\n",
-    )
-    .unwrap();
-
-    let check_keys_cfg = dir.path().join("truthy-check-keys.yml");
-    fs::write(
-        &check_keys_cfg,
-        "rules:\n  document-start: disable\n  truthy:\n    allowed-values: []\n    check-keys: false\n",
-    )
-    .unwrap();
-
-    let bad_file = dir.path().join("bad.yaml");
-    fs::write(&bad_file, "foo: True\nbar: yes\nTrue: 1\non: off\n").unwrap();
-
-    let allowed_file = dir.path().join("allowed.yaml");
-    fs::write(&allowed_file, "- yes\n- no\n- true\n- on\n").unwrap();
-
-    let ok_file = dir.path().join("ok.yaml");
-    fs::write(&ok_file, "foo: false\nbar: true\n").unwrap();
-
-    let exe = env!("CARGO_BIN_EXE_ryl");
-
-    for scenario in SCENARIOS {
-        // default configuration, expect errors on keys and values
-        let mut ryl_default = build_ryl_command(exe, scenario.ryl_format);
-        ryl_default.arg("-c").arg(&default_cfg).arg(&bad_file);
-        let (ryl_code, ryl_msg) = capture_with_env(ryl_default, scenario.envs);
-
-        let mut yam_default = build_yamllint_command(scenario.yam_format);
-        yam_default.arg("-c").arg(&default_cfg).arg(&bad_file);
-        let (yam_code, yam_msg) = capture_with_env(yam_default, scenario.envs);
-
-        assert_eq!(ryl_code, 1, "ryl default exit ({})", scenario.label);
-        assert_eq!(yam_code, 1, "yamllint default exit ({})", scenario.label);
-        assert_eq!(
-            ryl_msg, yam_msg,
-            "default diagnostics mismatch ({})",
-            scenario.label
-        );
-
-        // allowed-values override keeps yes/no allowed
-        let mut ryl_allowed = build_ryl_command(exe, scenario.ryl_format);
-        ryl_allowed.arg("-c").arg(&allowed_cfg).arg(&allowed_file);
-        let (ryl_allowed_code, ryl_allowed_msg) =
-            capture_with_env(ryl_allowed, scenario.envs);
-
-        let mut yam_allowed = build_yamllint_command(scenario.yam_format);
-        yam_allowed.arg("-c").arg(&allowed_cfg).arg(&allowed_file);
-        let (yam_allowed_code, yam_allowed_msg) =
-            capture_with_env(yam_allowed, scenario.envs);
-
-        assert_eq!(ryl_allowed_code, 1, "ryl allowed exit ({})", scenario.label);
-        assert_eq!(
-            yam_allowed_code, 1,
-            "yamllint allowed exit ({})",
-            scenario.label
-        );
-        assert_eq!(
-            ryl_allowed_msg, yam_allowed_msg,
-            "allowed diagnostics mismatch ({})",
-            scenario.label
-        );
-
-        // check-keys=false should suppress key diagnostics
-        let mut ryl_check_keys = build_ryl_command(exe, scenario.ryl_format);
-        ryl_check_keys.arg("-c").arg(&check_keys_cfg).arg(&bad_file);
-        let (ryl_ck_code, ryl_ck_msg) = capture_with_env(ryl_check_keys, scenario.envs);
-
-        let mut yam_check_keys = build_yamllint_command(scenario.yam_format);
-        yam_check_keys.arg("-c").arg(&check_keys_cfg).arg(&bad_file);
-        let (yam_ck_code, yam_ck_msg) = capture_with_env(yam_check_keys, scenario.envs);
-
-        assert_eq!(ryl_ck_code, 1, "ryl check-keys exit ({})", scenario.label);
-        assert_eq!(
-            yam_ck_code, 1,
-            "yamllint check-keys exit ({})",
-            scenario.label
-        );
-        assert_eq!(
-            ryl_ck_msg, yam_ck_msg,
-            "check-keys diagnostics mismatch ({})",
-            scenario.label
-        );
-
-        // success scenario: default config but compliant file
-        let mut ryl_ok = build_ryl_command(exe, scenario.ryl_format);
-        ryl_ok.arg("-c").arg(&default_cfg).arg(&ok_file);
-        let (ryl_ok_code, ryl_ok_msg) = capture_with_env(ryl_ok, scenario.envs);
-
-        let mut yam_ok = build_yamllint_command(scenario.yam_format);
-        yam_ok.arg("-c").arg(&default_cfg).arg(&ok_file);
-        let (yam_ok_code, yam_ok_msg) = capture_with_env(yam_ok, scenario.envs);
-
-        assert_eq!(ryl_ok_code, 0, "ryl ok exit ({})", scenario.label);
-        assert_eq!(yam_ok_code, 0, "yamllint ok exit ({})", scenario.label);
-        assert_eq!(
-            ryl_ok_msg, yam_ok_msg,
-            "ok diagnostics mismatch ({})",
-            scenario.label
-        );
-    }
-}